Commit 976080462cf62f6f112d38176b99e5bb8a57bf37 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-04-21 17:24:58-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-04-25 00:06:54-04:00
log	976080462cf62f6f112d38176b99e5bb8a57bf37
tree	0172c0811fc360f49e3c0eeacbd58ece78a30764
parent	56e07622c692f70eb10836b86c5fda02c53e2394
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	...	@@ -508,6 +508,7 @@ set(ZIG_STD_FILES
508	"heap.zig"	508	"heap.zig"
509	"io.zig"	509	"io.zig"
510	"io/seekable_stream.zig"	510	"io/seekable_stream.zig"
		511	"io/c_out_stream.zig"
511	"json.zig"	512	"json.zig"
512	"lazy_init.zig"	513	"lazy_init.zig"
513	"linked_list.zig"	514	"linked_list.zig"

src-self-hosted/clang.zig created+944

...	@@ -0,0 +1,944 @@
1	pub const struct_ZigClangAPValue = @OpaqueType();
2	pub const struct_ZigClangAPSInt = @OpaqueType();
3	pub const struct_ZigClangASTContext = @OpaqueType();
4	pub const struct_ZigClangASTUnit = @OpaqueType();
5	pub const struct_ZigClangArraySubscriptExpr = @OpaqueType();
6	pub const struct_ZigClangArrayType = @OpaqueType();
7	pub const struct_ZigClangAttributedType = @OpaqueType();
8	pub const struct_ZigClangBinaryOperator = @OpaqueType();
9	pub const struct_ZigClangBreakStmt = @OpaqueType();
10	pub const struct_ZigClangBuiltinType = @OpaqueType();
11	pub const struct_ZigClangCStyleCastExpr = @OpaqueType();
12	pub const struct_ZigClangCallExpr = @OpaqueType();
13	pub const struct_ZigClangCaseStmt = @OpaqueType();
14	pub const struct_ZigClangCompoundAssignOperator = @OpaqueType();
15	pub const struct_ZigClangCompoundStmt = @OpaqueType();
16	pub const struct_ZigClangConditionalOperator = @OpaqueType();
17	pub const struct_ZigClangConstantArrayType = @OpaqueType();
18	pub const struct_ZigClangContinueStmt = @OpaqueType();
19	pub const struct_ZigClangDecayedType = @OpaqueType();
20	pub const struct_ZigClangDecl = @OpaqueType();
21	pub const struct_ZigClangDeclRefExpr = @OpaqueType();
22	pub const struct_ZigClangDeclStmt = @OpaqueType();
23	pub const struct_ZigClangDefaultStmt = @OpaqueType();
24	pub const struct_ZigClangDiagnosticOptions = @OpaqueType();
25	pub const struct_ZigClangDiagnosticsEngine = @OpaqueType();
26	pub const struct_ZigClangDoStmt = @OpaqueType();
27	pub const struct_ZigClangElaboratedType = @OpaqueType();
28	pub const struct_ZigClangEnumConstantDecl = @OpaqueType();
29	pub const struct_ZigClangEnumDecl = @OpaqueType();
30	pub const struct_ZigClangEnumType = @OpaqueType();
31	pub const struct_ZigClangExpr = @OpaqueType();
32	pub const struct_ZigClangFieldDecl = @OpaqueType();
33	pub const struct_ZigClangFileID = @OpaqueType();
34	pub const struct_ZigClangForStmt = @OpaqueType();
35	pub const struct_ZigClangFullSourceLoc = @OpaqueType();
36	pub const struct_ZigClangFunctionDecl = @OpaqueType();
37	pub const struct_ZigClangFunctionProtoType = @OpaqueType();
38	pub const struct_ZigClangIfStmt = @OpaqueType();
39	pub const struct_ZigClangImplicitCastExpr = @OpaqueType();
40	pub const struct_ZigClangIncompleteArrayType = @OpaqueType();
41	pub const struct_ZigClangIntegerLiteral = @OpaqueType();
42	pub const struct_ZigClangMacroDefinitionRecord = @OpaqueType();
43	pub const struct_ZigClangMemberExpr = @OpaqueType();
44	pub const struct_ZigClangNamedDecl = @OpaqueType();
45	pub const struct_ZigClangNone = @OpaqueType();
46	pub const struct_ZigClangPCHContainerOperations = @OpaqueType();
47	pub const struct_ZigClangParenExpr = @OpaqueType();
48	pub const struct_ZigClangParenType = @OpaqueType();
49	pub const struct_ZigClangParmVarDecl = @OpaqueType();
50	pub const struct_ZigClangPointerType = @OpaqueType();
51	pub const struct_ZigClangPreprocessedEntity = @OpaqueType();
52	pub const struct_ZigClangRecordDecl = @OpaqueType();
53	pub const struct_ZigClangRecordType = @OpaqueType();
54	pub const struct_ZigClangReturnStmt = @OpaqueType();
55	pub const struct_ZigClangSkipFunctionBodiesScope = @OpaqueType();
56	pub const struct_ZigClangSourceManager = @OpaqueType();
57	pub const struct_ZigClangSourceRange = @OpaqueType();
58	pub const struct_ZigClangStmt = @OpaqueType();
59	pub const struct_ZigClangStorageClass = @OpaqueType();
60	pub const struct_ZigClangStringLiteral = @OpaqueType();
61	pub const struct_ZigClangStringRef = @OpaqueType();
62	pub const struct_ZigClangSwitchStmt = @OpaqueType();
63	pub const struct_ZigClangTagDecl = @OpaqueType();
64	pub const struct_ZigClangType = @OpaqueType();
65	pub const struct_ZigClangTypedefNameDecl = @OpaqueType();
66	pub const struct_ZigClangTypedefType = @OpaqueType();
67	pub const struct_ZigClangUnaryExprOrTypeTraitExpr = @OpaqueType();
68	pub const struct_ZigClangUnaryOperator = @OpaqueType();
69	pub const struct_ZigClangValueDecl = @OpaqueType();
70	pub const struct_ZigClangVarDecl = @OpaqueType();
71	pub const struct_ZigClangWhileStmt = @OpaqueType();
72	pub const ZigClangBO_PtrMemD = enum_ZigClangBO._PtrMemD;
73	pub const ZigClangBO_PtrMemI = enum_ZigClangBO._PtrMemI;
74	pub const ZigClangBO_Mul = enum_ZigClangBO._Mul;
75	pub const ZigClangBO_Div = enum_ZigClangBO._Div;
76	pub const ZigClangBO_Rem = enum_ZigClangBO._Rem;
77	pub const ZigClangBO_Add = enum_ZigClangBO._Add;
78	pub const ZigClangBO_Sub = enum_ZigClangBO._Sub;
79	pub const ZigClangBO_Shl = enum_ZigClangBO._Shl;
80	pub const ZigClangBO_Shr = enum_ZigClangBO._Shr;
81	pub const ZigClangBO_Cmp = enum_ZigClangBO._Cmp;
82	pub const ZigClangBO_LT = enum_ZigClangBO._LT;
83	pub const ZigClangBO_GT = enum_ZigClangBO._GT;
84	pub const ZigClangBO_LE = enum_ZigClangBO._LE;
85	pub const ZigClangBO_GE = enum_ZigClangBO._GE;
86	pub const ZigClangBO_EQ = enum_ZigClangBO._EQ;
87	pub const ZigClangBO_NE = enum_ZigClangBO._NE;
88	pub const ZigClangBO_And = enum_ZigClangBO._And;
89	pub const ZigClangBO_Xor = enum_ZigClangBO._Xor;
90	pub const ZigClangBO_Or = enum_ZigClangBO._Or;
91	pub const ZigClangBO_LAnd = enum_ZigClangBO._LAnd;
92	pub const ZigClangBO_LOr = enum_ZigClangBO._LOr;
93	pub const ZigClangBO_Assign = enum_ZigClangBO._Assign;
94	pub const ZigClangBO_MulAssign = enum_ZigClangBO._MulAssign;
95	pub const ZigClangBO_DivAssign = enum_ZigClangBO._DivAssign;
96	pub const ZigClangBO_RemAssign = enum_ZigClangBO._RemAssign;
97	pub const ZigClangBO_AddAssign = enum_ZigClangBO._AddAssign;
98	pub const ZigClangBO_SubAssign = enum_ZigClangBO._SubAssign;
99	pub const ZigClangBO_ShlAssign = enum_ZigClangBO._ShlAssign;
100	pub const ZigClangBO_ShrAssign = enum_ZigClangBO._ShrAssign;
101	pub const ZigClangBO_AndAssign = enum_ZigClangBO._AndAssign;
102	pub const ZigClangBO_XorAssign = enum_ZigClangBO._XorAssign;
103	pub const ZigClangBO_OrAssign = enum_ZigClangBO._OrAssign;
104	pub const ZigClangBO_Comma = enum_ZigClangBO._Comma;
105	pub 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	};
140	pub const ZigClangUO_PostInc = enum_ZigClangUO._PostInc;
141	pub const ZigClangUO_PostDec = enum_ZigClangUO._PostDec;
142	pub const ZigClangUO_PreInc = enum_ZigClangUO._PreInc;
143	pub const ZigClangUO_PreDec = enum_ZigClangUO._PreDec;
144	pub const ZigClangUO_AddrOf = enum_ZigClangUO._AddrOf;
145	pub const ZigClangUO_Deref = enum_ZigClangUO._Deref;
146	pub const ZigClangUO_Plus = enum_ZigClangUO._Plus;
147	pub const ZigClangUO_Minus = enum_ZigClangUO._Minus;
148	pub const ZigClangUO_Not = enum_ZigClangUO._Not;
149	pub const ZigClangUO_LNot = enum_ZigClangUO._LNot;
150	pub const ZigClangUO_Real = enum_ZigClangUO._Real;
151	pub const ZigClangUO_Imag = enum_ZigClangUO._Imag;
152	pub const ZigClangUO_Extension = enum_ZigClangUO._Extension;
153	pub const ZigClangUO_Coawait = enum_ZigClangUO._Coawait;
154	pub 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	};
170	pub const ZigClangType_Builtin = enum_ZigClangTypeClass.ZigClangType_Builtin;
171	pub const ZigClangType_Complex = enum_ZigClangTypeClass.ZigClangType_Complex;
172	pub const ZigClangType_Pointer = enum_ZigClangTypeClass.ZigClangType_Pointer;
173	pub const ZigClangType_BlockPointer = enum_ZigClangTypeClass.ZigClangType_BlockPointer;
174	pub const ZigClangType_LValueReference = enum_ZigClangTypeClass.ZigClangType_LValueReference;
175	pub const ZigClangType_RValueReference = enum_ZigClangTypeClass.ZigClangType_RValueReference;
176	pub const ZigClangType_MemberPointer = enum_ZigClangTypeClass.ZigClangType_MemberPointer;
177	pub const ZigClangType_ConstantArray = enum_ZigClangTypeClass.ZigClangType_ConstantArray;
178	pub const ZigClangType_IncompleteArray = enum_ZigClangTypeClass.ZigClangType_IncompleteArray;
179	pub const ZigClangType_VariableArray = enum_ZigClangTypeClass.ZigClangType_VariableArray;
180	pub const ZigClangType_DependentSizedArray = enum_ZigClangTypeClass.ZigClangType_DependentSizedArray;
181	pub const ZigClangType_DependentSizedExtVector = enum_ZigClangTypeClass.ZigClangType_DependentSizedExtVector;
182	pub const ZigClangType_DependentAddressSpace = enum_ZigClangTypeClass.ZigClangType_DependentAddressSpace;
183	pub const ZigClangType_Vector = enum_ZigClangTypeClass.ZigClangType_Vector;
184	pub const ZigClangType_DependentVector = enum_ZigClangTypeClass.ZigClangType_DependentVector;
185	pub const ZigClangType_ExtVector = enum_ZigClangTypeClass.ZigClangType_ExtVector;
186	pub const ZigClangType_FunctionProto = enum_ZigClangTypeClass.ZigClangType_FunctionProto;
187	pub const ZigClangType_FunctionNoProto = enum_ZigClangTypeClass.ZigClangType_FunctionNoProto;
188	pub const ZigClangType_UnresolvedUsing = enum_ZigClangTypeClass.ZigClangType_UnresolvedUsing;
189	pub const ZigClangType_Paren = enum_ZigClangTypeClass.ZigClangType_Paren;
190	pub const ZigClangType_Typedef = enum_ZigClangTypeClass.ZigClangType_Typedef;
191	pub const ZigClangType_Adjusted = enum_ZigClangTypeClass.ZigClangType_Adjusted;
192	pub const ZigClangType_Decayed = enum_ZigClangTypeClass.ZigClangType_Decayed;
193	pub const ZigClangType_TypeOfExpr = enum_ZigClangTypeClass.ZigClangType_TypeOfExpr;
194	pub const ZigClangType_TypeOf = enum_ZigClangTypeClass.ZigClangType_TypeOf;
195	pub const ZigClangType_Decltype = enum_ZigClangTypeClass.ZigClangType_Decltype;
196	pub const ZigClangType_UnaryTransform = enum_ZigClangTypeClass.ZigClangType_UnaryTransform;
197	pub const ZigClangType_Record = enum_ZigClangTypeClass.ZigClangType_Record;
198	pub const ZigClangType_Enum = enum_ZigClangTypeClass.ZigClangType_Enum;
199	pub const ZigClangType_Elaborated = enum_ZigClangTypeClass.ZigClangType_Elaborated;
200	pub const ZigClangType_Attributed = enum_ZigClangTypeClass.ZigClangType_Attributed;
201	pub const ZigClangType_TemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_TemplateTypeParm;
202	pub const ZigClangType_SubstTemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParm;
203	pub const ZigClangType_SubstTemplateTypeParmPack = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParmPack;
204	pub const ZigClangType_TemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_TemplateSpecialization;
205	pub const ZigClangType_Auto = enum_ZigClangTypeClass.ZigClangType_Auto;
206	pub const ZigClangType_DeducedTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DeducedTemplateSpecialization;
207	pub const ZigClangType_InjectedClassName = enum_ZigClangTypeClass.ZigClangType_InjectedClassName;
208	pub const ZigClangType_DependentName = enum_ZigClangTypeClass.ZigClangType_DependentName;
209	pub const ZigClangType_DependentTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DependentTemplateSpecialization;
210	pub const ZigClangType_PackExpansion = enum_ZigClangTypeClass.ZigClangType_PackExpansion;
211	pub const ZigClangType_ObjCTypeParam = enum_ZigClangTypeClass.ZigClangType_ObjCTypeParam;
212	pub const ZigClangType_ObjCObject = enum_ZigClangTypeClass.ZigClangType_ObjCObject;
213	pub const ZigClangType_ObjCInterface = enum_ZigClangTypeClass.ZigClangType_ObjCInterface;
214	pub const ZigClangType_ObjCObjectPointer = enum_ZigClangTypeClass.ZigClangType_ObjCObjectPointer;
215	pub const ZigClangType_Pipe = enum_ZigClangTypeClass.ZigClangType_Pipe;
216	pub const ZigClangType_Atomic = enum_ZigClangTypeClass.ZigClangType_Atomic;
217	pub 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	};
266	pub const ZigClangStmt_NoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NoStmtClass;
267	pub const ZigClangStmt_GCCAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GCCAsmStmtClass;
268	pub const ZigClangStmt_MSAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSAsmStmtClass;
269	pub const ZigClangStmt_AttributedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_AttributedStmtClass;
270	pub const ZigClangStmt_BreakStmtClass = enum_ZigClangStmtClass.ZigClangStmt_BreakStmtClass;
271	pub const ZigClangStmt_CXXCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXCatchStmtClass;
272	pub const ZigClangStmt_CXXForRangeStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXForRangeStmtClass;
273	pub const ZigClangStmt_CXXTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTryStmtClass;
274	pub const ZigClangStmt_CapturedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CapturedStmtClass;
275	pub const ZigClangStmt_CompoundStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundStmtClass;
276	pub const ZigClangStmt_ContinueStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ContinueStmtClass;
277	pub const ZigClangStmt_CoreturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoreturnStmtClass;
278	pub const ZigClangStmt_CoroutineBodyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoroutineBodyStmtClass;
279	pub const ZigClangStmt_DeclStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DeclStmtClass;
280	pub const ZigClangStmt_DoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DoStmtClass;
281	pub const ZigClangStmt_BinaryConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryConditionalOperatorClass;
282	pub const ZigClangStmt_ConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_ConditionalOperatorClass;
283	pub const ZigClangStmt_AddrLabelExprClass = enum_ZigClangStmtClass.ZigClangStmt_AddrLabelExprClass;
284	pub const ZigClangStmt_ArrayInitIndexExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitIndexExprClass;
285	pub const ZigClangStmt_ArrayInitLoopExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitLoopExprClass;
286	pub const ZigClangStmt_ArraySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArraySubscriptExprClass;
287	pub const ZigClangStmt_ArrayTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayTypeTraitExprClass;
288	pub const ZigClangStmt_AsTypeExprClass = enum_ZigClangStmtClass.ZigClangStmt_AsTypeExprClass;
289	pub const ZigClangStmt_AtomicExprClass = enum_ZigClangStmtClass.ZigClangStmt_AtomicExprClass;
290	pub const ZigClangStmt_BinaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryOperatorClass;
291	pub const ZigClangStmt_CompoundAssignOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundAssignOperatorClass;
292	pub const ZigClangStmt_BlockExprClass = enum_ZigClangStmtClass.ZigClangStmt_BlockExprClass;
293	pub const ZigClangStmt_CXXBindTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBindTemporaryExprClass;
294	pub const ZigClangStmt_CXXBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBoolLiteralExprClass;
295	pub const ZigClangStmt_CXXConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstructExprClass;
296	pub const ZigClangStmt_CXXTemporaryObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTemporaryObjectExprClass;
297	pub const ZigClangStmt_CXXDefaultArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultArgExprClass;
298	pub const ZigClangStmt_CXXDefaultInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultInitExprClass;
299	pub const ZigClangStmt_CXXDeleteExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDeleteExprClass;
300	pub const ZigClangStmt_CXXDependentScopeMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDependentScopeMemberExprClass;
301	pub const ZigClangStmt_CXXFoldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFoldExprClass;
302	pub const ZigClangStmt_CXXInheritedCtorInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXInheritedCtorInitExprClass;
303	pub const ZigClangStmt_CXXNewExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNewExprClass;
304	pub const ZigClangStmt_CXXNoexceptExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNoexceptExprClass;
305	pub const ZigClangStmt_CXXNullPtrLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNullPtrLiteralExprClass;
306	pub const ZigClangStmt_CXXPseudoDestructorExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXPseudoDestructorExprClass;
307	pub const ZigClangStmt_CXXScalarValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXScalarValueInitExprClass;
308	pub const ZigClangStmt_CXXStdInitializerListExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStdInitializerListExprClass;
309	pub const ZigClangStmt_CXXThisExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThisExprClass;
310	pub const ZigClangStmt_CXXThrowExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThrowExprClass;
311	pub const ZigClangStmt_CXXTypeidExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTypeidExprClass;
312	pub const ZigClangStmt_CXXUnresolvedConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUnresolvedConstructExprClass;
313	pub const ZigClangStmt_CXXUuidofExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUuidofExprClass;
314	pub const ZigClangStmt_CallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CallExprClass;
315	pub const ZigClangStmt_CUDAKernelCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CUDAKernelCallExprClass;
316	pub const ZigClangStmt_CXXMemberCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXMemberCallExprClass;
317	pub const ZigClangStmt_CXXOperatorCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXOperatorCallExprClass;
318	pub const ZigClangStmt_UserDefinedLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_UserDefinedLiteralClass;
319	pub const ZigClangStmt_CStyleCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CStyleCastExprClass;
320	pub const ZigClangStmt_CXXFunctionalCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFunctionalCastExprClass;
321	pub const ZigClangStmt_CXXConstCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstCastExprClass;
322	pub const ZigClangStmt_CXXDynamicCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDynamicCastExprClass;
323	pub const ZigClangStmt_CXXReinterpretCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXReinterpretCastExprClass;
324	pub const ZigClangStmt_CXXStaticCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStaticCastExprClass;
325	pub const ZigClangStmt_ObjCBridgedCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBridgedCastExprClass;
326	pub const ZigClangStmt_ImplicitCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitCastExprClass;
327	pub const ZigClangStmt_CharacterLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_CharacterLiteralClass;
328	pub const ZigClangStmt_ChooseExprClass = enum_ZigClangStmtClass.ZigClangStmt_ChooseExprClass;
329	pub const ZigClangStmt_CompoundLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundLiteralExprClass;
330	pub const ZigClangStmt_ConvertVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConvertVectorExprClass;
331	pub const ZigClangStmt_CoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoawaitExprClass;
332	pub const ZigClangStmt_CoyieldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoyieldExprClass;
333	pub const ZigClangStmt_DeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DeclRefExprClass;
334	pub const ZigClangStmt_DependentCoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentCoawaitExprClass;
335	pub const ZigClangStmt_DependentScopeDeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentScopeDeclRefExprClass;
336	pub const ZigClangStmt_DesignatedInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitExprClass;
337	pub const ZigClangStmt_DesignatedInitUpdateExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitUpdateExprClass;
338	pub const ZigClangStmt_ExpressionTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExpressionTraitExprClass;
339	pub const ZigClangStmt_ExtVectorElementExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExtVectorElementExprClass;
340	pub const ZigClangStmt_FixedPointLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FixedPointLiteralClass;
341	pub const ZigClangStmt_FloatingLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FloatingLiteralClass;
342	pub const ZigClangStmt_ConstantExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConstantExprClass;
343	pub const ZigClangStmt_ExprWithCleanupsClass = enum_ZigClangStmtClass.ZigClangStmt_ExprWithCleanupsClass;
344	pub const ZigClangStmt_FunctionParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_FunctionParmPackExprClass;
345	pub const ZigClangStmt_GNUNullExprClass = enum_ZigClangStmtClass.ZigClangStmt_GNUNullExprClass;
346	pub const ZigClangStmt_GenericSelectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_GenericSelectionExprClass;
347	pub const ZigClangStmt_ImaginaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ImaginaryLiteralClass;
348	pub const ZigClangStmt_ImplicitValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitValueInitExprClass;
349	pub const ZigClangStmt_InitListExprClass = enum_ZigClangStmtClass.ZigClangStmt_InitListExprClass;
350	pub const ZigClangStmt_IntegerLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_IntegerLiteralClass;
351	pub const ZigClangStmt_LambdaExprClass = enum_ZigClangStmtClass.ZigClangStmt_LambdaExprClass;
352	pub const ZigClangStmt_MSPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertyRefExprClass;
353	pub const ZigClangStmt_MSPropertySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertySubscriptExprClass;
354	pub const ZigClangStmt_MaterializeTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_MaterializeTemporaryExprClass;
355	pub const ZigClangStmt_MemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_MemberExprClass;
356	pub const ZigClangStmt_NoInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_NoInitExprClass;
357	pub const ZigClangStmt_OMPArraySectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_OMPArraySectionExprClass;
358	pub const ZigClangStmt_ObjCArrayLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCArrayLiteralClass;
359	pub const ZigClangStmt_ObjCAvailabilityCheckExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAvailabilityCheckExprClass;
360	pub const ZigClangStmt_ObjCBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoolLiteralExprClass;
361	pub const ZigClangStmt_ObjCBoxedExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoxedExprClass;
362	pub const ZigClangStmt_ObjCDictionaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCDictionaryLiteralClass;
363	pub const ZigClangStmt_ObjCEncodeExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCEncodeExprClass;
364	pub const ZigClangStmt_ObjCIndirectCopyRestoreExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIndirectCopyRestoreExprClass;
365	pub const ZigClangStmt_ObjCIsaExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIsaExprClass;
366	pub const ZigClangStmt_ObjCIvarRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIvarRefExprClass;
367	pub const ZigClangStmt_ObjCMessageExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCMessageExprClass;
368	pub const ZigClangStmt_ObjCPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCPropertyRefExprClass;
369	pub const ZigClangStmt_ObjCProtocolExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCProtocolExprClass;
370	pub const ZigClangStmt_ObjCSelectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSelectorExprClass;
371	pub const ZigClangStmt_ObjCStringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCStringLiteralClass;
372	pub const ZigClangStmt_ObjCSubscriptRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSubscriptRefExprClass;
373	pub const ZigClangStmt_OffsetOfExprClass = enum_ZigClangStmtClass.ZigClangStmt_OffsetOfExprClass;
374	pub const ZigClangStmt_OpaqueValueExprClass = enum_ZigClangStmtClass.ZigClangStmt_OpaqueValueExprClass;
375	pub const ZigClangStmt_UnresolvedLookupExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedLookupExprClass;
376	pub const ZigClangStmt_UnresolvedMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedMemberExprClass;
377	pub const ZigClangStmt_PackExpansionExprClass = enum_ZigClangStmtClass.ZigClangStmt_PackExpansionExprClass;
378	pub const ZigClangStmt_ParenExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenExprClass;
379	pub const ZigClangStmt_ParenListExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenListExprClass;
380	pub const ZigClangStmt_PredefinedExprClass = enum_ZigClangStmtClass.ZigClangStmt_PredefinedExprClass;
381	pub const ZigClangStmt_PseudoObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_PseudoObjectExprClass;
382	pub const ZigClangStmt_ShuffleVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ShuffleVectorExprClass;
383	pub const ZigClangStmt_SizeOfPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SizeOfPackExprClass;
384	pub const ZigClangStmt_StmtExprClass = enum_ZigClangStmtClass.ZigClangStmt_StmtExprClass;
385	pub const ZigClangStmt_StringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_StringLiteralClass;
386	pub const ZigClangStmt_SubstNonTypeTemplateParmExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmExprClass;
387	pub const ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmPackExprClass;
388	pub const ZigClangStmt_TypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypeTraitExprClass;
389	pub const ZigClangStmt_TypoExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypoExprClass;
390	pub const ZigClangStmt_UnaryExprOrTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryExprOrTypeTraitExprClass;
391	pub const ZigClangStmt_UnaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryOperatorClass;
392	pub const ZigClangStmt_VAArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_VAArgExprClass;
393	pub const ZigClangStmt_ForStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ForStmtClass;
394	pub const ZigClangStmt_GotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GotoStmtClass;
395	pub const ZigClangStmt_IfStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IfStmtClass;
396	pub const ZigClangStmt_IndirectGotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IndirectGotoStmtClass;
397	pub const ZigClangStmt_LabelStmtClass = enum_ZigClangStmtClass.ZigClangStmt_LabelStmtClass;
398	pub const ZigClangStmt_MSDependentExistsStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSDependentExistsStmtClass;
399	pub const ZigClangStmt_NullStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NullStmtClass;
400	pub const ZigClangStmt_OMPAtomicDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPAtomicDirectiveClass;
401	pub const ZigClangStmt_OMPBarrierDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPBarrierDirectiveClass;
402	pub const ZigClangStmt_OMPCancelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancelDirectiveClass;
403	pub const ZigClangStmt_OMPCancellationPointDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancellationPointDirectiveClass;
404	pub const ZigClangStmt_OMPCriticalDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCriticalDirectiveClass;
405	pub const ZigClangStmt_OMPFlushDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPFlushDirectiveClass;
406	pub const ZigClangStmt_OMPDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeDirectiveClass;
407	pub const ZigClangStmt_OMPDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForDirectiveClass;
408	pub const ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass;
409	pub const ZigClangStmt_OMPDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeSimdDirectiveClass;
410	pub const ZigClangStmt_OMPForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForDirectiveClass;
411	pub const ZigClangStmt_OMPForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForSimdDirectiveClass;
412	pub const ZigClangStmt_OMPParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForDirectiveClass;
413	pub const ZigClangStmt_OMPParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForSimdDirectiveClass;
414	pub const ZigClangStmt_OMPSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSimdDirectiveClass;
415	pub const ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForSimdDirectiveClass;
416	pub const ZigClangStmt_OMPTargetSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetSimdDirectiveClass;
417	pub const ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass;
418	pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass;
419	pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass;
420	pub const ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass;
421	pub const ZigClangStmt_OMPTaskLoopDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopDirectiveClass;
422	pub const ZigClangStmt_OMPTaskLoopSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopSimdDirectiveClass;
423	pub const ZigClangStmt_OMPTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeDirectiveClass;
424	pub const ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass;
425	pub const ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass;
426	pub const ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass;
427	pub const ZigClangStmt_OMPMasterDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPMasterDirectiveClass;
428	pub const ZigClangStmt_OMPOrderedDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPOrderedDirectiveClass;
429	pub const ZigClangStmt_OMPParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelDirectiveClass;
430	pub const ZigClangStmt_OMPParallelSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelSectionsDirectiveClass;
431	pub const ZigClangStmt_OMPSectionDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionDirectiveClass;
432	pub const ZigClangStmt_OMPSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionsDirectiveClass;
433	pub const ZigClangStmt_OMPSingleDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSingleDirectiveClass;
434	pub const ZigClangStmt_OMPTargetDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDataDirectiveClass;
435	pub const ZigClangStmt_OMPTargetDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDirectiveClass;
436	pub const ZigClangStmt_OMPTargetEnterDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetEnterDataDirectiveClass;
437	pub const ZigClangStmt_OMPTargetExitDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetExitDataDirectiveClass;
438	pub const ZigClangStmt_OMPTargetParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelDirectiveClass;
439	pub const ZigClangStmt_OMPTargetParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForDirectiveClass;
440	pub const ZigClangStmt_OMPTargetTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDirectiveClass;
441	pub const ZigClangStmt_OMPTargetUpdateDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetUpdateDirectiveClass;
442	pub const ZigClangStmt_OMPTaskDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskDirectiveClass;
443	pub const ZigClangStmt_OMPTaskgroupDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskgroupDirectiveClass;
444	pub const ZigClangStmt_OMPTaskwaitDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskwaitDirectiveClass;
445	pub const ZigClangStmt_OMPTaskyieldDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskyieldDirectiveClass;
446	pub const ZigClangStmt_OMPTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDirectiveClass;
447	pub const ZigClangStmt_ObjCAtCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtCatchStmtClass;
448	pub const ZigClangStmt_ObjCAtFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtFinallyStmtClass;
449	pub const ZigClangStmt_ObjCAtSynchronizedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtSynchronizedStmtClass;
450	pub const ZigClangStmt_ObjCAtThrowStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtThrowStmtClass;
451	pub const ZigClangStmt_ObjCAtTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtTryStmtClass;
452	pub const ZigClangStmt_ObjCAutoreleasePoolStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAutoreleasePoolStmtClass;
453	pub const ZigClangStmt_ObjCForCollectionStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCForCollectionStmtClass;
454	pub const ZigClangStmt_ReturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ReturnStmtClass;
455	pub const ZigClangStmt_SEHExceptStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHExceptStmtClass;
456	pub const ZigClangStmt_SEHFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHFinallyStmtClass;
457	pub const ZigClangStmt_SEHLeaveStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHLeaveStmtClass;
458	pub const ZigClangStmt_SEHTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHTryStmtClass;
459	pub const ZigClangStmt_CaseStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CaseStmtClass;
460	pub const ZigClangStmt_DefaultStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DefaultStmtClass;
461	pub const ZigClangStmt_SwitchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SwitchStmtClass;
462	pub const ZigClangStmt_WhileStmtClass = enum_ZigClangStmtClass.ZigClangStmt_WhileStmtClass;
463	pub 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	};
662	pub const ZigClangCK_Dependent = enum_ZigClangCK._Dependent;
663	pub const ZigClangCK_BitCast = enum_ZigClangCK._BitCast;
664	pub const ZigClangCK_LValueBitCast = enum_ZigClangCK._LValueBitCast;
665	pub const ZigClangCK_LValueToRValue = enum_ZigClangCK._LValueToRValue;
666	pub const ZigClangCK_NoOp = enum_ZigClangCK._NoOp;
667	pub const ZigClangCK_BaseToDerived = enum_ZigClangCK._BaseToDerived;
668	pub const ZigClangCK_DerivedToBase = enum_ZigClangCK._DerivedToBase;
669	pub const ZigClangCK_UncheckedDerivedToBase = enum_ZigClangCK._UncheckedDerivedToBase;
670	pub const ZigClangCK_Dynamic = enum_ZigClangCK._Dynamic;
671	pub const ZigClangCK_ToUnion = enum_ZigClangCK._ToUnion;
672	pub const ZigClangCK_ArrayToPointerDecay = enum_ZigClangCK._ArrayToPointerDecay;
673	pub const ZigClangCK_FunctionToPointerDecay = enum_ZigClangCK._FunctionToPointerDecay;
674	pub const ZigClangCK_NullToPointer = enum_ZigClangCK._NullToPointer;
675	pub const ZigClangCK_NullToMemberPointer = enum_ZigClangCK._NullToMemberPointer;
676	pub const ZigClangCK_BaseToDerivedMemberPointer = enum_ZigClangCK._BaseToDerivedMemberPointer;
677	pub const ZigClangCK_DerivedToBaseMemberPointer = enum_ZigClangCK._DerivedToBaseMemberPointer;
678	pub const ZigClangCK_MemberPointerToBoolean = enum_ZigClangCK._MemberPointerToBoolean;
679	pub const ZigClangCK_ReinterpretMemberPointer = enum_ZigClangCK._ReinterpretMemberPointer;
680	pub const ZigClangCK_UserDefinedConversion = enum_ZigClangCK._UserDefinedConversion;
681	pub const ZigClangCK_ConstructorConversion = enum_ZigClangCK._ConstructorConversion;
682	pub const ZigClangCK_IntegralToPointer = enum_ZigClangCK._IntegralToPointer;
683	pub const ZigClangCK_PointerToIntegral = enum_ZigClangCK._PointerToIntegral;
684	pub const ZigClangCK_PointerToBoolean = enum_ZigClangCK._PointerToBoolean;
685	pub const ZigClangCK_ToVoid = enum_ZigClangCK._ToVoid;
686	pub const ZigClangCK_VectorSplat = enum_ZigClangCK._VectorSplat;
687	pub const ZigClangCK_IntegralCast = enum_ZigClangCK._IntegralCast;
688	pub const ZigClangCK_IntegralToBoolean = enum_ZigClangCK._IntegralToBoolean;
689	pub const ZigClangCK_IntegralToFloating = enum_ZigClangCK._IntegralToFloating;
690	pub const ZigClangCK_FixedPointCast = enum_ZigClangCK._FixedPointCast;
691	pub const ZigClangCK_FixedPointToBoolean = enum_ZigClangCK._FixedPointToBoolean;
692	pub const ZigClangCK_FloatingToIntegral = enum_ZigClangCK._FloatingToIntegral;
693	pub const ZigClangCK_FloatingToBoolean = enum_ZigClangCK._FloatingToBoolean;
694	pub const ZigClangCK_BooleanToSignedIntegral = enum_ZigClangCK._BooleanToSignedIntegral;
695	pub const ZigClangCK_FloatingCast = enum_ZigClangCK._FloatingCast;
696	pub const ZigClangCK_CPointerToObjCPointerCast = enum_ZigClangCK._CPointerToObjCPointerCast;
697	pub const ZigClangCK_BlockPointerToObjCPointerCast = enum_ZigClangCK._BlockPointerToObjCPointerCast;
698	pub const ZigClangCK_AnyPointerToBlockPointerCast = enum_ZigClangCK._AnyPointerToBlockPointerCast;
699	pub const ZigClangCK_ObjCObjectLValueCast = enum_ZigClangCK._ObjCObjectLValueCast;
700	pub const ZigClangCK_FloatingRealToComplex = enum_ZigClangCK._FloatingRealToComplex;
701	pub const ZigClangCK_FloatingComplexToReal = enum_ZigClangCK._FloatingComplexToReal;
702	pub const ZigClangCK_FloatingComplexToBoolean = enum_ZigClangCK._FloatingComplexToBoolean;
703	pub const ZigClangCK_FloatingComplexCast = enum_ZigClangCK._FloatingComplexCast;
704	pub const ZigClangCK_FloatingComplexToIntegralComplex = enum_ZigClangCK._FloatingComplexToIntegralComplex;
705	pub const ZigClangCK_IntegralRealToComplex = enum_ZigClangCK._IntegralRealToComplex;
706	pub const ZigClangCK_IntegralComplexToReal = enum_ZigClangCK._IntegralComplexToReal;
707	pub const ZigClangCK_IntegralComplexToBoolean = enum_ZigClangCK._IntegralComplexToBoolean;
708	pub const ZigClangCK_IntegralComplexCast = enum_ZigClangCK._IntegralComplexCast;
709	pub const ZigClangCK_IntegralComplexToFloatingComplex = enum_ZigClangCK._IntegralComplexToFloatingComplex;
710	pub const ZigClangCK_ARCProduceObject = enum_ZigClangCK._ARCProduceObject;
711	pub const ZigClangCK_ARCConsumeObject = enum_ZigClangCK._ARCConsumeObject;
712	pub const ZigClangCK_ARCReclaimReturnedObject = enum_ZigClangCK._ARCReclaimReturnedObject;
713	pub const ZigClangCK_ARCExtendBlockObject = enum_ZigClangCK._ARCExtendBlockObject;
714	pub const ZigClangCK_AtomicToNonAtomic = enum_ZigClangCK._AtomicToNonAtomic;
715	pub const ZigClangCK_NonAtomicToAtomic = enum_ZigClangCK._NonAtomicToAtomic;
716	pub const ZigClangCK_CopyAndAutoreleaseBlockObject = enum_ZigClangCK._CopyAndAutoreleaseBlockObject;
717	pub const ZigClangCK_BuiltinFnToFnPtr = enum_ZigClangCK._BuiltinFnToFnPtr;
718	pub const ZigClangCK_ZeroToOCLOpaqueType = enum_ZigClangCK._ZeroToOCLOpaqueType;
719	pub const ZigClangCK_AddressSpaceConversion = enum_ZigClangCK._AddressSpaceConversion;
720	pub const ZigClangCK_IntToOCLSampler = enum_ZigClangCK._IntToOCLSampler;
721	pub 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	};
782	pub const ZigClangAPValueUninitialized = enum_ZigClangAPValueKind.ZigClangAPValueUninitialized;
783	pub const ZigClangAPValueInt = enum_ZigClangAPValueKind.ZigClangAPValueInt;
784	pub const ZigClangAPValueFloat = enum_ZigClangAPValueKind.ZigClangAPValueFloat;
785	pub const ZigClangAPValueComplexInt = enum_ZigClangAPValueKind.ZigClangAPValueComplexInt;
786	pub const ZigClangAPValueComplexFloat = enum_ZigClangAPValueKind.ZigClangAPValueComplexFloat;
787	pub const ZigClangAPValueLValue = enum_ZigClangAPValueKind.ZigClangAPValueLValue;
788	pub const ZigClangAPValueVector = enum_ZigClangAPValueKind.ZigClangAPValueVector;
789	pub const ZigClangAPValueArray = enum_ZigClangAPValueKind.ZigClangAPValueArray;
790	pub const ZigClangAPValueStruct = enum_ZigClangAPValueKind.ZigClangAPValueStruct;
791	pub const ZigClangAPValueUnion = enum_ZigClangAPValueKind.ZigClangAPValueUnion;
792	pub const ZigClangAPValueMemberPointer = enum_ZigClangAPValueKind.ZigClangAPValueMemberPointer;
793	pub const ZigClangAPValueAddrLabelDiff = enum_ZigClangAPValueKind.ZigClangAPValueAddrLabelDiff;
794	pub 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	};
808	pub extern fn ZigClangSourceManager_getSpellingLoc(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation;
809	pub extern fn ZigClangSourceManager_getFilename(arg0: ?const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) [c]const u8;
810	pub extern fn ZigClangSourceManager_getSpellingLineNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
811	pub extern fn ZigClangSourceManager_getSpellingColumnNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
812	pub extern fn ZigClangSourceManager_getCharacterData(arg0: ?const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [c]const u8;
813	pub extern fn ZigClangASTContext_getPointerType(arg0: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType;
814	pub extern fn ZigClangASTUnit_getASTContext(arg0: ?struct_ZigClangASTUnit) ?struct_ZigClangASTContext;
815	pub extern fn ZigClangASTUnit_getSourceManager(arg0: ?struct_ZigClangASTUnit) ?struct_ZigClangSourceManager;
816	pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(arg0: ?struct_ZigClangASTUnit, context: ?c_void, Fn: ?extern fn (?c_void, ?const struct_ZigClangDecl) bool) bool;
817	pub extern fn ZigClangRecordType_getDecl(record_ty: ?const struct_ZigClangRecordType) ?const struct_ZigClangRecordDecl;
818	pub extern fn ZigClangEnumType_getDecl(record_ty: ?const struct_ZigClangEnumType) ?const struct_ZigClangEnumDecl;
819	pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?const struct_ZigClangRecordDecl) ?const struct_ZigClangTagDecl;
820	pub extern fn ZigClangEnumDecl_getCanonicalDecl(arg0: ?const struct_ZigClangEnumDecl) ?const struct_ZigClangTagDecl;
821	pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(arg0: ?const struct_ZigClangTypedefNameDecl) ?const struct_ZigClangTypedefNameDecl;
822	pub extern fn ZigClangRecordDecl_getDefinition(arg0: ?const struct_ZigClangRecordDecl) ?const struct_ZigClangRecordDecl;
823	pub extern fn ZigClangEnumDecl_getDefinition(arg0: ?const struct_ZigClangEnumDecl) ?const struct_ZigClangEnumDecl;
824	pub extern fn ZigClangRecordDecl_getLocation(arg0: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation;
825	pub extern fn ZigClangEnumDecl_getLocation(arg0: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation;
826	pub extern fn ZigClangTypedefNameDecl_getLocation(arg0: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation;
827	pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
828	pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool;
829	pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
830	pub extern fn ZigClangEnumDecl_getIntegerType(arg0: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType;
831	pub extern fn ZigClangDecl_getName_bytes_begin(decl: ?const struct_ZigClangDecl) [c]const u8;
832	pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool;
833	pub extern fn ZigClangTypedefType_getDecl(arg0: ?const struct_ZigClangTypedefType) ?const struct_ZigClangTypedefNameDecl;
834	pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(arg0: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType;
835	pub extern fn ZigClangQualType_getCanonicalType(arg0: struct_ZigClangQualType) struct_ZigClangQualType;
836	pub extern fn ZigClangQualType_getTypePtr(arg0: struct_ZigClangQualType) ?*const struct_ZigClangType;
837	pub extern fn ZigClangQualType_addConst(arg0: [*c]struct_ZigClangQualType) void;
838	pub extern fn ZigClangQualType_eq(arg0: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool;
839	pub extern fn ZigClangQualType_isConstQualified(arg0: struct_ZigClangQualType) bool;
840	pub extern fn ZigClangQualType_isVolatileQualified(arg0: struct_ZigClangQualType) bool;
841	pub extern fn ZigClangQualType_isRestrictQualified(arg0: struct_ZigClangQualType) bool;
842	pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) enum_ZigClangTypeClass;
843	pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool;
844	pub extern fn ZigClangType_getTypeClassName(self: ?const struct_ZigClangType) [c]const u8;
845	pub extern fn ZigClangStmt_getBeginLoc(self: ?*const struct_ZigClangStmt) struct_ZigClangSourceLocation;
846	pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) enum_ZigClangStmtClass;
847	pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool;
848	pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) enum_ZigClangStmtClass;
849	pub extern fn ZigClangExpr_getType(self: ?*const struct_ZigClangExpr) struct_ZigClangQualType;
850	pub extern fn ZigClangExpr_getBeginLoc(self: ?*const struct_ZigClangExpr) struct_ZigClangSourceLocation;
851	pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) enum_ZigClangAPValueKind;
852	pub extern fn ZigClangAPValue_getInt(self: ?const struct_ZigClangAPValue) ?const struct_ZigClangAPSInt;
853	pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
854	pub extern fn ZigClangAPValue_getArrayInitializedElt(self: ?const struct_ZigClangAPValue, i: c_uint) ?const struct_ZigClangAPValue;
855	pub extern fn ZigClangAPValue_getArrayFiller(self: ?const struct_ZigClangAPValue) ?const struct_ZigClangAPValue;
856	pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
857	pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
858	pub extern fn ZigClangAPSInt_isSigned(self: ?*const struct_ZigClangAPSInt) bool;
859	pub extern fn ZigClangAPSInt_isNegative(self: ?*const struct_ZigClangAPSInt) bool;
860	pub extern fn ZigClangAPSInt_negate(self: ?const struct_ZigClangAPSInt) ?const struct_ZigClangAPSInt;
861	pub extern fn ZigClangAPSInt_free(self: ?*const struct_ZigClangAPSInt) void;
862	pub extern fn ZigClangAPSInt_getRawData(self: ?const struct_ZigClangAPSInt) [c]const u64;
863	pub extern fn ZigClangAPSInt_getNumWords(self: ?*const struct_ZigClangAPSInt) c_uint;
864	pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr;
865	pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
866	pub const ZigClangQualType = struct_ZigClangQualType;
867	pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase;
868	pub const ZigClangAPValue = struct_ZigClangAPValue;
869	pub const ZigClangAPSInt = struct_ZigClangAPSInt;
870	pub const ZigClangASTContext = struct_ZigClangASTContext;
871	pub const ZigClangASTUnit = struct_ZigClangASTUnit;
872	pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr;
873	pub const ZigClangArrayType = struct_ZigClangArrayType;
874	pub const ZigClangAttributedType = struct_ZigClangAttributedType;
875	pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator;
876	pub const ZigClangBreakStmt = struct_ZigClangBreakStmt;
877	pub const ZigClangBuiltinType = struct_ZigClangBuiltinType;
878	pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr;
879	pub const ZigClangCallExpr = struct_ZigClangCallExpr;
880	pub const ZigClangCaseStmt = struct_ZigClangCaseStmt;
881	pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator;
882	pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt;
883	pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator;
884	pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType;
885	pub const ZigClangContinueStmt = struct_ZigClangContinueStmt;
886	pub const ZigClangDecayedType = struct_ZigClangDecayedType;
887	pub const ZigClangDecl = struct_ZigClangDecl;
888	pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr;
889	pub const ZigClangDeclStmt = struct_ZigClangDeclStmt;
890	pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt;
891	pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions;
892	pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine;
893	pub const ZigClangDoStmt = struct_ZigClangDoStmt;
894	pub const ZigClangElaboratedType = struct_ZigClangElaboratedType;
895	pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl;
896	pub const ZigClangEnumDecl = struct_ZigClangEnumDecl;
897	pub const ZigClangEnumType = struct_ZigClangEnumType;
898	pub const ZigClangExpr = struct_ZigClangExpr;
899	pub const ZigClangFieldDecl = struct_ZigClangFieldDecl;
900	pub const ZigClangFileID = struct_ZigClangFileID;
901	pub const ZigClangForStmt = struct_ZigClangForStmt;
902	pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc;
903	pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl;
904	pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType;
905	pub const ZigClangIfStmt = struct_ZigClangIfStmt;
906	pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
907	pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
908	pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
909	pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
910	pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
911	pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
912	pub const ZigClangNone = struct_ZigClangNone;
913	pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations;
914	pub const ZigClangParenExpr = struct_ZigClangParenExpr;
915	pub const ZigClangParenType = struct_ZigClangParenType;
916	pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl;
917	pub const ZigClangPointerType = struct_ZigClangPointerType;
918	pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity;
919	pub const ZigClangRecordDecl = struct_ZigClangRecordDecl;
920	pub const ZigClangRecordType = struct_ZigClangRecordType;
921	pub const ZigClangReturnStmt = struct_ZigClangReturnStmt;
922	pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope;
923	pub const ZigClangSourceManager = struct_ZigClangSourceManager;
924	pub const ZigClangSourceRange = struct_ZigClangSourceRange;
925	pub const ZigClangStmt = struct_ZigClangStmt;
926	pub const ZigClangStorageClass = struct_ZigClangStorageClass;
927	pub const ZigClangStringLiteral = struct_ZigClangStringLiteral;
928	pub const ZigClangStringRef = struct_ZigClangStringRef;
929	pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt;
930	pub const ZigClangTagDecl = struct_ZigClangTagDecl;
931	pub const ZigClangType = struct_ZigClangType;
932	pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl;
933	pub const ZigClangTypedefType = struct_ZigClangTypedefType;
934	pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr;
935	pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
936	pub const ZigClangValueDecl = struct_ZigClangValueDecl;
937	pub const ZigClangVarDecl = struct_ZigClangVarDecl;
938	pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
939	pub const ZigClangBO = enum_ZigClangBO;
940	pub const ZigClangUO = enum_ZigClangUO;
941	pub const ZigClangTypeClass = enum_ZigClangTypeClass;
942	pub const ZigClangStmtClass = enum_ZigClangStmtClass;
943	pub const ZigClangCK = enum_ZigClangCK;
944	pub const ZigClangAPValueKind = enum_ZigClangAPValueKind;

src-self-hosted/stage1.zig+92-3

...	@@ -1,8 +1,7 @@	...	@@ -1,8 +1,7 @@
1	// This is Zig code that is used by both stage1 and stage2.	1	// This is Zig code that is used by both stage1 and stage2.
2	// The prototypes in src/userland.h must match these definitions.	2	// The prototypes in src/userland.h must match these definitions.
3	comptime {	3
4	_ = @import("translate_c.zig");	4	const std = @import("std");
5	}
6		5
7	pub const info_zen =	6	pub const info_zen =
8	\\	7	\\
...	@@ -29,3 +28,93 @@ export fn stage2_zen(ptr: []const u8, len: *usize) void {	...	@@ -29,3 +28,93 @@ export fn stage2_zen(ptr: []const u8, len: *usize) void {
29	export fn stage2_panic(ptr: [*]const u8, len: usize) void {	28	export fn stage2_panic(ptr: [*]const u8, len: usize) void {
30	@panic(ptr[0..len]);	29	@panic(ptr[0..len]);
31	}	30	}
		31
		32	const TranslateMode = extern enum {
		33	import,
		34	translate,
		35	};
		36
		37	const 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
		85	const FILE = std.c.FILE;
		86	const ast = std.zig.ast;
		87
		88	/// Args should have a null terminating last arg.
		89	export 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
		105	export 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 @@	...	@@ -2,7 +2,14 @@
2	// and stage2. Currently it's not used by anything, as it's not feature complete.	2	// and stage2. Currently it's not used by anything, as it's not feature complete.
3		3
4	const std = @import("std");	4	const std = @import("std");
		5	const ast = std.zig.ast;
		6	use @import("clang.zig");
5		7
6	export fn stage2_translate_c() void {	8	pub const Mode = enum {
7	std.debug.panic("unimplemented");	9	import,
		10	translate,
		11	};
		12
		13	pub fn translate(args_begin: []?[]const u8, args_end: []?[]const u8, mode: Mode) !*ast.Tree {
		14	return error.Unimplemented;
8	}	15	}

src/analyze.cpp+1-1

...	@@ -3725,7 +3725,7 @@ static void analyze_fn_body(CodeGen g, ZigFn fn_table_entry) {	...	@@ -3725,7 +3725,7 @@ static void analyze_fn_body(CodeGen g, ZigFn fn_table_entry) {
3725	}	3725	}
3726	if (g->verbose_ir) {	3726	if (g->verbose_ir) {
3727	fprintf(stderr, "\n");	3727	fprintf(stderr, "\n");
3728	ast_render(g, stderr, fn_table_entry->body_node, 4);	3728	ast_render(stderr, fn_table_entry->body_node, 4);
3729	fprintf(stderr, "\n{ // (IR)\n");	3729	fprintf(stderr, "\n{ // (IR)\n");
3730	ir_print(g, stderr, &fn_table_entry->ir_executable, 4);	3730	ir_print(g, stderr, &fn_table_entry->ir_executable, 4);
3731	fprintf(stderr, "}\n");	3731	fprintf(stderr, "}\n");

src/analyze.hpp+2

...	@@ -247,4 +247,6 @@ Error create_c_object_cache(CodeGen g, CacheHash *out_cache_hash, bool verbose	...	@@ -247,4 +247,6 @@ Error create_c_object_cache(CodeGen g, CacheHash *out_cache_hash, bool verbose
247	LLVMTypeRef get_llvm_type(CodeGen g, ZigType type);	247	LLVMTypeRef get_llvm_type(CodeGen g, ZigType type);
248	ZigLLVMDIType get_llvm_di_type(CodeGen g, ZigType *type);	248	ZigLLVMDIType get_llvm_di_type(CodeGen g, ZigType *type);
249		249
		250	void add_cc_args(CodeGen g, ZigList<const char > &args, const char *out_dep_path, bool translate_c);
		251
250	#endif	252	#endif

src/ast_render.cpp+1-3

...	@@ -296,7 +296,6 @@ void ast_print(FILE f, AstNode node, int indent) {	...	@@ -296,7 +296,6 @@ void ast_print(FILE f, AstNode node, int indent) {
296		296
297		297
298	struct AstRender {	298	struct AstRender {
299	CodeGen *codegen;
300	int indent;	299	int indent;
301	int indent_size;	300	int indent_size;
302	FILE *f;	301	FILE *f;
...	@@ -1170,9 +1169,8 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {	...	@@ -1170,9 +1169,8 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
1170	}	1169	}
1171		1170
1172		1171
1173	void ast_render(CodeGen codegen, FILE f, AstNode *node, int indent_size) {	1172	void ast_render(FILE f, AstNode node, int indent_size) {
1174	AstRender ar = {0};	1173	AstRender ar = {0};
1175	ar.codegen = codegen;
1176	ar.f = f;	1174	ar.f = f;
1177	ar.indent_size = indent_size;	1175	ar.indent_size = indent_size;
1178	ar.indent = 0;	1176	ar.indent = 0;

src/ast_render.hpp+1-1

...	@@ -15,6 +15,6 @@	...	@@ -15,6 +15,6 @@
15		15
16	void ast_print(FILE f, AstNode node, int indent);	16	void ast_print(FILE f, AstNode node, int indent);
17		17
18	void ast_render(CodeGen codegen, FILE f, AstNode *node, int indent_size);	18	void ast_render(FILE f, AstNode node, int indent_size);
19		19
20	#endif	20	#endif

src/codegen.cpp+156-115

 @@ -8153,7 +8153,128 @@ static void detect_libc(CodeGen *g) {
     }
 }
-AstNode *codegen_translate_c(CodeGen *g, Buf *full_path, bool use_userland_implementation) {
+// does not add the "cc" arg
+void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_path, bool translate_c) {
+    if (out_dep_path != nullptr) {
+        args.append("-MD");
+        args.append("-MV");
+        args.append("-MF");
+        args.append(out_dep_path);
+    }
+    args.append("-nostdinc");
+    args.append("-fno-spell-checking");
+    if (translate_c) {
+        // TODO these args shouldn't be special from the non-translate-c args, probably.
+        args.append("-nobuiltininc");
+        args.append("-nostdinc++");
+        if (g->libc_link_lib == nullptr) {
+            args.append("-nolibc");
+        }
+        // this gives us access to preprocessing entities, presumably at
+        // the cost of performance
+        args.append("-Xclang");
+        args.append("-detailed-preprocessing-record");
+    } else {
+        switch (g->err_color) {
+            case ErrColorAuto:
+                break;
+            case ErrColorOff:
+                args.append("-fno-color-diagnostics");
+                args.append("-fno-caret-diagnostics");
+                break;
+            case ErrColorOn:
+                args.append("-fcolor-diagnostics");
+                args.append("-fcaret-diagnostics");
+                break;
+        }
+    }
+    args.append("-isystem");
+    args.append(buf_ptr(g->zig_c_headers_dir));
+    for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
+        Buf *include_dir = g->libc_include_dir_list[i];
+        args.append("-isystem");
+        args.append(buf_ptr(include_dir));
+    }
+    if (g->zig_target->is_native) {
+        args.append("-march=native");
+    } else {
+        args.append("-target");
+        args.append(buf_ptr(&g->triple_str));
+    }
+    if (g->zig_target->os == OsFreestanding) {
+        args.append("-ffreestanding");
+    }
+    if (!g->strip_debug_symbols) {
+        args.append("-g");
+    }
+    switch (g->build_mode) {
+        case BuildModeDebug:
+            // windows c runtime requires -D_DEBUG if using debug libraries
+            args.append("-D_DEBUG");
+            if (g->libc_link_lib != nullptr) {
+                args.append("-fstack-protector-strong");
+                args.append("--param");
+                args.append("ssp-buffer-size=4");
+            } else {
+                args.append("-fno-stack-protector");
+            }
+            args.append("-fno-omit-frame-pointer");
+            break;
+        case BuildModeSafeRelease:
+            // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
+            // than -O3 here.
+            args.append("-O2");
+            if (g->libc_link_lib != nullptr) {
+                args.append("-D_FORTIFY_SOURCE=2");
+                args.append("-fstack-protector-strong");
+                args.append("--param");
+                args.append("ssp-buffer-size=4");
+            } else {
+                args.append("-fno-stack-protector");
+            }
+            args.append("-fomit-frame-pointer");
+            break;
+        case BuildModeFastRelease:
+            args.append("-DNDEBUG");
+            // Here we pass -O2 rather than -O3 because, although we do the equivalent of
+            // -O3 in Zig code, the justification for the difference here is that Zig
+            // has better detection and prevention of undefined behavior, so -O3 is safer for
+            // Zig code than it is for C code. Also, C programmers are used to their code
+            // running in -O2 and thus the -O3 path has been tested less.
+            args.append("-O2");
+            args.append("-fno-stack-protector");
+            args.append("-fomit-frame-pointer");
+            break;
+        case BuildModeSmallRelease:
+            args.append("-DNDEBUG");
+            args.append("-Os");
+            args.append("-fno-stack-protector");
+            args.append("-fomit-frame-pointer");
+            break;
+    }
+    if (target_supports_fpic(g->zig_target) && g->have_pic) {
+        args.append("-fPIC");
+    }
+    for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
+        args.append(g->clang_argv[arg_i]);
+    }
+}
+void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation) {
+    Error err;
     Buf *src_basename = buf_alloc();
     Buf *src_dirname = buf_alloc();
     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
     init(g);
+    Stage2TranslateMode trans_mode = buf_ends_with_str(full_path, ".h") ?
+        Stage2TranslateModeImport : Stage2TranslateModeTranslate;
+    ZigList<const char *> clang_argv = {0};
+    add_cc_args(g, clang_argv, nullptr, true);
+    clang_argv.append("-c");
+    clang_argv.append(buf_ptr(full_path));
+    clang_argv.append(nullptr); // to make the [start...end] argument work
     if (use_userland_implementation) {
-        // TODO improve this
+        Stage2Ast *ast;
-        stage2_translate_c();
+        if ((err = stage2_translate_c(&ast, &clang_argv.at(0), &clang_argv.last(), trans_mode))) {
-        zig_panic("TODO");
+            zig_panic("TODO");
-    }
+        }
+        stage2_render_ast(ast, out_file);
+    } else {
+        ZigList<ErrorMsg *> errors = {0};
+        AstNode *root_node;
-    ZigList<ErrorMsg *> errors = {0};
+        err = parse_h_file(g, &root_node, &clang_argv.at(0), &clang_argv.last(), trans_mode, &errors);
-    AstNode *root_node;
-    Error err = parse_h_file(&root_node, &errors, buf_ptr(full_path), g, nullptr);
-    if (err == ErrorCCompileErrors && errors.length > 0) {
+        if (err == ErrorCCompileErrors && errors.length > 0) {
-        for (size_t i = 0; i < errors.length; i += 1) {
+            for (size_t i = 0; i < errors.length; i += 1) {
-            ErrorMsg *err_msg = errors.at(i);
+                ErrorMsg *err_msg = errors.at(i);
-            print_err_msg(err_msg, g->err_color);
+                print_err_msg(err_msg, g->err_color);
+            }
+            exit(1);
         }
-        exit(1);
-    }
-    if (err) {
+        if (err) {
-        fprintf(stderr, "unable to parse C file: %s\n", err_str(err));
+            fprintf(stderr, "unable to parse C file: %s\n", err_str(err));
-        exit(1);
+            exit(1);
-    }
+        }
-    return root_node;
+        ast_render(out_file, root_node, 4);
+    }
 }
 static 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) {
         args.append("cc");
         Buf *out_dep_path = buf_sprintf("%s.d", buf_ptr(out_obj_path));
-        args.append("-MD");
+        add_cc_args(g, args, buf_ptr(out_dep_path), false);
-        args.append("-MV");
-        args.append("-MF");
-        args.append(buf_ptr(out_dep_path));
-        args.append("-nostdinc");
-        args.append("-fno-spell-checking");
-        switch (g->err_color) {
-            case ErrColorAuto:
-                break;
-            case ErrColorOff:
-                args.append("-fno-color-diagnostics");
-                args.append("-fno-caret-diagnostics");
-                break;
-            case ErrColorOn:
-                args.append("-fcolor-diagnostics");
-                args.append("-fcaret-diagnostics");
-                break;
-        }
-        args.append("-isystem");
-        args.append(buf_ptr(g->zig_c_headers_dir));
-        for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
-            Buf *include_dir = g->libc_include_dir_list[i];
-            args.append("-isystem");
-            args.append(buf_ptr(include_dir));
-        }
-        if (g->zig_target->is_native) {
-            args.append("-march=native");
-        } else {
-            args.append("-target");
-            args.append(buf_ptr(&g->triple_str));
-        }
-        if (g->zig_target->os == OsFreestanding) {
-            args.append("-ffreestanding");
-        }
-        if (!g->strip_debug_symbols) {
-            args.append("-g");
-        }
-        switch (g->build_mode) {
-            case BuildModeDebug:
-                if (g->libc_link_lib != nullptr) {
-                    args.append("-fstack-protector-strong");
-                    args.append("--param");
-                    args.append("ssp-buffer-size=4");
-                } else {
-                    args.append("-fno-stack-protector");
-                }
-                args.append("-fno-omit-frame-pointer");
-                break;
-            case BuildModeSafeRelease:
-                // See the comment in the BuildModeFastRelease case for why we pass -O2 rather
-                // than -O3 here.
-                args.append("-O2");
-                if (g->libc_link_lib != nullptr) {
-                    args.append("-D_FORTIFY_SOURCE=2");
-                    args.append("-fstack-protector-strong");
-                    args.append("--param");
-                    args.append("ssp-buffer-size=4");
-                } else {
-                    args.append("-fno-stack-protector");
-                }
-                args.append("-fomit-frame-pointer");
-                break;
-            case BuildModeFastRelease:
-                args.append("-DNDEBUG");
-                // Here we pass -O2 rather than -O3 because, although we do the equivalent of
-                // -O3 in Zig code, the justification for the difference here is that Zig
-                // has better detection and prevention of undefined behavior, so -O3 is safer for
-                // Zig code than it is for C code. Also, C programmers are used to their code
-                // running in -O2 and thus the -O3 path has been tested less.
-                args.append("-O2");
-                args.append("-fno-stack-protector");
-                args.append("-fomit-frame-pointer");
-                break;
-            case BuildModeSmallRelease:
-                args.append("-DNDEBUG");
-                args.append("-Os");
-                args.append("-fno-stack-protector");
-                args.append("-fomit-frame-pointer");
-                break;
-        }
         args.append("-o");
         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) {
         args.append("-c");
         args.append(buf_ptr(c_source_file));
-        if (target_supports_fpic(g->zig_target) && g->have_pic) {
-            args.append("-fPIC");
-        }
-        for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
-            args.append(g->clang_argv[arg_i]);
-        }
         for (size_t arg_i = 0; arg_i < c_file->args.length; arg_i += 1) {
             args.append(c_file->args.at(arg_i));
         }
         if (g->verbose_cc) {
             print_zig_cc_cmd("zig", &args);
         }

src/codegen.hpp+2-1

...	@@ -12,6 +12,7 @@	...	@@ -12,6 +12,7 @@
12	#include "errmsg.hpp"	12	#include "errmsg.hpp"
13	#include "target.hpp"	13	#include "target.hpp"
14	#include "libc_installation.hpp"	14	#include "libc_installation.hpp"
		15	#include "userland.h"
15		16
16	#include <stdio.h>	17	#include <stdio.h>
17		18
...	@@ -50,7 +51,7 @@ ZigPackage codegen_create_package(CodeGen g, const char *root_src_dir, const c	...	@@ -50,7 +51,7 @@ ZigPackage codegen_create_package(CodeGen g, const char *root_src_dir, const c
50	void codegen_add_assembly(CodeGen g, Buf path);	51	void codegen_add_assembly(CodeGen g, Buf path);
51	void codegen_add_object(CodeGen g, Buf object_path);	52	void codegen_add_object(CodeGen g, Buf object_path);
52		53
53	AstNode codegen_translate_c(CodeGen g, Buf *path, bool use_userland_implementation);	54	void codegen_translate_c(CodeGen g, Buf full_path, FILE *out_file, bool use_userland_implementation);
54		55
55	Buf codegen_generate_builtin_source(CodeGen g);	56	Buf codegen_generate_builtin_source(CodeGen g);
56		57

src/error.cpp+4

 @@ -50,6 +50,10 @@ const char *err_str(Error err) {
         case ErrorUnexpectedWriteFailure: return "unexpected write failure";
         case ErrorUnexpectedSeekFailure: return "unexpected seek failure";
         case ErrorUnexpectedFileTruncationFailure: return "unexpected file truncation failure";
+        case ErrorUnimplemented: return "unimplemented";
+        case ErrorOperationAborted: return "operation aborted";
+        case ErrorBrokenPipe: return "broken pipe";
+        case ErrorNoSpaceLeft: return "no space left";
     }
     return "(invalid error)";
 }

src/error.hpp+1-43

...	@@ -8,49 +8,7 @@	...	@@ -8,49 +8,7 @@
8	#ifndef ERROR_HPP	8	#ifndef ERROR_HPP
9	#define ERROR_HPP	9	#define ERROR_HPP
10		10
11	enum Error {	11	#include "userland.h"
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	};
54		12
55	const char *err_str(Error err);	13	const char *err_str(Error err);
56		14

src/ir.cpp+17-5

...	@@ -10350,7 +10350,7 @@ ConstExprValue ir_eval_const_value(CodeGen codegen, Scope scope, AstNode nod	...	@@ -10350,7 +10350,7 @@ ConstExprValue ir_eval_const_value(CodeGen codegen, Scope scope, AstNode nod
10350		10350
10351	if (codegen->verbose_ir) {	10351	if (codegen->verbose_ir) {
10352	fprintf(stderr, "\nSource: ");	10352	fprintf(stderr, "\nSource: ");
10353	ast_render(codegen, stderr, node, 4);	10353	ast_render(stderr, node, 4);
10354	fprintf(stderr, "\n{ // (IR)\n");	10354	fprintf(stderr, "\n{ // (IR)\n");
10355	ir_print(codegen, stderr, ir_executable, 2);	10355	ir_print(codegen, stderr, ir_executable, 2);
10356	fprintf(stderr, "}\n");	10356	fprintf(stderr, "}\n");
...	@@ -19092,11 +19092,23 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct	...	@@ -19092,11 +19092,23 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
19092	fprintf(stderr, "@cImport source: %s\n", buf_ptr(&tmp_c_file_path));	19092	fprintf(stderr, "@cImport source: %s\n", buf_ptr(&tmp_c_file_path));
19093	}	19093	}
19094		19094
19095	ZigList<ErrorMsg *> errors = {0};
19096
19097	Buf *tmp_dep_file = buf_sprintf("%s.d", buf_ptr(&tmp_c_file_path));	19095	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};
19098	AstNode *root_node;	19107	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	{
19100	if (err != ErrorCCompileErrors) {	19112	if (err != ErrorCCompileErrors) {
19101	ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));	19113	ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
19102	return ira->codegen->invalid_instruction;	19114	return ira->codegen->invalid_instruction;
...	@@ -19139,7 +19151,7 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct	...	@@ -19139,7 +19151,7 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
19139	buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));	19151	buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));
19140	return ira->codegen->invalid_instruction;	19152	return ira->codegen->invalid_instruction;
19141	}	19153	}
19142	ast_render(ira->codegen, out_file, root_node, 4);	19154	ast_render(out_file, root_node, 4);
19143	if (fclose(out_file) != 0) {	19155	if (fclose(out_file) != 0) {
19144	ir_add_error_node(ira, node,	19156	ir_add_error_node(ira, node,
19145	buf_sprintf("C import failed: unable to write to output file: %s", strerror(errno)));	19157	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) {	...	@@ -1188,8 +1188,7 @@ int main(int argc, char **argv) {
1188	zig_unreachable();	1188	zig_unreachable();
1189	}	1189	}
1190	} else if (cmd == CmdTranslateC \|\| cmd == CmdTranslateCUserland) {	1190	} else if (cmd == CmdTranslateC \|\| cmd == CmdTranslateCUserland) {
1191	AstNode *root_node = codegen_translate_c(g, in_file_buf, cmd == CmdTranslateCUserland);	1191	codegen_translate_c(g, in_file_buf, stdout, cmd == CmdTranslateCUserland);
1192	ast_render(g, stdout, root_node, 4);
1193	if (timing_info)	1192	if (timing_info)
1194	codegen_print_timing_report(g, stderr);	1193	codegen_print_timing_report(g, stderr);
1195	return EXIT_SUCCESS;	1194	return EXIT_SUCCESS;

src/translate_c.cpp+4-90

...	@@ -5018,14 +5018,14 @@ static void process_preprocessor_entities(Context c, ZigClangASTUnit zunit) {	...	@@ -5018,14 +5018,14 @@ static void process_preprocessor_entities(Context c, ZigClangASTUnit zunit) {
5018	}	5018	}
5019	}	5019	}
5020		5020
5021	Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > errors, const char target_file,	5021	Error parse_h_file(CodeGen codegen, AstNode out_root_node, const char args_begin, const char *args_end,
5022	CodeGen codegen, Buf tmp_dep_file)	5022	Stage2TranslateMode mode, ZigList<ErrorMsg > errors)
5023	{	5023	{
5024	Context context = {0};	5024	Context context = {0};
5025	Context *c = &context;	5025	Context *c = &context;
5026	c->warnings_on = codegen->verbose_cimport;	5026	c->warnings_on = codegen->verbose_cimport;
5027	c->errors = errors;	5027	c->errors = errors;
5028	if (buf_ends_with_str(buf_create_from_str(target_file), ".h")) {	5028	if (mode == Stage2TranslateModeImport) {
5029	c->visib_mod = VisibModPub;	5029	c->visib_mod = VisibModPub;
5030	c->want_export = false;	5030	c->want_export = false;
5031	} else {	5031	} else {
...	@@ -5039,92 +5039,6 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c	...	@@ -5039,92 +5039,6 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c
5039	c->codegen = codegen;	5039	c->codegen = codegen;
5040	c->global_scope = trans_scope_root_create(c);	5040	c->global_scope = trans_scope_root_create(c);
5041		5041
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);
5128		5042
5129	clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));	5043	clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));
5130		5044
...	@@ -5139,7 +5053,7 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c	...	@@ -5139,7 +5053,7 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c
5139	const char *resources_path = buf_ptr(codegen->zig_c_headers_dir);	5053	const char *resources_path = buf_ptr(codegen->zig_c_headers_dir);
5140	std::unique_ptr<clang::ASTUnit> err_unit;	5054	std::unique_ptr<clang::ASTUnit> err_unit;
5141	ZigClangASTUnit ast_unit = reinterpret_cast<ZigClangASTUnit >(clang::ASTUnit::LoadFromCommandLine(	5055	ZigClangASTUnit ast_unit = reinterpret_cast<ZigClangASTUnit >(clang::ASTUnit::LoadFromCommandLine(
5142	&clang_argv.at(0), &clang_argv.last(),	5056	args_begin, args_end,
5143	pch_container_ops, diags, resources_path,	5057	pch_container_ops, diags, resources_path,
5144	only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,	5058	only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,
5145	false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,	5059	false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,

src/translate_c.hpp+2-2

...	@@ -11,7 +11,7 @@	...	@@ -11,7 +11,7 @@
11		11
12	#include "all_types.hpp"	12	#include "all_types.hpp"
13		13
14	Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > errors, const char target_file,	14	Error parse_h_file(CodeGen codegen, AstNode out_root_node, const char args_begin, const char *args_end,
15	CodeGen codegen, Buf tmp_dep_file);	15	Stage2TranslateMode mode, ZigList<ErrorMsg > errors);
16		16
17	#endif	17	#endif

src/userland.cpp+9-1

 @@ -2,11 +2,14 @@
 // src-self-hosted/stage1.zig
 #include "userland.h"
+#include "ast_render.hpp"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-void stage2_translate_c(void) {
+Error stage2_translate_c(struct Stage2Ast **out_ast,
+        const char **args_begin, const char **args_end, enum Stage2TranslateMode mode)
+{
     const char *msg = "stage0 called stage2_translate_c";
     stage2_panic(msg, strlen(msg));
 }
 @@ -22,3 +25,8 @@ void stage2_panic(const char *ptr, size_t len) {
     fflush(stderr);
     abort();
 }
+void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file) {
+    const char *msg = "stage0 called stage2_render_ast";
+    stage2_panic(msg, strlen(msg));
+}

src/userland.h+70-2

...	@@ -9,6 +9,7 @@	...	@@ -9,6 +9,7 @@
9	#define ZIG_USERLAND_H	9	#define ZIG_USERLAND_H
10		10
11	#include <stddef.h>	11	#include <stddef.h>
		12	#include <stdio.h>
12		13
13	#ifdef __cplusplus	14	#ifdef __cplusplus
14	#define ZIG_USERLAND_EXTERN_C extern "C"	15	#define ZIG_USERLAND_EXTERN_C extern "C"
...	@@ -16,10 +17,77 @@	...	@@ -16,10 +17,77 @@
16	#define ZIG_USERLAND_EXTERN_C	17	#define ZIG_USERLAND_EXTERN_C
17	#endif	18	#endif
18		19
19	ZIG_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
		29	enum 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
		77	enum Stage2TranslateMode {
		78	Stage2TranslateModeImport,
		79	Stage2TranslateModeTranslate,
		80	};
		81
		82	struct Stage2Ast;
		83
		84	ZIG_USERLAND_EXTERN_C Error stage2_translate_c(struct Stage2Ast **out_ast,
		85	const char args_begin, const char args_end, enum Stage2TranslateMode mode);
		86
		87	ZIG_USERLAND_EXTERN_C void stage2_render_ast(struct Stage2Ast ast, FILE output_file);
20		88
21	ZIG_USERLAND_EXTERN_C void stage2_zen(const char *ptr, size_t len);	89	ZIG_USERLAND_EXTERN_C void stage2_zen(const char *ptr, size_t len);
22		90
23	ZIG_USERLAND_EXTERN_C void stage2_panic(const char *ptr, size_t len);	91	ZIG_USERLAND_EXTERN_C ZIG_USERLAND_ATTRIBUTE_NORETURN void stage2_panic(const char *ptr, size_t len);
24		92
25	#endif	93	#endif

src/zig_clang.h+84-83

std/c.zig+4

 @@ -12,6 +12,10 @@ pub use switch (builtin.os) {
 // TODO https://github.com/ziglang/zig/issues/265 on this whole file
+pub const FILE = @OpaqueType();
+pub extern "c" fn fwrite(ptr: [*]const u8, size_of_type: usize, item_count: usize, stream: *FILE) usize;
+pub extern "c" fn fread(ptr: [*]u8, size_of_type: usize, item_count: usize, stream: *FILE) usize;
 pub extern "c" fn abort() noreturn;
 pub extern "c" fn exit(code: c_int) noreturn;
 pub extern "c" fn isatty(fd: c_int) c_int;

std/io.zig+18-12

...	@@ -36,6 +36,7 @@ pub fn getStdIn() GetStdIoErrs!File {	...	@@ -36,6 +36,7 @@ pub fn getStdIn() GetStdIoErrs!File {
36	}	36	}
37		37
38	pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;	38	pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;
		39	pub const COutStream = @import("io/c_out_stream.zig").COutStream;
39		40
40	pub fn InStream(comptime ReadError: type) type {	41	pub fn InStream(comptime ReadError: type) type {
41	return struct {	42	return struct {
...	@@ -1089,8 +1090,10 @@ test "io.readLineSliceFrom" {	...	@@ -1089,8 +1090,10 @@ test "io.readLineSliceFrom" {
1089	}	1090	}
1090		1091
1091	pub const Packing = enum {	1092	pub const Packing = enum {
1092	Byte, /// Pack data to byte alignment	1093	/// Pack data to byte alignment
1093	Bit, /// Pack data to bit alignment	1094	Byte,
		1095	/// Pack data to bit alignment
		1096	Bit,
1094	};	1097	};
1095		1098
1096	/// Creates a deserializer that deserializes types from any stream.	1099	/// Creates a deserializer that deserializes types from any stream.
...	@@ -1111,10 +1114,12 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,	...	@@ -1111,10 +1114,12 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
1111	pub const Stream = InStream(Error);	1114	pub const Stream = InStream(Error);
1112		1115
1113	pub fn init(in_stream: *Stream) Self {	1116	pub fn init(in_stream: *Stream) Self {
1114	return Self{ .in_stream = switch (packing) {	1117	return Self{
1115	.Bit => BitInStream(endian, Stream.Error).init(in_stream),	1118	.in_stream = switch (packing) {
1116	.Byte => in_stream,	1119	.Bit => BitInStream(endian, Stream.Error).init(in_stream),
1117	} };	1120	.Byte => in_stream,
		1121	},
		1122	};
1118	}	1123	}
1119		1124
1120	pub fn alignToByte(self: *Self) void {	1125	pub fn alignToByte(self: *Self) void {
...	@@ -1281,7 +1286,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,	...	@@ -1281,7 +1286,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
1281	ptr.* = null;	1286	ptr.* = null;
1282	return;	1287	return;
1283	}	1288	}
1284		1289
1285	ptr.* = OC(undefined); //make it non-null so the following .? is guaranteed safe	1290	ptr.* = OC(undefined); //make it non-null so the following .? is guaranteed safe
1286	const val_ptr = &ptr.*.?;	1291	const val_ptr = &ptr.*.?;
1287	try self.deserializeInto(val_ptr);	1292	try self.deserializeInto(val_ptr);
...	@@ -1320,10 +1325,12 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co	...	@@ -1320,10 +1325,12 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
1320	pub const Stream = OutStream(Error);	1325	pub const Stream = OutStream(Error);
1321		1326
1322	pub fn init(out_stream: *Stream) Self {	1327	pub fn init(out_stream: *Stream) Self {
1323	return Self{ .out_stream = switch (packing) {	1328	return Self{
1324	.Bit => BitOutStream(endian, Stream.Error).init(out_stream),	1329	.out_stream = switch (packing) {
1325	.Byte => out_stream,	1330	.Bit => BitOutStream(endian, Stream.Error).init(out_stream),
1326	} };	1331	.Byte => out_stream,
		1332	},
		1333	};
1327	}	1334	}
1328		1335
1329	/// Flushes any unwritten bits to the stream	1336	/// Flushes any unwritten bits to the stream
...	@@ -1450,4 +1457,3 @@ test "import io tests" {	...	@@ -1450,4 +1457,3 @@ test "import io tests" {
1450	_ = @import("io_test.zig");	1457	_ = @import("io_test.zig");
1451	}	1458	}
1452	}	1459	}
1453

std/io/c_out_stream.zig created+44

...	@@ -0,0 +1,44 @@
1	const std = @import("../std.zig");
2	const OutStream = std.io.OutStream;
3	const builtin = @import("builtin");
4	const 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.
9	pub 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	};

...	@@ -9,6 +9,7 @@	...	@@ -9,6 +9,7 @@
9	#define ZIG_ZIG_CLANG_H	9	#define ZIG_ZIG_CLANG_H
10		10
11	#include <inttypes.h>	11	#include <inttypes.h>
		12	#include <stdbool.h>
12		13
13	#ifdef __cplusplus	14	#ifdef __cplusplus
14	#define ZIG_EXTERN_C extern "C"	15	#define ZIG_EXTERN_C extern "C"
...	@@ -17,8 +18,8 @@	...	@@ -17,8 +18,8 @@
17	#endif	18	#endif
18		19
19	// ATTENTION: If you modify this file, be sure to update the corresponding	20	// ATTENTION: If you modify this file, be sure to update the corresponding
20	// extern function declarations in the self-hosted compiler.	21	// extern function declarations in the self-hosted compiler file
21	// Note: not yet, we don't have the corresponding clang.zig yet.	22	// src-self-hosted/clang.zig.
22		23
23	struct ZigClangSourceLocation {	24	struct ZigClangSourceLocation {
24	unsigned ID;	25	unsigned ID;
...	@@ -486,86 +487,86 @@ enum ZigClangAPValueKind {	...	@@ -486,86 +487,86 @@ enum ZigClangAPValueKind {
486	ZigClangAPValueAddrLabelDiff,	487	ZigClangAPValueAddrLabelDiff,
487	};	488	};
488		489
489	ZIG_EXTERN_C ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *,	490	ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *,
490	ZigClangSourceLocation Loc);	491	struct ZigClangSourceLocation Loc);
491	ZIG_EXTERN_C const char ZigClangSourceManager_getFilename(const ZigClangSourceManager ,	492	ZIG_EXTERN_C const char ZigClangSourceManager_getFilename(const struct ZigClangSourceManager ,
492	ZigClangSourceLocation SpellingLoc);	493	struct ZigClangSourceLocation SpellingLoc);
493	ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingLineNumber(const ZigClangSourceManager *,	494	ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingLineNumber(const struct ZigClangSourceManager *,
494	ZigClangSourceLocation Loc);	495	struct ZigClangSourceLocation Loc);
495	ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingColumnNumber(const ZigClangSourceManager *,	496	ZIG_EXTERN_C unsigned ZigClangSourceManager_getSpellingColumnNumber(const struct ZigClangSourceManager *,
496	ZigClangSourceLocation Loc);	497	struct ZigClangSourceLocation Loc);
497	ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const ZigClangSourceManager *,	498	ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const struct ZigClangSourceManager *,
498	ZigClangSourceLocation SL);	499	struct ZigClangSourceLocation SL);
499		500
500	ZIG_EXTERN_C ZigClangQualType ZigClangASTContext_getPointerType(const ZigClangASTContext*, ZigClangQualType T);	501	ZIG_EXTERN_C struct ZigClangQualType ZigClangASTContext_getPointerType(const struct ZigClangASTContext*, struct ZigClangQualType T);
501		502
502	ZIG_EXTERN_C ZigClangASTContext ZigClangASTUnit_getASTContext(ZigClangASTUnit );	503	ZIG_EXTERN_C struct ZigClangASTContext ZigClangASTUnit_getASTContext(struct ZigClangASTUnit );
503	ZIG_EXTERN_C ZigClangSourceManager ZigClangASTUnit_getSourceManager(ZigClangASTUnit );	504	ZIG_EXTERN_C struct ZigClangSourceManager ZigClangASTUnit_getSourceManager(struct ZigClangASTUnit );
504	ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(ZigClangASTUnit , void context,	505	ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(struct ZigClangASTUnit , void context,
505	bool (Fn)(void context, const ZigClangDecl *decl));	506	bool (Fn)(void context, const struct ZigClangDecl *decl));
506		507
507	ZIG_EXTERN_C const ZigClangRecordDecl ZigClangRecordType_getDecl(const ZigClangRecordType record_ty);	508	ZIG_EXTERN_C const struct ZigClangRecordDecl ZigClangRecordType_getDecl(const struct ZigClangRecordType record_ty);
508	ZIG_EXTERN_C const ZigClangEnumDecl ZigClangEnumType_getDecl(const ZigClangEnumType record_ty);	509	ZIG_EXTERN_C const struct ZigClangEnumDecl ZigClangEnumType_getDecl(const struct ZigClangEnumType record_ty);
509		510
510	ZIG_EXTERN_C const ZigClangTagDecl ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl record_decl);	511	ZIG_EXTERN_C const struct ZigClangTagDecl ZigClangRecordDecl_getCanonicalDecl(const struct ZigClangRecordDecl record_decl);
511	ZIG_EXTERN_C const ZigClangTagDecl ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl );	512	ZIG_EXTERN_C const struct ZigClangTagDecl ZigClangEnumDecl_getCanonicalDecl(const struct ZigClangEnumDecl );
512	ZIG_EXTERN_C const ZigClangTypedefNameDecl ZigClangTypedefNameDecl_getCanonicalDecl(const ZigClangTypedefNameDecl );	513	ZIG_EXTERN_C const struct ZigClangTypedefNameDecl ZigClangTypedefNameDecl_getCanonicalDecl(const struct ZigClangTypedefNameDecl );
513		514
514	ZIG_EXTERN_C const ZigClangRecordDecl ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl );	515	ZIG_EXTERN_C const struct ZigClangRecordDecl ZigClangRecordDecl_getDefinition(const struct ZigClangRecordDecl );
515	ZIG_EXTERN_C const ZigClangEnumDecl ZigClangEnumDecl_getDefinition(const ZigClangEnumDecl );	516	ZIG_EXTERN_C const struct ZigClangEnumDecl ZigClangEnumDecl_getDefinition(const struct ZigClangEnumDecl );
516		517
517	ZIG_EXTERN_C ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *);	518	ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangRecordDecl_getLocation(const struct ZigClangRecordDecl *);
518	ZIG_EXTERN_C ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *);	519	ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangEnumDecl_getLocation(const struct ZigClangEnumDecl *);
519	ZIG_EXTERN_C ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const ZigClangTypedefNameDecl *);	520	ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const struct ZigClangTypedefNameDecl *);
520		521
521	ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl);	522	ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const struct ZigClangRecordDecl *record_decl);
522	ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const ZigClangRecordDecl *record_decl);	523	ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const struct ZigClangRecordDecl *record_decl);
523	ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const ZigClangRecordDecl *record_decl);	524	ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const struct ZigClangRecordDecl *record_decl);
524		525
525	ZIG_EXTERN_C ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *);	526	ZIG_EXTERN_C struct ZigClangQualType ZigClangEnumDecl_getIntegerType(const struct ZigClangEnumDecl *);
526		527
527	ZIG_EXTERN_C const char ZigClangDecl_getName_bytes_begin(const ZigClangDecl decl);	528	ZIG_EXTERN_C const char ZigClangDecl_getName_bytes_begin(const struct ZigClangDecl decl);
528		529
529	ZIG_EXTERN_C bool ZigClangSourceLocation_eq(ZigClangSourceLocation a, ZigClangSourceLocation b);	530	ZIG_EXTERN_C bool ZigClangSourceLocation_eq(struct ZigClangSourceLocation a, struct ZigClangSourceLocation b);
530		531
531	ZIG_EXTERN_C const ZigClangTypedefNameDecl ZigClangTypedefType_getDecl(const ZigClangTypedefType );	532	ZIG_EXTERN_C const struct ZigClangTypedefNameDecl ZigClangTypedefType_getDecl(const struct ZigClangTypedefType );
532	ZIG_EXTERN_C ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *);	533	ZIG_EXTERN_C struct ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const struct ZigClangTypedefNameDecl *);
533		534
534	ZIG_EXTERN_C ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType);	535	ZIG_EXTERN_C struct ZigClangQualType ZigClangQualType_getCanonicalType(struct ZigClangQualType);
535	ZIG_EXTERN_C const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType);	536	ZIG_EXTERN_C const struct ZigClangType *ZigClangQualType_getTypePtr(struct ZigClangQualType);
536	ZIG_EXTERN_C void ZigClangQualType_addConst(ZigClangQualType *);	537	ZIG_EXTERN_C void ZigClangQualType_addConst(struct ZigClangQualType *);
537	ZIG_EXTERN_C bool ZigClangQualType_eq(ZigClangQualType, ZigClangQualType);	538	ZIG_EXTERN_C bool ZigClangQualType_eq(struct ZigClangQualType, struct ZigClangQualType);
538	ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(ZigClangQualType);	539	ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(struct ZigClangQualType);
539	ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(ZigClangQualType);	540	ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(struct ZigClangQualType);
540	ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(ZigClangQualType);	541	ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(struct ZigClangQualType);
541		542
542	ZIG_EXTERN_C ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self);	543	ZIG_EXTERN_C enum ZigClangTypeClass ZigClangType_getTypeClass(const struct ZigClangType *self);
543	ZIG_EXTERN_C bool ZigClangType_isVoidType(const ZigClangType *self);	544	ZIG_EXTERN_C bool ZigClangType_isVoidType(const struct ZigClangType *self);
544	ZIG_EXTERN_C const char ZigClangType_getTypeClassName(const ZigClangType self);	545	ZIG_EXTERN_C const char ZigClangType_getTypeClassName(const struct ZigClangType self);
545		546
546	ZIG_EXTERN_C ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt *self);	547	ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangStmt_getBeginLoc(const struct ZigClangStmt *self);
547	ZIG_EXTERN_C ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self);	548	ZIG_EXTERN_C enum ZigClangStmtClass ZigClangStmt_getStmtClass(const struct ZigClangStmt *self);
548	ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const ZigClangStmt *self);	549	ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const struct ZigClangStmt *self);
549		550
550	ZIG_EXTERN_C ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self);	551	ZIG_EXTERN_C enum ZigClangStmtClass ZigClangExpr_getStmtClass(const struct ZigClangExpr *self);
551	ZIG_EXTERN_C ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self);	552	ZIG_EXTERN_C struct ZigClangQualType ZigClangExpr_getType(const struct ZigClangExpr *self);
552	ZIG_EXTERN_C ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self);	553	ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangExpr_getBeginLoc(const struct ZigClangExpr *self);
553		554
554	ZIG_EXTERN_C ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self);	555	ZIG_EXTERN_C enum ZigClangAPValueKind ZigClangAPValue_getKind(const struct ZigClangAPValue *self);
555	ZIG_EXTERN_C const ZigClangAPSInt ZigClangAPValue_getInt(const ZigClangAPValue self);	556	ZIG_EXTERN_C const struct ZigClangAPSInt ZigClangAPValue_getInt(const struct ZigClangAPValue self);
556	ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const ZigClangAPValue *self);	557	ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const struct ZigClangAPValue *self);
557	ZIG_EXTERN_C const ZigClangAPValue ZigClangAPValue_getArrayInitializedElt(const ZigClangAPValue self, unsigned i);	558	ZIG_EXTERN_C const struct ZigClangAPValue ZigClangAPValue_getArrayInitializedElt(const struct ZigClangAPValue self, unsigned i);
558	ZIG_EXTERN_C const ZigClangAPValue ZigClangAPValue_getArrayFiller(const ZigClangAPValue self);	559	ZIG_EXTERN_C const struct ZigClangAPValue ZigClangAPValue_getArrayFiller(const struct ZigClangAPValue self);
559	ZIG_EXTERN_C unsigned ZigClangAPValue_getArraySize(const ZigClangAPValue *self);	560	ZIG_EXTERN_C unsigned ZigClangAPValue_getArraySize(const struct ZigClangAPValue *self);
560	ZIG_EXTERN_C ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *self);	561	ZIG_EXTERN_C struct ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const struct ZigClangAPValue *self);
561		562
562	ZIG_EXTERN_C bool ZigClangAPSInt_isSigned(const ZigClangAPSInt *self);	563	ZIG_EXTERN_C bool ZigClangAPSInt_isSigned(const struct ZigClangAPSInt *self);
563	ZIG_EXTERN_C bool ZigClangAPSInt_isNegative(const ZigClangAPSInt *self);	564	ZIG_EXTERN_C bool ZigClangAPSInt_isNegative(const struct ZigClangAPSInt *self);
564	ZIG_EXTERN_C const ZigClangAPSInt ZigClangAPSInt_negate(const ZigClangAPSInt self);	565	ZIG_EXTERN_C const struct ZigClangAPSInt ZigClangAPSInt_negate(const struct ZigClangAPSInt self);
565	ZIG_EXTERN_C void ZigClangAPSInt_free(const ZigClangAPSInt *self);	566	ZIG_EXTERN_C void ZigClangAPSInt_free(const struct ZigClangAPSInt *self);
566	ZIG_EXTERN_C const uint64_t ZigClangAPSInt_getRawData(const ZigClangAPSInt self);	567	ZIG_EXTERN_C const uint64_t ZigClangAPSInt_getRawData(const struct ZigClangAPSInt self);
567	ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const ZigClangAPSInt *self);	568	ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const struct ZigClangAPSInt *self);
568		569
569	ZIG_EXTERN_C const ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(ZigClangAPValueLValueBase self);	570	ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(struct ZigClangAPValueLValueBase self);
570		571
571	#endif	572	#endif