authorgravatar for me@tadeo.caTadeo Kondrak <me@tadeo.ca> 2020-09-30 10:46:19-06:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-10-08 12:29:59+03:00
log83eda214882e33e65794cee1e7c0d87777b31bf4
treeb374ccc868c0123e5c83d1a4d3316e5c2a8e754c
parent0e57f220fb71efefa9c6246818758d9c30994f73

zig_clang/translate_c: Use opaque declarations in Zig

3 files changed, 1593 insertions(+), 1192 deletions(-)

src/clang.zig+929-521
......@@ -1,91 +1,901 @@
1const builtin = @import("builtin");
2
3pub const struct_ZigClangConditionalOperator = opaque {};
4pub const struct_ZigClangBinaryConditionalOperator = opaque {};
5pub const struct_ZigClangAbstractConditionalOperator = opaque {};
6pub const struct_ZigClangAPInt = opaque {};
7pub const struct_ZigClangAPSInt = opaque {};
8pub const struct_ZigClangAPFloat = opaque {};
9pub const struct_ZigClangASTContext = opaque {};
10pub const struct_ZigClangASTUnit = opaque {};
11pub const struct_ZigClangArraySubscriptExpr = opaque {};
12pub const struct_ZigClangArrayType = opaque {};
13pub const struct_ZigClangAttributedType = opaque {};
14pub const struct_ZigClangBinaryOperator = opaque {};
15pub const struct_ZigClangBreakStmt = opaque {};
16pub const struct_ZigClangBuiltinType = opaque {};
17pub const struct_ZigClangCStyleCastExpr = opaque {};
18pub const struct_ZigClangCallExpr = opaque {};
19pub const struct_ZigClangCaseStmt = opaque {};
20pub const struct_ZigClangCompoundAssignOperator = opaque {};
21pub const struct_ZigClangCompoundStmt = opaque {};
22pub const struct_ZigClangConstantArrayType = opaque {};
23pub const struct_ZigClangContinueStmt = opaque {};
24pub const struct_ZigClangDecayedType = opaque {};
25pub const ZigClangDecl = opaque {};
26pub const struct_ZigClangDeclRefExpr = opaque {};
27pub const struct_ZigClangDeclStmt = opaque {};
28pub const struct_ZigClangDefaultStmt = opaque {};
29pub const struct_ZigClangDiagnosticOptions = opaque {};
30pub const struct_ZigClangDiagnosticsEngine = opaque {};
31pub const struct_ZigClangDoStmt = opaque {};
32pub const struct_ZigClangElaboratedType = opaque {};
33pub const struct_ZigClangEnumConstantDecl = opaque {};
34pub const struct_ZigClangEnumDecl = opaque {};
35pub const struct_ZigClangEnumType = opaque {};
36pub const struct_ZigClangExpr = opaque {};
37pub const struct_ZigClangFieldDecl = opaque {};
38pub const struct_ZigClangFileID = opaque {};
39pub const struct_ZigClangForStmt = opaque {};
40pub const struct_ZigClangFullSourceLoc = opaque {};
41pub const struct_ZigClangFunctionDecl = opaque {};
42pub const struct_ZigClangFunctionProtoType = opaque {};
43pub const struct_ZigClangIfStmt = opaque {};
44pub const struct_ZigClangImplicitCastExpr = opaque {};
45pub const struct_ZigClangIncompleteArrayType = opaque {};
46pub const struct_ZigClangIntegerLiteral = opaque {};
47pub const struct_ZigClangMacroDefinitionRecord = opaque {};
48pub const struct_ZigClangMacroExpansion = opaque {};
49pub const struct_ZigClangMacroQualifiedType = opaque {};
50pub const struct_ZigClangMemberExpr = opaque {};
51pub const struct_ZigClangNamedDecl = opaque {};
52pub const struct_ZigClangNone = opaque {};
53pub const struct_ZigClangOpaqueValueExpr = opaque {};
54pub const struct_ZigClangPCHContainerOperations = opaque {};
55pub const struct_ZigClangParenExpr = opaque {};
56pub const struct_ZigClangParenType = opaque {};
57pub const struct_ZigClangParmVarDecl = opaque {};
58pub const struct_ZigClangPointerType = opaque {};
59pub const struct_ZigClangPreprocessedEntity = opaque {};
60pub const struct_ZigClangRecordDecl = opaque {};
61pub const struct_ZigClangRecordType = opaque {};
62pub const struct_ZigClangReturnStmt = opaque {};
63pub const struct_ZigClangSkipFunctionBodiesScope = opaque {};
64pub const struct_ZigClangSourceManager = opaque {};
65pub const struct_ZigClangSourceRange = opaque {};
66pub const ZigClangStmt = opaque {};
67pub const struct_ZigClangStringLiteral = opaque {};
68pub const struct_ZigClangStringRef = opaque {};
69pub const struct_ZigClangSwitchStmt = opaque {};
70pub const struct_ZigClangTagDecl = opaque {};
71pub const struct_ZigClangType = opaque {};
72pub const struct_ZigClangTypedefNameDecl = opaque {};
73pub const struct_ZigClangTypedefType = opaque {};
74pub const struct_ZigClangUnaryExprOrTypeTraitExpr = opaque {};
75pub const struct_ZigClangUnaryOperator = opaque {};
76pub const struct_ZigClangValueDecl = opaque {};
77pub const struct_ZigClangVarDecl = opaque {};
78pub const struct_ZigClangWhileStmt = opaque {};
79pub const struct_ZigClangFunctionType = opaque {};
80pub const struct_ZigClangPredefinedExpr = opaque {};
81pub const struct_ZigClangInitListExpr = opaque {};
82pub const ZigClangPreprocessingRecord = opaque {};
83pub const ZigClangFloatingLiteral = opaque {};
84pub const ZigClangConstantExpr = opaque {};
85pub const ZigClangCharacterLiteral = opaque {};
86pub const ZigClangStmtExpr = 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,
......@@ -189,7 +999,7 @@ pub const ZigClangTypeClass = extern enum {
189999 ExtVector,
1901000};
1911001
192const ZigClangStmtClass = extern enum {
1002const StmtClass = extern enum {
1931003 NoStmtClass,
1941004 GCCAsmStmtClass,
1951005 MSAsmStmtClass,
......@@ -399,7 +1209,7 @@ const ZigClangStmtClass = extern enum {
3991209 WhileStmtClass,
4001210};
4011211
402pub const ZigClangCK = extern enum {
1212pub const CK = extern enum {
4031213 Dependent,
4041214 BitCast,
4051215 LValueBitCast,
......@@ -464,24 +1274,7 @@ pub const ZigClangCK = extern enum {
4641274 IntToOCLSampler,
4651275};
4661276
467pub const ZigClangAPValueKind = extern enum {
468 None,
469 Indeterminate,
470 Int,
471 Float,
472 FixedPoint,
473 ComplexInt,
474 ComplexFloat,
475 LValue,
476 Vector,
477 Array,
478 Struct,
479 Union,
480 MemberPointer,
481 AddrLabelDiff,
482};
483
484pub const ZigClangDeclKind = extern enum {
1277pub const DeclKind = extern enum {
4851278 AccessSpec,
4861279 Block,
4871280 Captured,
......@@ -563,7 +1356,7 @@ pub const ZigClangDeclKind = extern enum {
5631356 TranslationUnit,
5641357};
5651358
566pub const ZigClangBuiltinTypeKind = extern enum {
1359pub const BuiltinTypeKind = extern enum {
5671360 OCLImage1dRO,
5681361 OCLImage1dArrayRO,
5691362 OCLImage1dBufferRO,
......@@ -694,7 +1487,7 @@ pub const ZigClangBuiltinTypeKind = extern enum {
6941487 OMPArraySection,
6951488};
6961489
697pub const ZigClangCallingConv = extern enum {
1490pub const CallingConv = extern enum {
6981491 C,
6991492 X86StdCall,
7001493 X86FastCall,
......@@ -715,7 +1508,7 @@ pub const ZigClangCallingConv = extern enum {
7151508 AArch64VectorCall,
7161509};
7171510
718pub const ZigClangStorageClass = extern enum {
1511pub const StorageClass = extern enum {
7191512 None,
7201513 Extern,
7211514 Static,
......@@ -724,7 +1517,7 @@ pub const ZigClangStorageClass = extern enum {
7241517 Register,
7251518};
7261519
727pub const ZigClangAPFloat_roundingMode = extern enum {
1520pub const APFloat_roundingMode = extern enum {
7281521 NearestTiesToEven,
7291522 TowardPositive,
7301523 TowardNegative,
......@@ -732,7 +1525,7 @@ pub const ZigClangAPFloat_roundingMode = extern enum {
7321525 NearestTiesToAway,
7331526};
7341527
735pub const ZigClangStringLiteral_StringKind = extern enum {
1528pub const StringLiteral_StringKind = extern enum {
7361529 Ascii,
7371530 Wide,
7381531 UTF8,
......@@ -740,7 +1533,7 @@ pub const ZigClangStringLiteral_StringKind = extern enum {
7401533 UTF32,
7411534};
7421535
743pub const ZigClangCharacterLiteral_CharacterKind = extern enum {
1536pub const CharacterLiteral_CharacterKind = extern enum {
7441537 Ascii,
7451538 Wide,
7461539 UTF8,
......@@ -748,32 +1541,35 @@ pub const ZigClangCharacterLiteral_CharacterKind = extern enum {
7481541 UTF32,
7491542};
7501543
751pub const ZigClangRecordDecl_field_iterator = extern struct {
752 ptr: *c_void,
753};
754
755pub const ZigClangEnumDecl_enumerator_iterator = extern struct {
756 ptr: *c_void,
1544pub const VarDecl_TLSKind = extern enum {
1545 None,
1546 Static,
1547 Dynamic,
7571548};
7581549
759pub const ZigClangPreprocessingRecord_iterator = extern struct {
760 I: c_int,
761 Self: *ZigClangPreprocessingRecord,
1550pub const ElaboratedTypeKeyword = extern enum {
1551 Struct,
1552 Interface,
1553 Union,
1554 Class,
1555 Enum,
1556 Typename,
1557 None,
7621558};
7631559
764pub const ZigClangPreprocessedEntity_EntityKind = extern enum {
1560pub const PreprocessedEntity_EntityKind = extern enum {
7651561 InvalidKind,
7661562 MacroExpansionKind,
7671563 MacroDefinitionKind,
7681564 InclusionDirectiveKind,
7691565};
7701566
771pub const ZigClangExpr_ConstExprUsage = extern enum {
1567pub const Expr_ConstExprUsage = extern enum {
7721568 EvaluateForCodeGen,
7731569 EvaluateForMangling,
7741570};
7751571
776pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {
1572pub const UnaryExprOrTypeTrait_Kind = extern enum {
7771573 SizeOf,
7781574 AlignOf,
7791575 VecStep,
......@@ -781,211 +1577,6 @@ pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {
7811577 PreferredAlignOf,
7821578};
7831579
784pub extern fn ZigClangSourceManager_getSpellingLoc(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation;
785pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*:0]const u8;
786pub extern fn ZigClangSourceManager_getSpellingLineNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
787pub extern fn ZigClangSourceManager_getSpellingColumnNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
788pub extern fn ZigClangSourceManager_getCharacterData(self: ?*const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [*:0]const u8;
789pub extern fn ZigClangASTContext_getPointerType(self: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType;
790pub extern fn ZigClangASTUnit_getASTContext(self: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext;
791pub extern fn ZigClangASTUnit_getSourceManager(self: *struct_ZigClangASTUnit) *struct_ZigClangSourceManager;
792pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: *struct_ZigClangASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const ZigClangDecl) callconv(.C) bool) bool;
793pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) *const struct_ZigClangRecordDecl;
794pub extern fn ZigClangTagDecl_isThisDeclarationADefinition(self: *const ZigClangTagDecl) bool;
795pub extern fn ZigClangEnumType_getDecl(record_ty: ?*const struct_ZigClangEnumType) *const struct_ZigClangEnumDecl;
796pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangTagDecl;
797pub extern fn ZigClangFieldDecl_getCanonicalDecl(field_decl: ?*const struct_ZigClangFieldDecl) ?*const struct_ZigClangFieldDecl;
798pub extern fn ZigClangFieldDecl_getAlignedAttribute(field_decl: ?*const struct_ZigClangFieldDecl, *const ZigClangASTContext) c_uint;
799pub extern fn ZigClangEnumDecl_getCanonicalDecl(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangTagDecl;
800pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(self: ?*const struct_ZigClangTypedefNameDecl) ?*const struct_ZigClangTypedefNameDecl;
801pub extern fn ZigClangFunctionDecl_getCanonicalDecl(self: ?*const struct_ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl;
802pub extern fn ZigClangParmVarDecl_getOriginalType(self: ?*const struct_ZigClangParmVarDecl) struct_ZigClangQualType;
803pub extern fn ZigClangVarDecl_getCanonicalDecl(self: ?*const struct_ZigClangVarDecl) ?*const struct_ZigClangVarDecl;
804pub extern fn ZigClangVarDecl_getSectionAttribute(self: *const ZigClangVarDecl, len: *usize) ?[*]const u8;
805pub extern fn ZigClangFunctionDecl_getAlignedAttribute(self: *const ZigClangFunctionDecl, *const ZigClangASTContext) c_uint;
806pub extern fn ZigClangVarDecl_getAlignedAttribute(self: *const ZigClangVarDecl, *const ZigClangASTContext) c_uint;
807pub extern fn ZigClangRecordDecl_getPackedAttribute(self: ?*const struct_ZigClangRecordDecl) bool;
808pub extern fn ZigClangRecordDecl_getDefinition(self: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangRecordDecl;
809pub extern fn ZigClangEnumDecl_getDefinition(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangEnumDecl;
810pub extern fn ZigClangRecordDecl_getLocation(self: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation;
811pub extern fn ZigClangEnumDecl_getLocation(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation;
812pub extern fn ZigClangTypedefNameDecl_getLocation(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation;
813pub extern fn ZigClangDecl_getLocation(self: *const ZigClangDecl) ZigClangSourceLocation;
814pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
815pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool;
816pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
817pub extern fn ZigClangRecordDecl_field_begin(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator;
818pub extern fn ZigClangRecordDecl_field_end(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator;
819pub extern fn ZigClangRecordDecl_field_iterator_next(ZigClangRecordDecl_field_iterator) ZigClangRecordDecl_field_iterator;
820pub extern fn ZigClangRecordDecl_field_iterator_deref(ZigClangRecordDecl_field_iterator) *const struct_ZigClangFieldDecl;
821pub extern fn ZigClangRecordDecl_field_iterator_neq(ZigClangRecordDecl_field_iterator, ZigClangRecordDecl_field_iterator) bool;
822pub extern fn ZigClangEnumDecl_getIntegerType(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType;
823pub extern fn ZigClangEnumDecl_enumerator_begin(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator;
824pub extern fn ZigClangEnumDecl_enumerator_end(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator;
825pub extern fn ZigClangEnumDecl_enumerator_iterator_next(ZigClangEnumDecl_enumerator_iterator) ZigClangEnumDecl_enumerator_iterator;
826pub extern fn ZigClangEnumDecl_enumerator_iterator_deref(ZigClangEnumDecl_enumerator_iterator) *const ZigClangEnumConstantDecl;
827pub extern fn ZigClangEnumDecl_enumerator_iterator_neq(ZigClangEnumDecl_enumerator_iterator, ZigClangEnumDecl_enumerator_iterator) bool;
828pub extern fn ZigClangDecl_castToNamedDecl(decl: *const ZigClangDecl) ?*const ZigClangNamedDecl;
829pub extern fn ZigClangNamedDecl_getName_bytes_begin(decl: ?*const struct_ZigClangNamedDecl) [*:0]const u8;
830pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool;
831pub extern fn ZigClangTypedefType_getDecl(self: ?*const struct_ZigClangTypedefType) *const struct_ZigClangTypedefNameDecl;
832pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType;
833pub extern fn ZigClangQualType_getCanonicalType(self: struct_ZigClangQualType) struct_ZigClangQualType;
834pub extern fn ZigClangQualType_getTypeClass(self: struct_ZigClangQualType) ZigClangTypeClass;
835pub extern fn ZigClangQualType_getTypePtr(self: struct_ZigClangQualType) *const struct_ZigClangType;
836pub extern fn ZigClangQualType_addConst(self: *struct_ZigClangQualType) void;
837pub extern fn ZigClangQualType_eq(self: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool;
838pub extern fn ZigClangQualType_isConstQualified(self: struct_ZigClangQualType) bool;
839pub extern fn ZigClangQualType_isVolatileQualified(self: struct_ZigClangQualType) bool;
840pub extern fn ZigClangQualType_isRestrictQualified(self: struct_ZigClangQualType) bool;
841pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass;
842pub extern fn ZigClangType_getPointeeType(self: ?*const struct_ZigClangType) struct_ZigClangQualType;
843pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool;
844pub extern fn ZigClangType_isConstantArrayType(self: ?*const struct_ZigClangType) bool;
845pub extern fn ZigClangType_isRecordType(self: ?*const struct_ZigClangType) bool;
846pub extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(self: ?*const struct_ZigClangType, *const ZigClangASTContext) bool;
847pub extern fn ZigClangType_isArrayType(self: ?*const struct_ZigClangType) bool;
848pub extern fn ZigClangType_isBooleanType(self: ?*const struct_ZigClangType) bool;
849pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*:0]const u8;
850pub extern fn ZigClangType_getAsArrayTypeUnsafe(self: *const ZigClangType) *const ZigClangArrayType;
851pub extern fn ZigClangType_getAsRecordType(self: *const ZigClangType) ?*const ZigClangRecordType;
852pub extern fn ZigClangType_getAsUnionType(self: *const ZigClangType) ?*const ZigClangRecordType;
853pub extern fn ZigClangStmt_getBeginLoc(self: *const ZigClangStmt) struct_ZigClangSourceLocation;
854pub extern fn ZigClangStmt_getStmtClass(self: ?*const ZigClangStmt) ZigClangStmtClass;
855pub extern fn ZigClangStmt_classof_Expr(self: ?*const ZigClangStmt) bool;
856pub extern fn ZigClangExpr_getStmtClass(self: *const struct_ZigClangExpr) ZigClangStmtClass;
857pub extern fn ZigClangExpr_getType(self: *const struct_ZigClangExpr) struct_ZigClangQualType;
858pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation;
859pub extern fn ZigClangInitListExpr_getInit(self: ?*const struct_ZigClangInitListExpr, i: c_uint) *const ZigClangExpr;
860pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?*const struct_ZigClangInitListExpr) *const ZigClangExpr;
861pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint;
862pub extern fn ZigClangInitListExpr_getInitializedFieldInUnion(self: ?*const struct_ZigClangInitListExpr) ?*ZigClangFieldDecl;
863pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind;
864pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) *const struct_ZigClangAPSInt;
865pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
866pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
867pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
868pub extern fn ZigClangAPSInt_isSigned(self: *const struct_ZigClangAPSInt) bool;
869pub extern fn ZigClangAPSInt_isNegative(self: *const struct_ZigClangAPSInt) bool;
870pub extern fn ZigClangAPSInt_negate(self: *const struct_ZigClangAPSInt) *const struct_ZigClangAPSInt;
871pub extern fn ZigClangAPSInt_free(self: *const struct_ZigClangAPSInt) void;
872pub extern fn ZigClangAPSInt_getRawData(self: *const struct_ZigClangAPSInt) [*:0]const u64;
873pub extern fn ZigClangAPSInt_getNumWords(self: *const struct_ZigClangAPSInt) c_uint;
874
875pub extern fn ZigClangAPInt_getLimitedValue(self: *const struct_ZigClangAPInt, limit: u64) u64;
876pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr;
877pub extern fn ZigClangASTUnit_delete(self: ?*struct_ZigClangASTUnit) void;
878
879pub extern fn ZigClangFunctionDecl_getType(self: *const ZigClangFunctionDecl) struct_ZigClangQualType;
880pub extern fn ZigClangFunctionDecl_getLocation(self: *const ZigClangFunctionDecl) struct_ZigClangSourceLocation;
881pub extern fn ZigClangFunctionDecl_hasBody(self: *const ZigClangFunctionDecl) bool;
882pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const ZigClangFunctionDecl) ZigClangStorageClass;
883pub extern fn ZigClangFunctionDecl_getParamDecl(self: *const ZigClangFunctionDecl, i: c_uint) *const struct_ZigClangParmVarDecl;
884pub extern fn ZigClangFunctionDecl_getBody(self: *const ZigClangFunctionDecl) *const ZigClangStmt;
885pub extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(self: *const ZigClangFunctionDecl) bool;
886pub extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(self: *const ZigClangFunctionDecl) bool;
887pub extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(self: *const ZigClangFunctionDecl) bool;
888pub extern fn ZigClangFunctionDecl_isInlineSpecified(self: *const ZigClangFunctionDecl) bool;
889pub extern fn ZigClangFunctionDecl_isDefined(self: *const ZigClangFunctionDecl) bool;
890pub extern fn ZigClangFunctionDecl_getDefinition(self: *const ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl;
891pub extern fn ZigClangFunctionDecl_getSectionAttribute(self: *const ZigClangFunctionDecl, len: *usize) ?[*]const u8;
892
893pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind;
894
895pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool;
896pub extern fn ZigClangFunctionType_getCallConv(self: *const ZigClangFunctionType) ZigClangCallingConv;
897pub extern fn ZigClangFunctionType_getReturnType(self: *const ZigClangFunctionType) ZigClangQualType;
898
899pub extern fn ZigClangFunctionProtoType_isVariadic(self: *const struct_ZigClangFunctionProtoType) bool;
900pub extern fn ZigClangFunctionProtoType_getNumParams(self: *const struct_ZigClangFunctionProtoType) c_uint;
901pub extern fn ZigClangFunctionProtoType_getParamType(self: *const struct_ZigClangFunctionProtoType, i: c_uint) ZigClangQualType;
902pub extern fn ZigClangFunctionProtoType_getReturnType(self: *const ZigClangFunctionProtoType) ZigClangQualType;
903
904pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
905pub const ZigClangQualType = struct_ZigClangQualType;
906pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator;
907pub const ZigClangBinaryConditionalOperator = struct_ZigClangBinaryConditionalOperator;
908pub const ZigClangAbstractConditionalOperator = struct_ZigClangAbstractConditionalOperator;
909pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase;
910pub const ZigClangAPValue = struct_ZigClangAPValue;
911pub const ZigClangAPSInt = struct_ZigClangAPSInt;
912pub const ZigClangAPFloat = struct_ZigClangAPFloat;
913pub const ZigClangASTContext = struct_ZigClangASTContext;
914pub const ZigClangASTUnit = struct_ZigClangASTUnit;
915pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr;
916pub const ZigClangArrayType = struct_ZigClangArrayType;
917pub const ZigClangAttributedType = struct_ZigClangAttributedType;
918pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator;
919pub const ZigClangBreakStmt = struct_ZigClangBreakStmt;
920pub const ZigClangBuiltinType = struct_ZigClangBuiltinType;
921pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr;
922pub const ZigClangCallExpr = struct_ZigClangCallExpr;
923pub const ZigClangCaseStmt = struct_ZigClangCaseStmt;
924pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator;
925pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt;
926pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType;
927pub const ZigClangContinueStmt = struct_ZigClangContinueStmt;
928pub const ZigClangDecayedType = struct_ZigClangDecayedType;
929pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr;
930pub const ZigClangDeclStmt = struct_ZigClangDeclStmt;
931pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt;
932pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions;
933pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine;
934pub const ZigClangDoStmt = struct_ZigClangDoStmt;
935pub const ZigClangElaboratedType = struct_ZigClangElaboratedType;
936pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl;
937pub const ZigClangEnumDecl = struct_ZigClangEnumDecl;
938pub const ZigClangEnumType = struct_ZigClangEnumType;
939pub const ZigClangExpr = struct_ZigClangExpr;
940pub const ZigClangFieldDecl = struct_ZigClangFieldDecl;
941pub const ZigClangFileID = struct_ZigClangFileID;
942pub const ZigClangForStmt = struct_ZigClangForStmt;
943pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc;
944pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl;
945pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType;
946pub const ZigClangIfStmt = struct_ZigClangIfStmt;
947pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
948pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
949pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
950pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
951pub const ZigClangMacroExpansion = struct_ZigClangMacroExpansion;
952pub const ZigClangMacroQualifiedType = struct_ZigClangMacroQualifiedType;
953pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
954pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
955pub const ZigClangNone = struct_ZigClangNone;
956pub const ZigClangOpaqueValueExpr = struct_ZigClangOpaqueValueExpr;
957pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations;
958pub const ZigClangParenExpr = struct_ZigClangParenExpr;
959pub const ZigClangParenType = struct_ZigClangParenType;
960pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl;
961pub const ZigClangPointerType = struct_ZigClangPointerType;
962pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity;
963pub const ZigClangRecordDecl = struct_ZigClangRecordDecl;
964pub const ZigClangRecordType = struct_ZigClangRecordType;
965pub const ZigClangReturnStmt = struct_ZigClangReturnStmt;
966pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope;
967pub const ZigClangSourceManager = struct_ZigClangSourceManager;
968pub const ZigClangSourceRange = struct_ZigClangSourceRange;
969pub const ZigClangStringLiteral = struct_ZigClangStringLiteral;
970pub const ZigClangStringRef = struct_ZigClangStringRef;
971pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt;
972pub const ZigClangTagDecl = struct_ZigClangTagDecl;
973pub const ZigClangType = struct_ZigClangType;
974pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl;
975pub const ZigClangTypedefType = struct_ZigClangTypedefType;
976pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr;
977pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
978pub const ZigClangValueDecl = struct_ZigClangValueDecl;
979pub const ZigClangVarDecl = struct_ZigClangVarDecl;
980pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
981pub const ZigClangFunctionType = struct_ZigClangFunctionType;
982pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr;
983pub const ZigClangInitListExpr = struct_ZigClangInitListExpr;
984
985pub const struct_ZigClangSourceLocation = extern struct {
986 ID: c_uint,
987};
988
9891580pub const Stage2ErrorMsg = extern struct {
9901581 filename_ptr: ?[*]const u8,
9911582 filename_len: usize,
......@@ -999,199 +1590,16 @@ pub const Stage2ErrorMsg = extern struct {
9991590 column: c_uint,
10001591 // byte offset into source
10011592 offset: c_uint,
1002};
10031593
1004pub const struct_ZigClangQualType = extern struct {
1005 ptr: ?*c_void,
1594 pub const delete = ZigClangErrorMsg_delete;
1595 extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
10061596};
10071597
1008pub const struct_ZigClangAPValueLValueBase = extern struct {
1009 Ptr: ?*c_void,
1010 CallIndex: c_uint,
1011 Version: c_uint,
1012};
1013
1014pub extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
1015
1016pub extern fn ZigClangLoadFromCommandLine(
1598pub const LoadFromCommandLine = ZigClangLoadFromCommandLine;
1599extern fn ZigClangLoadFromCommandLine(
10171600 args_begin: [*]?[*]const u8,
10181601 args_end: [*]?[*]const u8,
10191602 errors_ptr: *[*]Stage2ErrorMsg,
10201603 errors_len: *usize,
10211604 resources_path: [*:0]const u8,
1022) ?*ZigClangASTUnit;
1023
1024pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind;
1025pub extern fn ZigClangDecl_getDeclKindName(decl: *const ZigClangDecl) [*:0]const u8;
1026
1027pub const ZigClangCompoundStmt_const_body_iterator = [*]const *ZigClangStmt;
1028
1029pub extern fn ZigClangCompoundStmt_body_begin(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator;
1030pub extern fn ZigClangCompoundStmt_body_end(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator;
1031
1032pub const ZigClangDeclStmt_const_decl_iterator = [*]const *ZigClangDecl;
1033
1034pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
1035pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
1036
1037pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation;
1038pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool;
1039pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass;
1040pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType;
1041pub extern fn ZigClangVarDecl_getInit(*const ZigClangVarDecl) ?*const ZigClangExpr;
1042pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind;
1043pub const ZigClangVarDecl_TLSKind = extern enum {
1044 None,
1045 Static,
1046 Dynamic,
1047};
1048
1049pub extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ZigClangImplicitCastExpr) ZigClangSourceLocation;
1050pub extern fn ZigClangImplicitCastExpr_getCastKind(*const ZigClangImplicitCastExpr) ZigClangCK;
1051pub extern fn ZigClangImplicitCastExpr_getSubExpr(*const ZigClangImplicitCastExpr) *const ZigClangExpr;
1052
1053pub extern fn ZigClangArrayType_getElementType(*const ZigClangArrayType) ZigClangQualType;
1054pub extern fn ZigClangIncompleteArrayType_getElementType(*const ZigClangIncompleteArrayType) ZigClangQualType;
1055
1056pub extern fn ZigClangConstantArrayType_getElementType(self: *const struct_ZigClangConstantArrayType) ZigClangQualType;
1057pub extern fn ZigClangConstantArrayType_getSize(self: *const struct_ZigClangConstantArrayType) *const struct_ZigClangAPInt;
1058pub extern fn ZigClangDeclRefExpr_getDecl(*const ZigClangDeclRefExpr) *const ZigClangValueDecl;
1059pub extern fn ZigClangDeclRefExpr_getFoundDecl(*const ZigClangDeclRefExpr) *const ZigClangNamedDecl;
1060
1061pub extern fn ZigClangParenType_getInnerType(*const ZigClangParenType) ZigClangQualType;
1062
1063pub extern fn ZigClangElaboratedType_getNamedType(*const ZigClangElaboratedType) ZigClangQualType;
1064
1065pub extern fn ZigClangAttributedType_getEquivalentType(*const ZigClangAttributedType) ZigClangQualType;
1066
1067pub extern fn ZigClangMacroQualifiedType_getModifiedType(*const ZigClangMacroQualifiedType) ZigClangQualType;
1068
1069pub extern fn ZigClangCStyleCastExpr_getBeginLoc(*const ZigClangCStyleCastExpr) ZigClangSourceLocation;
1070pub extern fn ZigClangCStyleCastExpr_getSubExpr(*const ZigClangCStyleCastExpr) *const ZigClangExpr;
1071pub extern fn ZigClangCStyleCastExpr_getType(*const ZigClangCStyleCastExpr) ZigClangQualType;
1072
1073pub const ZigClangExprEvalResult = struct_ZigClangExprEvalResult;
1074pub const struct_ZigClangExprEvalResult = extern struct {
1075 HasSideEffects: bool,
1076 HasUndefinedBehavior: bool,
1077 SmallVectorImpl: ?*c_void,
1078 Val: ZigClangAPValue,
1079};
1080
1081pub const struct_ZigClangAPValue = extern struct {
1082 Kind: ZigClangAPValueKind,
1083 Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
1084};
1085pub extern fn ZigClangVarDecl_getTypeSourceInfo_getType(self: *const struct_ZigClangVarDecl) struct_ZigClangQualType;
1086
1087pub extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const ZigClangIntegerLiteral, *ZigClangExprEvalResult, *const ZigClangASTContext) bool;
1088pub extern fn ZigClangIntegerLiteral_getBeginLoc(*const ZigClangIntegerLiteral) ZigClangSourceLocation;
1089pub extern fn ZigClangIntegerLiteral_isZero(*const ZigClangIntegerLiteral, *bool, *const ZigClangASTContext) bool;
1090
1091pub extern fn ZigClangReturnStmt_getRetValue(*const ZigClangReturnStmt) ?*const ZigClangExpr;
1092
1093pub extern fn ZigClangBinaryOperator_getOpcode(*const ZigClangBinaryOperator) ZigClangBO;
1094pub extern fn ZigClangBinaryOperator_getBeginLoc(*const ZigClangBinaryOperator) ZigClangSourceLocation;
1095pub extern fn ZigClangBinaryOperator_getLHS(*const ZigClangBinaryOperator) *const ZigClangExpr;
1096pub extern fn ZigClangBinaryOperator_getRHS(*const ZigClangBinaryOperator) *const ZigClangExpr;
1097pub extern fn ZigClangBinaryOperator_getType(*const ZigClangBinaryOperator) ZigClangQualType;
1098
1099pub extern fn ZigClangDecayedType_getDecayedType(*const ZigClangDecayedType) ZigClangQualType;
1100
1101pub extern fn ZigClangStringLiteral_getKind(*const ZigClangStringLiteral) ZigClangStringLiteral_StringKind;
1102pub extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const ZigClangStringLiteral, *usize) [*]const u8;
1103
1104pub extern fn ZigClangParenExpr_getSubExpr(*const ZigClangParenExpr) *const ZigClangExpr;
1105
1106pub extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const struct_ZigClangFieldDecl) bool;
1107pub extern fn ZigClangFieldDecl_isBitField(*const struct_ZigClangFieldDecl) bool;
1108pub extern fn ZigClangFieldDecl_getType(*const struct_ZigClangFieldDecl) struct_ZigClangQualType;
1109pub extern fn ZigClangFieldDecl_getLocation(*const struct_ZigClangFieldDecl) struct_ZigClangSourceLocation;
1110
1111pub extern fn ZigClangEnumConstantDecl_getInitExpr(*const ZigClangEnumConstantDecl) ?*const ZigClangExpr;
1112pub extern fn ZigClangEnumConstantDecl_getInitVal(*const ZigClangEnumConstantDecl) *const ZigClangAPSInt;
1113
1114pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator;
1115pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator;
1116pub extern fn ZigClangPreprocessingRecord_iterator_deref(ZigClangPreprocessingRecord_iterator) *ZigClangPreprocessedEntity;
1117pub extern fn ZigClangPreprocessedEntity_getKind(*const ZigClangPreprocessedEntity) ZigClangPreprocessedEntity_EntityKind;
1118
1119pub extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const ZigClangMacroDefinitionRecord) [*:0]const u8;
1120pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
1121pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
1122
1123pub extern fn ZigClangMacroExpansion_getDefinition(*const ZigClangMacroExpansion) *const ZigClangMacroDefinitionRecord;
1124
1125pub extern fn ZigClangIfStmt_getThen(*const ZigClangIfStmt) *const ZigClangStmt;
1126pub extern fn ZigClangIfStmt_getElse(*const ZigClangIfStmt) ?*const ZigClangStmt;
1127pub extern fn ZigClangIfStmt_getCond(*const ZigClangIfStmt) *const ZigClangStmt;
1128
1129pub extern fn ZigClangWhileStmt_getCond(*const ZigClangWhileStmt) *const ZigClangExpr;
1130pub extern fn ZigClangWhileStmt_getBody(*const ZigClangWhileStmt) *const ZigClangStmt;
1131
1132pub extern fn ZigClangDoStmt_getCond(*const ZigClangDoStmt) *const ZigClangExpr;
1133pub extern fn ZigClangDoStmt_getBody(*const ZigClangDoStmt) *const ZigClangStmt;
1134
1135pub extern fn ZigClangForStmt_getInit(*const ZigClangForStmt) ?*const ZigClangStmt;
1136pub extern fn ZigClangForStmt_getCond(*const ZigClangForStmt) ?*const ZigClangExpr;
1137pub extern fn ZigClangForStmt_getInc(*const ZigClangForStmt) ?*const ZigClangExpr;
1138pub extern fn ZigClangForStmt_getBody(*const ZigClangForStmt) *const ZigClangStmt;
1139
1140pub extern fn ZigClangAPFloat_toString(self: *const ZigClangAPFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8;
1141pub extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const ZigClangFloatingLiteral) f64;
1142
1143pub extern fn ZigClangAbstractConditionalOperator_getCond(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr;
1144pub extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr;
1145pub extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr;
1146
1147pub extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const ZigClangSwitchStmt) ?*const ZigClangDeclStmt;
1148pub extern fn ZigClangSwitchStmt_getCond(*const ZigClangSwitchStmt) *const ZigClangExpr;
1149pub extern fn ZigClangSwitchStmt_getBody(*const ZigClangSwitchStmt) *const ZigClangStmt;
1150pub extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const ZigClangSwitchStmt) bool;
1151
1152pub extern fn ZigClangCaseStmt_getLHS(*const ZigClangCaseStmt) *const ZigClangExpr;
1153pub extern fn ZigClangCaseStmt_getRHS(*const ZigClangCaseStmt) ?*const ZigClangExpr;
1154pub extern fn ZigClangCaseStmt_getBeginLoc(*const ZigClangCaseStmt) ZigClangSourceLocation;
1155pub extern fn ZigClangCaseStmt_getSubStmt(*const ZigClangCaseStmt) *const ZigClangStmt;
1156
1157pub extern fn ZigClangDefaultStmt_getSubStmt(*const ZigClangDefaultStmt) *const ZigClangStmt;
1158
1159pub extern fn ZigClangExpr_EvaluateAsConstantExpr(*const ZigClangExpr, *ZigClangExprEvalResult, ZigClangExpr_ConstExprUsage, *const ZigClangASTContext) bool;
1160
1161pub extern fn ZigClangPredefinedExpr_getFunctionName(*const ZigClangPredefinedExpr) *const ZigClangStringLiteral;
1162
1163pub extern fn ZigClangCharacterLiteral_getBeginLoc(*const ZigClangCharacterLiteral) ZigClangSourceLocation;
1164pub extern fn ZigClangCharacterLiteral_getKind(*const ZigClangCharacterLiteral) ZigClangCharacterLiteral_CharacterKind;
1165pub extern fn ZigClangCharacterLiteral_getValue(*const ZigClangCharacterLiteral) c_uint;
1166
1167pub extern fn ZigClangStmtExpr_getSubStmt(*const ZigClangStmtExpr) *const ZigClangCompoundStmt;
1168
1169pub extern fn ZigClangMemberExpr_getBase(*const ZigClangMemberExpr) *const ZigClangExpr;
1170pub extern fn ZigClangMemberExpr_isArrow(*const ZigClangMemberExpr) bool;
1171pub extern fn ZigClangMemberExpr_getMemberDecl(*const ZigClangMemberExpr) *const ZigClangValueDecl;
1172
1173pub extern fn ZigClangArraySubscriptExpr_getBase(*const ZigClangArraySubscriptExpr) *const ZigClangExpr;
1174pub extern fn ZigClangArraySubscriptExpr_getIdx(*const ZigClangArraySubscriptExpr) *const ZigClangExpr;
1175
1176pub extern fn ZigClangCallExpr_getCallee(*const ZigClangCallExpr) *const ZigClangExpr;
1177pub extern fn ZigClangCallExpr_getNumArgs(*const ZigClangCallExpr) c_uint;
1178pub extern fn ZigClangCallExpr_getArgs(*const ZigClangCallExpr) [*]const *const ZigClangExpr;
1179
1180pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangQualType;
1181pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangSourceLocation;
1182pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangUnaryExprOrTypeTrait_Kind;
1183
1184pub extern fn ZigClangUnaryOperator_getOpcode(*const ZigClangUnaryOperator) ZigClangUO;
1185pub extern fn ZigClangUnaryOperator_getType(*const ZigClangUnaryOperator) ZigClangQualType;
1186pub extern fn ZigClangUnaryOperator_getSubExpr(*const ZigClangUnaryOperator) *const ZigClangExpr;
1187pub extern fn ZigClangUnaryOperator_getBeginLoc(*const ZigClangUnaryOperator) ZigClangSourceLocation;
1188
1189pub extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const ZigClangOpaqueValueExpr) ?*const ZigClangExpr;
1190
1191pub extern fn ZigClangCompoundAssignOperator_getType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1192pub extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1193pub extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1194pub extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const ZigClangCompoundAssignOperator) ZigClangSourceLocation;
1195pub extern fn ZigClangCompoundAssignOperator_getOpcode(*const ZigClangCompoundAssignOperator) ZigClangBO;
1196pub extern fn ZigClangCompoundAssignOperator_getLHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr;
1197pub extern fn ZigClangCompoundAssignOperator_getRHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr;
1605) ?*ASTUnit;
src/translate_c.zig+662-670
......@@ -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 {
932 const record_def = record_decl.getDefinition() orelse {
933933 const opaque_type = try transCreateNodeOpaqueType(c);
934934 semicolon = try appendToken(c, .Semicolon, ";");
935935 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,21 +946,21 @@ 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)) {
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()) {
957957 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});
960960 break :blk opaque_type;
961961 }
962962
963 if (ZigClangType_isIncompleteOrZeroLengthArrayType(qualTypeCanon(field_qt), c.clang_context)) {
963 if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) {
964964 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});
......@@ -968,8 +968,8 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
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;
......@@ -988,7 +988,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
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;
......@@ -4697,23 +4689,23 @@ fn transCreateNodeSwitchElse(c: *Context) !*ast.Node {
46974689fn transCreateNodeShiftOp(
46984690 rp: RestorePoint,
46994691 scope: *Scope,
4700 stmt: *const ZigClangBinaryOperator,
4692 stmt: *const clang.BinaryOperator,
47014693 op: ast.Node.Tag,
47024694 op_tok_id: std.zig.Token.Id,
47034695 bytes: []const u8,
47044696) !*ast.Node {
47054697 std.debug.assert(op == .BitShiftLeft or op == .BitShiftRight);
47064698
4707 const lhs_expr = ZigClangBinaryOperator_getLHS(stmt);
4708 const rhs_expr = ZigClangBinaryOperator_getRHS(stmt);
4709 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();
47104702 // lhs >> @as(u5, rh)
47114703
47124704 const lhs = try transExpr(rp, scope, lhs_expr, .used, .l_value);
47134705 const op_token = try appendToken(rp.c, op_tok_id, bytes);
47144706
47154707 const cast_node = try rp.c.createBuiltinCall("@intCast", 2);
4716 const rhs_type = try qualTypeToLog2IntRef(rp, ZigClangBinaryOperator_getType(stmt), rhs_location);
4708 const rhs_type = try qualTypeToLog2IntRef(rp, stmt.getType(), rhs_location);
47174709 cast_node.params()[0] = rhs_type;
47184710 _ = try appendToken(rp.c, .Comma, ",");
47194711 const rhs = try transExprCoercing(rp, scope, rhs_expr, .used, .r_value);
......@@ -4772,11 +4764,11 @@ fn makeRestorePoint(c: *Context) RestorePoint {
47724764 };
47734765}
47744766
4775fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node {
4776 switch (ZigClangType_getTypeClass(ty)) {
4767fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!*ast.Node {
4768 switch (ty.getTypeClass()) {
47774769 .Builtin => {
4778 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
4779 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()) {
47804772 .Void => "c_void",
47814773 .Bool => "bool",
47824774 .Char_U, .UChar, .Char_S, .Char8 => "u8",
......@@ -4800,32 +4792,32 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
48004792 });
48014793 },
48024794 .FunctionProto => {
4803 const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty);
4795 const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty);
48044796 const fn_proto = try transFnProto(rp, null, fn_proto_ty, source_loc, null, false);
48054797 return &fn_proto.base;
48064798 },
48074799 .FunctionNoProto => {
4808 const fn_no_proto_ty = @ptrCast(*const ZigClangFunctionType, ty);
4800 const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty);
48094801 const fn_proto = try transFnNoProto(rp, fn_no_proto_ty, source_loc, null, false);
48104802 return &fn_proto.base;
48114803 },
48124804 .Paren => {
4813 const paren_ty = @ptrCast(*const ZigClangParenType, ty);
4814 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);
48154807 },
48164808 .Pointer => {
4817 const child_qt = ZigClangType_getPointeeType(ty);
4809 const child_qt = ty.getPointeeType();
48184810 if (qualTypeChildIsFnProto(child_qt)) {
48194811 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
48204812 optional_node.rhs = try transQualType(rp, child_qt, source_loc);
48214813 return &optional_node.base;
48224814 }
4823 if (typeIsOpaque(rp.c, ZigClangQualType_getTypePtr(child_qt), source_loc)) {
4815 if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc)) {
48244816 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
48254817 const pointer_node = try transCreateNodePtrType(
48264818 rp.c,
4827 ZigClangQualType_isConstQualified(child_qt),
4828 ZigClangQualType_isVolatileQualified(child_qt),
4819 child_qt.isConstQualified(),
4820 child_qt.isVolatileQualified(),
48294821 .Asterisk,
48304822 );
48314823 optional_node.rhs = &pointer_node.base;
......@@ -4834,83 +4826,83 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
48344826 }
48354827 const pointer_node = try transCreateNodePtrType(
48364828 rp.c,
4837 ZigClangQualType_isConstQualified(child_qt),
4838 ZigClangQualType_isVolatileQualified(child_qt),
4829 child_qt.isConstQualified(),
4830 child_qt.isVolatileQualified(),
48394831 .Identifier,
48404832 );
48414833 pointer_node.rhs = try transQualType(rp, child_qt, source_loc);
48424834 return &pointer_node.base;
48434835 },
48444836 .ConstantArray => {
4845 const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, ty);
4837 const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty);
48464838
4847 const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty);
4848 const size = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
4849 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();
48504842 return try transCreateNodeArrayType(rp, source_loc, elem_ty, size);
48514843 },
48524844 .IncompleteArray => {
4853 const incomplete_array_ty = @ptrCast(*const ZigClangIncompleteArrayType, ty);
4845 const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty);
48544846
4855 const child_qt = ZigClangIncompleteArrayType_getElementType(incomplete_array_ty);
4847 const child_qt = incomplete_array_ty.getElementType();
48564848 var node = try transCreateNodePtrType(
48574849 rp.c,
4858 ZigClangQualType_isConstQualified(child_qt),
4859 ZigClangQualType_isVolatileQualified(child_qt),
4850 child_qt.isConstQualified(),
4851 child_qt.isVolatileQualified(),
48604852 .Identifier,
48614853 );
48624854 node.rhs = try transQualType(rp, child_qt, source_loc);
48634855 return &node.base;
48644856 },
48654857 .Typedef => {
4866 const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
4858 const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
48674859
4868 const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
4860 const typedef_decl = typedef_ty.getDecl();
48694861 return (try transTypeDef(rp.c, typedef_decl, false)) orelse
48704862 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate typedef declaration", .{});
48714863 },
48724864 .Record => {
4873 const record_ty = @ptrCast(*const ZigClangRecordType, ty);
4865 const record_ty = @ptrCast(*const clang.RecordType, ty);
48744866
4875 const record_decl = ZigClangRecordType_getDecl(record_ty);
4867 const record_decl = record_ty.getDecl();
48764868 return (try transRecordDecl(rp.c, record_decl)) orelse
48774869 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to resolve record declaration", .{});
48784870 },
48794871 .Enum => {
4880 const enum_ty = @ptrCast(*const ZigClangEnumType, ty);
4872 const enum_ty = @ptrCast(*const clang.EnumType, ty);
48814873
4882 const enum_decl = ZigClangEnumType_getDecl(enum_ty);
4874 const enum_decl = enum_ty.getDecl();
48834875 return (try transEnumDecl(rp.c, enum_decl)) orelse
48844876 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate enum declaration", .{});
48854877 },
48864878 .Elaborated => {
4887 const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
4888 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);
48894881 },
48904882 .Decayed => {
4891 const decayed_ty = @ptrCast(*const ZigClangDecayedType, ty);
4892 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);
48934885 },
48944886 .Attributed => {
4895 const attributed_ty = @ptrCast(*const ZigClangAttributedType, ty);
4896 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);
48974889 },
48984890 .MacroQualified => {
4899 const macroqualified_ty = @ptrCast(*const ZigClangMacroQualifiedType, ty);
4900 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);
49014893 },
49024894 else => {
4903 const type_name = rp.c.str(ZigClangType_getTypeClassName(ty));
4895 const type_name = rp.c.str(ty.getTypeClassName());
49044896 return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", .{type_name});
49054897 },
49064898 }
49074899}
49084900
4909fn isCVoid(qt: ZigClangQualType) bool {
4910 const ty = ZigClangQualType_getTypePtr(qt);
4911 if (ZigClangType_getTypeClass(ty) == .Builtin) {
4912 const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
4913 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;
49144906 }
49154907 return false;
49164908}
......@@ -4918,16 +4910,16 @@ fn isCVoid(qt: ZigClangQualType) bool {
49184910const FnDeclContext = struct {
49194911 fn_name: []const u8,
49204912 has_body: bool,
4921 storage_class: ZigClangStorageClass,
4913 storage_class: clang.StorageClass,
49224914 is_export: bool,
49234915};
49244916
49254917fn transCC(
49264918 rp: RestorePoint,
4927 fn_ty: *const ZigClangFunctionType,
4928 source_loc: ZigClangSourceLocation,
4919 fn_ty: *const clang.FunctionType,
4920 source_loc: clang.SourceLocation,
49294921) !CallingConvention {
4930 const clang_cc = ZigClangFunctionType_getCallConv(fn_ty);
4922 const clang_cc = fn_ty.getCallConv();
49314923 switch (clang_cc) {
49324924 .C => return CallingConvention.C,
49334925 .X86StdCall => return CallingConvention.Stdcall,
......@@ -4948,22 +4940,22 @@ fn transCC(
49484940
49494941fn transFnProto(
49504942 rp: RestorePoint,
4951 fn_decl: ?*const ZigClangFunctionDecl,
4952 fn_proto_ty: *const ZigClangFunctionProtoType,
4953 source_loc: ZigClangSourceLocation,
4943 fn_decl: ?*const clang.FunctionDecl,
4944 fn_proto_ty: *const clang.FunctionProtoType,
4945 source_loc: clang.SourceLocation,
49544946 fn_decl_context: ?FnDeclContext,
49554947 is_pub: bool,
49564948) !*ast.Node.FnProto {
4957 const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty);
4949 const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty);
49584950 const cc = try transCC(rp, fn_ty, source_loc);
4959 const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty);
4951 const is_var_args = fn_proto_ty.isVariadic();
49604952 return finishTransFnProto(rp, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub);
49614953}
49624954
49634955fn transFnNoProto(
49644956 rp: RestorePoint,
4965 fn_ty: *const ZigClangFunctionType,
4966 source_loc: ZigClangSourceLocation,
4957 fn_ty: *const clang.FunctionType,
4958 source_loc: clang.SourceLocation,
49674959 fn_decl_context: ?FnDeclContext,
49684960 is_pub: bool,
49694961) !*ast.Node.FnProto {
......@@ -4974,10 +4966,10 @@ fn transFnNoProto(
49744966
49754967fn finishTransFnProto(
49764968 rp: RestorePoint,
4977 fn_decl: ?*const ZigClangFunctionDecl,
4978 fn_proto_ty: ?*const ZigClangFunctionProtoType,
4979 fn_ty: *const ZigClangFunctionType,
4980 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,
49814973 fn_decl_context: ?FnDeclContext,
49824974 is_var_args: bool,
49834975 cc: CallingConvention,
......@@ -5003,19 +4995,19 @@ fn finishTransFnProto(
50034995
50044996 var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(rp.c.gpa);
50054997 defer fn_params.deinit();
5006 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;
50074999 try fn_params.ensureCapacity(param_count + 1); // +1 for possible var args node
50085000
50095001 var i: usize = 0;
50105002 while (i < param_count) : (i += 1) {
5011 const param_qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty.?, @intCast(c_uint, i));
5003 const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i));
50125004
5013 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;
50145006
50155007 const param_name_tok: ?ast.TokenIndex = blk: {
50165008 if (fn_decl) |decl| {
5017 const param = ZigClangFunctionDecl_getParamDecl(decl, @intCast(c_uint, i));
5018 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());
50195011 if (param_name.len < 1)
50205012 break :blk null;
50215013
......@@ -5053,7 +5045,7 @@ fn finishTransFnProto(
50535045 const linksection_expr = blk: {
50545046 if (fn_decl) |decl| {
50555047 var str_len: usize = undefined;
5056 if (ZigClangFunctionDecl_getSectionAttribute(decl, &str_len)) |str_ptr| {
5048 if (decl.getSectionAttribute(&str_len)) |str_ptr| {
50575049 _ = try appendToken(rp.c, .Keyword_linksection, "linksection");
50585050 _ = try appendToken(rp.c, .LParen, "(");
50595051 const expr = try transCreateNodeStringLiteral(
......@@ -5070,7 +5062,7 @@ fn finishTransFnProto(
50705062
50715063 const align_expr = blk: {
50725064 if (fn_decl) |decl| {
5073 const alignment = ZigClangFunctionDecl_getAlignedAttribute(decl, rp.c.clang_context);
5065 const alignment = decl.getAlignedAttribute(rp.c.clang_context);
50745066 if (alignment != 0) {
50755067 _ = try appendToken(rp.c, .Keyword_align, "align");
50765068 _ = try appendToken(rp.c, .LParen, "(");
......@@ -5093,10 +5085,10 @@ fn finishTransFnProto(
50935085 };
50945086
50955087 const return_type_node = blk: {
5096 if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) {
5088 if (fn_ty.getNoReturnAttr()) {
50975089 break :blk try transCreateNodeIdentifier(rp.c, "noreturn");
50985090 } else {
5099 const return_qt = ZigClangFunctionType_getReturnType(fn_ty);
5091 const return_qt = fn_ty.getReturnType();
51005092 if (isCVoid(return_qt)) {
51015093 // convert primitive c_void to actual void (only for return type)
51025094 break :blk try transCreateNodeIdentifier(rp.c, "void");
......@@ -5144,7 +5136,7 @@ fn finishTransFnProto(
51445136fn revertAndWarn(
51455137 rp: RestorePoint,
51465138 err: anytype,
5147 source_loc: ZigClangSourceLocation,
5139 source_loc: clang.SourceLocation,
51485140 comptime format: []const u8,
51495141 args: anytype,
51505142) (@TypeOf(err) || error{OutOfMemory}) {
......@@ -5153,12 +5145,12 @@ fn revertAndWarn(
51535145 return err;
51545146}
51555147
5156fn 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 {
51575149 const args_prefix = .{c.locStr(loc)};
51585150 _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args);
51595151}
51605152
5161pub 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 {
51625154 // pub const name = @compileError(msg);
51635155 const pub_tok = try appendToken(c, .Keyword_pub, "pub");
51645156 const const_tok = try appendToken(c, .Keyword_const, "const");
......@@ -5295,14 +5287,14 @@ fn transCreateNodeIdentifierUnchecked(c: *Context, name: []const u8) !*ast.Node
52955287}
52965288
52975289pub fn freeErrors(errors: []ClangErrMsg) void {
5298 ZigClangErrorMsg_delete(errors.ptr, errors.len);
5290 errors.ptr.delete(errors.len);
52995291}
53005292
53015293const MacroCtx = struct {
53025294 source: []const u8,
53035295 list: []const CToken,
53045296 i: usize = 0,
5305 loc: ZigClangSourceLocation,
5297 loc: clang.SourceLocation,
53065298 name: []const u8,
53075299
53085300 fn peek(self: *MacroCtx) ?CToken.Id {
......@@ -5326,22 +5318,22 @@ const MacroCtx = struct {
53265318 }
53275319};
53285320
5329fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
5321fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
53305322 // TODO if we see #undef, delete it from the table
5331 var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(unit);
5332 const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(unit);
5323 var it = unit.getLocalPreprocessingEntities_begin();
5324 const it_end = unit.getLocalPreprocessingEntities_end();
53335325 var tok_list = std.ArrayList(CToken).init(c.gpa);
53345326 defer tok_list.deinit();
53355327 const scope = c.global_scope;
53365328
53375329 while (it.I != it_end.I) : (it.I += 1) {
5338 const entity = ZigClangPreprocessingRecord_iterator_deref(it);
5330 const entity = it.deref();
53395331 tok_list.items.len = 0;
5340 switch (ZigClangPreprocessedEntity_getKind(entity)) {
5332 switch (entity.getKind()) {
53415333 .MacroDefinitionKind => {
5342 const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity);
5343 const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro);
5344 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();
53455337
53465338 const name = try c.str(raw_name);
53475339 // TODO https://github.com/ziglang/zig/issues/3756
......@@ -5351,7 +5343,7 @@ fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
53515343 continue;
53525344 }
53535345
5354 const begin_c = ZigClangSourceManager_getCharacterData(c.source_manager, begin_loc);
5346 const begin_c = c.source_manager.getCharacterData(begin_loc);
53555347 const slice = begin_c[0..mem.len(begin_c)];
53565348
53575349 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;