authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-04-21 17:24:58-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-04-25 00:06:54-04:00
log976080462cf62f6f112d38176b99e5bb8a57bf37
tree0172c0811fc360f49e3c0eeacbd58ece78a30764
parent56e07622c692f70eb10836b86c5fda02c53e2394
signature Commit is signed but in an unrecognized format.

translate-c: a little closer to self-hosted implementation

22 files changed, 1467 insertions(+), 366 deletions(-)

CMakeLists.txt+1
......@@ -508,6 +508,7 @@ set(ZIG_STD_FILES
508508 "heap.zig"
509509 "io.zig"
510510 "io/seekable_stream.zig"
511 "io/c_out_stream.zig"
511512 "json.zig"
512513 "lazy_init.zig"
513514 "linked_list.zig"
src-self-hosted/clang.zig created+944
......@@ -0,0 +1,944 @@
1pub const struct_ZigClangAPValue = @OpaqueType();
2pub const struct_ZigClangAPSInt = @OpaqueType();
3pub const struct_ZigClangASTContext = @OpaqueType();
4pub const struct_ZigClangASTUnit = @OpaqueType();
5pub const struct_ZigClangArraySubscriptExpr = @OpaqueType();
6pub const struct_ZigClangArrayType = @OpaqueType();
7pub const struct_ZigClangAttributedType = @OpaqueType();
8pub const struct_ZigClangBinaryOperator = @OpaqueType();
9pub const struct_ZigClangBreakStmt = @OpaqueType();
10pub const struct_ZigClangBuiltinType = @OpaqueType();
11pub const struct_ZigClangCStyleCastExpr = @OpaqueType();
12pub const struct_ZigClangCallExpr = @OpaqueType();
13pub const struct_ZigClangCaseStmt = @OpaqueType();
14pub const struct_ZigClangCompoundAssignOperator = @OpaqueType();
15pub const struct_ZigClangCompoundStmt = @OpaqueType();
16pub const struct_ZigClangConditionalOperator = @OpaqueType();
17pub const struct_ZigClangConstantArrayType = @OpaqueType();
18pub const struct_ZigClangContinueStmt = @OpaqueType();
19pub const struct_ZigClangDecayedType = @OpaqueType();
20pub const struct_ZigClangDecl = @OpaqueType();
21pub const struct_ZigClangDeclRefExpr = @OpaqueType();
22pub const struct_ZigClangDeclStmt = @OpaqueType();
23pub const struct_ZigClangDefaultStmt = @OpaqueType();
24pub const struct_ZigClangDiagnosticOptions = @OpaqueType();
25pub const struct_ZigClangDiagnosticsEngine = @OpaqueType();
26pub const struct_ZigClangDoStmt = @OpaqueType();
27pub const struct_ZigClangElaboratedType = @OpaqueType();
28pub const struct_ZigClangEnumConstantDecl = @OpaqueType();
29pub const struct_ZigClangEnumDecl = @OpaqueType();
30pub const struct_ZigClangEnumType = @OpaqueType();
31pub const struct_ZigClangExpr = @OpaqueType();
32pub const struct_ZigClangFieldDecl = @OpaqueType();
33pub const struct_ZigClangFileID = @OpaqueType();
34pub const struct_ZigClangForStmt = @OpaqueType();
35pub const struct_ZigClangFullSourceLoc = @OpaqueType();
36pub const struct_ZigClangFunctionDecl = @OpaqueType();
37pub const struct_ZigClangFunctionProtoType = @OpaqueType();
38pub const struct_ZigClangIfStmt = @OpaqueType();
39pub const struct_ZigClangImplicitCastExpr = @OpaqueType();
40pub const struct_ZigClangIncompleteArrayType = @OpaqueType();
41pub const struct_ZigClangIntegerLiteral = @OpaqueType();
42pub const struct_ZigClangMacroDefinitionRecord = @OpaqueType();
43pub const struct_ZigClangMemberExpr = @OpaqueType();
44pub const struct_ZigClangNamedDecl = @OpaqueType();
45pub const struct_ZigClangNone = @OpaqueType();
46pub const struct_ZigClangPCHContainerOperations = @OpaqueType();
47pub const struct_ZigClangParenExpr = @OpaqueType();
48pub const struct_ZigClangParenType = @OpaqueType();
49pub const struct_ZigClangParmVarDecl = @OpaqueType();
50pub const struct_ZigClangPointerType = @OpaqueType();
51pub const struct_ZigClangPreprocessedEntity = @OpaqueType();
52pub const struct_ZigClangRecordDecl = @OpaqueType();
53pub const struct_ZigClangRecordType = @OpaqueType();
54pub const struct_ZigClangReturnStmt = @OpaqueType();
55pub const struct_ZigClangSkipFunctionBodiesScope = @OpaqueType();
56pub const struct_ZigClangSourceManager = @OpaqueType();
57pub const struct_ZigClangSourceRange = @OpaqueType();
58pub const struct_ZigClangStmt = @OpaqueType();
59pub const struct_ZigClangStorageClass = @OpaqueType();
60pub const struct_ZigClangStringLiteral = @OpaqueType();
61pub const struct_ZigClangStringRef = @OpaqueType();
62pub const struct_ZigClangSwitchStmt = @OpaqueType();
63pub const struct_ZigClangTagDecl = @OpaqueType();
64pub const struct_ZigClangType = @OpaqueType();
65pub const struct_ZigClangTypedefNameDecl = @OpaqueType();
66pub const struct_ZigClangTypedefType = @OpaqueType();
67pub const struct_ZigClangUnaryExprOrTypeTraitExpr = @OpaqueType();
68pub const struct_ZigClangUnaryOperator = @OpaqueType();
69pub const struct_ZigClangValueDecl = @OpaqueType();
70pub const struct_ZigClangVarDecl = @OpaqueType();
71pub const struct_ZigClangWhileStmt = @OpaqueType();
72pub const ZigClangBO_PtrMemD = enum_ZigClangBO._PtrMemD;
73pub const ZigClangBO_PtrMemI = enum_ZigClangBO._PtrMemI;
74pub const ZigClangBO_Mul = enum_ZigClangBO._Mul;
75pub const ZigClangBO_Div = enum_ZigClangBO._Div;
76pub const ZigClangBO_Rem = enum_ZigClangBO._Rem;
77pub const ZigClangBO_Add = enum_ZigClangBO._Add;
78pub const ZigClangBO_Sub = enum_ZigClangBO._Sub;
79pub const ZigClangBO_Shl = enum_ZigClangBO._Shl;
80pub const ZigClangBO_Shr = enum_ZigClangBO._Shr;
81pub const ZigClangBO_Cmp = enum_ZigClangBO._Cmp;
82pub const ZigClangBO_LT = enum_ZigClangBO._LT;
83pub const ZigClangBO_GT = enum_ZigClangBO._GT;
84pub const ZigClangBO_LE = enum_ZigClangBO._LE;
85pub const ZigClangBO_GE = enum_ZigClangBO._GE;
86pub const ZigClangBO_EQ = enum_ZigClangBO._EQ;
87pub const ZigClangBO_NE = enum_ZigClangBO._NE;
88pub const ZigClangBO_And = enum_ZigClangBO._And;
89pub const ZigClangBO_Xor = enum_ZigClangBO._Xor;
90pub const ZigClangBO_Or = enum_ZigClangBO._Or;
91pub const ZigClangBO_LAnd = enum_ZigClangBO._LAnd;
92pub const ZigClangBO_LOr = enum_ZigClangBO._LOr;
93pub const ZigClangBO_Assign = enum_ZigClangBO._Assign;
94pub const ZigClangBO_MulAssign = enum_ZigClangBO._MulAssign;
95pub const ZigClangBO_DivAssign = enum_ZigClangBO._DivAssign;
96pub const ZigClangBO_RemAssign = enum_ZigClangBO._RemAssign;
97pub const ZigClangBO_AddAssign = enum_ZigClangBO._AddAssign;
98pub const ZigClangBO_SubAssign = enum_ZigClangBO._SubAssign;
99pub const ZigClangBO_ShlAssign = enum_ZigClangBO._ShlAssign;
100pub const ZigClangBO_ShrAssign = enum_ZigClangBO._ShrAssign;
101pub const ZigClangBO_AndAssign = enum_ZigClangBO._AndAssign;
102pub const ZigClangBO_XorAssign = enum_ZigClangBO._XorAssign;
103pub const ZigClangBO_OrAssign = enum_ZigClangBO._OrAssign;
104pub const ZigClangBO_Comma = enum_ZigClangBO._Comma;
105pub const enum_ZigClangBO = extern enum {
106 _PtrMemD,
107 _PtrMemI,
108 _Mul,
109 _Div,
110 _Rem,
111 _Add,
112 _Sub,
113 _Shl,
114 _Shr,
115 _Cmp,
116 _LT,
117 _GT,
118 _LE,
119 _GE,
120 _EQ,
121 _NE,
122 _And,
123 _Xor,
124 _Or,
125 _LAnd,
126 _LOr,
127 _Assign,
128 _MulAssign,
129 _DivAssign,
130 _RemAssign,
131 _AddAssign,
132 _SubAssign,
133 _ShlAssign,
134 _ShrAssign,
135 _AndAssign,
136 _XorAssign,
137 _OrAssign,
138 _Comma,
139};
140pub const ZigClangUO_PostInc = enum_ZigClangUO._PostInc;
141pub const ZigClangUO_PostDec = enum_ZigClangUO._PostDec;
142pub const ZigClangUO_PreInc = enum_ZigClangUO._PreInc;
143pub const ZigClangUO_PreDec = enum_ZigClangUO._PreDec;
144pub const ZigClangUO_AddrOf = enum_ZigClangUO._AddrOf;
145pub const ZigClangUO_Deref = enum_ZigClangUO._Deref;
146pub const ZigClangUO_Plus = enum_ZigClangUO._Plus;
147pub const ZigClangUO_Minus = enum_ZigClangUO._Minus;
148pub const ZigClangUO_Not = enum_ZigClangUO._Not;
149pub const ZigClangUO_LNot = enum_ZigClangUO._LNot;
150pub const ZigClangUO_Real = enum_ZigClangUO._Real;
151pub const ZigClangUO_Imag = enum_ZigClangUO._Imag;
152pub const ZigClangUO_Extension = enum_ZigClangUO._Extension;
153pub const ZigClangUO_Coawait = enum_ZigClangUO._Coawait;
154pub const enum_ZigClangUO = extern enum {
155 _PostInc,
156 _PostDec,
157 _PreInc,
158 _PreDec,
159 _AddrOf,
160 _Deref,
161 _Plus,
162 _Minus,
163 _Not,
164 _LNot,
165 _Real,
166 _Imag,
167 _Extension,
168 _Coawait,
169};
170pub const ZigClangType_Builtin = enum_ZigClangTypeClass.ZigClangType_Builtin;
171pub const ZigClangType_Complex = enum_ZigClangTypeClass.ZigClangType_Complex;
172pub const ZigClangType_Pointer = enum_ZigClangTypeClass.ZigClangType_Pointer;
173pub const ZigClangType_BlockPointer = enum_ZigClangTypeClass.ZigClangType_BlockPointer;
174pub const ZigClangType_LValueReference = enum_ZigClangTypeClass.ZigClangType_LValueReference;
175pub const ZigClangType_RValueReference = enum_ZigClangTypeClass.ZigClangType_RValueReference;
176pub const ZigClangType_MemberPointer = enum_ZigClangTypeClass.ZigClangType_MemberPointer;
177pub const ZigClangType_ConstantArray = enum_ZigClangTypeClass.ZigClangType_ConstantArray;
178pub const ZigClangType_IncompleteArray = enum_ZigClangTypeClass.ZigClangType_IncompleteArray;
179pub const ZigClangType_VariableArray = enum_ZigClangTypeClass.ZigClangType_VariableArray;
180pub const ZigClangType_DependentSizedArray = enum_ZigClangTypeClass.ZigClangType_DependentSizedArray;
181pub const ZigClangType_DependentSizedExtVector = enum_ZigClangTypeClass.ZigClangType_DependentSizedExtVector;
182pub const ZigClangType_DependentAddressSpace = enum_ZigClangTypeClass.ZigClangType_DependentAddressSpace;
183pub const ZigClangType_Vector = enum_ZigClangTypeClass.ZigClangType_Vector;
184pub const ZigClangType_DependentVector = enum_ZigClangTypeClass.ZigClangType_DependentVector;
185pub const ZigClangType_ExtVector = enum_ZigClangTypeClass.ZigClangType_ExtVector;
186pub const ZigClangType_FunctionProto = enum_ZigClangTypeClass.ZigClangType_FunctionProto;
187pub const ZigClangType_FunctionNoProto = enum_ZigClangTypeClass.ZigClangType_FunctionNoProto;
188pub const ZigClangType_UnresolvedUsing = enum_ZigClangTypeClass.ZigClangType_UnresolvedUsing;
189pub const ZigClangType_Paren = enum_ZigClangTypeClass.ZigClangType_Paren;
190pub const ZigClangType_Typedef = enum_ZigClangTypeClass.ZigClangType_Typedef;
191pub const ZigClangType_Adjusted = enum_ZigClangTypeClass.ZigClangType_Adjusted;
192pub const ZigClangType_Decayed = enum_ZigClangTypeClass.ZigClangType_Decayed;
193pub const ZigClangType_TypeOfExpr = enum_ZigClangTypeClass.ZigClangType_TypeOfExpr;
194pub const ZigClangType_TypeOf = enum_ZigClangTypeClass.ZigClangType_TypeOf;
195pub const ZigClangType_Decltype = enum_ZigClangTypeClass.ZigClangType_Decltype;
196pub const ZigClangType_UnaryTransform = enum_ZigClangTypeClass.ZigClangType_UnaryTransform;
197pub const ZigClangType_Record = enum_ZigClangTypeClass.ZigClangType_Record;
198pub const ZigClangType_Enum = enum_ZigClangTypeClass.ZigClangType_Enum;
199pub const ZigClangType_Elaborated = enum_ZigClangTypeClass.ZigClangType_Elaborated;
200pub const ZigClangType_Attributed = enum_ZigClangTypeClass.ZigClangType_Attributed;
201pub const ZigClangType_TemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_TemplateTypeParm;
202pub const ZigClangType_SubstTemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParm;
203pub const ZigClangType_SubstTemplateTypeParmPack = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParmPack;
204pub const ZigClangType_TemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_TemplateSpecialization;
205pub const ZigClangType_Auto = enum_ZigClangTypeClass.ZigClangType_Auto;
206pub const ZigClangType_DeducedTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DeducedTemplateSpecialization;
207pub const ZigClangType_InjectedClassName = enum_ZigClangTypeClass.ZigClangType_InjectedClassName;
208pub const ZigClangType_DependentName = enum_ZigClangTypeClass.ZigClangType_DependentName;
209pub const ZigClangType_DependentTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DependentTemplateSpecialization;
210pub const ZigClangType_PackExpansion = enum_ZigClangTypeClass.ZigClangType_PackExpansion;
211pub const ZigClangType_ObjCTypeParam = enum_ZigClangTypeClass.ZigClangType_ObjCTypeParam;
212pub const ZigClangType_ObjCObject = enum_ZigClangTypeClass.ZigClangType_ObjCObject;
213pub const ZigClangType_ObjCInterface = enum_ZigClangTypeClass.ZigClangType_ObjCInterface;
214pub const ZigClangType_ObjCObjectPointer = enum_ZigClangTypeClass.ZigClangType_ObjCObjectPointer;
215pub const ZigClangType_Pipe = enum_ZigClangTypeClass.ZigClangType_Pipe;
216pub const ZigClangType_Atomic = enum_ZigClangTypeClass.ZigClangType_Atomic;
217pub const enum_ZigClangTypeClass = extern enum {
218 ZigClangType_Builtin,
219 ZigClangType_Complex,
220 ZigClangType_Pointer,
221 ZigClangType_BlockPointer,
222 ZigClangType_LValueReference,
223 ZigClangType_RValueReference,
224 ZigClangType_MemberPointer,
225 ZigClangType_ConstantArray,
226 ZigClangType_IncompleteArray,
227 ZigClangType_VariableArray,
228 ZigClangType_DependentSizedArray,
229 ZigClangType_DependentSizedExtVector,
230 ZigClangType_DependentAddressSpace,
231 ZigClangType_Vector,
232 ZigClangType_DependentVector,
233 ZigClangType_ExtVector,
234 ZigClangType_FunctionProto,
235 ZigClangType_FunctionNoProto,
236 ZigClangType_UnresolvedUsing,
237 ZigClangType_Paren,
238 ZigClangType_Typedef,
239 ZigClangType_Adjusted,
240 ZigClangType_Decayed,
241 ZigClangType_TypeOfExpr,
242 ZigClangType_TypeOf,
243 ZigClangType_Decltype,
244 ZigClangType_UnaryTransform,
245 ZigClangType_Record,
246 ZigClangType_Enum,
247 ZigClangType_Elaborated,
248 ZigClangType_Attributed,
249 ZigClangType_TemplateTypeParm,
250 ZigClangType_SubstTemplateTypeParm,
251 ZigClangType_SubstTemplateTypeParmPack,
252 ZigClangType_TemplateSpecialization,
253 ZigClangType_Auto,
254 ZigClangType_DeducedTemplateSpecialization,
255 ZigClangType_InjectedClassName,
256 ZigClangType_DependentName,
257 ZigClangType_DependentTemplateSpecialization,
258 ZigClangType_PackExpansion,
259 ZigClangType_ObjCTypeParam,
260 ZigClangType_ObjCObject,
261 ZigClangType_ObjCInterface,
262 ZigClangType_ObjCObjectPointer,
263 ZigClangType_Pipe,
264 ZigClangType_Atomic,
265};
266pub const ZigClangStmt_NoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NoStmtClass;
267pub const ZigClangStmt_GCCAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GCCAsmStmtClass;
268pub const ZigClangStmt_MSAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSAsmStmtClass;
269pub const ZigClangStmt_AttributedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_AttributedStmtClass;
270pub const ZigClangStmt_BreakStmtClass = enum_ZigClangStmtClass.ZigClangStmt_BreakStmtClass;
271pub const ZigClangStmt_CXXCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXCatchStmtClass;
272pub const ZigClangStmt_CXXForRangeStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXForRangeStmtClass;
273pub const ZigClangStmt_CXXTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTryStmtClass;
274pub const ZigClangStmt_CapturedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CapturedStmtClass;
275pub const ZigClangStmt_CompoundStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundStmtClass;
276pub const ZigClangStmt_ContinueStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ContinueStmtClass;
277pub const ZigClangStmt_CoreturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoreturnStmtClass;
278pub const ZigClangStmt_CoroutineBodyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoroutineBodyStmtClass;
279pub const ZigClangStmt_DeclStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DeclStmtClass;
280pub const ZigClangStmt_DoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DoStmtClass;
281pub const ZigClangStmt_BinaryConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryConditionalOperatorClass;
282pub const ZigClangStmt_ConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_ConditionalOperatorClass;
283pub const ZigClangStmt_AddrLabelExprClass = enum_ZigClangStmtClass.ZigClangStmt_AddrLabelExprClass;
284pub const ZigClangStmt_ArrayInitIndexExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitIndexExprClass;
285pub const ZigClangStmt_ArrayInitLoopExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitLoopExprClass;
286pub const ZigClangStmt_ArraySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArraySubscriptExprClass;
287pub const ZigClangStmt_ArrayTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayTypeTraitExprClass;
288pub const ZigClangStmt_AsTypeExprClass = enum_ZigClangStmtClass.ZigClangStmt_AsTypeExprClass;
289pub const ZigClangStmt_AtomicExprClass = enum_ZigClangStmtClass.ZigClangStmt_AtomicExprClass;
290pub const ZigClangStmt_BinaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryOperatorClass;
291pub const ZigClangStmt_CompoundAssignOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundAssignOperatorClass;
292pub const ZigClangStmt_BlockExprClass = enum_ZigClangStmtClass.ZigClangStmt_BlockExprClass;
293pub const ZigClangStmt_CXXBindTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBindTemporaryExprClass;
294pub const ZigClangStmt_CXXBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBoolLiteralExprClass;
295pub const ZigClangStmt_CXXConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstructExprClass;
296pub const ZigClangStmt_CXXTemporaryObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTemporaryObjectExprClass;
297pub const ZigClangStmt_CXXDefaultArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultArgExprClass;
298pub const ZigClangStmt_CXXDefaultInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultInitExprClass;
299pub const ZigClangStmt_CXXDeleteExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDeleteExprClass;
300pub const ZigClangStmt_CXXDependentScopeMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDependentScopeMemberExprClass;
301pub const ZigClangStmt_CXXFoldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFoldExprClass;
302pub const ZigClangStmt_CXXInheritedCtorInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXInheritedCtorInitExprClass;
303pub const ZigClangStmt_CXXNewExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNewExprClass;
304pub const ZigClangStmt_CXXNoexceptExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNoexceptExprClass;
305pub const ZigClangStmt_CXXNullPtrLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNullPtrLiteralExprClass;
306pub const ZigClangStmt_CXXPseudoDestructorExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXPseudoDestructorExprClass;
307pub const ZigClangStmt_CXXScalarValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXScalarValueInitExprClass;
308pub const ZigClangStmt_CXXStdInitializerListExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStdInitializerListExprClass;
309pub const ZigClangStmt_CXXThisExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThisExprClass;
310pub const ZigClangStmt_CXXThrowExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThrowExprClass;
311pub const ZigClangStmt_CXXTypeidExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTypeidExprClass;
312pub const ZigClangStmt_CXXUnresolvedConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUnresolvedConstructExprClass;
313pub const ZigClangStmt_CXXUuidofExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUuidofExprClass;
314pub const ZigClangStmt_CallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CallExprClass;
315pub const ZigClangStmt_CUDAKernelCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CUDAKernelCallExprClass;
316pub const ZigClangStmt_CXXMemberCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXMemberCallExprClass;
317pub const ZigClangStmt_CXXOperatorCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXOperatorCallExprClass;
318pub const ZigClangStmt_UserDefinedLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_UserDefinedLiteralClass;
319pub const ZigClangStmt_CStyleCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CStyleCastExprClass;
320pub const ZigClangStmt_CXXFunctionalCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFunctionalCastExprClass;
321pub const ZigClangStmt_CXXConstCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstCastExprClass;
322pub const ZigClangStmt_CXXDynamicCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDynamicCastExprClass;
323pub const ZigClangStmt_CXXReinterpretCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXReinterpretCastExprClass;
324pub const ZigClangStmt_CXXStaticCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStaticCastExprClass;
325pub const ZigClangStmt_ObjCBridgedCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBridgedCastExprClass;
326pub const ZigClangStmt_ImplicitCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitCastExprClass;
327pub const ZigClangStmt_CharacterLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_CharacterLiteralClass;
328pub const ZigClangStmt_ChooseExprClass = enum_ZigClangStmtClass.ZigClangStmt_ChooseExprClass;
329pub const ZigClangStmt_CompoundLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundLiteralExprClass;
330pub const ZigClangStmt_ConvertVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConvertVectorExprClass;
331pub const ZigClangStmt_CoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoawaitExprClass;
332pub const ZigClangStmt_CoyieldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoyieldExprClass;
333pub const ZigClangStmt_DeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DeclRefExprClass;
334pub const ZigClangStmt_DependentCoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentCoawaitExprClass;
335pub const ZigClangStmt_DependentScopeDeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentScopeDeclRefExprClass;
336pub const ZigClangStmt_DesignatedInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitExprClass;
337pub const ZigClangStmt_DesignatedInitUpdateExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitUpdateExprClass;
338pub const ZigClangStmt_ExpressionTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExpressionTraitExprClass;
339pub const ZigClangStmt_ExtVectorElementExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExtVectorElementExprClass;
340pub const ZigClangStmt_FixedPointLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FixedPointLiteralClass;
341pub const ZigClangStmt_FloatingLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FloatingLiteralClass;
342pub const ZigClangStmt_ConstantExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConstantExprClass;
343pub const ZigClangStmt_ExprWithCleanupsClass = enum_ZigClangStmtClass.ZigClangStmt_ExprWithCleanupsClass;
344pub const ZigClangStmt_FunctionParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_FunctionParmPackExprClass;
345pub const ZigClangStmt_GNUNullExprClass = enum_ZigClangStmtClass.ZigClangStmt_GNUNullExprClass;
346pub const ZigClangStmt_GenericSelectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_GenericSelectionExprClass;
347pub const ZigClangStmt_ImaginaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ImaginaryLiteralClass;
348pub const ZigClangStmt_ImplicitValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitValueInitExprClass;
349pub const ZigClangStmt_InitListExprClass = enum_ZigClangStmtClass.ZigClangStmt_InitListExprClass;
350pub const ZigClangStmt_IntegerLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_IntegerLiteralClass;
351pub const ZigClangStmt_LambdaExprClass = enum_ZigClangStmtClass.ZigClangStmt_LambdaExprClass;
352pub const ZigClangStmt_MSPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertyRefExprClass;
353pub const ZigClangStmt_MSPropertySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertySubscriptExprClass;
354pub const ZigClangStmt_MaterializeTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_MaterializeTemporaryExprClass;
355pub const ZigClangStmt_MemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_MemberExprClass;
356pub const ZigClangStmt_NoInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_NoInitExprClass;
357pub const ZigClangStmt_OMPArraySectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_OMPArraySectionExprClass;
358pub const ZigClangStmt_ObjCArrayLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCArrayLiteralClass;
359pub const ZigClangStmt_ObjCAvailabilityCheckExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAvailabilityCheckExprClass;
360pub const ZigClangStmt_ObjCBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoolLiteralExprClass;
361pub const ZigClangStmt_ObjCBoxedExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoxedExprClass;
362pub const ZigClangStmt_ObjCDictionaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCDictionaryLiteralClass;
363pub const ZigClangStmt_ObjCEncodeExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCEncodeExprClass;
364pub const ZigClangStmt_ObjCIndirectCopyRestoreExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIndirectCopyRestoreExprClass;
365pub const ZigClangStmt_ObjCIsaExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIsaExprClass;
366pub const ZigClangStmt_ObjCIvarRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIvarRefExprClass;
367pub const ZigClangStmt_ObjCMessageExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCMessageExprClass;
368pub const ZigClangStmt_ObjCPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCPropertyRefExprClass;
369pub const ZigClangStmt_ObjCProtocolExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCProtocolExprClass;
370pub const ZigClangStmt_ObjCSelectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSelectorExprClass;
371pub const ZigClangStmt_ObjCStringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCStringLiteralClass;
372pub const ZigClangStmt_ObjCSubscriptRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSubscriptRefExprClass;
373pub const ZigClangStmt_OffsetOfExprClass = enum_ZigClangStmtClass.ZigClangStmt_OffsetOfExprClass;
374pub const ZigClangStmt_OpaqueValueExprClass = enum_ZigClangStmtClass.ZigClangStmt_OpaqueValueExprClass;
375pub const ZigClangStmt_UnresolvedLookupExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedLookupExprClass;
376pub const ZigClangStmt_UnresolvedMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedMemberExprClass;
377pub const ZigClangStmt_PackExpansionExprClass = enum_ZigClangStmtClass.ZigClangStmt_PackExpansionExprClass;
378pub const ZigClangStmt_ParenExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenExprClass;
379pub const ZigClangStmt_ParenListExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenListExprClass;
380pub const ZigClangStmt_PredefinedExprClass = enum_ZigClangStmtClass.ZigClangStmt_PredefinedExprClass;
381pub const ZigClangStmt_PseudoObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_PseudoObjectExprClass;
382pub const ZigClangStmt_ShuffleVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ShuffleVectorExprClass;
383pub const ZigClangStmt_SizeOfPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SizeOfPackExprClass;
384pub const ZigClangStmt_StmtExprClass = enum_ZigClangStmtClass.ZigClangStmt_StmtExprClass;
385pub const ZigClangStmt_StringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_StringLiteralClass;
386pub const ZigClangStmt_SubstNonTypeTemplateParmExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmExprClass;
387pub const ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmPackExprClass;
388pub const ZigClangStmt_TypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypeTraitExprClass;
389pub const ZigClangStmt_TypoExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypoExprClass;
390pub const ZigClangStmt_UnaryExprOrTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryExprOrTypeTraitExprClass;
391pub const ZigClangStmt_UnaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryOperatorClass;
392pub const ZigClangStmt_VAArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_VAArgExprClass;
393pub const ZigClangStmt_ForStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ForStmtClass;
394pub const ZigClangStmt_GotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GotoStmtClass;
395pub const ZigClangStmt_IfStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IfStmtClass;
396pub const ZigClangStmt_IndirectGotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IndirectGotoStmtClass;
397pub const ZigClangStmt_LabelStmtClass = enum_ZigClangStmtClass.ZigClangStmt_LabelStmtClass;
398pub const ZigClangStmt_MSDependentExistsStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSDependentExistsStmtClass;
399pub const ZigClangStmt_NullStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NullStmtClass;
400pub const ZigClangStmt_OMPAtomicDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPAtomicDirectiveClass;
401pub const ZigClangStmt_OMPBarrierDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPBarrierDirectiveClass;
402pub const ZigClangStmt_OMPCancelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancelDirectiveClass;
403pub const ZigClangStmt_OMPCancellationPointDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancellationPointDirectiveClass;
404pub const ZigClangStmt_OMPCriticalDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCriticalDirectiveClass;
405pub const ZigClangStmt_OMPFlushDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPFlushDirectiveClass;
406pub const ZigClangStmt_OMPDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeDirectiveClass;
407pub const ZigClangStmt_OMPDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForDirectiveClass;
408pub const ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass;
409pub const ZigClangStmt_OMPDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeSimdDirectiveClass;
410pub const ZigClangStmt_OMPForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForDirectiveClass;
411pub const ZigClangStmt_OMPForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForSimdDirectiveClass;
412pub const ZigClangStmt_OMPParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForDirectiveClass;
413pub const ZigClangStmt_OMPParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForSimdDirectiveClass;
414pub const ZigClangStmt_OMPSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSimdDirectiveClass;
415pub const ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForSimdDirectiveClass;
416pub const ZigClangStmt_OMPTargetSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetSimdDirectiveClass;
417pub const ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass;
418pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass;
419pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass;
420pub const ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass;
421pub const ZigClangStmt_OMPTaskLoopDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopDirectiveClass;
422pub const ZigClangStmt_OMPTaskLoopSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopSimdDirectiveClass;
423pub const ZigClangStmt_OMPTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeDirectiveClass;
424pub const ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass;
425pub const ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass;
426pub const ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass;
427pub const ZigClangStmt_OMPMasterDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPMasterDirectiveClass;
428pub const ZigClangStmt_OMPOrderedDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPOrderedDirectiveClass;
429pub const ZigClangStmt_OMPParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelDirectiveClass;
430pub const ZigClangStmt_OMPParallelSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelSectionsDirectiveClass;
431pub const ZigClangStmt_OMPSectionDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionDirectiveClass;
432pub const ZigClangStmt_OMPSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionsDirectiveClass;
433pub const ZigClangStmt_OMPSingleDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSingleDirectiveClass;
434pub const ZigClangStmt_OMPTargetDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDataDirectiveClass;
435pub const ZigClangStmt_OMPTargetDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDirectiveClass;
436pub const ZigClangStmt_OMPTargetEnterDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetEnterDataDirectiveClass;
437pub const ZigClangStmt_OMPTargetExitDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetExitDataDirectiveClass;
438pub const ZigClangStmt_OMPTargetParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelDirectiveClass;
439pub const ZigClangStmt_OMPTargetParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForDirectiveClass;
440pub const ZigClangStmt_OMPTargetTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDirectiveClass;
441pub const ZigClangStmt_OMPTargetUpdateDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetUpdateDirectiveClass;
442pub const ZigClangStmt_OMPTaskDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskDirectiveClass;
443pub const ZigClangStmt_OMPTaskgroupDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskgroupDirectiveClass;
444pub const ZigClangStmt_OMPTaskwaitDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskwaitDirectiveClass;
445pub const ZigClangStmt_OMPTaskyieldDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskyieldDirectiveClass;
446pub const ZigClangStmt_OMPTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDirectiveClass;
447pub const ZigClangStmt_ObjCAtCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtCatchStmtClass;
448pub const ZigClangStmt_ObjCAtFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtFinallyStmtClass;
449pub const ZigClangStmt_ObjCAtSynchronizedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtSynchronizedStmtClass;
450pub const ZigClangStmt_ObjCAtThrowStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtThrowStmtClass;
451pub const ZigClangStmt_ObjCAtTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtTryStmtClass;
452pub const ZigClangStmt_ObjCAutoreleasePoolStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAutoreleasePoolStmtClass;
453pub const ZigClangStmt_ObjCForCollectionStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCForCollectionStmtClass;
454pub const ZigClangStmt_ReturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ReturnStmtClass;
455pub const ZigClangStmt_SEHExceptStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHExceptStmtClass;
456pub const ZigClangStmt_SEHFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHFinallyStmtClass;
457pub const ZigClangStmt_SEHLeaveStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHLeaveStmtClass;
458pub const ZigClangStmt_SEHTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHTryStmtClass;
459pub const ZigClangStmt_CaseStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CaseStmtClass;
460pub const ZigClangStmt_DefaultStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DefaultStmtClass;
461pub const ZigClangStmt_SwitchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SwitchStmtClass;
462pub const ZigClangStmt_WhileStmtClass = enum_ZigClangStmtClass.ZigClangStmt_WhileStmtClass;
463pub const enum_ZigClangStmtClass = extern enum {
464 ZigClangStmt_NoStmtClass = 0,
465 ZigClangStmt_GCCAsmStmtClass = 1,
466 ZigClangStmt_MSAsmStmtClass = 2,
467 ZigClangStmt_AttributedStmtClass = 3,
468 ZigClangStmt_BreakStmtClass = 4,
469 ZigClangStmt_CXXCatchStmtClass = 5,
470 ZigClangStmt_CXXForRangeStmtClass = 6,
471 ZigClangStmt_CXXTryStmtClass = 7,
472 ZigClangStmt_CapturedStmtClass = 8,
473 ZigClangStmt_CompoundStmtClass = 9,
474 ZigClangStmt_ContinueStmtClass = 10,
475 ZigClangStmt_CoreturnStmtClass = 11,
476 ZigClangStmt_CoroutineBodyStmtClass = 12,
477 ZigClangStmt_DeclStmtClass = 13,
478 ZigClangStmt_DoStmtClass = 14,
479 ZigClangStmt_BinaryConditionalOperatorClass = 15,
480 ZigClangStmt_ConditionalOperatorClass = 16,
481 ZigClangStmt_AddrLabelExprClass = 17,
482 ZigClangStmt_ArrayInitIndexExprClass = 18,
483 ZigClangStmt_ArrayInitLoopExprClass = 19,
484 ZigClangStmt_ArraySubscriptExprClass = 20,
485 ZigClangStmt_ArrayTypeTraitExprClass = 21,
486 ZigClangStmt_AsTypeExprClass = 22,
487 ZigClangStmt_AtomicExprClass = 23,
488 ZigClangStmt_BinaryOperatorClass = 24,
489 ZigClangStmt_CompoundAssignOperatorClass = 25,
490 ZigClangStmt_BlockExprClass = 26,
491 ZigClangStmt_CXXBindTemporaryExprClass = 27,
492 ZigClangStmt_CXXBoolLiteralExprClass = 28,
493 ZigClangStmt_CXXConstructExprClass = 29,
494 ZigClangStmt_CXXTemporaryObjectExprClass = 30,
495 ZigClangStmt_CXXDefaultArgExprClass = 31,
496 ZigClangStmt_CXXDefaultInitExprClass = 32,
497 ZigClangStmt_CXXDeleteExprClass = 33,
498 ZigClangStmt_CXXDependentScopeMemberExprClass = 34,
499 ZigClangStmt_CXXFoldExprClass = 35,
500 ZigClangStmt_CXXInheritedCtorInitExprClass = 36,
501 ZigClangStmt_CXXNewExprClass = 37,
502 ZigClangStmt_CXXNoexceptExprClass = 38,
503 ZigClangStmt_CXXNullPtrLiteralExprClass = 39,
504 ZigClangStmt_CXXPseudoDestructorExprClass = 40,
505 ZigClangStmt_CXXScalarValueInitExprClass = 41,
506 ZigClangStmt_CXXStdInitializerListExprClass = 42,
507 ZigClangStmt_CXXThisExprClass = 43,
508 ZigClangStmt_CXXThrowExprClass = 44,
509 ZigClangStmt_CXXTypeidExprClass = 45,
510 ZigClangStmt_CXXUnresolvedConstructExprClass = 46,
511 ZigClangStmt_CXXUuidofExprClass = 47,
512 ZigClangStmt_CallExprClass = 48,
513 ZigClangStmt_CUDAKernelCallExprClass = 49,
514 ZigClangStmt_CXXMemberCallExprClass = 50,
515 ZigClangStmt_CXXOperatorCallExprClass = 51,
516 ZigClangStmt_UserDefinedLiteralClass = 52,
517 ZigClangStmt_CStyleCastExprClass = 53,
518 ZigClangStmt_CXXFunctionalCastExprClass = 54,
519 ZigClangStmt_CXXConstCastExprClass = 55,
520 ZigClangStmt_CXXDynamicCastExprClass = 56,
521 ZigClangStmt_CXXReinterpretCastExprClass = 57,
522 ZigClangStmt_CXXStaticCastExprClass = 58,
523 ZigClangStmt_ObjCBridgedCastExprClass = 59,
524 ZigClangStmt_ImplicitCastExprClass = 60,
525 ZigClangStmt_CharacterLiteralClass = 61,
526 ZigClangStmt_ChooseExprClass = 62,
527 ZigClangStmt_CompoundLiteralExprClass = 63,
528 ZigClangStmt_ConvertVectorExprClass = 64,
529 ZigClangStmt_CoawaitExprClass = 65,
530 ZigClangStmt_CoyieldExprClass = 66,
531 ZigClangStmt_DeclRefExprClass = 67,
532 ZigClangStmt_DependentCoawaitExprClass = 68,
533 ZigClangStmt_DependentScopeDeclRefExprClass = 69,
534 ZigClangStmt_DesignatedInitExprClass = 70,
535 ZigClangStmt_DesignatedInitUpdateExprClass = 71,
536 ZigClangStmt_ExpressionTraitExprClass = 72,
537 ZigClangStmt_ExtVectorElementExprClass = 73,
538 ZigClangStmt_FixedPointLiteralClass = 74,
539 ZigClangStmt_FloatingLiteralClass = 75,
540 ZigClangStmt_ConstantExprClass = 76,
541 ZigClangStmt_ExprWithCleanupsClass = 77,
542 ZigClangStmt_FunctionParmPackExprClass = 78,
543 ZigClangStmt_GNUNullExprClass = 79,
544 ZigClangStmt_GenericSelectionExprClass = 80,
545 ZigClangStmt_ImaginaryLiteralClass = 81,
546 ZigClangStmt_ImplicitValueInitExprClass = 82,
547 ZigClangStmt_InitListExprClass = 83,
548 ZigClangStmt_IntegerLiteralClass = 84,
549 ZigClangStmt_LambdaExprClass = 85,
550 ZigClangStmt_MSPropertyRefExprClass = 86,
551 ZigClangStmt_MSPropertySubscriptExprClass = 87,
552 ZigClangStmt_MaterializeTemporaryExprClass = 88,
553 ZigClangStmt_MemberExprClass = 89,
554 ZigClangStmt_NoInitExprClass = 90,
555 ZigClangStmt_OMPArraySectionExprClass = 91,
556 ZigClangStmt_ObjCArrayLiteralClass = 92,
557 ZigClangStmt_ObjCAvailabilityCheckExprClass = 93,
558 ZigClangStmt_ObjCBoolLiteralExprClass = 94,
559 ZigClangStmt_ObjCBoxedExprClass = 95,
560 ZigClangStmt_ObjCDictionaryLiteralClass = 96,
561 ZigClangStmt_ObjCEncodeExprClass = 97,
562 ZigClangStmt_ObjCIndirectCopyRestoreExprClass = 98,
563 ZigClangStmt_ObjCIsaExprClass = 99,
564 ZigClangStmt_ObjCIvarRefExprClass = 100,
565 ZigClangStmt_ObjCMessageExprClass = 101,
566 ZigClangStmt_ObjCPropertyRefExprClass = 102,
567 ZigClangStmt_ObjCProtocolExprClass = 103,
568 ZigClangStmt_ObjCSelectorExprClass = 104,
569 ZigClangStmt_ObjCStringLiteralClass = 105,
570 ZigClangStmt_ObjCSubscriptRefExprClass = 106,
571 ZigClangStmt_OffsetOfExprClass = 107,
572 ZigClangStmt_OpaqueValueExprClass = 108,
573 ZigClangStmt_UnresolvedLookupExprClass = 109,
574 ZigClangStmt_UnresolvedMemberExprClass = 110,
575 ZigClangStmt_PackExpansionExprClass = 111,
576 ZigClangStmt_ParenExprClass = 112,
577 ZigClangStmt_ParenListExprClass = 113,
578 ZigClangStmt_PredefinedExprClass = 114,
579 ZigClangStmt_PseudoObjectExprClass = 115,
580 ZigClangStmt_ShuffleVectorExprClass = 116,
581 ZigClangStmt_SizeOfPackExprClass = 117,
582 ZigClangStmt_StmtExprClass = 118,
583 ZigClangStmt_StringLiteralClass = 119,
584 ZigClangStmt_SubstNonTypeTemplateParmExprClass = 120,
585 ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = 121,
586 ZigClangStmt_TypeTraitExprClass = 122,
587 ZigClangStmt_TypoExprClass = 123,
588 ZigClangStmt_UnaryExprOrTypeTraitExprClass = 124,
589 ZigClangStmt_UnaryOperatorClass = 125,
590 ZigClangStmt_VAArgExprClass = 126,
591 ZigClangStmt_ForStmtClass = 127,
592 ZigClangStmt_GotoStmtClass = 128,
593 ZigClangStmt_IfStmtClass = 129,
594 ZigClangStmt_IndirectGotoStmtClass = 130,
595 ZigClangStmt_LabelStmtClass = 131,
596 ZigClangStmt_MSDependentExistsStmtClass = 132,
597 ZigClangStmt_NullStmtClass = 133,
598 ZigClangStmt_OMPAtomicDirectiveClass = 134,
599 ZigClangStmt_OMPBarrierDirectiveClass = 135,
600 ZigClangStmt_OMPCancelDirectiveClass = 136,
601 ZigClangStmt_OMPCancellationPointDirectiveClass = 137,
602 ZigClangStmt_OMPCriticalDirectiveClass = 138,
603 ZigClangStmt_OMPFlushDirectiveClass = 139,
604 ZigClangStmt_OMPDistributeDirectiveClass = 140,
605 ZigClangStmt_OMPDistributeParallelForDirectiveClass = 141,
606 ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = 142,
607 ZigClangStmt_OMPDistributeSimdDirectiveClass = 143,
608 ZigClangStmt_OMPForDirectiveClass = 144,
609 ZigClangStmt_OMPForSimdDirectiveClass = 145,
610 ZigClangStmt_OMPParallelForDirectiveClass = 146,
611 ZigClangStmt_OMPParallelForSimdDirectiveClass = 147,
612 ZigClangStmt_OMPSimdDirectiveClass = 148,
613 ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = 149,
614 ZigClangStmt_OMPTargetSimdDirectiveClass = 150,
615 ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = 151,
616 ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = 152,
617 ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = 153,
618 ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = 154,
619 ZigClangStmt_OMPTaskLoopDirectiveClass = 155,
620 ZigClangStmt_OMPTaskLoopSimdDirectiveClass = 156,
621 ZigClangStmt_OMPTeamsDistributeDirectiveClass = 157,
622 ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = 158,
623 ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = 159,
624 ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = 160,
625 ZigClangStmt_OMPMasterDirectiveClass = 161,
626 ZigClangStmt_OMPOrderedDirectiveClass = 162,
627 ZigClangStmt_OMPParallelDirectiveClass = 163,
628 ZigClangStmt_OMPParallelSectionsDirectiveClass = 164,
629 ZigClangStmt_OMPSectionDirectiveClass = 165,
630 ZigClangStmt_OMPSectionsDirectiveClass = 166,
631 ZigClangStmt_OMPSingleDirectiveClass = 167,
632 ZigClangStmt_OMPTargetDataDirectiveClass = 168,
633 ZigClangStmt_OMPTargetDirectiveClass = 169,
634 ZigClangStmt_OMPTargetEnterDataDirectiveClass = 170,
635 ZigClangStmt_OMPTargetExitDataDirectiveClass = 171,
636 ZigClangStmt_OMPTargetParallelDirectiveClass = 172,
637 ZigClangStmt_OMPTargetParallelForDirectiveClass = 173,
638 ZigClangStmt_OMPTargetTeamsDirectiveClass = 174,
639 ZigClangStmt_OMPTargetUpdateDirectiveClass = 175,
640 ZigClangStmt_OMPTaskDirectiveClass = 176,
641 ZigClangStmt_OMPTaskgroupDirectiveClass = 177,
642 ZigClangStmt_OMPTaskwaitDirectiveClass = 178,
643 ZigClangStmt_OMPTaskyieldDirectiveClass = 179,
644 ZigClangStmt_OMPTeamsDirectiveClass = 180,
645 ZigClangStmt_ObjCAtCatchStmtClass = 181,
646 ZigClangStmt_ObjCAtFinallyStmtClass = 182,
647 ZigClangStmt_ObjCAtSynchronizedStmtClass = 183,
648 ZigClangStmt_ObjCAtThrowStmtClass = 184,
649 ZigClangStmt_ObjCAtTryStmtClass = 185,
650 ZigClangStmt_ObjCAutoreleasePoolStmtClass = 186,
651 ZigClangStmt_ObjCForCollectionStmtClass = 187,
652 ZigClangStmt_ReturnStmtClass = 188,
653 ZigClangStmt_SEHExceptStmtClass = 189,
654 ZigClangStmt_SEHFinallyStmtClass = 190,
655 ZigClangStmt_SEHLeaveStmtClass = 191,
656 ZigClangStmt_SEHTryStmtClass = 192,
657 ZigClangStmt_CaseStmtClass = 193,
658 ZigClangStmt_DefaultStmtClass = 194,
659 ZigClangStmt_SwitchStmtClass = 195,
660 ZigClangStmt_WhileStmtClass = 196,
661};
662pub const ZigClangCK_Dependent = enum_ZigClangCK._Dependent;
663pub const ZigClangCK_BitCast = enum_ZigClangCK._BitCast;
664pub const ZigClangCK_LValueBitCast = enum_ZigClangCK._LValueBitCast;
665pub const ZigClangCK_LValueToRValue = enum_ZigClangCK._LValueToRValue;
666pub const ZigClangCK_NoOp = enum_ZigClangCK._NoOp;
667pub const ZigClangCK_BaseToDerived = enum_ZigClangCK._BaseToDerived;
668pub const ZigClangCK_DerivedToBase = enum_ZigClangCK._DerivedToBase;
669pub const ZigClangCK_UncheckedDerivedToBase = enum_ZigClangCK._UncheckedDerivedToBase;
670pub const ZigClangCK_Dynamic = enum_ZigClangCK._Dynamic;
671pub const ZigClangCK_ToUnion = enum_ZigClangCK._ToUnion;
672pub const ZigClangCK_ArrayToPointerDecay = enum_ZigClangCK._ArrayToPointerDecay;
673pub const ZigClangCK_FunctionToPointerDecay = enum_ZigClangCK._FunctionToPointerDecay;
674pub const ZigClangCK_NullToPointer = enum_ZigClangCK._NullToPointer;
675pub const ZigClangCK_NullToMemberPointer = enum_ZigClangCK._NullToMemberPointer;
676pub const ZigClangCK_BaseToDerivedMemberPointer = enum_ZigClangCK._BaseToDerivedMemberPointer;
677pub const ZigClangCK_DerivedToBaseMemberPointer = enum_ZigClangCK._DerivedToBaseMemberPointer;
678pub const ZigClangCK_MemberPointerToBoolean = enum_ZigClangCK._MemberPointerToBoolean;
679pub const ZigClangCK_ReinterpretMemberPointer = enum_ZigClangCK._ReinterpretMemberPointer;
680pub const ZigClangCK_UserDefinedConversion = enum_ZigClangCK._UserDefinedConversion;
681pub const ZigClangCK_ConstructorConversion = enum_ZigClangCK._ConstructorConversion;
682pub const ZigClangCK_IntegralToPointer = enum_ZigClangCK._IntegralToPointer;
683pub const ZigClangCK_PointerToIntegral = enum_ZigClangCK._PointerToIntegral;
684pub const ZigClangCK_PointerToBoolean = enum_ZigClangCK._PointerToBoolean;
685pub const ZigClangCK_ToVoid = enum_ZigClangCK._ToVoid;
686pub const ZigClangCK_VectorSplat = enum_ZigClangCK._VectorSplat;
687pub const ZigClangCK_IntegralCast = enum_ZigClangCK._IntegralCast;
688pub const ZigClangCK_IntegralToBoolean = enum_ZigClangCK._IntegralToBoolean;
689pub const ZigClangCK_IntegralToFloating = enum_ZigClangCK._IntegralToFloating;
690pub const ZigClangCK_FixedPointCast = enum_ZigClangCK._FixedPointCast;
691pub const ZigClangCK_FixedPointToBoolean = enum_ZigClangCK._FixedPointToBoolean;
692pub const ZigClangCK_FloatingToIntegral = enum_ZigClangCK._FloatingToIntegral;
693pub const ZigClangCK_FloatingToBoolean = enum_ZigClangCK._FloatingToBoolean;
694pub const ZigClangCK_BooleanToSignedIntegral = enum_ZigClangCK._BooleanToSignedIntegral;
695pub const ZigClangCK_FloatingCast = enum_ZigClangCK._FloatingCast;
696pub const ZigClangCK_CPointerToObjCPointerCast = enum_ZigClangCK._CPointerToObjCPointerCast;
697pub const ZigClangCK_BlockPointerToObjCPointerCast = enum_ZigClangCK._BlockPointerToObjCPointerCast;
698pub const ZigClangCK_AnyPointerToBlockPointerCast = enum_ZigClangCK._AnyPointerToBlockPointerCast;
699pub const ZigClangCK_ObjCObjectLValueCast = enum_ZigClangCK._ObjCObjectLValueCast;
700pub const ZigClangCK_FloatingRealToComplex = enum_ZigClangCK._FloatingRealToComplex;
701pub const ZigClangCK_FloatingComplexToReal = enum_ZigClangCK._FloatingComplexToReal;
702pub const ZigClangCK_FloatingComplexToBoolean = enum_ZigClangCK._FloatingComplexToBoolean;
703pub const ZigClangCK_FloatingComplexCast = enum_ZigClangCK._FloatingComplexCast;
704pub const ZigClangCK_FloatingComplexToIntegralComplex = enum_ZigClangCK._FloatingComplexToIntegralComplex;
705pub const ZigClangCK_IntegralRealToComplex = enum_ZigClangCK._IntegralRealToComplex;
706pub const ZigClangCK_IntegralComplexToReal = enum_ZigClangCK._IntegralComplexToReal;
707pub const ZigClangCK_IntegralComplexToBoolean = enum_ZigClangCK._IntegralComplexToBoolean;
708pub const ZigClangCK_IntegralComplexCast = enum_ZigClangCK._IntegralComplexCast;
709pub const ZigClangCK_IntegralComplexToFloatingComplex = enum_ZigClangCK._IntegralComplexToFloatingComplex;
710pub const ZigClangCK_ARCProduceObject = enum_ZigClangCK._ARCProduceObject;
711pub const ZigClangCK_ARCConsumeObject = enum_ZigClangCK._ARCConsumeObject;
712pub const ZigClangCK_ARCReclaimReturnedObject = enum_ZigClangCK._ARCReclaimReturnedObject;
713pub const ZigClangCK_ARCExtendBlockObject = enum_ZigClangCK._ARCExtendBlockObject;
714pub const ZigClangCK_AtomicToNonAtomic = enum_ZigClangCK._AtomicToNonAtomic;
715pub const ZigClangCK_NonAtomicToAtomic = enum_ZigClangCK._NonAtomicToAtomic;
716pub const ZigClangCK_CopyAndAutoreleaseBlockObject = enum_ZigClangCK._CopyAndAutoreleaseBlockObject;
717pub const ZigClangCK_BuiltinFnToFnPtr = enum_ZigClangCK._BuiltinFnToFnPtr;
718pub const ZigClangCK_ZeroToOCLOpaqueType = enum_ZigClangCK._ZeroToOCLOpaqueType;
719pub const ZigClangCK_AddressSpaceConversion = enum_ZigClangCK._AddressSpaceConversion;
720pub const ZigClangCK_IntToOCLSampler = enum_ZigClangCK._IntToOCLSampler;
721pub const enum_ZigClangCK = extern enum {
722 _Dependent,
723 _BitCast,
724 _LValueBitCast,
725 _LValueToRValue,
726 _NoOp,
727 _BaseToDerived,
728 _DerivedToBase,
729 _UncheckedDerivedToBase,
730 _Dynamic,
731 _ToUnion,
732 _ArrayToPointerDecay,
733 _FunctionToPointerDecay,
734 _NullToPointer,
735 _NullToMemberPointer,
736 _BaseToDerivedMemberPointer,
737 _DerivedToBaseMemberPointer,
738 _MemberPointerToBoolean,
739 _ReinterpretMemberPointer,
740 _UserDefinedConversion,
741 _ConstructorConversion,
742 _IntegralToPointer,
743 _PointerToIntegral,
744 _PointerToBoolean,
745 _ToVoid,
746 _VectorSplat,
747 _IntegralCast,
748 _IntegralToBoolean,
749 _IntegralToFloating,
750 _FixedPointCast,
751 _FixedPointToBoolean,
752 _FloatingToIntegral,
753 _FloatingToBoolean,
754 _BooleanToSignedIntegral,
755 _FloatingCast,
756 _CPointerToObjCPointerCast,
757 _BlockPointerToObjCPointerCast,
758 _AnyPointerToBlockPointerCast,
759 _ObjCObjectLValueCast,
760 _FloatingRealToComplex,
761 _FloatingComplexToReal,
762 _FloatingComplexToBoolean,
763 _FloatingComplexCast,
764 _FloatingComplexToIntegralComplex,
765 _IntegralRealToComplex,
766 _IntegralComplexToReal,
767 _IntegralComplexToBoolean,
768 _IntegralComplexCast,
769 _IntegralComplexToFloatingComplex,
770 _ARCProduceObject,
771 _ARCConsumeObject,
772 _ARCReclaimReturnedObject,
773 _ARCExtendBlockObject,
774 _AtomicToNonAtomic,
775 _NonAtomicToAtomic,
776 _CopyAndAutoreleaseBlockObject,
777 _BuiltinFnToFnPtr,
778 _ZeroToOCLOpaqueType,
779 _AddressSpaceConversion,
780 _IntToOCLSampler,
781};
782pub const ZigClangAPValueUninitialized = enum_ZigClangAPValueKind.ZigClangAPValueUninitialized;
783pub const ZigClangAPValueInt = enum_ZigClangAPValueKind.ZigClangAPValueInt;
784pub const ZigClangAPValueFloat = enum_ZigClangAPValueKind.ZigClangAPValueFloat;
785pub const ZigClangAPValueComplexInt = enum_ZigClangAPValueKind.ZigClangAPValueComplexInt;
786pub const ZigClangAPValueComplexFloat = enum_ZigClangAPValueKind.ZigClangAPValueComplexFloat;
787pub const ZigClangAPValueLValue = enum_ZigClangAPValueKind.ZigClangAPValueLValue;
788pub const ZigClangAPValueVector = enum_ZigClangAPValueKind.ZigClangAPValueVector;
789pub const ZigClangAPValueArray = enum_ZigClangAPValueKind.ZigClangAPValueArray;
790pub const ZigClangAPValueStruct = enum_ZigClangAPValueKind.ZigClangAPValueStruct;
791pub const ZigClangAPValueUnion = enum_ZigClangAPValueKind.ZigClangAPValueUnion;
792pub const ZigClangAPValueMemberPointer = enum_ZigClangAPValueKind.ZigClangAPValueMemberPointer;
793pub const ZigClangAPValueAddrLabelDiff = enum_ZigClangAPValueKind.ZigClangAPValueAddrLabelDiff;
794pub const enum_ZigClangAPValueKind = extern enum {
795 ZigClangAPValueUninitialized,
796 ZigClangAPValueInt,
797 ZigClangAPValueFloat,
798 ZigClangAPValueComplexInt,
799 ZigClangAPValueComplexFloat,
800 ZigClangAPValueLValue,
801 ZigClangAPValueVector,
802 ZigClangAPValueArray,
803 ZigClangAPValueStruct,
804 ZigClangAPValueUnion,
805 ZigClangAPValueMemberPointer,
806 ZigClangAPValueAddrLabelDiff,
807};
808pub extern fn ZigClangSourceManager_getSpellingLoc(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation;
809pub extern fn ZigClangSourceManager_getFilename(arg0: ?*const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) [*c]const u8;
810pub extern fn ZigClangSourceManager_getSpellingLineNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
811pub extern fn ZigClangSourceManager_getSpellingColumnNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
812pub extern fn ZigClangSourceManager_getCharacterData(arg0: ?*const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [*c]const u8;
813pub extern fn ZigClangASTContext_getPointerType(arg0: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType;
814pub extern fn ZigClangASTUnit_getASTContext(arg0: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext;
815pub extern fn ZigClangASTUnit_getSourceManager(arg0: ?*struct_ZigClangASTUnit) ?*struct_ZigClangSourceManager;
816pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(arg0: ?*struct_ZigClangASTUnit, context: ?*c_void, Fn: ?extern fn (?*c_void, ?*const struct_ZigClangDecl) bool) bool;
817pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) ?*const struct_ZigClangRecordDecl;
818pub extern fn ZigClangEnumType_getDecl(record_ty: ?*const struct_ZigClangEnumType) ?*const struct_ZigClangEnumDecl;
819pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangTagDecl;
820pub extern fn ZigClangEnumDecl_getCanonicalDecl(arg0: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangTagDecl;
821pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(arg0: ?*const struct_ZigClangTypedefNameDecl) ?*const struct_ZigClangTypedefNameDecl;
822pub extern fn ZigClangRecordDecl_getDefinition(arg0: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangRecordDecl;
823pub extern fn ZigClangEnumDecl_getDefinition(arg0: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangEnumDecl;
824pub extern fn ZigClangRecordDecl_getLocation(arg0: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation;
825pub extern fn ZigClangEnumDecl_getLocation(arg0: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation;
826pub extern fn ZigClangTypedefNameDecl_getLocation(arg0: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation;
827pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
828pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool;
829pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
830pub extern fn ZigClangEnumDecl_getIntegerType(arg0: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType;
831pub extern fn ZigClangDecl_getName_bytes_begin(decl: ?*const struct_ZigClangDecl) [*c]const u8;
832pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool;
833pub extern fn ZigClangTypedefType_getDecl(arg0: ?*const struct_ZigClangTypedefType) ?*const struct_ZigClangTypedefNameDecl;
834pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(arg0: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType;
835pub extern fn ZigClangQualType_getCanonicalType(arg0: struct_ZigClangQualType) struct_ZigClangQualType;
836pub extern fn ZigClangQualType_getTypePtr(arg0: struct_ZigClangQualType) ?*const struct_ZigClangType;
837pub extern fn ZigClangQualType_addConst(arg0: [*c]struct_ZigClangQualType) void;
838pub extern fn ZigClangQualType_eq(arg0: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool;
839pub extern fn ZigClangQualType_isConstQualified(arg0: struct_ZigClangQualType) bool;
840pub extern fn ZigClangQualType_isVolatileQualified(arg0: struct_ZigClangQualType) bool;
841pub extern fn ZigClangQualType_isRestrictQualified(arg0: struct_ZigClangQualType) bool;
842pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) enum_ZigClangTypeClass;
843pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool;
844pub extern fn ZigClangType_getTypeClassName(self: ?*const struct_ZigClangType) [*c]const u8;
845pub extern fn ZigClangStmt_getBeginLoc(self: ?*const struct_ZigClangStmt) struct_ZigClangSourceLocation;
846pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) enum_ZigClangStmtClass;
847pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool;
848pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) enum_ZigClangStmtClass;
849pub extern fn ZigClangExpr_getType(self: ?*const struct_ZigClangExpr) struct_ZigClangQualType;
850pub extern fn ZigClangExpr_getBeginLoc(self: ?*const struct_ZigClangExpr) struct_ZigClangSourceLocation;
851pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) enum_ZigClangAPValueKind;
852pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) ?*const struct_ZigClangAPSInt;
853pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
854pub extern fn ZigClangAPValue_getArrayInitializedElt(self: ?*const struct_ZigClangAPValue, i: c_uint) ?*const struct_ZigClangAPValue;
855pub extern fn ZigClangAPValue_getArrayFiller(self: ?*const struct_ZigClangAPValue) ?*const struct_ZigClangAPValue;
856pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
857pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
858pub extern fn ZigClangAPSInt_isSigned(self: ?*const struct_ZigClangAPSInt) bool;
859pub extern fn ZigClangAPSInt_isNegative(self: ?*const struct_ZigClangAPSInt) bool;
860pub extern fn ZigClangAPSInt_negate(self: ?*const struct_ZigClangAPSInt) ?*const struct_ZigClangAPSInt;
861pub extern fn ZigClangAPSInt_free(self: ?*const struct_ZigClangAPSInt) void;
862pub extern fn ZigClangAPSInt_getRawData(self: ?*const struct_ZigClangAPSInt) [*c]const u64;
863pub extern fn ZigClangAPSInt_getNumWords(self: ?*const struct_ZigClangAPSInt) c_uint;
864pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr;
865pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
866pub const ZigClangQualType = struct_ZigClangQualType;
867pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase;
868pub const ZigClangAPValue = struct_ZigClangAPValue;
869pub const ZigClangAPSInt = struct_ZigClangAPSInt;
870pub const ZigClangASTContext = struct_ZigClangASTContext;
871pub const ZigClangASTUnit = struct_ZigClangASTUnit;
872pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr;
873pub const ZigClangArrayType = struct_ZigClangArrayType;
874pub const ZigClangAttributedType = struct_ZigClangAttributedType;
875pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator;
876pub const ZigClangBreakStmt = struct_ZigClangBreakStmt;
877pub const ZigClangBuiltinType = struct_ZigClangBuiltinType;
878pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr;
879pub const ZigClangCallExpr = struct_ZigClangCallExpr;
880pub const ZigClangCaseStmt = struct_ZigClangCaseStmt;
881pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator;
882pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt;
883pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator;
884pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType;
885pub const ZigClangContinueStmt = struct_ZigClangContinueStmt;
886pub const ZigClangDecayedType = struct_ZigClangDecayedType;
887pub const ZigClangDecl = struct_ZigClangDecl;
888pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr;
889pub const ZigClangDeclStmt = struct_ZigClangDeclStmt;
890pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt;
891pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions;
892pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine;
893pub const ZigClangDoStmt = struct_ZigClangDoStmt;
894pub const ZigClangElaboratedType = struct_ZigClangElaboratedType;
895pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl;
896pub const ZigClangEnumDecl = struct_ZigClangEnumDecl;
897pub const ZigClangEnumType = struct_ZigClangEnumType;
898pub const ZigClangExpr = struct_ZigClangExpr;
899pub const ZigClangFieldDecl = struct_ZigClangFieldDecl;
900pub const ZigClangFileID = struct_ZigClangFileID;
901pub const ZigClangForStmt = struct_ZigClangForStmt;
902pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc;
903pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl;
904pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType;
905pub const ZigClangIfStmt = struct_ZigClangIfStmt;
906pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
907pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
908pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
909pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
910pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
911pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
912pub const ZigClangNone = struct_ZigClangNone;
913pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations;
914pub const ZigClangParenExpr = struct_ZigClangParenExpr;
915pub const ZigClangParenType = struct_ZigClangParenType;
916pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl;
917pub const ZigClangPointerType = struct_ZigClangPointerType;
918pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity;
919pub const ZigClangRecordDecl = struct_ZigClangRecordDecl;
920pub const ZigClangRecordType = struct_ZigClangRecordType;
921pub const ZigClangReturnStmt = struct_ZigClangReturnStmt;
922pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope;
923pub const ZigClangSourceManager = struct_ZigClangSourceManager;
924pub const ZigClangSourceRange = struct_ZigClangSourceRange;
925pub const ZigClangStmt = struct_ZigClangStmt;
926pub const ZigClangStorageClass = struct_ZigClangStorageClass;
927pub const ZigClangStringLiteral = struct_ZigClangStringLiteral;
928pub const ZigClangStringRef = struct_ZigClangStringRef;
929pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt;
930pub const ZigClangTagDecl = struct_ZigClangTagDecl;
931pub const ZigClangType = struct_ZigClangType;
932pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl;
933pub const ZigClangTypedefType = struct_ZigClangTypedefType;
934pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr;
935pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
936pub const ZigClangValueDecl = struct_ZigClangValueDecl;
937pub const ZigClangVarDecl = struct_ZigClangVarDecl;
938pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
939pub const ZigClangBO = enum_ZigClangBO;
940pub const ZigClangUO = enum_ZigClangUO;
941pub const ZigClangTypeClass = enum_ZigClangTypeClass;
942pub const ZigClangStmtClass = enum_ZigClangStmtClass;
943pub const ZigClangCK = enum_ZigClangCK;
944pub const ZigClangAPValueKind = enum_ZigClangAPValueKind;
src-self-hosted/stage1.zig+92-3
......@@ -1,8 +1,7 @@
11// This is Zig code that is used by both stage1 and stage2.
22// The prototypes in src/userland.h must match these definitions.
3comptime {
4 _ = @import("translate_c.zig");
5}
3
4const std = @import("std");
65
76pub const info_zen =
87 \\
......@@ -29,3 +28,93 @@ export fn stage2_zen(ptr: *[*]const u8, len: *usize) void {
2928export fn stage2_panic(ptr: [*]const u8, len: usize) void {
3029 @panic(ptr[0..len]);
3130}
31
32const TranslateMode = extern enum {
33 import,
34 translate,
35};
36
37const Error = extern enum {
38 None,
39 OutOfMemory,
40 InvalidFormat,
41 SemanticAnalyzeFail,
42 AccessDenied,
43 Interrupted,
44 SystemResources,
45 FileNotFound,
46 FileSystem,
47 FileTooBig,
48 DivByZero,
49 Overflow,
50 PathAlreadyExists,
51 Unexpected,
52 ExactDivRemainder,
53 NegativeDenominator,
54 ShiftedOutOneBits,
55 CCompileErrors,
56 EndOfFile,
57 IsDir,
58 NotDir,
59 UnsupportedOperatingSystem,
60 SharingViolation,
61 PipeBusy,
62 PrimitiveTypeNotFound,
63 CacheUnavailable,
64 PathTooLong,
65 CCompilerCannotFindFile,
66 ReadingDepFile,
67 InvalidDepFile,
68 MissingArchitecture,
69 MissingOperatingSystem,
70 UnknownArchitecture,
71 UnknownOperatingSystem,
72 UnknownABI,
73 InvalidFilename,
74 DiskQuota,
75 DiskSpace,
76 UnexpectedWriteFailure,
77 UnexpectedSeekFailure,
78 UnexpectedFileTruncationFailure,
79 Unimplemented,
80 OperationAborted,
81 BrokenPipe,
82 NoSpaceLeft,
83};
84
85const FILE = std.c.FILE;
86const ast = std.zig.ast;
87
88/// Args should have a null terminating last arg.
89export fn stage2_translate_c(
90 out_ast: **ast.Tree,
91 args_begin: [*]?[*]const u8,
92 args_end: [*]?[*]const u8,
93 mode: TranslateMode,
94) Error {
95 const translate_c = @import("translate_c.zig");
96 out_ast.* = translate_c.translate(args_begin, args_end, switch (mode) {
97 .import => translate_c.Mode.import,
98 .translate => translate_c.Mode.translate,
99 }) catch |err| switch (err) {
100 error.Unimplemented => return Error.Unimplemented,
101 };
102 return Error.None;
103}
104
105export fn stage2_render_ast(tree: *ast.Tree, output_file: *FILE) Error {
106 const c_out_stream = &std.io.COutStream.init(output_file).stream;
107 _ = std.zig.render(std.heap.c_allocator, c_out_stream, tree) catch |e| switch (e) {
108 error.SystemResources => return Error.SystemResources,
109 error.OperationAborted => return Error.OperationAborted,
110 error.BrokenPipe => return Error.BrokenPipe,
111 error.DiskQuota => return Error.DiskQuota,
112 error.FileTooBig => return Error.FileTooBig,
113 error.NoSpaceLeft => return Error.NoSpaceLeft,
114 error.AccessDenied => return Error.AccessDenied,
115 error.OutOfMemory => return Error.OutOfMemory,
116 error.Unexpected => return Error.Unexpected,
117 error.InputOutput => return Error.FileSystem,
118 };
119 return Error.None;
120}
src-self-hosted/translate_c.zig+9-2
......@@ -2,7 +2,14 @@
22// and stage2. Currently it's not used by anything, as it's not feature complete.
33
44const std = @import("std");
5const ast = std.zig.ast;
6use @import("clang.zig");
57
6export fn stage2_translate_c() void {
7 std.debug.panic("unimplemented");
8pub const Mode = enum {
9 import,
10 translate,
11};
12
13pub fn translate(args_begin: [*]?[*]const u8, args_end: [*]?[*]const u8, mode: Mode) !*ast.Tree {
14 return error.Unimplemented;
815}
src/analyze.cpp+1-1
......@@ -3725,7 +3725,7 @@ static void analyze_fn_body(CodeGen *g, ZigFn *fn_table_entry) {
37253725 }
37263726 if (g->verbose_ir) {
37273727 fprintf(stderr, "\n");
3728 ast_render(g, stderr, fn_table_entry->body_node, 4);
3728 ast_render(stderr, fn_table_entry->body_node, 4);
37293729 fprintf(stderr, "\n{ // (IR)\n");
37303730 ir_print(g, stderr, &fn_table_entry->ir_executable, 4);
37313731 fprintf(stderr, "}\n");
src/analyze.hpp+2
......@@ -247,4 +247,6 @@ Error create_c_object_cache(CodeGen *g, CacheHash **out_cache_hash, bool verbose
247247LLVMTypeRef get_llvm_type(CodeGen *g, ZigType *type);
248248ZigLLVMDIType *get_llvm_di_type(CodeGen *g, ZigType *type);
249249
250void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_path, bool translate_c);
251
250252#endif
src/ast_render.cpp+1-3
......@@ -296,7 +296,6 @@ void ast_print(FILE *f, AstNode *node, int indent) {
296296
297297
298298struct AstRender {
299 CodeGen *codegen;
300299 int indent;
301300 int indent_size;
302301 FILE *f;
......@@ -1170,9 +1169,8 @@ static void render_node_extra(AstRender *ar, AstNode *node, bool grouped) {
11701169}
11711170
11721171
1173void ast_render(CodeGen *codegen, FILE *f, AstNode *node, int indent_size) {
1172void ast_render(FILE *f, AstNode *node, int indent_size) {
11741173 AstRender ar = {0};
1175 ar.codegen = codegen;
11761174 ar.f = f;
11771175 ar.indent_size = indent_size;
11781176 ar.indent = 0;
src/ast_render.hpp+1-1
......@@ -15,6 +15,6 @@
1515
1616void ast_print(FILE *f, AstNode *node, int indent);
1717
18void ast_render(CodeGen *codegen, FILE *f, AstNode *node, int indent_size);
18void ast_render(FILE *f, AstNode *node, int indent_size);
1919
2020#endif
src/codegen.cpp+156-115
......@@ -8153,7 +8153,128 @@ static void detect_libc(CodeGen *g) {
81538153 }
81548154}
81558155
8156AstNode *codegen_translate_c(CodeGen *g, Buf *full_path, bool use_userland_implementation) {
8156// does not add the "cc" arg
8157void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_path, bool translate_c) {
8158 if (out_dep_path != nullptr) {
8159 args.append("-MD");
8160 args.append("-MV");
8161 args.append("-MF");
8162 args.append(out_dep_path);
8163 }
8164
8165 args.append("-nostdinc");
8166 args.append("-fno-spell-checking");
8167
8168 if (translate_c) {
8169 // TODO these args shouldn't be special from the non-translate-c args, probably.
8170 args.append("-nobuiltininc");
8171 args.append("-nostdinc++");
8172 if (g->libc_link_lib == nullptr) {
8173 args.append("-nolibc");
8174 }
8175
8176 // this gives us access to preprocessing entities, presumably at
8177 // the cost of performance
8178 args.append("-Xclang");
8179 args.append("-detailed-preprocessing-record");
8180 } else {
8181 switch (g->err_color) {
8182 case ErrColorAuto:
8183 break;
8184 case ErrColorOff:
8185 args.append("-fno-color-diagnostics");
8186 args.append("-fno-caret-diagnostics");
8187 break;
8188 case ErrColorOn:
8189 args.append("-fcolor-diagnostics");
8190 args.append("-fcaret-diagnostics");
8191 break;
8192 }
8193 }
8194
8195 args.append("-isystem");
8196 args.append(buf_ptr(g->zig_c_headers_dir));
8197
8198 for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
8199 Buf *include_dir = g->libc_include_dir_list[i];
8200 args.append("-isystem");
8201 args.append(buf_ptr(include_dir));
8202 }
8203
8204 if (g->zig_target->is_native) {
8205 args.append("-march=native");
8206 } else {
8207 args.append("-target");
8208 args.append(buf_ptr(&g->triple_str));
8209 }
8210 if (g->zig_target->os == OsFreestanding) {
8211 args.append("-ffreestanding");
8212 }
8213
8214 if (!g->strip_debug_symbols) {
8215 args.append("-g");
8216 }
8217
8218 switch (g->build_mode) {
8219 case BuildModeDebug:
8220 // windows c runtime requires -D_DEBUG if using debug libraries
8221 args.append("-D_DEBUG");
8222
8223 if (g->libc_link_lib != nullptr) {
8224 args.append("-fstack-protector-strong");
8225 args.append("--param");
8226 args.append("ssp-buffer-size=4");
8227 } else {
8228 args.append("-fno-stack-protector");
8229 }
8230 args.append("-fno-omit-frame-pointer");
8231 break;
8232 case BuildModeSafeRelease:
8233 // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
8234 // than -O3 here.
8235 args.append("-O2");
8236 if (g->libc_link_lib != nullptr) {
8237 args.append("-D_FORTIFY_SOURCE=2");
8238 args.append("-fstack-protector-strong");
8239 args.append("--param");
8240 args.append("ssp-buffer-size=4");
8241 } else {
8242 args.append("-fno-stack-protector");
8243 }
8244 args.append("-fomit-frame-pointer");
8245 break;
8246 case BuildModeFastRelease:
8247 args.append("-DNDEBUG");
8248 // Here we pass -O2 rather than -O3 because, although we do the equivalent of
8249 // -O3 in Zig code, the justification for the difference here is that Zig
8250 // has better detection and prevention of undefined behavior, so -O3 is safer for
8251 // Zig code than it is for C code. Also, C programmers are used to their code
8252 // running in -O2 and thus the -O3 path has been tested less.
8253 args.append("-O2");
8254 args.append("-fno-stack-protector");
8255 args.append("-fomit-frame-pointer");
8256 break;
8257 case BuildModeSmallRelease:
8258 args.append("-DNDEBUG");
8259 args.append("-Os");
8260 args.append("-fno-stack-protector");
8261 args.append("-fomit-frame-pointer");
8262 break;
8263 }
8264
8265 if (target_supports_fpic(g->zig_target) && g->have_pic) {
8266 args.append("-fPIC");
8267 }
8268
8269 for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
8270 args.append(g->clang_argv[arg_i]);
8271 }
8272
8273
8274}
8275
8276void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation) {
8277 Error err;
81578278 Buf *src_basename = buf_alloc();
81588279 Buf *src_dirname = buf_alloc();
81598280 os_path_split(full_path, src_dirname, src_basename);
......@@ -8165,30 +8286,45 @@ AstNode *codegen_translate_c(CodeGen *g, Buf *full_path, bool use_userland_imple
81658286
81668287 init(g);
81678288
8289 Stage2TranslateMode trans_mode = buf_ends_with_str(full_path, ".h") ?
8290 Stage2TranslateModeImport : Stage2TranslateModeTranslate;
8291
8292
8293 ZigList<const char *> clang_argv = {0};
8294 add_cc_args(g, clang_argv, nullptr, true);
8295
8296 clang_argv.append("-c");
8297 clang_argv.append(buf_ptr(full_path));
8298
8299 clang_argv.append(nullptr); // to make the [start...end] argument work
8300
81688301 if (use_userland_implementation) {
8169 // TODO improve this
8170 stage2_translate_c();
8171 zig_panic("TODO");
8172 }
8302 Stage2Ast *ast;
8303 if ((err = stage2_translate_c(&ast, &clang_argv.at(0), &clang_argv.last(), trans_mode))) {
8304 zig_panic("TODO");
8305 }
8306 stage2_render_ast(ast, out_file);
8307 } else {
8308 ZigList<ErrorMsg *> errors = {0};
8309 AstNode *root_node;
81738310
8174 ZigList<ErrorMsg *> errors = {0};
8175 AstNode *root_node;
8176 Error err = parse_h_file(&root_node, &errors, buf_ptr(full_path), g, nullptr);
8311 err = parse_h_file(g, &root_node, &clang_argv.at(0), &clang_argv.last(), trans_mode, &errors);
81778312
8178 if (err == ErrorCCompileErrors && errors.length > 0) {
8179 for (size_t i = 0; i < errors.length; i += 1) {
8180 ErrorMsg *err_msg = errors.at(i);
8181 print_err_msg(err_msg, g->err_color);
8313 if (err == ErrorCCompileErrors && errors.length > 0) {
8314 for (size_t i = 0; i < errors.length; i += 1) {
8315 ErrorMsg *err_msg = errors.at(i);
8316 print_err_msg(err_msg, g->err_color);
8317 }
8318 exit(1);
81828319 }
8183 exit(1);
8184 }
81858320
8186 if (err) {
8187 fprintf(stderr, "unable to parse C file: %s\n", err_str(err));
8188 exit(1);
8189 }
8321 if (err) {
8322 fprintf(stderr, "unable to parse C file: %s\n", err_str(err));
8323 exit(1);
8324 }
81908325
8191 return root_node;
8326 ast_render(out_file, root_node, 4);
8327 }
81928328}
81938329
81948330static ZigType *add_special_code(CodeGen *g, ZigPackage *package, const char *basename) {
......@@ -8507,93 +8643,7 @@ static void gen_c_object(CodeGen *g, Buf *self_exe_path, CFile *c_file) {
85078643 args.append("cc");
85088644
85098645 Buf *out_dep_path = buf_sprintf("%s.d", buf_ptr(out_obj_path));
8510 args.append("-MD");
8511 args.append("-MV");
8512 args.append("-MF");
8513 args.append(buf_ptr(out_dep_path));
8514
8515 args.append("-nostdinc");
8516 args.append("-fno-spell-checking");
8517
8518 switch (g->err_color) {
8519 case ErrColorAuto:
8520 break;
8521 case ErrColorOff:
8522 args.append("-fno-color-diagnostics");
8523 args.append("-fno-caret-diagnostics");
8524 break;
8525 case ErrColorOn:
8526 args.append("-fcolor-diagnostics");
8527 args.append("-fcaret-diagnostics");
8528 break;
8529 }
8530
8531 args.append("-isystem");
8532 args.append(buf_ptr(g->zig_c_headers_dir));
8533
8534 for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
8535 Buf *include_dir = g->libc_include_dir_list[i];
8536 args.append("-isystem");
8537 args.append(buf_ptr(include_dir));
8538 }
8539
8540 if (g->zig_target->is_native) {
8541 args.append("-march=native");
8542 } else {
8543 args.append("-target");
8544 args.append(buf_ptr(&g->triple_str));
8545 }
8546 if (g->zig_target->os == OsFreestanding) {
8547 args.append("-ffreestanding");
8548 }
8549
8550 if (!g->strip_debug_symbols) {
8551 args.append("-g");
8552 }
8553
8554 switch (g->build_mode) {
8555 case BuildModeDebug:
8556 if (g->libc_link_lib != nullptr) {
8557 args.append("-fstack-protector-strong");
8558 args.append("--param");
8559 args.append("ssp-buffer-size=4");
8560 } else {
8561 args.append("-fno-stack-protector");
8562 }
8563 args.append("-fno-omit-frame-pointer");
8564 break;
8565 case BuildModeSafeRelease:
8566 // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
8567 // than -O3 here.
8568 args.append("-O2");
8569 if (g->libc_link_lib != nullptr) {
8570 args.append("-D_FORTIFY_SOURCE=2");
8571 args.append("-fstack-protector-strong");
8572 args.append("--param");
8573 args.append("ssp-buffer-size=4");
8574 } else {
8575 args.append("-fno-stack-protector");
8576 }
8577 args.append("-fomit-frame-pointer");
8578 break;
8579 case BuildModeFastRelease:
8580 args.append("-DNDEBUG");
8581 // Here we pass -O2 rather than -O3 because, although we do the equivalent of
8582 // -O3 in Zig code, the justification for the difference here is that Zig
8583 // has better detection and prevention of undefined behavior, so -O3 is safer for
8584 // Zig code than it is for C code. Also, C programmers are used to their code
8585 // running in -O2 and thus the -O3 path has been tested less.
8586 args.append("-O2");
8587 args.append("-fno-stack-protector");
8588 args.append("-fomit-frame-pointer");
8589 break;
8590 case BuildModeSmallRelease:
8591 args.append("-DNDEBUG");
8592 args.append("-Os");
8593 args.append("-fno-stack-protector");
8594 args.append("-fomit-frame-pointer");
8595 break;
8596 }
8646 add_cc_args(g, args, buf_ptr(out_dep_path), false);
85978647
85988648 args.append("-o");
85998649 args.append(buf_ptr(out_obj_path));
......@@ -8601,19 +8651,10 @@ static void gen_c_object(CodeGen *g, Buf *self_exe_path, CFile *c_file) {
86018651 args.append("-c");
86028652 args.append(buf_ptr(c_source_file));
86038653
8604 if (target_supports_fpic(g->zig_target) && g->have_pic) {
8605 args.append("-fPIC");
8606 }
8607
8608 for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
8609 args.append(g->clang_argv[arg_i]);
8610 }
8611
86128654 for (size_t arg_i = 0; arg_i < c_file->args.length; arg_i += 1) {
86138655 args.append(c_file->args.at(arg_i));
86148656 }
86158657
8616
86178658 if (g->verbose_cc) {
86188659 print_zig_cc_cmd("zig", &args);
86198660 }
src/codegen.hpp+2-1
......@@ -12,6 +12,7 @@
1212#include "errmsg.hpp"
1313#include "target.hpp"
1414#include "libc_installation.hpp"
15#include "userland.h"
1516
1617#include <stdio.h>
1718
......@@ -50,7 +51,7 @@ ZigPackage *codegen_create_package(CodeGen *g, const char *root_src_dir, const c
5051void codegen_add_assembly(CodeGen *g, Buf *path);
5152void codegen_add_object(CodeGen *g, Buf *object_path);
5253
53AstNode *codegen_translate_c(CodeGen *g, Buf *path, bool use_userland_implementation);
54void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation);
5455
5556Buf *codegen_generate_builtin_source(CodeGen *g);
5657
src/error.cpp+4
......@@ -50,6 +50,10 @@ const char *err_str(Error err) {
5050 case ErrorUnexpectedWriteFailure: return "unexpected write failure";
5151 case ErrorUnexpectedSeekFailure: return "unexpected seek failure";
5252 case ErrorUnexpectedFileTruncationFailure: return "unexpected file truncation failure";
53 case ErrorUnimplemented: return "unimplemented";
54 case ErrorOperationAborted: return "operation aborted";
55 case ErrorBrokenPipe: return "broken pipe";
56 case ErrorNoSpaceLeft: return "no space left";
5357 }
5458 return "(invalid error)";
5559}
src/error.hpp+1-43
......@@ -8,49 +8,7 @@
88#ifndef ERROR_HPP
99#define ERROR_HPP
1010
11enum Error {
12 ErrorNone,
13 ErrorNoMem,
14 ErrorInvalidFormat,
15 ErrorSemanticAnalyzeFail,
16 ErrorAccess,
17 ErrorInterrupted,
18 ErrorSystemResources,
19 ErrorFileNotFound,
20 ErrorFileSystem,
21 ErrorFileTooBig,
22 ErrorDivByZero,
23 ErrorOverflow,
24 ErrorPathAlreadyExists,
25 ErrorUnexpected,
26 ErrorExactDivRemainder,
27 ErrorNegativeDenominator,
28 ErrorShiftedOutOneBits,
29 ErrorCCompileErrors,
30 ErrorEndOfFile,
31 ErrorIsDir,
32 ErrorNotDir,
33 ErrorUnsupportedOperatingSystem,
34 ErrorSharingViolation,
35 ErrorPipeBusy,
36 ErrorPrimitiveTypeNotFound,
37 ErrorCacheUnavailable,
38 ErrorPathTooLong,
39 ErrorCCompilerCannotFindFile,
40 ErrorReadingDepFile,
41 ErrorInvalidDepFile,
42 ErrorMissingArchitecture,
43 ErrorMissingOperatingSystem,
44 ErrorUnknownArchitecture,
45 ErrorUnknownOperatingSystem,
46 ErrorUnknownABI,
47 ErrorInvalidFilename,
48 ErrorDiskQuota,
49 ErrorDiskSpace,
50 ErrorUnexpectedWriteFailure,
51 ErrorUnexpectedSeekFailure,
52 ErrorUnexpectedFileTruncationFailure,
53};
11#include "userland.h"
5412
5513const char *err_str(Error err);
5614
src/ir.cpp+17-5
......@@ -10350,7 +10350,7 @@ ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *nod
1035010350
1035110351 if (codegen->verbose_ir) {
1035210352 fprintf(stderr, "\nSource: ");
10353 ast_render(codegen, stderr, node, 4);
10353 ast_render(stderr, node, 4);
1035410354 fprintf(stderr, "\n{ // (IR)\n");
1035510355 ir_print(codegen, stderr, ir_executable, 2);
1035610356 fprintf(stderr, "}\n");
......@@ -19092,11 +19092,23 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
1909219092 fprintf(stderr, "@cImport source: %s\n", buf_ptr(&tmp_c_file_path));
1909319093 }
1909419094
19095 ZigList<ErrorMsg *> errors = {0};
19096
1909719095 Buf *tmp_dep_file = buf_sprintf("%s.d", buf_ptr(&tmp_c_file_path));
19096
19097 ZigList<const char *> clang_argv = {0};
19098
19099 add_cc_args(ira->codegen, clang_argv, buf_ptr(tmp_dep_file), true);
19100
19101 clang_argv.append("-c");
19102 clang_argv.append(buf_ptr(&tmp_c_file_path));
19103
19104 clang_argv.append(nullptr); // to make the [start...end] argument work
19105
19106 ZigList<ErrorMsg *> errors = {0};
1909819107 AstNode *root_node;
19099 if ((err = parse_h_file(&root_node, &errors, buf_ptr(&tmp_c_file_path), ira->codegen, tmp_dep_file))) {
19108
19109 if ((err = parse_h_file(ira->codegen, &root_node, &clang_argv.at(0), &clang_argv.last(),
19110 Stage2TranslateModeImport, &errors)))
19111 {
1910019112 if (err != ErrorCCompileErrors) {
1910119113 ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
1910219114 return ira->codegen->invalid_instruction;
......@@ -19139,7 +19151,7 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
1913919151 buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));
1914019152 return ira->codegen->invalid_instruction;
1914119153 }
19142 ast_render(ira->codegen, out_file, root_node, 4);
19154 ast_render(out_file, root_node, 4);
1914319155 if (fclose(out_file) != 0) {
1914419156 ir_add_error_node(ira, node,
1914519157 buf_sprintf("C import failed: unable to write to output file: %s", strerror(errno)));
src/main.cpp+1-2
......@@ -1188,8 +1188,7 @@ int main(int argc, char **argv) {
11881188 zig_unreachable();
11891189 }
11901190 } else if (cmd == CmdTranslateC || cmd == CmdTranslateCUserland) {
1191 AstNode *root_node = codegen_translate_c(g, in_file_buf, cmd == CmdTranslateCUserland);
1192 ast_render(g, stdout, root_node, 4);
1191 codegen_translate_c(g, in_file_buf, stdout, cmd == CmdTranslateCUserland);
11931192 if (timing_info)
11941193 codegen_print_timing_report(g, stderr);
11951194 return EXIT_SUCCESS;
src/translate_c.cpp+4-90
......@@ -5018,14 +5018,14 @@ static void process_preprocessor_entities(Context *c, ZigClangASTUnit *zunit) {
50185018 }
50195019}
50205020
5021Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const char *target_file,
5022 CodeGen *codegen, Buf *tmp_dep_file)
5021Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, const char **args_begin, const char **args_end,
5022 Stage2TranslateMode mode, ZigList<ErrorMsg *> *errors)
50235023{
50245024 Context context = {0};
50255025 Context *c = &context;
50265026 c->warnings_on = codegen->verbose_cimport;
50275027 c->errors = errors;
5028 if (buf_ends_with_str(buf_create_from_str(target_file), ".h")) {
5028 if (mode == Stage2TranslateModeImport) {
50295029 c->visib_mod = VisibModPub;
50305030 c->want_export = false;
50315031 } else {
......@@ -5039,92 +5039,6 @@ Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const c
50395039 c->codegen = codegen;
50405040 c->global_scope = trans_scope_root_create(c);
50415041
5042 ZigList<const char *> clang_argv = {0};
5043
5044 clang_argv.append("-x");
5045 clang_argv.append("c");
5046
5047 if (tmp_dep_file != nullptr) {
5048 clang_argv.append("-MD");
5049 clang_argv.append("-MV");
5050 clang_argv.append("-MF");
5051 clang_argv.append(buf_ptr(tmp_dep_file));
5052 }
5053
5054 if (c->codegen->zig_target->is_native) {
5055 char *ZIG_PARSEC_CFLAGS = getenv("ZIG_NATIVE_PARSEC_CFLAGS");
5056 if (ZIG_PARSEC_CFLAGS) {
5057 Buf tmp_buf = BUF_INIT;
5058 char *start = ZIG_PARSEC_CFLAGS;
5059 char *space = strstr(start, " ");
5060 while (space) {
5061 if (space - start > 0) {
5062 buf_init_from_mem(&tmp_buf, start, space - start);
5063 clang_argv.append(buf_ptr(buf_create_from_buf(&tmp_buf)));
5064 }
5065 start = space + 1;
5066 space = strstr(start, " ");
5067 }
5068 buf_init_from_str(&tmp_buf, start);
5069 clang_argv.append(buf_ptr(buf_create_from_buf(&tmp_buf)));
5070 }
5071 }
5072
5073 clang_argv.append("-nobuiltininc");
5074 clang_argv.append("-nostdinc");
5075 clang_argv.append("-nostdinc++");
5076 if (codegen->libc_link_lib == nullptr) {
5077 clang_argv.append("-nolibc");
5078 }
5079
5080 clang_argv.append("-isystem");
5081 clang_argv.append(buf_ptr(codegen->zig_c_headers_dir));
5082
5083 for (size_t i = 0; i < codegen->libc_include_dir_len; i += 1) {
5084 Buf *include_dir = codegen->libc_include_dir_list[i];
5085 clang_argv.append("-isystem");
5086 clang_argv.append(buf_ptr(include_dir));
5087 }
5088
5089 // windows c runtime requires -D_DEBUG if using debug libraries
5090 if (codegen->build_mode == BuildModeDebug) {
5091 clang_argv.append("-D_DEBUG");
5092 }
5093
5094 for (size_t i = 0; i < codegen->clang_argv_len; i += 1) {
5095 clang_argv.append(codegen->clang_argv[i]);
5096 }
5097
5098 // we don't need spell checking and it slows things down
5099 clang_argv.append("-fno-spell-checking");
5100
5101 // this gives us access to preprocessing entities, presumably at
5102 // the cost of performance
5103 clang_argv.append("-Xclang");
5104 clang_argv.append("-detailed-preprocessing-record");
5105
5106 if (c->codegen->zig_target->is_native) {
5107 clang_argv.append("-march=native");
5108 } else {
5109 clang_argv.append("-target");
5110 clang_argv.append(buf_ptr(&c->codegen->triple_str));
5111 }
5112 if (c->codegen->zig_target->os == OsFreestanding) {
5113 clang_argv.append("-ffreestanding");
5114 }
5115
5116 clang_argv.append(target_file);
5117
5118 if (codegen->verbose_cc) {
5119 fprintf(stderr, "clang");
5120 for (size_t i = 0; i < clang_argv.length; i += 1) {
5121 fprintf(stderr, " %s", clang_argv.at(i));
5122 }
5123 fprintf(stderr, "\n");
5124 }
5125
5126 // to make the [start...end] argument work
5127 clang_argv.append(nullptr);
51285042
51295043 clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));
51305044
......@@ -5139,7 +5053,7 @@ Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const c
51395053 const char *resources_path = buf_ptr(codegen->zig_c_headers_dir);
51405054 std::unique_ptr<clang::ASTUnit> err_unit;
51415055 ZigClangASTUnit *ast_unit = reinterpret_cast<ZigClangASTUnit *>(clang::ASTUnit::LoadFromCommandLine(
5142 &clang_argv.at(0), &clang_argv.last(),
5056 args_begin, args_end,
51435057 pch_container_ops, diags, resources_path,
51445058 only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,
51455059 false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,
src/translate_c.hpp+2-2
......@@ -11,7 +11,7 @@
1111
1212#include "all_types.hpp"
1313
14Error parse_h_file(AstNode **out_root_node, ZigList<ErrorMsg *> *errors, const char *target_file,
15 CodeGen *codegen, Buf *tmp_dep_file);
14Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, const char **args_begin, const char **args_end,
15 Stage2TranslateMode mode, ZigList<ErrorMsg *> *errors);
1616
1717#endif
src/userland.cpp+9-1
......@@ -2,11 +2,14 @@
22// src-self-hosted/stage1.zig
33
44#include "userland.h"
5#include "ast_render.hpp"
56#include <stdio.h>
67#include <stdlib.h>
78#include <string.h>
89
9void stage2_translate_c(void) {
10Error stage2_translate_c(struct Stage2Ast **out_ast,
11 const char **args_begin, const char **args_end, enum Stage2TranslateMode mode)
12{
1013 const char *msg = "stage0 called stage2_translate_c";
1114 stage2_panic(msg, strlen(msg));
1215}
......@@ -22,3 +25,8 @@ void stage2_panic(const char *ptr, size_t len) {
2225 fflush(stderr);
2326 abort();
2427}
28
29void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file) {
30 const char *msg = "stage0 called stage2_render_ast";
31 stage2_panic(msg, strlen(msg));
32}
src/userland.h+70-2
......@@ -9,6 +9,7 @@
99#define ZIG_USERLAND_H
1010
1111#include <stddef.h>
12#include <stdio.h>
1213
1314#ifdef __cplusplus
1415#define ZIG_USERLAND_EXTERN_C extern "C"
......@@ -16,10 +17,77 @@
1617#define ZIG_USERLAND_EXTERN_C
1718#endif
1819
19ZIG_USERLAND_EXTERN_C void stage2_translate_c(void);
20#if defined(_MSC_VER)
21#define ZIG_USERLAND_ATTRIBUTE_NORETURN __declspec(noreturn)
22#else
23#define ZIG_USERLAND_ATTRIBUTE_NORETURN __attribute__((noreturn))
24#endif
25
26// The types and declarations in this file must match both those in userland.cpp and
27// src-self-hosted/stage1.zig.
28
29enum Error {
30 ErrorNone,
31 ErrorNoMem,
32 ErrorInvalidFormat,
33 ErrorSemanticAnalyzeFail,
34 ErrorAccess,
35 ErrorInterrupted,
36 ErrorSystemResources,
37 ErrorFileNotFound,
38 ErrorFileSystem,
39 ErrorFileTooBig,
40 ErrorDivByZero,
41 ErrorOverflow,
42 ErrorPathAlreadyExists,
43 ErrorUnexpected,
44 ErrorExactDivRemainder,
45 ErrorNegativeDenominator,
46 ErrorShiftedOutOneBits,
47 ErrorCCompileErrors,
48 ErrorEndOfFile,
49 ErrorIsDir,
50 ErrorNotDir,
51 ErrorUnsupportedOperatingSystem,
52 ErrorSharingViolation,
53 ErrorPipeBusy,
54 ErrorPrimitiveTypeNotFound,
55 ErrorCacheUnavailable,
56 ErrorPathTooLong,
57 ErrorCCompilerCannotFindFile,
58 ErrorReadingDepFile,
59 ErrorInvalidDepFile,
60 ErrorMissingArchitecture,
61 ErrorMissingOperatingSystem,
62 ErrorUnknownArchitecture,
63 ErrorUnknownOperatingSystem,
64 ErrorUnknownABI,
65 ErrorInvalidFilename,
66 ErrorDiskQuota,
67 ErrorDiskSpace,
68 ErrorUnexpectedWriteFailure,
69 ErrorUnexpectedSeekFailure,
70 ErrorUnexpectedFileTruncationFailure,
71 ErrorUnimplemented,
72 ErrorOperationAborted,
73 ErrorBrokenPipe,
74 ErrorNoSpaceLeft,
75};
76
77enum Stage2TranslateMode {
78 Stage2TranslateModeImport,
79 Stage2TranslateModeTranslate,
80};
81
82struct Stage2Ast;
83
84ZIG_USERLAND_EXTERN_C Error stage2_translate_c(struct Stage2Ast **out_ast,
85 const char **args_begin, const char **args_end, enum Stage2TranslateMode mode);
86
87ZIG_USERLAND_EXTERN_C void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file);
2088
2189ZIG_USERLAND_EXTERN_C void stage2_zen(const char **ptr, size_t *len);
2290
23ZIG_USERLAND_EXTERN_C void stage2_panic(const char *ptr, size_t len);
91ZIG_USERLAND_EXTERN_C ZIG_USERLAND_ATTRIBUTE_NORETURN void stage2_panic(const char *ptr, size_t len);
2492
2593#endif
src/zig_clang.h+84-83
......@@ -9,6 +9,7 @@
99#define ZIG_ZIG_CLANG_H
1010
1111#include <inttypes.h>
12#include <stdbool.h>
1213
1314#ifdef __cplusplus
1415#define ZIG_EXTERN_C extern "C"
......@@ -17,8 +18,8 @@
1718#endif
1819
1920// ATTENTION: If you modify this file, be sure to update the corresponding
20// extern function declarations in the self-hosted compiler.
21// Note: not yet, we don't have the corresponding clang.zig yet.
21// extern function declarations in the self-hosted compiler file
22// src-self-hosted/clang.zig.
2223
2324struct ZigClangSourceLocation {
2425 unsigned ID;
......@@ -486,86 +487,86 @@ enum ZigClangAPValueKind {
486487 ZigClangAPValueAddrLabelDiff,
487488};
488489
489ZIG_EXTERN_C ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *,
490 ZigClangSourceLocation Loc);
491ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const ZigClangSourceManager *,
492 ZigClangSourceLocation SpellingLoc);
493ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingLineNumber(const ZigClangSourceManager *,
494 ZigClangSourceLocation Loc);
495ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingColumnNumber(const ZigClangSourceManager *,
496 ZigClangSourceLocation Loc);
497ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const ZigClangSourceManager *,
498 ZigClangSourceLocation SL);
499
500ZIG_EXTERN_C ZigClangQualType ZigClangASTContext_getPointerType(const ZigClangASTContext*, ZigClangQualType T);
501
502ZIG_EXTERN_C ZigClangASTContext *ZigClangASTUnit_getASTContext(ZigClangASTUnit *);
503ZIG_EXTERN_C ZigClangSourceManager *ZigClangASTUnit_getSourceManager(ZigClangASTUnit *);
504ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(ZigClangASTUnit *, void *context,
505 bool (*Fn)(void *context, const ZigClangDecl *decl));
506
507ZIG_EXTERN_C const ZigClangRecordDecl *ZigClangRecordType_getDecl(const ZigClangRecordType *record_ty);
508ZIG_EXTERN_C const ZigClangEnumDecl *ZigClangEnumType_getDecl(const ZigClangEnumType *record_ty);
509
510ZIG_EXTERN_C const ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl *record_decl);
511ZIG_EXTERN_C const ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl *);
512ZIG_EXTERN_C const ZigClangTypedefNameDecl *ZigClangTypedefNameDecl_getCanonicalDecl(const ZigClangTypedefNameDecl *);
513
514ZIG_EXTERN_C const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *);
515ZIG_EXTERN_C const ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const ZigClangEnumDecl *);
516
517ZIG_EXTERN_C ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *);
518ZIG_EXTERN_C ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *);
519ZIG_EXTERN_C ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const ZigClangTypedefNameDecl *);
520
521ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl);
522ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const ZigClangRecordDecl *record_decl);
523ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const ZigClangRecordDecl *record_decl);
524
525ZIG_EXTERN_C ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *);
526
527ZIG_EXTERN_C const char *ZigClangDecl_getName_bytes_begin(const ZigClangDecl *decl);
528
529ZIG_EXTERN_C bool ZigClangSourceLocation_eq(ZigClangSourceLocation a, ZigClangSourceLocation b);
530
531ZIG_EXTERN_C const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *);
532ZIG_EXTERN_C ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *);
533
534ZIG_EXTERN_C ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType);
535ZIG_EXTERN_C const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType);
536ZIG_EXTERN_C void ZigClangQualType_addConst(ZigClangQualType *);
537ZIG_EXTERN_C bool ZigClangQualType_eq(ZigClangQualType, ZigClangQualType);
538ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(ZigClangQualType);
539ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(ZigClangQualType);
540ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(ZigClangQualType);
541
542ZIG_EXTERN_C ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self);
543ZIG_EXTERN_C bool ZigClangType_isVoidType(const ZigClangType *self);
544ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const ZigClangType *self);
545
546ZIG_EXTERN_C ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt *self);
547ZIG_EXTERN_C ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self);
548ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const ZigClangStmt *self);
549
550ZIG_EXTERN_C ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self);
551ZIG_EXTERN_C ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self);
552ZIG_EXTERN_C ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self);
553
554ZIG_EXTERN_C ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self);
555ZIG_EXTERN_C const ZigClangAPSInt *ZigClangAPValue_getInt(const ZigClangAPValue *self);
556ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const ZigClangAPValue *self);
557ZIG_EXTERN_C const ZigClangAPValue *ZigClangAPValue_getArrayInitializedElt(const ZigClangAPValue *self, unsigned i);
558ZIG_EXTERN_C const ZigClangAPValue *ZigClangAPValue_getArrayFiller(const ZigClangAPValue *self);
559ZIG_EXTERN_C unsigned ZigClangAPValue_getArraySize(const ZigClangAPValue *self);
560ZIG_EXTERN_C ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *self);
561
562ZIG_EXTERN_C bool ZigClangAPSInt_isSigned(const ZigClangAPSInt *self);
563ZIG_EXTERN_C bool ZigClangAPSInt_isNegative(const ZigClangAPSInt *self);
564ZIG_EXTERN_C const ZigClangAPSInt *ZigClangAPSInt_negate(const ZigClangAPSInt *self);
565ZIG_EXTERN_C void ZigClangAPSInt_free(const ZigClangAPSInt *self);
566ZIG_EXTERN_C const uint64_t *ZigClangAPSInt_getRawData(const ZigClangAPSInt *self);
567ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const ZigClangAPSInt *self);
568
569ZIG_EXTERN_C const ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(ZigClangAPValueLValueBase self);
490ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *,
491 struct ZigClangSourceLocation Loc);
492ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *,
493 struct ZigClangSourceLocation SpellingLoc);
494ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingLineNumber(const struct ZigClangSourceManager *,
495 struct ZigClangSourceLocation Loc);
496ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingColumnNumber(const struct ZigClangSourceManager *,
497 struct ZigClangSourceLocation Loc);
498ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const struct ZigClangSourceManager *,
499 struct ZigClangSourceLocation SL);
500
501ZIG_EXTERN_C struct ZigClangQualType ZigClangASTContext_getPointerType(const struct ZigClangASTContext*, struct ZigClangQualType T);
502
503ZIG_EXTERN_C struct ZigClangASTContext *ZigClangASTUnit_getASTContext(struct ZigClangASTUnit *);
504ZIG_EXTERN_C struct ZigClangSourceManager *ZigClangASTUnit_getSourceManager(struct ZigClangASTUnit *);
505ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(struct ZigClangASTUnit *, void *context,
506 bool (*Fn)(void *context, const struct ZigClangDecl *decl));
507
508ZIG_EXTERN_C const struct ZigClangRecordDecl *ZigClangRecordType_getDecl(const struct ZigClangRecordType *record_ty);
509ZIG_EXTERN_C const struct ZigClangEnumDecl *ZigClangEnumType_getDecl(const struct ZigClangEnumType *record_ty);
510
511ZIG_EXTERN_C const struct ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const struct ZigClangRecordDecl *record_decl);
512ZIG_EXTERN_C const struct ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const struct ZigClangEnumDecl *);
513ZIG_EXTERN_C const struct ZigClangTypedefNameDecl *ZigClangTypedefNameDecl_getCanonicalDecl(const struct ZigClangTypedefNameDecl *);
514
515ZIG_EXTERN_C const struct ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const struct ZigClangRecordDecl *);
516ZIG_EXTERN_C const struct ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const struct ZigClangEnumDecl *);
517
518ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangRecordDecl_getLocation(const struct ZigClangRecordDecl *);
519ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangEnumDecl_getLocation(const struct ZigClangEnumDecl *);
520ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const struct ZigClangTypedefNameDecl *);
521
522ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const struct ZigClangRecordDecl *record_decl);
523ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const struct ZigClangRecordDecl *record_decl);
524ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const struct ZigClangRecordDecl *record_decl);
525
526ZIG_EXTERN_C struct ZigClangQualType ZigClangEnumDecl_getIntegerType(const struct ZigClangEnumDecl *);
527
528ZIG_EXTERN_C const char *ZigClangDecl_getName_bytes_begin(const struct ZigClangDecl *decl);
529
530ZIG_EXTERN_C bool ZigClangSourceLocation_eq(struct ZigClangSourceLocation a, struct ZigClangSourceLocation b);
531
532ZIG_EXTERN_C const struct ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const struct ZigClangTypedefType *);
533ZIG_EXTERN_C struct ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const struct ZigClangTypedefNameDecl *);
534
535ZIG_EXTERN_C struct ZigClangQualType ZigClangQualType_getCanonicalType(struct ZigClangQualType);
536ZIG_EXTERN_C const struct ZigClangType *ZigClangQualType_getTypePtr(struct ZigClangQualType);
537ZIG_EXTERN_C void ZigClangQualType_addConst(struct ZigClangQualType *);
538ZIG_EXTERN_C bool ZigClangQualType_eq(struct ZigClangQualType, struct ZigClangQualType);
539ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(struct ZigClangQualType);
540ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(struct ZigClangQualType);
541ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(struct ZigClangQualType);
542
543ZIG_EXTERN_C enum ZigClangTypeClass ZigClangType_getTypeClass(const struct ZigClangType *self);
544ZIG_EXTERN_C bool ZigClangType_isVoidType(const struct ZigClangType *self);
545ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const struct ZigClangType *self);
546
547ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangStmt_getBeginLoc(const struct ZigClangStmt *self);
548ZIG_EXTERN_C enum ZigClangStmtClass ZigClangStmt_getStmtClass(const struct ZigClangStmt *self);
549ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const struct ZigClangStmt *self);
550
551ZIG_EXTERN_C enum ZigClangStmtClass ZigClangExpr_getStmtClass(const struct ZigClangExpr *self);
552ZIG_EXTERN_C struct ZigClangQualType ZigClangExpr_getType(const struct ZigClangExpr *self);
553ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangExpr_getBeginLoc(const struct ZigClangExpr *self);
554
555ZIG_EXTERN_C enum ZigClangAPValueKind ZigClangAPValue_getKind(const struct ZigClangAPValue *self);
556ZIG_EXTERN_C const struct ZigClangAPSInt *ZigClangAPValue_getInt(const struct ZigClangAPValue *self);
557ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const struct ZigClangAPValue *self);
558ZIG_EXTERN_C const struct ZigClangAPValue *ZigClangAPValue_getArrayInitializedElt(const struct ZigClangAPValue *self, unsigned i);
559ZIG_EXTERN_C const struct ZigClangAPValue *ZigClangAPValue_getArrayFiller(const struct ZigClangAPValue *self);
560ZIG_EXTERN_C unsigned ZigClangAPValue_getArraySize(const struct ZigClangAPValue *self);
561ZIG_EXTERN_C struct ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const struct ZigClangAPValue *self);
562
563ZIG_EXTERN_C bool ZigClangAPSInt_isSigned(const struct ZigClangAPSInt *self);
564ZIG_EXTERN_C bool ZigClangAPSInt_isNegative(const struct ZigClangAPSInt *self);
565ZIG_EXTERN_C const struct ZigClangAPSInt *ZigClangAPSInt_negate(const struct ZigClangAPSInt *self);
566ZIG_EXTERN_C void ZigClangAPSInt_free(const struct ZigClangAPSInt *self);
567ZIG_EXTERN_C const uint64_t *ZigClangAPSInt_getRawData(const struct ZigClangAPSInt *self);
568ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const struct ZigClangAPSInt *self);
569
570ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(struct ZigClangAPValueLValueBase self);
570571
571572#endif
std/c.zig+4
......@@ -12,6 +12,10 @@ pub use switch (builtin.os) {
1212
1313// TODO https://github.com/ziglang/zig/issues/265 on this whole file
1414
15pub const FILE = @OpaqueType();
16pub extern "c" fn fwrite(ptr: [*]const u8, size_of_type: usize, item_count: usize, stream: *FILE) usize;
17pub extern "c" fn fread(ptr: [*]u8, size_of_type: usize, item_count: usize, stream: *FILE) usize;
18
1519pub extern "c" fn abort() noreturn;
1620pub extern "c" fn exit(code: c_int) noreturn;
1721pub extern "c" fn isatty(fd: c_int) c_int;
std/io.zig+18-12
......@@ -36,6 +36,7 @@ pub fn getStdIn() GetStdIoErrs!File {
3636}
3737
3838pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;
39pub const COutStream = @import("io/c_out_stream.zig").COutStream;
3940
4041pub fn InStream(comptime ReadError: type) type {
4142 return struct {
......@@ -1089,8 +1090,10 @@ test "io.readLineSliceFrom" {
10891090}
10901091
10911092pub const Packing = enum {
1092 Byte, /// Pack data to byte alignment
1093 Bit, /// Pack data to bit alignment
1093 /// Pack data to byte alignment
1094 Byte,
1095 /// Pack data to bit alignment
1096 Bit,
10941097};
10951098
10961099/// Creates a deserializer that deserializes types from any stream.
......@@ -1111,10 +1114,12 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
11111114 pub const Stream = InStream(Error);
11121115
11131116 pub fn init(in_stream: *Stream) Self {
1114 return Self{ .in_stream = switch (packing) {
1115 .Bit => BitInStream(endian, Stream.Error).init(in_stream),
1116 .Byte => in_stream,
1117 } };
1117 return Self{
1118 .in_stream = switch (packing) {
1119 .Bit => BitInStream(endian, Stream.Error).init(in_stream),
1120 .Byte => in_stream,
1121 },
1122 };
11181123 }
11191124
11201125 pub fn alignToByte(self: *Self) void {
......@@ -1281,7 +1286,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
12811286 ptr.* = null;
12821287 return;
12831288 }
1284
1289
12851290 ptr.* = OC(undefined); //make it non-null so the following .? is guaranteed safe
12861291 const val_ptr = &ptr.*.?;
12871292 try self.deserializeInto(val_ptr);
......@@ -1320,10 +1325,12 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
13201325 pub const Stream = OutStream(Error);
13211326
13221327 pub fn init(out_stream: *Stream) Self {
1323 return Self{ .out_stream = switch (packing) {
1324 .Bit => BitOutStream(endian, Stream.Error).init(out_stream),
1325 .Byte => out_stream,
1326 } };
1328 return Self{
1329 .out_stream = switch (packing) {
1330 .Bit => BitOutStream(endian, Stream.Error).init(out_stream),
1331 .Byte => out_stream,
1332 },
1333 };
13271334 }
13281335
13291336 /// Flushes any unwritten bits to the stream
......@@ -1450,4 +1457,3 @@ test "import io tests" {
14501457 _ = @import("io_test.zig");
14511458 }
14521459}
1453
std/io/c_out_stream.zig created+44
......@@ -0,0 +1,44 @@
1const std = @import("../std.zig");
2const OutStream = std.io.OutStream;
3const builtin = @import("builtin");
4const posix = std.os.posix;
5
6/// TODO make std.os.FILE use *FILE when linking libc and this just becomes
7/// std.io.FileOutStream because std.os.File.write would do this when linking
8/// libc.
9pub const COutStream = struct {
10 pub const Error = std.os.File.WriteError;
11 pub const Stream = OutStream(Error);
12
13 stream: Stream,
14 c_file: *std.c.FILE,
15
16 pub fn init(c_file: *std.c.FILE) COutStream {
17 return COutStream{
18 .c_file = c_file,
19 .stream = Stream{ .writeFn = writeFn },
20 };
21 }
22
23 fn writeFn(out_stream: *Stream, bytes: []const u8) Error!void {
24 const self = @fieldParentPtr(COutStream, "stream", out_stream);
25 const amt_written = std.c.fwrite(bytes.ptr, 1, bytes.len, self.c_file);
26 if (amt_written == bytes.len) return;
27 const errno = std.c._errno().*;
28 switch (errno) {
29 0 => unreachable,
30 posix.EINVAL => unreachable,
31 posix.EFAULT => unreachable,
32 posix.EAGAIN => unreachable, // this is a blocking API
33 posix.EBADF => unreachable, // always a race condition
34 posix.EDESTADDRREQ => unreachable, // connect was never called
35 posix.EDQUOT => return error.DiskQuota,
36 posix.EFBIG => return error.FileTooBig,
37 posix.EIO => return error.InputOutput,
38 posix.ENOSPC => return error.NoSpaceLeft,
39 posix.EPERM => return error.AccessDenied,
40 posix.EPIPE => return error.BrokenPipe,
41 else => return std.os.unexpectedErrorPosix(@intCast(usize, errno)),
42 }
43 }
44};