Commit 92d9cef07116da8639ac33b7fd83ba1b35f0750c | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-04-25 08:35:28-04:00
committer	GitHub <noreply@github.com> 2019-04-25 08:35:28-04:00
log	92d9cef07116da8639ac33b7fd83ba1b35f0750c
tree	b76b7924fb16a2313721b7a294b04f75db621bcb
parent	56e07622c692f70eb10836b86c5fda02c53e2394
parent	17ffe166c286de5ff0ef4d67f60267abba5f6e12
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #2332 from ziglang/translate-c-userland

beginnings of implementing translate-c in userland

26 files changed, 2349 insertions(+), 1053 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+969

...	@@ -0,0 +1,969 @@
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 extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void;
866	pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
867	pub const ZigClangQualType = struct_ZigClangQualType;
868	pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase;
869	pub const ZigClangAPValue = struct_ZigClangAPValue;
870	pub const ZigClangAPSInt = struct_ZigClangAPSInt;
871	pub const ZigClangASTContext = struct_ZigClangASTContext;
872	pub const ZigClangASTUnit = struct_ZigClangASTUnit;
873	pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr;
874	pub const ZigClangArrayType = struct_ZigClangArrayType;
875	pub const ZigClangAttributedType = struct_ZigClangAttributedType;
876	pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator;
877	pub const ZigClangBreakStmt = struct_ZigClangBreakStmt;
878	pub const ZigClangBuiltinType = struct_ZigClangBuiltinType;
879	pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr;
880	pub const ZigClangCallExpr = struct_ZigClangCallExpr;
881	pub const ZigClangCaseStmt = struct_ZigClangCaseStmt;
882	pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator;
883	pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt;
884	pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator;
885	pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType;
886	pub const ZigClangContinueStmt = struct_ZigClangContinueStmt;
887	pub const ZigClangDecayedType = struct_ZigClangDecayedType;
888	pub const ZigClangDecl = struct_ZigClangDecl;
889	pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr;
890	pub const ZigClangDeclStmt = struct_ZigClangDeclStmt;
891	pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt;
892	pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions;
893	pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine;
894	pub const ZigClangDoStmt = struct_ZigClangDoStmt;
895	pub const ZigClangElaboratedType = struct_ZigClangElaboratedType;
896	pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl;
897	pub const ZigClangEnumDecl = struct_ZigClangEnumDecl;
898	pub const ZigClangEnumType = struct_ZigClangEnumType;
899	pub const ZigClangExpr = struct_ZigClangExpr;
900	pub const ZigClangFieldDecl = struct_ZigClangFieldDecl;
901	pub const ZigClangFileID = struct_ZigClangFileID;
902	pub const ZigClangForStmt = struct_ZigClangForStmt;
903	pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc;
904	pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl;
905	pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType;
906	pub const ZigClangIfStmt = struct_ZigClangIfStmt;
907	pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
908	pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
909	pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
910	pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
911	pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
912	pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
913	pub const ZigClangNone = struct_ZigClangNone;
914	pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations;
915	pub const ZigClangParenExpr = struct_ZigClangParenExpr;
916	pub const ZigClangParenType = struct_ZigClangParenType;
917	pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl;
918	pub const ZigClangPointerType = struct_ZigClangPointerType;
919	pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity;
920	pub const ZigClangRecordDecl = struct_ZigClangRecordDecl;
921	pub const ZigClangRecordType = struct_ZigClangRecordType;
922	pub const ZigClangReturnStmt = struct_ZigClangReturnStmt;
923	pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope;
924	pub const ZigClangSourceManager = struct_ZigClangSourceManager;
925	pub const ZigClangSourceRange = struct_ZigClangSourceRange;
926	pub const ZigClangStmt = struct_ZigClangStmt;
927	pub const ZigClangStorageClass = struct_ZigClangStorageClass;
928	pub const ZigClangStringLiteral = struct_ZigClangStringLiteral;
929	pub const ZigClangStringRef = struct_ZigClangStringRef;
930	pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt;
931	pub const ZigClangTagDecl = struct_ZigClangTagDecl;
932	pub const ZigClangType = struct_ZigClangType;
933	pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl;
934	pub const ZigClangTypedefType = struct_ZigClangTypedefType;
935	pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr;
936	pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
937	pub const ZigClangValueDecl = struct_ZigClangValueDecl;
938	pub const ZigClangVarDecl = struct_ZigClangVarDecl;
939	pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
940	pub const ZigClangBO = enum_ZigClangBO;
941	pub const ZigClangUO = enum_ZigClangUO;
942	pub const ZigClangTypeClass = enum_ZigClangTypeClass;
943	pub const ZigClangStmtClass = enum_ZigClangStmtClass;
944	pub const ZigClangCK = enum_ZigClangCK;
945	pub const ZigClangAPValueKind = enum_ZigClangAPValueKind;
946
947	pub const Stage2ErrorMsg = extern struct {
948	filename_ptr: ?[*]const u8,
949	filename_len: usize,
950	msg_ptr: [*]const u8,
951	msg_len: usize,
952	// valid until the ASTUnit is freed
953	source: ?[*]const u8,
954	// 0 based
955	line: c_uint,
956	// 0 based
957	column: c_uint,
958	// byte offset into source
959	offset: c_uint,
960	};
961	pub extern fn ZigClangErrorMsg_delete(ptr: [*c]Stage2ErrorMsg, len: usize) void;
962
963	pub extern fn ZigClangLoadFromCommandLine(
964	args_begin: []?[]const u8,
965	args_end: []?[]const u8,
966	errors_ptr: []Stage2ErrorMsg,
967	errors_len: *usize,
968	resources_path: [*c]const u8,
969	) ?*ZigClangASTUnit;

src-self-hosted/main.zig+17-1

...	@@ -858,7 +858,23 @@ fn cmdHelp(allocator: *Allocator, args: []const []const u8) !void {	...	@@ -858,7 +858,23 @@ fn cmdHelp(allocator: *Allocator, args: []const []const u8) !void {
858	try stdout.write(usage);	858	try stdout.write(usage);
859	}	859	}
860		860
861	const info_zen = @import("stage1.zig").info_zen;	861	pub const info_zen =
		862	\\
		863	\\ * Communicate intent precisely.
		864	\\ * Edge cases matter.
		865	\\ * Favor reading code over writing code.
		866	\\ * Only one obvious way to do things.
		867	\\ * Runtime crashes are better than bugs.
		868	\\ * Compile errors are better than runtime crashes.
		869	\\ * Incremental improvements.
		870	\\ * Avoid local maximums.
		871	\\ * Reduce the amount one must remember.
		872	\\ * Minimize energy spent on coding style.
		873	\\ * Together we serve end users.
		874	\\
		875	\\
		876	;
		877
862	fn cmdZen(allocator: *Allocator, args: []const []const u8) !void {	878	fn cmdZen(allocator: *Allocator, args: []const []const u8) !void {
863	try stdout.write(info_zen);	879	try stdout.write(info_zen);
864	}	880	}

src-self-hosted/stage1.zig+110-19

...	@@ -1,31 +1,122 @@	...	@@ -1,31 +1,122 @@
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 {
4	_ = @import("translate_c.zig");
5	}
6		3
7	pub const info_zen =	4	const std = @import("std");
8	\\
9	\\ * Communicate intent precisely.
10	\\ * Edge cases matter.
11	\\ * Favor reading code over writing code.
12	\\ * Only one obvious way to do things.
13	\\ * Runtime crashes are better than bugs.
14	\\ * Compile errors are better than runtime crashes.
15	\\ * Incremental improvements.
16	\\ * Avoid local maximums.
17	\\ * Reduce the amount one must remember.
18	\\ * Minimize energy spent on coding style.
19	\\ * Together we serve end users.
20	\\
21	\\
22	;
23		5
		6	// ABI warning
24	export fn stage2_zen(ptr: []const u8, len: *usize) void {	7	export fn stage2_zen(ptr: []const u8, len: *usize) void {
		8	const info_zen = @import("main.zig").info_zen;
25	ptr.* = &info_zen;	9	ptr.* = &info_zen;
26	len.* = info_zen.len;	10	len.* = info_zen.len;
27	}	11	}
28		12
		13	// ABI warning
29	export fn stage2_panic(ptr: [*]const u8, len: usize) void {	14	export fn stage2_panic(ptr: [*]const u8, len: usize) void {
30	@panic(ptr[0..len]);	15	@panic(ptr[0..len]);
31	}	16	}
		17
		18	// ABI warning
		19	const TranslateMode = extern enum {
		20	import,
		21	translate,
		22	};
		23
		24	// ABI warning
		25	const Error = extern enum {
		26	None,
		27	OutOfMemory,
		28	InvalidFormat,
		29	SemanticAnalyzeFail,
		30	AccessDenied,
		31	Interrupted,
		32	SystemResources,
		33	FileNotFound,
		34	FileSystem,
		35	FileTooBig,
		36	DivByZero,
		37	Overflow,
		38	PathAlreadyExists,
		39	Unexpected,
		40	ExactDivRemainder,
		41	NegativeDenominator,
		42	ShiftedOutOneBits,
		43	CCompileErrors,
		44	EndOfFile,
		45	IsDir,
		46	NotDir,
		47	UnsupportedOperatingSystem,
		48	SharingViolation,
		49	PipeBusy,
		50	PrimitiveTypeNotFound,
		51	CacheUnavailable,
		52	PathTooLong,
		53	CCompilerCannotFindFile,
		54	ReadingDepFile,
		55	InvalidDepFile,
		56	MissingArchitecture,
		57	MissingOperatingSystem,
		58	UnknownArchitecture,
		59	UnknownOperatingSystem,
		60	UnknownABI,
		61	InvalidFilename,
		62	DiskQuota,
		63	DiskSpace,
		64	UnexpectedWriteFailure,
		65	UnexpectedSeekFailure,
		66	UnexpectedFileTruncationFailure,
		67	Unimplemented,
		68	OperationAborted,
		69	BrokenPipe,
		70	NoSpaceLeft,
		71	};
		72
		73	const FILE = std.c.FILE;
		74	const ast = std.zig.ast;
		75	const translate_c = @import("translate_c.zig");
		76
		77	/// Args should have a null terminating last arg.
		78	export fn stage2_translate_c(
		79	out_ast: **ast.Tree,
		80	out_errors_ptr: []translate_c.ClangErrMsg,
		81	out_errors_len: *usize,
		82	args_begin: []?[]const u8,
		83	args_end: []?[]const u8,
		84	mode: TranslateMode,
		85	resources_path: [*]const u8,
		86	) Error {
		87	var errors: []translate_c.ClangErrMsg = undefined;
		88	out_ast.* = translate_c.translate(args_begin, args_end, switch (mode) {
		89	.import => translate_c.Mode.import,
		90	.translate => translate_c.Mode.translate,
		91	}, &errors, resources_path) catch \|err\| switch (err) {
		92	error.Unimplemented => return Error.Unimplemented,
		93	error.SemanticAnalyzeFail => {
		94	out_errors_ptr.* = errors.ptr;
		95	out_errors_len.* = errors.len;
		96	return Error.CCompileErrors;
		97	},
		98	error.OutOfMemory => return Error.OutOfMemory,
		99	};
		100	return Error.None;
		101	}
		102
		103	export fn stage2_free_clang_errors(errors_ptr: [*]translate_c.ClangErrMsg, errors_len: usize) void {
		104	translate_c.freeErrors(errors_ptr[0..errors_len]);
		105	}
		106
		107	export fn stage2_render_ast(tree: ast.Tree, output_file: FILE) Error {
		108	const c_out_stream = &std.io.COutStream.init(output_file).stream;
		109	_ = std.zig.render(std.heap.c_allocator, c_out_stream, tree) catch \|e\| switch (e) {
		110	error.SystemResources => return Error.SystemResources,
		111	error.OperationAborted => return Error.OperationAborted,
		112	error.BrokenPipe => return Error.BrokenPipe,
		113	error.DiskQuota => return Error.DiskQuota,
		114	error.FileTooBig => return Error.FileTooBig,
		115	error.NoSpaceLeft => return Error.NoSpaceLeft,
		116	error.AccessDenied => return Error.AccessDenied,
		117	error.OutOfMemory => return Error.OutOfMemory,
		118	error.Unexpected => return Error.Unexpected,
		119	error.InputOutput => return Error.FileSystem,
		120	};
		121	return Error.None;
		122	}

src-self-hosted/translate_c.zig+32-2

...	@@ -2,7 +2,37 @@	...	@@ -2,7 +2,37 @@
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 const ClangErrMsg = Stage2ErrorMsg;
		14
		15	pub fn translate(
		16	args_begin: []?[]const u8,
		17	args_end: []?[]const u8,
		18	mode: Mode,
		19	errors: *[]ClangErrMsg,
		20	resources_path: [*]const u8,
		21	) !*ast.Tree {
		22	const ast_unit = ZigClangLoadFromCommandLine(
		23	args_begin,
		24	args_end,
		25	&errors.ptr,
		26	&errors.len,
		27	resources_path,
		28	) orelse {
		29	if (errors.len == 0) return error.OutOfMemory;
		30	return error.SemanticAnalyzeFail;
		31	};
		32
		33	return error.Unimplemented;
		34	}
		35
		36	pub fn freeErrors(errors: []ClangErrMsg) void {
		37	ZigClangErrorMsg_delete(errors.ptr, errors.len);
8	}	38	}

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+164-107

...	@@ -8153,7 +8153,126 @@ static void detect_libc(CodeGen *g) {	...	@@ -8153,7 +8153,126 @@ static void detect_libc(CodeGen *g) {
8153	}	8153	}
8154	}	8154	}
8155		8155
8156	AstNode codegen_translate_c(CodeGen g, Buf *full_path, bool use_userland_implementation) {	8156	// does not add the "cc" arg
		8157	void add_cc_args(CodeGen g, ZigList<const char > &args, const char *out_dep_path, bool translate_c) {
		8158	if (translate_c) {
		8159	args.append("-x");
		8160	args.append("c");
		8161	}
		8162
		8163	if (out_dep_path != nullptr) {
		8164	args.append("-MD");
		8165	args.append("-MV");
		8166	args.append("-MF");
		8167	args.append(out_dep_path);
		8168	}
		8169
		8170	args.append("-nostdinc");
		8171	args.append("-fno-spell-checking");
		8172
		8173	if (translate_c) {
		8174	// this gives us access to preprocessing entities, presumably at
		8175	// the cost of performance
		8176	args.append("-Xclang");
		8177	args.append("-detailed-preprocessing-record");
		8178	} else {
		8179	switch (g->err_color) {
		8180	case ErrColorAuto:
		8181	break;
		8182	case ErrColorOff:
		8183	args.append("-fno-color-diagnostics");
		8184	args.append("-fno-caret-diagnostics");
		8185	break;
		8186	case ErrColorOn:
		8187	args.append("-fcolor-diagnostics");
		8188	args.append("-fcaret-diagnostics");
		8189	break;
		8190	}
		8191	}
		8192
		8193	args.append("-isystem");
		8194	args.append(buf_ptr(g->zig_c_headers_dir));
		8195
		8196	for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
		8197	Buf *include_dir = g->libc_include_dir_list[i];
		8198	args.append("-isystem");
		8199	args.append(buf_ptr(include_dir));
		8200	}
		8201
		8202	if (g->zig_target->is_native) {
		8203	args.append("-march=native");
		8204	} else {
		8205	args.append("-target");
		8206	args.append(buf_ptr(&g->triple_str));
		8207	}
		8208	if (g->zig_target->os == OsFreestanding) {
		8209	args.append("-ffreestanding");
		8210	}
		8211
		8212	if (!g->strip_debug_symbols) {
		8213	args.append("-g");
		8214	}
		8215
		8216	switch (g->build_mode) {
		8217	case BuildModeDebug:
		8218	// windows c runtime requires -D_DEBUG if using debug libraries
		8219	args.append("-D_DEBUG");
		8220
		8221	if (g->libc_link_lib != nullptr) {
		8222	args.append("-fstack-protector-strong");
		8223	args.append("--param");
		8224	args.append("ssp-buffer-size=4");
		8225	} else {
		8226	args.append("-fno-stack-protector");
		8227	}
		8228	args.append("-fno-omit-frame-pointer");
		8229	break;
		8230	case BuildModeSafeRelease:
		8231	// See the comment in the BuildModeFastRelease case for why we pass -O2 rather
		8232	// than -O3 here.
		8233	args.append("-O2");
		8234	if (g->libc_link_lib != nullptr) {
		8235	args.append("-D_FORTIFY_SOURCE=2");
		8236	args.append("-fstack-protector-strong");
		8237	args.append("--param");
		8238	args.append("ssp-buffer-size=4");
		8239	} else {
		8240	args.append("-fno-stack-protector");
		8241	}
		8242	args.append("-fomit-frame-pointer");
		8243	break;
		8244	case BuildModeFastRelease:
		8245	args.append("-DNDEBUG");
		8246	// Here we pass -O2 rather than -O3 because, although we do the equivalent of
		8247	// -O3 in Zig code, the justification for the difference here is that Zig
		8248	// has better detection and prevention of undefined behavior, so -O3 is safer for
		8249	// Zig code than it is for C code. Also, C programmers are used to their code
		8250	// running in -O2 and thus the -O3 path has been tested less.
		8251	args.append("-O2");
		8252	args.append("-fno-stack-protector");
		8253	args.append("-fomit-frame-pointer");
		8254	break;
		8255	case BuildModeSmallRelease:
		8256	args.append("-DNDEBUG");
		8257	args.append("-Os");
		8258	args.append("-fno-stack-protector");
		8259	args.append("-fomit-frame-pointer");
		8260	break;
		8261	}
		8262
		8263	if (target_supports_fpic(g->zig_target) && g->have_pic) {
		8264	args.append("-fPIC");
		8265	}
		8266
		8267	for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
		8268	args.append(g->clang_argv[arg_i]);
		8269	}
		8270
		8271
		8272	}
		8273
		8274	void codegen_translate_c(CodeGen g, Buf full_path, FILE *out_file, bool use_userland_implementation) {
		8275	Error err;
8157	Buf *src_basename = buf_alloc();	8276	Buf *src_basename = buf_alloc();
8158	Buf *src_dirname = buf_alloc();	8277	Buf *src_dirname = buf_alloc();
8159	os_path_split(full_path, src_dirname, src_basename);	8278	os_path_split(full_path, src_dirname, src_basename);
...	@@ -8165,19 +8284,47 @@ AstNode codegen_translate_c(CodeGen g, Buf *full_path, bool use_userland_imple	...	@@ -8165,19 +8284,47 @@ AstNode codegen_translate_c(CodeGen g, Buf *full_path, bool use_userland_imple
8165		8284
8166	init(g);	8285	init(g);
8167		8286
8168	if (use_userland_implementation) {	8287	Stage2TranslateMode trans_mode = buf_ends_with_str(full_path, ".h") ?
8169	// TODO improve this	8288	Stage2TranslateModeImport : Stage2TranslateModeTranslate;
8170	stage2_translate_c();	8289
8171	zig_panic("TODO");	8290
		8291	ZigList<const char *> clang_argv = {0};
		8292	add_cc_args(g, clang_argv, nullptr, true);
		8293
		8294	clang_argv.append(buf_ptr(full_path));
		8295
		8296	if (g->verbose_cc) {
		8297	fprintf(stderr, "clang");
		8298	for (size_t i = 0; i < clang_argv.length; i += 1) {
		8299	fprintf(stderr, " %s", clang_argv.at(i));
		8300	}
		8301	fprintf(stderr, "\n");
8172	}	8302	}
8173		8303
8174	ZigList<ErrorMsg *> errors = {0};	8304	clang_argv.append(nullptr); // to make the [start...end] argument work
		8305
		8306	const char *resources_path = buf_ptr(g->zig_c_headers_dir);
		8307	Stage2ErrorMsg *errors_ptr;
		8308	size_t errors_len;
		8309	Stage2Ast *ast;
8175	AstNode *root_node;	8310	AstNode *root_node;
8176	Error err = parse_h_file(&root_node, &errors, buf_ptr(full_path), g, nullptr);
8177		8311
8178	if (err == ErrorCCompileErrors && errors.length > 0) {	8312	if (use_userland_implementation) {
8179	for (size_t i = 0; i < errors.length; i += 1) {	8313	err = stage2_translate_c(&ast, &errors_ptr, &errors_len,
8180	ErrorMsg *err_msg = errors.at(i);	8314	&clang_argv.at(0), &clang_argv.last(), trans_mode, resources_path);
		8315	} else {
		8316	err = parse_h_file(g, &root_node, &errors_ptr, &errors_len, &clang_argv.at(0), &clang_argv.last(),
		8317	trans_mode, resources_path);
		8318	}
		8319
		8320	if (err == ErrorCCompileErrors && errors_len > 0) {
		8321	for (size_t i = 0; i < errors_len; i += 1) {
		8322	Stage2ErrorMsg *clang_err = &errors_ptr[i];
		8323	ErrorMsg *err_msg = err_msg_create_with_offset(
		8324	clang_err->filename_ptr ?
		8325	buf_create_from_mem(clang_err->filename_ptr, clang_err->filename_len) : buf_alloc(),
		8326	clang_err->line, clang_err->column, clang_err->offset, clang_err->source,
		8327	buf_create_from_mem(clang_err->msg_ptr, clang_err->msg_len));
8181	print_err_msg(err_msg, g->err_color);	8328	print_err_msg(err_msg, g->err_color);
8182	}	8329	}
8183	exit(1);	8330	exit(1);
...	@@ -8188,7 +8335,12 @@ AstNode codegen_translate_c(CodeGen g, Buf *full_path, bool use_userland_imple	...	@@ -8188,7 +8335,12 @@ AstNode codegen_translate_c(CodeGen g, Buf *full_path, bool use_userland_imple
8188	exit(1);	8335	exit(1);
8189	}	8336	}
8190		8337
8191	return root_node;	8338
		8339	if (use_userland_implementation) {
		8340	stage2_render_ast(ast, out_file);
		8341	} else {
		8342	ast_render(out_file, root_node, 4);
		8343	}
8192	}	8344	}
8193		8345
8194	static ZigType add_special_code(CodeGen g, ZigPackage package, const char basename) {	8346	static ZigType add_special_code(CodeGen g, ZigPackage package, const char basename) {
...	@@ -8507,93 +8659,7 @@ static void gen_c_object(CodeGen g, Buf self_exe_path, CFile *c_file) {	...	@@ -8507,93 +8659,7 @@ static void gen_c_object(CodeGen g, Buf self_exe_path, CFile *c_file) {
8507	args.append("cc");	8659	args.append("cc");
8508		8660
8509	Buf *out_dep_path = buf_sprintf("%s.d", buf_ptr(out_obj_path));	8661	Buf *out_dep_path = buf_sprintf("%s.d", buf_ptr(out_obj_path));
8510	args.append("-MD");	8662	add_cc_args(g, args, buf_ptr(out_dep_path), false);
8511	args.append("-MV");
8512	args.append("-MF");
8513	args.append(buf_ptr(out_dep_path));
8514
8515	args.append("-nostdinc");
8516	args.append("-fno-spell-checking");
8517
8518	switch (g->err_color) {
8519	case ErrColorAuto:
8520	break;
8521	case ErrColorOff:
8522	args.append("-fno-color-diagnostics");
8523	args.append("-fno-caret-diagnostics");
8524	break;
8525	case ErrColorOn:
8526	args.append("-fcolor-diagnostics");
8527	args.append("-fcaret-diagnostics");
8528	break;
8529	}
8530
8531	args.append("-isystem");
8532	args.append(buf_ptr(g->zig_c_headers_dir));
8533
8534	for (size_t i = 0; i < g->libc_include_dir_len; i += 1) {
8535	Buf *include_dir = g->libc_include_dir_list[i];
8536	args.append("-isystem");
8537	args.append(buf_ptr(include_dir));
8538	}
8539
8540	if (g->zig_target->is_native) {
8541	args.append("-march=native");
8542	} else {
8543	args.append("-target");
8544	args.append(buf_ptr(&g->triple_str));
8545	}
8546	if (g->zig_target->os == OsFreestanding) {
8547	args.append("-ffreestanding");
8548	}
8549
8550	if (!g->strip_debug_symbols) {
8551	args.append("-g");
8552	}
8553
8554	switch (g->build_mode) {
8555	case BuildModeDebug:
8556	if (g->libc_link_lib != nullptr) {
8557	args.append("-fstack-protector-strong");
8558	args.append("--param");
8559	args.append("ssp-buffer-size=4");
8560	} else {
8561	args.append("-fno-stack-protector");
8562	}
8563	args.append("-fno-omit-frame-pointer");
8564	break;
8565	case BuildModeSafeRelease:
8566	// See the comment in the BuildModeFastRelease case for why we pass -O2 rather
8567	// than -O3 here.
8568	args.append("-O2");
8569	if (g->libc_link_lib != nullptr) {
8570	args.append("-D_FORTIFY_SOURCE=2");
8571	args.append("-fstack-protector-strong");
8572	args.append("--param");
8573	args.append("ssp-buffer-size=4");
8574	} else {
8575	args.append("-fno-stack-protector");
8576	}
8577	args.append("-fomit-frame-pointer");
8578	break;
8579	case BuildModeFastRelease:
8580	args.append("-DNDEBUG");
8581	// Here we pass -O2 rather than -O3 because, although we do the equivalent of
8582	// -O3 in Zig code, the justification for the difference here is that Zig
8583	// has better detection and prevention of undefined behavior, so -O3 is safer for
8584	// Zig code than it is for C code. Also, C programmers are used to their code
8585	// running in -O2 and thus the -O3 path has been tested less.
8586	args.append("-O2");
8587	args.append("-fno-stack-protector");
8588	args.append("-fomit-frame-pointer");
8589	break;
8590	case BuildModeSmallRelease:
8591	args.append("-DNDEBUG");
8592	args.append("-Os");
8593	args.append("-fno-stack-protector");
8594	args.append("-fomit-frame-pointer");
8595	break;
8596	}
8597		8663
8598	args.append("-o");	8664	args.append("-o");
8599	args.append(buf_ptr(out_obj_path));	8665	args.append(buf_ptr(out_obj_path));
...	@@ -8601,19 +8667,10 @@ static void gen_c_object(CodeGen g, Buf self_exe_path, CFile *c_file) {	...	@@ -8601,19 +8667,10 @@ static void gen_c_object(CodeGen g, Buf self_exe_path, CFile *c_file) {
8601	args.append("-c");	8667	args.append("-c");
8602	args.append(buf_ptr(c_source_file));	8668	args.append(buf_ptr(c_source_file));
8603		8669
8604	if (target_supports_fpic(g->zig_target) && g->have_pic) {
8605	args.append("-fPIC");
8606	}
8607
8608	for (size_t arg_i = 0; arg_i < g->clang_argv_len; arg_i += 1) {
8609	args.append(g->clang_argv[arg_i]);
8610	}
8611
8612	for (size_t arg_i = 0; arg_i < c_file->args.length; arg_i += 1) {	8670	for (size_t arg_i = 0; arg_i < c_file->args.length; arg_i += 1) {
8613	args.append(c_file->args.at(arg_i));	8671	args.append(c_file->args.at(arg_i));
8614	}	8672	}
8615		8673
8616
8617	if (g->verbose_cc) {	8674	if (g->verbose_cc) {
8618	print_zig_cc_cmd("zig", &args);	8675	print_zig_cc_cmd("zig", &args);
8619	}	8676	}

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+34-8

 @@ -10350,7 +10350,7 @@ ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *nod
     if (codegen->verbose_ir) {
         fprintf(stderr, "\nSource: ");
-        ast_render(codegen, stderr, node, 4);
+        ast_render(stderr, node, 4);
         fprintf(stderr, "\n{ // (IR)\n");
         ir_print(codegen, stderr, ir_executable, 2);
         fprintf(stderr, "}\n");
 @@ -19092,24 +19092,50 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
             fprintf(stderr, "@cImport source: %s\n", buf_ptr(&tmp_c_file_path));
         }
-        ZigList<ErrorMsg *> errors = {0};
         Buf *tmp_dep_file = buf_sprintf("%s.d", buf_ptr(&tmp_c_file_path));
+        ZigList<const char *> clang_argv = {0};
+        add_cc_args(ira->codegen, clang_argv, buf_ptr(tmp_dep_file), true);
+        clang_argv.append(buf_ptr(&tmp_c_file_path));
+        if (ira->codegen->verbose_cc) {
+            fprintf(stderr, "clang");
+            for (size_t i = 0; i < clang_argv.length; i += 1) {
+                fprintf(stderr, " %s", clang_argv.at(i));
+            }
+            fprintf(stderr, "\n");
+        }
+        clang_argv.append(nullptr); // to make the [start...end] argument work
         AstNode *root_node;
-        if ((err = parse_h_file(&root_node, &errors, buf_ptr(&tmp_c_file_path), ira->codegen, tmp_dep_file))) {
+        Stage2ErrorMsg *errors_ptr;
+        size_t errors_len;
+        const char *resources_path = buf_ptr(ira->codegen->zig_c_headers_dir);
+        if ((err = parse_h_file(ira->codegen, &root_node, &errors_ptr, &errors_len,
+            &clang_argv.at(0), &clang_argv.last(), Stage2TranslateModeImport, resources_path)))
+        {
             if (err != ErrorCCompileErrors) {
                 ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
                 return ira->codegen->invalid_instruction;
             }
-            assert(errors.length > 0);
             ErrorMsg *parent_err_msg = ir_add_error_node(ira, node, buf_sprintf("C import failed"));
             if (ira->codegen->libc_link_lib == nullptr) {
                 add_error_note(ira->codegen, parent_err_msg, node,
                     buf_sprintf("libc headers not available; compilation does not link against libc"));
             }
-            for (size_t i = 0; i < errors.length; i += 1) {
+            for (size_t i = 0; i < errors_len; i += 1) {
-                ErrorMsg *err_msg = errors.at(i);
+                Stage2ErrorMsg *clang_err = &errors_ptr[i];
+                ErrorMsg *err_msg = err_msg_create_with_offset(
+                    clang_err->filename_ptr ?
+                        buf_create_from_mem(clang_err->filename_ptr, clang_err->filename_len) : buf_alloc(),
+                    clang_err->line, clang_err->column, clang_err->offset, clang_err->source,
+                    buf_create_from_mem(clang_err->msg_ptr, clang_err->msg_len));
                 err_msg_add_note(parent_err_msg, err_msg);
             }
 @@ -19139,7 +19165,7 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
                     buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));
             return ira->codegen->invalid_instruction;
         }
-        ast_render(ira->codegen, out_file, root_node, 4);
+        ast_render(out_file, root_node, 4);
         if (fclose(out_file) != 0) {
             ir_add_error_node(ira, node,
                     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+12-164

...	@@ -76,10 +76,9 @@ struct TransScopeWhile {	...	@@ -76,10 +76,9 @@ struct TransScopeWhile {
76	};	76	};
77		77
78	struct Context {	78	struct Context {
79	ZigList<ErrorMsg > errors;	79	AstNode *root;
80	VisibMod visib_mod;	80	VisibMod visib_mod;
81	bool want_export;	81	bool want_export;
82	AstNode *root;
83	HashMap<const void , AstNode , ptr_hash, ptr_eq> decl_table;	82	HashMap<const void , AstNode , ptr_hash, ptr_eq> decl_table;
84	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> macro_table;	83	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> macro_table;
85	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> global_table;	84	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> global_table;
...	@@ -5018,14 +5017,15 @@ static void process_preprocessor_entities(Context c, ZigClangASTUnit zunit) {	...	@@ -5018,14 +5017,15 @@ static void process_preprocessor_entities(Context c, ZigClangASTUnit zunit) {
5018	}	5017	}
5019	}	5018	}
5020		5019
5021	Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > errors, const char target_file,	5020	Error parse_h_file(CodeGen codegen, AstNode *out_root_node,
5022	CodeGen codegen, Buf tmp_dep_file)	5021	Stage2ErrorMsg *errors_ptr, size_t errors_len,
		5022	const char args_begin, const char args_end,
		5023	Stage2TranslateMode mode, const char *resources_path)
5023	{	5024	{
5024	Context context = {0};	5025	Context context = {0};
5025	Context *c = &context;	5026	Context *c = &context;
5026	c->warnings_on = codegen->verbose_cimport;	5027	c->warnings_on = codegen->verbose_cimport;
5027	c->errors = errors;	5028	if (mode == Stage2TranslateModeImport) {
5028	if (buf_ends_with_str(buf_create_from_str(target_file), ".h")) {
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,164 +5039,10 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c	...	@@ -5039,164 +5039,10 @@ 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};	5042	ZigClangASTUnit *ast_unit = ZigClangLoadFromCommandLine(args_begin, args_end, errors_ptr, errors_len,
5043		5043	resources_path);
5044	clang_argv.append("-x");	5044	if (ast_unit == nullptr) {
5045	clang_argv.append("c");	5045	if (*errors_len == 0) return ErrorNoMem;
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
5129	clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));
5130
5131	std::shared_ptr<clang::PCHContainerOperations> pch_container_ops = std::make_shared<clang::PCHContainerOperations>();
5132
5133	bool only_local_decls = true;
5134	bool capture_diagnostics = true;
5135	bool user_files_are_volatile = true;
5136	bool allow_pch_with_compiler_errors = false;
5137	bool single_file_parse = false;
5138	bool for_serialization = false;
5139	const char *resources_path = buf_ptr(codegen->zig_c_headers_dir);
5140	std::unique_ptr<clang::ASTUnit> err_unit;
5141	ZigClangASTUnit ast_unit = reinterpret_cast<ZigClangASTUnit >(clang::ASTUnit::LoadFromCommandLine(
5142	&clang_argv.at(0), &clang_argv.last(),
5143	pch_container_ops, diags, resources_path,
5144	only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,
5145	false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,
5146	single_file_parse, user_files_are_volatile, for_serialization, clang::None, &err_unit,
5147	nullptr));
5148
5149	// Early failures in LoadFromCommandLine may return with ErrUnit unset.
5150	if (!ast_unit && !err_unit) {
5151	return ErrorFileSystem;
5152	}
5153
5154	if (diags->getClient()->getNumErrors() > 0) {
5155	if (ast_unit) {
5156	err_unit = std::unique_ptr<clang::ASTUnit>(reinterpret_cast<clang::ASTUnit *>(ast_unit));
5157	}
5158
5159	for (clang::ASTUnit::stored_diag_iterator it = err_unit->stored_diag_begin(),
5160	it_end = err_unit->stored_diag_end();
5161	it != it_end; ++it)
5162	{
5163	switch (it->getLevel()) {
5164	case clang::DiagnosticsEngine::Ignored:
5165	case clang::DiagnosticsEngine::Note:
5166	case clang::DiagnosticsEngine::Remark:
5167	case clang::DiagnosticsEngine::Warning:
5168	continue;
5169	case clang::DiagnosticsEngine::Error:
5170	case clang::DiagnosticsEngine::Fatal:
5171	break;
5172	}
5173	llvm::StringRef msg_str_ref = it->getMessage();
5174	Buf *msg = string_ref_to_buf(msg_str_ref);
5175	clang::FullSourceLoc fsl = it->getLocation();
5176	if (fsl.hasManager()) {
5177	clang::FileID file_id = fsl.getFileID();
5178	clang::StringRef filename = fsl.getManager().getFilename(fsl);
5179	unsigned line = fsl.getSpellingLineNumber() - 1;
5180	unsigned column = fsl.getSpellingColumnNumber() - 1;
5181	unsigned offset = fsl.getManager().getFileOffset(fsl);
5182	const char source = (const char )fsl.getManager().getBufferData(file_id).bytes_begin();
5183	Buf *path;
5184	if (filename.empty()) {
5185	path = buf_alloc();
5186	} else {
5187	path = string_ref_to_buf(filename);
5188	}
5189
5190	ErrorMsg *err_msg = err_msg_create_with_offset(path, line, column, offset, source, msg);
5191
5192	c->errors->append(err_msg);
5193	} else {
5194	// NOTE the only known way this gets triggered right now is if you have a lot of errors
5195	// clang emits "too many errors emitted, stopping now"
5196	fprintf(stderr, "unexpected error from clang: %s\n", buf_ptr(msg));
5197	}
5198	}
5199
5200	return ErrorCCompileErrors;	5046	return ErrorCCompileErrors;
5201	}	5047	}
5202		5048
...	@@ -5214,5 +5060,7 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c	...	@@ -5214,5 +5060,7 @@ Error parse_h_file(AstNode *out_root_node, ZigList<ErrorMsg > *errors, const c
5214		5060
5215	*out_root_node = c->root;	5061	*out_root_node = c->root;
5216		5062
		5063	ZigClangASTUnit_delete(ast_unit);
		5064
5217	return ErrorNone;	5065	return ErrorNone;
5218	}	5066	}

src/translate_c.hpp+4-2

...	@@ -11,7 +11,9 @@	...	@@ -11,7 +11,9 @@
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,
15	CodeGen codegen, Buf tmp_dep_file);	15	Stage2ErrorMsg *errors_ptr, size_t errors_len,
		16	const char args_begin, const char args_end,
		17	Stage2TranslateMode mode, const char *resources_path);
16		18
17	#endif	19	#endif

src/userland.cpp+16-1

 @@ -2,15 +2,25 @@
 // 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,
+        struct Stage2ErrorMsg **out_errors_ptr, size_t *out_errors_len,
+        const char **args_begin, const char **args_end, enum Stage2TranslateMode mode,
+        const char *resources_path)
+{
     const char *msg = "stage0 called stage2_translate_c";
     stage2_panic(msg, strlen(msg));
 }
+void stage2_free_clang_errors(struct Stage2ErrorMsg *ptr, size_t len) {
+    const char *msg = "stage0 called stage2_free_clang_errors";
+    stage2_panic(msg, strlen(msg));
+}
 void stage2_zen(const char **ptr, size_t *len) {
     const char *msg = "stage0 called stage2_zen";
     stage2_panic(msg, strlen(msg));
 @@ -22,3 +32,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+97-5

...	@@ -9,17 +9,109 @@	...	@@ -9,17 +9,109 @@
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_EXTERN_C extern "C"
15	#else	16	#else
16	#define ZIG_USERLAND_EXTERN_C	17	#define ZIG_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_ATTRIBUTE_NORETURN __declspec(noreturn)
		22	#else
		23	#define ZIG_ATTRIBUTE_NORETURN __attribute__((noreturn))
		24	#endif
		25
		26	// ABI warning: the types and declarations in this file must match both those in
		27	// userland.cpp and src-self-hosted/stage1.zig.
		28
		29	// ABI warning
		30	enum Error {
		31	ErrorNone,
		32	ErrorNoMem,
		33	ErrorInvalidFormat,
		34	ErrorSemanticAnalyzeFail,
		35	ErrorAccess,
		36	ErrorInterrupted,
		37	ErrorSystemResources,
		38	ErrorFileNotFound,
		39	ErrorFileSystem,
		40	ErrorFileTooBig,
		41	ErrorDivByZero,
		42	ErrorOverflow,
		43	ErrorPathAlreadyExists,
		44	ErrorUnexpected,
		45	ErrorExactDivRemainder,
		46	ErrorNegativeDenominator,
		47	ErrorShiftedOutOneBits,
		48	ErrorCCompileErrors,
		49	ErrorEndOfFile,
		50	ErrorIsDir,
		51	ErrorNotDir,
		52	ErrorUnsupportedOperatingSystem,
		53	ErrorSharingViolation,
		54	ErrorPipeBusy,
		55	ErrorPrimitiveTypeNotFound,
		56	ErrorCacheUnavailable,
		57	ErrorPathTooLong,
		58	ErrorCCompilerCannotFindFile,
		59	ErrorReadingDepFile,
		60	ErrorInvalidDepFile,
		61	ErrorMissingArchitecture,
		62	ErrorMissingOperatingSystem,
		63	ErrorUnknownArchitecture,
		64	ErrorUnknownOperatingSystem,
		65	ErrorUnknownABI,
		66	ErrorInvalidFilename,
		67	ErrorDiskQuota,
		68	ErrorDiskSpace,
		69	ErrorUnexpectedWriteFailure,
		70	ErrorUnexpectedSeekFailure,
		71	ErrorUnexpectedFileTruncationFailure,
		72	ErrorUnimplemented,
		73	ErrorOperationAborted,
		74	ErrorBrokenPipe,
		75	ErrorNoSpaceLeft,
		76	};
		77
		78	// ABI warning
		79	enum Stage2TranslateMode {
		80	Stage2TranslateModeImport,
		81	Stage2TranslateModeTranslate,
		82	};
		83
		84	// ABI warning
		85	struct Stage2ErrorMsg {
		86	const char *filename_ptr; // can be null
		87	size_t filename_len;
		88	const char *msg_ptr;
		89	size_t msg_len;
		90	const char *source; // valid until the ASTUnit is freed. can be null
		91	unsigned line; // 0 based
		92	unsigned column; // 0 based
		93	unsigned offset; // byte offset into source
		94	};
		95
		96	// ABI warning
		97	struct Stage2Ast;
		98
		99	// ABI warning
		100	ZIG_EXTERN_C enum Error stage2_translate_c(struct Stage2Ast **out_ast,
		101	struct Stage2ErrorMsg *out_errors_ptr, size_t out_errors_len,
		102	const char args_begin, const char args_end, enum Stage2TranslateMode mode,
		103	const char *resources_path);
		104
		105	// ABI warning
		106	ZIG_EXTERN_C void stage2_free_clang_errors(struct Stage2ErrorMsg *ptr, size_t len);
		107
		108	// ABI warning
		109	ZIG_EXTERN_C void stage2_render_ast(struct Stage2Ast ast, FILE output_file);
20		110
21	ZIG_USERLAND_EXTERN_C void stage2_zen(const char *ptr, size_t len);	111	// ABI warning
		112	ZIG_EXTERN_C void stage2_zen(const char *ptr, size_t len);
22		113
23	ZIG_USERLAND_EXTERN_C void stage2_panic(const char *ptr, size_t len);	114	// ABI warning
		115	ZIG_EXTERN_C ZIG_ATTRIBUTE_NORETURN void stage2_panic(const char *ptr, size_t len);
24		116
25	#endif	117	#endif

src/zig_clang.cpp+112

...	@@ -1147,3 +1147,115 @@ ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *s	...	@@ -1147,3 +1147,115 @@ ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *s
1147	clang::APValue::LValueBase lval_base = casted->getLValueBase();	1147	clang::APValue::LValueBase lval_base = casted->getLValueBase();
1148	return bitcast(lval_base);	1148	return bitcast(lval_base);
1149	}	1149	}
		1150
		1151	ZigClangASTUnit ZigClangLoadFromCommandLine(const char args_begin, const char *args_end,
		1152	struct Stage2ErrorMsg *errors_ptr, size_t errors_len, const char *resources_path)
		1153	{
		1154	clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions));
		1155
		1156	std::shared_ptr<clang::PCHContainerOperations> pch_container_ops = std::make_shared<clang::PCHContainerOperations>();
		1157
		1158	bool only_local_decls = true;
		1159	bool capture_diagnostics = true;
		1160	bool user_files_are_volatile = true;
		1161	bool allow_pch_with_compiler_errors = false;
		1162	bool single_file_parse = false;
		1163	bool for_serialization = false;
		1164	std::unique_ptr<clang::ASTUnit> *err_unit = new std::unique_ptr<clang::ASTUnit>();
		1165	clang::ASTUnit *ast_unit = clang::ASTUnit::LoadFromCommandLine(
		1166	args_begin, args_end,
		1167	pch_container_ops, diags, resources_path,
		1168	only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete,
		1169	false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None,
		1170	single_file_parse, user_files_are_volatile, for_serialization, clang::None, err_unit,
		1171	nullptr);
		1172
		1173	// Early failures in LoadFromCommandLine may return with ErrUnit unset.
		1174	if (!ast_unit && !err_unit) {
		1175	return nullptr;
		1176	}
		1177
		1178	if (diags->getClient()->getNumErrors() > 0) {
		1179	if (ast_unit) {
		1180	*err_unit = std::unique_ptr<clang::ASTUnit>(ast_unit);
		1181	}
		1182
		1183	size_t cap = 4;
		1184	*errors_len = 0;
		1185	errors_ptr = reinterpret_cast<Stage2ErrorMsg>(malloc(cap * sizeof(Stage2ErrorMsg)));
		1186	if (*errors_ptr == nullptr) {
		1187	return nullptr;
		1188	}
		1189
		1190	for (clang::ASTUnit::stored_diag_iterator it = (*err_unit)->stored_diag_begin(),
		1191	it_end = (*err_unit)->stored_diag_end();
		1192	it != it_end; ++it)
		1193	{
		1194	switch (it->getLevel()) {
		1195	case clang::DiagnosticsEngine::Ignored:
		1196	case clang::DiagnosticsEngine::Note:
		1197	case clang::DiagnosticsEngine::Remark:
		1198	case clang::DiagnosticsEngine::Warning:
		1199	continue;
		1200	case clang::DiagnosticsEngine::Error:
		1201	case clang::DiagnosticsEngine::Fatal:
		1202	break;
		1203	}
		1204	llvm::StringRef msg_str_ref = it->getMessage();
		1205	if (*errors_len >= cap) {
		1206	cap *= 2;
		1207	Stage2ErrorMsg new_errors = reinterpret_cast<Stage2ErrorMsg >(
		1208	realloc(errors_ptr, cap sizeof(Stage2ErrorMsg)));
		1209	if (new_errors == nullptr) {
		1210	free(*errors_ptr);
		1211	*errors_ptr = nullptr;
		1212	*errors_len = 0;
		1213	return nullptr;
		1214	}
		1215	*errors_ptr = new_errors;
		1216	}
		1217	Stage2ErrorMsg msg = errors_ptr + *errors_len;
		1218	*errors_len += 1;
		1219	msg->msg_ptr = (const char *)msg_str_ref.bytes_begin();
		1220	msg->msg_len = msg_str_ref.size();
		1221
		1222	clang::FullSourceLoc fsl = it->getLocation();
		1223	if (fsl.hasManager()) {
		1224	clang::FileID file_id = fsl.getFileID();
		1225	clang::StringRef filename = fsl.getManager().getFilename(fsl);
		1226	if (filename.empty()) {
		1227	msg->filename_ptr = nullptr;
		1228	} else {
		1229	msg->filename_ptr = (const char *)filename.bytes_begin();
		1230	msg->filename_len = filename.size();
		1231	}
		1232	msg->source = (const char *)fsl.getManager().getBufferData(file_id).bytes_begin();
		1233	msg->line = fsl.getSpellingLineNumber() - 1;
		1234	msg->column = fsl.getSpellingColumnNumber() - 1;
		1235	msg->offset = fsl.getManager().getFileOffset(fsl);
		1236	} else {
		1237	// The only known way this gets triggered right now is if you have a lot of errors
		1238	// clang emits "too many errors emitted, stopping now"
		1239	msg->filename_ptr = nullptr;
		1240	msg->source = nullptr;
		1241	}
		1242	}
		1243
		1244	if (*errors_len == 0) {
		1245	free(*errors_ptr);
		1246	*errors_ptr = nullptr;
		1247	}
		1248
		1249	return nullptr;
		1250	}
		1251
		1252	return reinterpret_cast<ZigClangASTUnit *>(ast_unit);
		1253	}
		1254
		1255	void ZigClangErrorMsg_delete(Stage2ErrorMsg *ptr, size_t len) {
		1256	free(ptr);
		1257	}
		1258
		1259	void ZigClangASTUnit_delete(struct ZigClangASTUnit *self) {
		1260	delete reinterpret_cast<clang::ASTUnit *>(self);
		1261	}

src/zig_clang.h+92-89

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

std/c.zig+6

...	@@ -12,6 +12,12 @@ pub use switch (builtin.os) {	...	@@ -12,6 +12,12 @@ pub use switch (builtin.os) {
12		12
13	// TODO https://github.com/ziglang/zig/issues/265 on this whole file	13	// TODO https://github.com/ziglang/zig/issues/265 on this whole file
14		14
		15	pub const FILE = @OpaqueType();
		16	pub extern "c" fn fopen(filename: []const u8, modes: []const u8) ?*FILE;
		17	pub extern "c" fn fclose(stream: *FILE) c_int;
		18	pub extern "c" fn fwrite(ptr: []const u8, size_of_type: usize, item_count: usize, stream: FILE) usize;
		19	pub extern "c" fn fread(ptr: []u8, size_of_type: usize, item_count: usize, stream: FILE) usize;
		20
15	pub extern "c" fn abort() noreturn;	21	pub extern "c" fn abort() noreturn;
16	pub extern "c" fn exit(code: c_int) noreturn;	22	pub extern "c" fn exit(code: c_int) noreturn;
17	pub extern "c" fn isatty(fd: c_int) c_int;	23	pub extern "c" fn isatty(fd: c_int) c_int;

std/io.zig+20-13

 @@ -36,6 +36,7 @@ pub fn getStdIn() GetStdIoErrs!File {
 }
 pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;
+pub const COutStream = @import("io/c_out_stream.zig").COutStream;
 pub fn InStream(comptime ReadError: type) type {
     return struct {
 @@ -1089,8 +1090,11 @@ test "io.readLineSliceFrom" {
 }
 pub const Packing = enum {
-    Byte,   /// Pack data to byte alignment
+    /// Pack data to byte alignment
-    Bit,    /// Pack data to bit alignment
+    Byte,
+    /// Pack data to bit alignment
+    Bit,
 };
 /// Creates a deserializer that deserializes types from any stream.
 @@ -1111,10 +1115,12 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
         pub const Stream = InStream(Error);
         pub fn init(in_stream: *Stream) Self {
-            return Self{ .in_stream = switch (packing) {
+            return Self{
-                .Bit => BitInStream(endian, Stream.Error).init(in_stream),
+                .in_stream = switch (packing) {
-                .Byte => in_stream,
+                    .Bit => BitInStream(endian, Stream.Error).init(in_stream),
-            } };
+                    .Byte => in_stream,
+                },
+            };
         }
         pub fn alignToByte(self: *Self) void {
 @@ -1281,7 +1287,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
                         ptr.* = null;
                         return;
                     }
                     ptr.* = OC(undefined); //make it non-null so the following .? is guaranteed safe
                     const val_ptr = &ptr.*.?;
                     try self.deserializeInto(val_ptr);
 @@ -1320,10 +1326,12 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
         pub const Stream = OutStream(Error);
         pub fn init(out_stream: *Stream) Self {
-            return Self{ .out_stream = switch (packing) {
+            return Self{
-                .Bit => BitOutStream(endian, Stream.Error).init(out_stream),
+                .out_stream = switch (packing) {
-                .Byte => out_stream,
+                    .Bit => BitOutStream(endian, Stream.Error).init(out_stream),
-            } };
+                    .Byte => out_stream,
+                },
+            };
         }
         /// Flushes any unwritten bits to the stream
 @@ -1447,7 +1455,6 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
 test "import io tests" {
     comptime {
-        _ = @import("io_test.zig");
+        _ = @import("io/test.zig");
     }
 }

std/io/c_out_stream.zig created+48

...	@@ -0,0 +1,48 @@
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	// TODO errno on windows. should we have a posix layer for windows?
28	if (builtin.os == .windows) {
29	return error.InputOutput;
30	}
31	const errno = std.c._errno().*;
32	switch (errno) {
33	0 => unreachable,
34	posix.EINVAL => unreachable,
35	posix.EFAULT => unreachable,
36	posix.EAGAIN => unreachable, // this is a blocking API
37	posix.EBADF => unreachable, // always a race condition
38	posix.EDESTADDRREQ => unreachable, // connect was never called
39	posix.EDQUOT => return error.DiskQuota,
40	posix.EFBIG => return error.FileTooBig,
41	posix.EIO => return error.InputOutput,
42	posix.ENOSPC => return error.NoSpaceLeft,
43	posix.EPERM => return error.AccessDenied,
44	posix.EPIPE => return error.BrokenPipe,
45	else => return std.os.unexpectedErrorPosix(@intCast(usize, errno)),
46	}
47	}
48	};

std/io/test.zig created+602

...	@@ -0,0 +1,602 @@
1	const std = @import("../std.zig");
2	const io = std.io;
3	const meta = std.meta;
4	const trait = std.trait;
5	const DefaultPrng = std.rand.DefaultPrng;
6	const expect = std.testing.expect;
7	const expectError = std.testing.expectError;
8	const mem = std.mem;
9	const os = std.os;
10	const builtin = @import("builtin");
11
12	test "write a file, read it, then delete it" {
13	var raw_bytes: [200 * 1024]u8 = undefined;
14	var allocator = &std.heap.FixedBufferAllocator.init(raw_bytes[0..]).allocator;
15
16	var data: [1024]u8 = undefined;
17	var prng = DefaultPrng.init(1234);
18	prng.random.bytes(data[0..]);
19	const tmp_file_name = "temp_test_file.txt";
20	{
21	var file = try os.File.openWrite(tmp_file_name);
22	defer file.close();
23
24	var file_out_stream = file.outStream();
25	var buf_stream = io.BufferedOutStream(os.File.WriteError).init(&file_out_stream.stream);
26	const st = &buf_stream.stream;
27	try st.print("begin");
28	try st.write(data[0..]);
29	try st.print("end");
30	try buf_stream.flush();
31	}
32
33	{
34	// make sure openWriteNoClobber doesn't harm the file
35	if (os.File.openWriteNoClobber(tmp_file_name, os.File.default_mode)) \|file\| {
36	unreachable;
37	} else \|err\| {
38	std.debug.assert(err == os.File.OpenError.PathAlreadyExists);
39	}
40	}
41
42	{
43	var file = try os.File.openRead(tmp_file_name);
44	defer file.close();
45
46	const file_size = try file.getEndPos();
47	const expected_file_size = "begin".len + data.len + "end".len;
48	expect(file_size == expected_file_size);
49
50	var file_in_stream = file.inStream();
51	var buf_stream = io.BufferedInStream(os.File.ReadError).init(&file_in_stream.stream);
52	const st = &buf_stream.stream;
53	const contents = try st.readAllAlloc(allocator, 2 * 1024);
54	defer allocator.free(contents);
55
56	expect(mem.eql(u8, contents[0.."begin".len], "begin"));
57	expect(mem.eql(u8, contents["begin".len .. contents.len - "end".len], data));
58	expect(mem.eql(u8, contents[contents.len - "end".len ..], "end"));
59	}
60	try os.deleteFile(tmp_file_name);
61	}
62
63	test "BufferOutStream" {
64	var bytes: [100]u8 = undefined;
65	var allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
66
67	var buffer = try std.Buffer.initSize(allocator, 0);
68	var buf_stream = &std.io.BufferOutStream.init(&buffer).stream;
69
70	const x: i32 = 42;
71	const y: i32 = 1234;
72	try buf_stream.print("x: {}\ny: {}\n", x, y);
73
74	expect(mem.eql(u8, buffer.toSlice(), "x: 42\ny: 1234\n"));
75	}
76
77	test "SliceInStream" {
78	const bytes = []const u8{ 1, 2, 3, 4, 5, 6, 7 };
79	var ss = io.SliceInStream.init(bytes);
80
81	var dest: [4]u8 = undefined;
82
83	var read = try ss.stream.read(dest[0..4]);
84	expect(read == 4);
85	expect(mem.eql(u8, dest[0..4], bytes[0..4]));
86
87	read = try ss.stream.read(dest[0..4]);
88	expect(read == 3);
89	expect(mem.eql(u8, dest[0..3], bytes[4..7]));
90
91	read = try ss.stream.read(dest[0..4]);
92	expect(read == 0);
93	}
94
95	test "PeekStream" {
96	const bytes = []const u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
97	var ss = io.SliceInStream.init(bytes);
98	var ps = io.PeekStream(2, io.SliceInStream.Error).init(&ss.stream);
99
100	var dest: [4]u8 = undefined;
101
102	ps.putBackByte(9);
103	ps.putBackByte(10);
104
105	var read = try ps.stream.read(dest[0..4]);
106	expect(read == 4);
107	expect(dest[0] == 10);
108	expect(dest[1] == 9);
109	expect(mem.eql(u8, dest[2..4], bytes[0..2]));
110
111	read = try ps.stream.read(dest[0..4]);
112	expect(read == 4);
113	expect(mem.eql(u8, dest[0..4], bytes[2..6]));
114
115	read = try ps.stream.read(dest[0..4]);
116	expect(read == 2);
117	expect(mem.eql(u8, dest[0..2], bytes[6..8]));
118
119	ps.putBackByte(11);
120	ps.putBackByte(12);
121
122	read = try ps.stream.read(dest[0..4]);
123	expect(read == 2);
124	expect(dest[0] == 12);
125	expect(dest[1] == 11);
126	}
127
128	test "SliceOutStream" {
129	var buffer: [10]u8 = undefined;
130	var ss = io.SliceOutStream.init(buffer[0..]);
131
132	try ss.stream.write("Hello");
133	expect(mem.eql(u8, ss.getWritten(), "Hello"));
134
135	try ss.stream.write("world");
136	expect(mem.eql(u8, ss.getWritten(), "Helloworld"));
137
138	expectError(error.OutOfSpace, ss.stream.write("!"));
139	expect(mem.eql(u8, ss.getWritten(), "Helloworld"));
140
141	ss.reset();
142	expect(ss.getWritten().len == 0);
143
144	expectError(error.OutOfSpace, ss.stream.write("Hello world!"));
145	expect(mem.eql(u8, ss.getWritten(), "Hello worl"));
146	}
147
148	test "BitInStream" {
149	const mem_be = []u8{ 0b11001101, 0b00001011 };
150	const mem_le = []u8{ 0b00011101, 0b10010101 };
151
152	var mem_in_be = io.SliceInStream.init(mem_be[0..]);
153	const InError = io.SliceInStream.Error;
154	var bit_stream_be = io.BitInStream(builtin.Endian.Big, InError).init(&mem_in_be.stream);
155
156	var out_bits: usize = undefined;
157
158	expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits));
159	expect(out_bits == 1);
160	expect(2 == try bit_stream_be.readBits(u5, 2, &out_bits));
161	expect(out_bits == 2);
162	expect(3 == try bit_stream_be.readBits(u128, 3, &out_bits));
163	expect(out_bits == 3);
164	expect(4 == try bit_stream_be.readBits(u8, 4, &out_bits));
165	expect(out_bits == 4);
166	expect(5 == try bit_stream_be.readBits(u9, 5, &out_bits));
167	expect(out_bits == 5);
168	expect(1 == try bit_stream_be.readBits(u1, 1, &out_bits));
169	expect(out_bits == 1);
170
171	mem_in_be.pos = 0;
172	bit_stream_be.bit_count = 0;
173	expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits));
174	expect(out_bits == 15);
175
176	mem_in_be.pos = 0;
177	bit_stream_be.bit_count = 0;
178	expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits));
179	expect(out_bits == 16);
180
181	_ = try bit_stream_be.readBits(u0, 0, &out_bits);
182
183	expect(0 == try bit_stream_be.readBits(u1, 1, &out_bits));
184	expect(out_bits == 0);
185	expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1));
186
187	var mem_in_le = io.SliceInStream.init(mem_le[0..]);
188	var bit_stream_le = io.BitInStream(builtin.Endian.Little, InError).init(&mem_in_le.stream);
189
190	expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits));
191	expect(out_bits == 1);
192	expect(2 == try bit_stream_le.readBits(u5, 2, &out_bits));
193	expect(out_bits == 2);
194	expect(3 == try bit_stream_le.readBits(u128, 3, &out_bits));
195	expect(out_bits == 3);
196	expect(4 == try bit_stream_le.readBits(u8, 4, &out_bits));
197	expect(out_bits == 4);
198	expect(5 == try bit_stream_le.readBits(u9, 5, &out_bits));
199	expect(out_bits == 5);
200	expect(1 == try bit_stream_le.readBits(u1, 1, &out_bits));
201	expect(out_bits == 1);
202
203	mem_in_le.pos = 0;
204	bit_stream_le.bit_count = 0;
205	expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits));
206	expect(out_bits == 15);
207
208	mem_in_le.pos = 0;
209	bit_stream_le.bit_count = 0;
210	expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits));
211	expect(out_bits == 16);
212
213	_ = try bit_stream_le.readBits(u0, 0, &out_bits);
214
215	expect(0 == try bit_stream_le.readBits(u1, 1, &out_bits));
216	expect(out_bits == 0);
217	expectError(error.EndOfStream, bit_stream_le.readBitsNoEof(u1, 1));
218	}
219
220	test "BitOutStream" {
221	var mem_be = []u8{0} ** 2;
222	var mem_le = []u8{0} ** 2;
223
224	var mem_out_be = io.SliceOutStream.init(mem_be[0..]);
225	const OutError = io.SliceOutStream.Error;
226	var bit_stream_be = io.BitOutStream(builtin.Endian.Big, OutError).init(&mem_out_be.stream);
227
228	try bit_stream_be.writeBits(u2(1), 1);
229	try bit_stream_be.writeBits(u5(2), 2);
230	try bit_stream_be.writeBits(u128(3), 3);
231	try bit_stream_be.writeBits(u8(4), 4);
232	try bit_stream_be.writeBits(u9(5), 5);
233	try bit_stream_be.writeBits(u1(1), 1);
234
235	expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001011);
236
237	mem_out_be.pos = 0;
238
239	try bit_stream_be.writeBits(u15(0b110011010000101), 15);
240	try bit_stream_be.flushBits();
241	expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001010);
242
243	mem_out_be.pos = 0;
244	try bit_stream_be.writeBits(u32(0b110011010000101), 16);
245	expect(mem_be[0] == 0b01100110 and mem_be[1] == 0b10000101);
246
247	try bit_stream_be.writeBits(u0(0), 0);
248
249	var mem_out_le = io.SliceOutStream.init(mem_le[0..]);
250	var bit_stream_le = io.BitOutStream(builtin.Endian.Little, OutError).init(&mem_out_le.stream);
251
252	try bit_stream_le.writeBits(u2(1), 1);
253	try bit_stream_le.writeBits(u5(2), 2);
254	try bit_stream_le.writeBits(u128(3), 3);
255	try bit_stream_le.writeBits(u8(4), 4);
256	try bit_stream_le.writeBits(u9(5), 5);
257	try bit_stream_le.writeBits(u1(1), 1);
258
259	expect(mem_le[0] == 0b00011101 and mem_le[1] == 0b10010101);
260
261	mem_out_le.pos = 0;
262	try bit_stream_le.writeBits(u15(0b110011010000101), 15);
263	try bit_stream_le.flushBits();
264	expect(mem_le[0] == 0b10000101 and mem_le[1] == 0b01100110);
265
266	mem_out_le.pos = 0;
267	try bit_stream_le.writeBits(u32(0b1100110100001011), 16);
268	expect(mem_le[0] == 0b00001011 and mem_le[1] == 0b11001101);
269
270	try bit_stream_le.writeBits(u0(0), 0);
271	}
272
273	test "BitStreams with File Stream" {
274	const tmp_file_name = "temp_test_file.txt";
275	{
276	var file = try os.File.openWrite(tmp_file_name);
277	defer file.close();
278
279	var file_out = file.outStream();
280	var file_out_stream = &file_out.stream;
281	const OutError = os.File.WriteError;
282	var bit_stream = io.BitOutStream(builtin.endian, OutError).init(file_out_stream);
283
284	try bit_stream.writeBits(u2(1), 1);
285	try bit_stream.writeBits(u5(2), 2);
286	try bit_stream.writeBits(u128(3), 3);
287	try bit_stream.writeBits(u8(4), 4);
288	try bit_stream.writeBits(u9(5), 5);
289	try bit_stream.writeBits(u1(1), 1);
290	try bit_stream.flushBits();
291	}
292	{
293	var file = try os.File.openRead(tmp_file_name);
294	defer file.close();
295
296	var file_in = file.inStream();
297	var file_in_stream = &file_in.stream;
298	const InError = os.File.ReadError;
299	var bit_stream = io.BitInStream(builtin.endian, InError).init(file_in_stream);
300
301	var out_bits: usize = undefined;
302
303	expect(1 == try bit_stream.readBits(u2, 1, &out_bits));
304	expect(out_bits == 1);
305	expect(2 == try bit_stream.readBits(u5, 2, &out_bits));
306	expect(out_bits == 2);
307	expect(3 == try bit_stream.readBits(u128, 3, &out_bits));
308	expect(out_bits == 3);
309	expect(4 == try bit_stream.readBits(u8, 4, &out_bits));
310	expect(out_bits == 4);
311	expect(5 == try bit_stream.readBits(u9, 5, &out_bits));
312	expect(out_bits == 5);
313	expect(1 == try bit_stream.readBits(u1, 1, &out_bits));
314	expect(out_bits == 1);
315
316	expectError(error.EndOfStream, bit_stream.readBitsNoEof(u1, 1));
317	}
318	try os.deleteFile(tmp_file_name);
319	}
320
321	fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
322	//@NOTE: if this test is taking too long, reduce the maximum tested bitsize
323	const max_test_bitsize = 128;
324
325	const total_bytes = comptime blk: {
326	var bytes = 0;
327	comptime var i = 0;
328	while (i <= max_test_bitsize) : (i += 1) bytes += (i / 8) + @boolToInt(i % 8 > 0);
329	break :blk bytes * 2;
330	};
331
332	var data_mem: [total_bytes]u8 = undefined;
333	var out = io.SliceOutStream.init(data_mem[0..]);
334	const OutError = io.SliceOutStream.Error;
335	var out_stream = &out.stream;
336	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
337
338	var in = io.SliceInStream.init(data_mem[0..]);
339	const InError = io.SliceInStream.Error;
340	var in_stream = &in.stream;
341	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
342
343	comptime var i = 0;
344	inline while (i <= max_test_bitsize) : (i += 1) {
345	const U = @IntType(false, i);
346	const S = @IntType(true, i);
347	try serializer.serializeInt(U(i));
348	if (i != 0) try serializer.serializeInt(S(-1)) else try serializer.serialize(S(0));
349	}
350	try serializer.flush();
351
352	i = 0;
353	inline while (i <= max_test_bitsize) : (i += 1) {
354	const U = @IntType(false, i);
355	const S = @IntType(true, i);
356	const x = try deserializer.deserializeInt(U);
357	const y = try deserializer.deserializeInt(S);
358	expect(x == U(i));
359	if (i != 0) expect(y == S(-1)) else expect(y == 0);
360	}
361
362	const u8_bit_count = comptime meta.bitCount(u8);
363	//0 + 1 + 2 + ... n = (n * (n + 1)) / 2
364	//and we have each for unsigned and signed, so * 2
365	const total_bits = (max_test_bitsize * (max_test_bitsize + 1));
366	const extra_packed_byte = @boolToInt(total_bits % u8_bit_count > 0);
367	const total_packed_bytes = (total_bits / u8_bit_count) + extra_packed_byte;
368
369	expect(in.pos == if (packing == .Bit) total_packed_bytes else total_bytes);
370
371	//Verify that empty error set works with serializer.
372	//deserializer is covered by SliceInStream
373	const NullError = io.NullOutStream.Error;
374	var null_out = io.NullOutStream.init();
375	var null_out_stream = &null_out.stream;
376	var null_serializer = io.Serializer(endian, packing, NullError).init(null_out_stream);
377	try null_serializer.serialize(data_mem[0..]);
378	try null_serializer.flush();
379	}
380
381	test "Serializer/Deserializer Int" {
382	try testIntSerializerDeserializer(.Big, .Byte);
383	try testIntSerializerDeserializer(.Little, .Byte);
384	// TODO these tests are disabled due to tripping an LLVM assertion
385	// https://github.com/ziglang/zig/issues/2019
386	//try testIntSerializerDeserializer(builtin.Endian.Big, true);
387	//try testIntSerializerDeserializer(builtin.Endian.Little, true);
388	}
389
390	fn testIntSerializerDeserializerInfNaN(
391	comptime endian: builtin.Endian,
392	comptime packing: io.Packing,
393	) !void {
394	const mem_size = (16 * 2 + 32 * 2 + 64 * 2 + 128 * 2) / comptime meta.bitCount(u8);
395	var data_mem: [mem_size]u8 = undefined;
396
397	var out = io.SliceOutStream.init(data_mem[0..]);
398	const OutError = io.SliceOutStream.Error;
399	var out_stream = &out.stream;
400	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
401
402	var in = io.SliceInStream.init(data_mem[0..]);
403	const InError = io.SliceInStream.Error;
404	var in_stream = &in.stream;
405	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
406
407	//@TODO: isInf/isNan not currently implemented for f128.
408	try serializer.serialize(std.math.nan(f16));
409	try serializer.serialize(std.math.inf(f16));
410	try serializer.serialize(std.math.nan(f32));
411	try serializer.serialize(std.math.inf(f32));
412	try serializer.serialize(std.math.nan(f64));
413	try serializer.serialize(std.math.inf(f64));
414	//try serializer.serialize(std.math.nan(f128));
415	//try serializer.serialize(std.math.inf(f128));
416	const nan_check_f16 = try deserializer.deserialize(f16);
417	const inf_check_f16 = try deserializer.deserialize(f16);
418	const nan_check_f32 = try deserializer.deserialize(f32);
419	const inf_check_f32 = try deserializer.deserialize(f32);
420	const nan_check_f64 = try deserializer.deserialize(f64);
421	const inf_check_f64 = try deserializer.deserialize(f64);
422	//const nan_check_f128 = try deserializer.deserialize(f128);
423	//const inf_check_f128 = try deserializer.deserialize(f128);
424	expect(std.math.isNan(nan_check_f16));
425	expect(std.math.isInf(inf_check_f16));
426	expect(std.math.isNan(nan_check_f32));
427	expect(std.math.isInf(inf_check_f32));
428	expect(std.math.isNan(nan_check_f64));
429	expect(std.math.isInf(inf_check_f64));
430	//expect(std.math.isNan(nan_check_f128));
431	//expect(std.math.isInf(inf_check_f128));
432	}
433
434	test "Serializer/Deserializer Int: Inf/NaN" {
435	try testIntSerializerDeserializerInfNaN(.Big, .Byte);
436	try testIntSerializerDeserializerInfNaN(.Little, .Byte);
437	try testIntSerializerDeserializerInfNaN(.Big, .Bit);
438	try testIntSerializerDeserializerInfNaN(.Little, .Bit);
439	}
440
441	fn testAlternateSerializer(self: var, serializer: var) !void {
442	try serializer.serialize(self.f_f16);
443	}
444
445	fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
446	const ColorType = enum(u4) {
447	RGB8 = 1,
448	RA16 = 2,
449	R32 = 3,
450	};
451
452	const TagAlign = union(enum(u32)) {
453	A: u8,
454	B: u8,
455	C: u8,
456	};
457
458	const Color = union(ColorType) {
459	RGB8: struct {
460	r: u8,
461	g: u8,
462	b: u8,
463	a: u8,
464	},
465	RA16: struct {
466	r: u16,
467	a: u16,
468	},
469	R32: u32,
470	};
471
472	const PackedStruct = packed struct {
473	f_i3: i3,
474	f_u2: u2,
475	};
476
477	//to test custom serialization
478	const Custom = struct {
479	f_f16: f16,
480	f_unused_u32: u32,
481
482	pub fn deserialize(self: *@This(), deserializer: var) !void {
483	try deserializer.deserializeInto(&self.f_f16);
484	self.f_unused_u32 = 47;
485	}
486
487	pub const serialize = testAlternateSerializer;
488	};
489
490	const MyStruct = struct {
491	f_i3: i3,
492	f_u8: u8,
493	f_tag_align: TagAlign,
494	f_u24: u24,
495	f_i19: i19,
496	f_void: void,
497	f_f32: f32,
498	f_f128: f128,
499	f_packed_0: PackedStruct,
500	f_i7arr: [10]i7,
501	f_of64n: ?f64,
502	f_of64v: ?f64,
503	f_color_type: ColorType,
504	f_packed_1: PackedStruct,
505	f_custom: Custom,
506	f_color: Color,
507	};
508
509	const my_inst = MyStruct{
510	.f_i3 = -1,
511	.f_u8 = 8,
512	.f_tag_align = TagAlign{ .B = 148 },
513	.f_u24 = 24,
514	.f_i19 = 19,
515	.f_void = {},
516	.f_f32 = 32.32,
517	.f_f128 = 128.128,
518	.f_packed_0 = PackedStruct{ .f_i3 = -1, .f_u2 = 2 },
519	.f_i7arr = [10]i7{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
520	.f_of64n = null,
521	.f_of64v = 64.64,
522	.f_color_type = ColorType.R32,
523	.f_packed_1 = PackedStruct{ .f_i3 = 1, .f_u2 = 1 },
524	.f_custom = Custom{ .f_f16 = 38.63, .f_unused_u32 = 47 },
525	.f_color = Color{ .R32 = 123822 },
526	};
527
528	var data_mem: [@sizeOf(MyStruct)]u8 = undefined;
529	var out = io.SliceOutStream.init(data_mem[0..]);
530	const OutError = io.SliceOutStream.Error;
531	var out_stream = &out.stream;
532	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
533
534	var in = io.SliceInStream.init(data_mem[0..]);
535	const InError = io.SliceInStream.Error;
536	var in_stream = &in.stream;
537	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
538
539	try serializer.serialize(my_inst);
540
541	const my_copy = try deserializer.deserialize(MyStruct);
542	expect(meta.eql(my_copy, my_inst));
543	}
544
545	test "Serializer/Deserializer generic" {
546	try testSerializerDeserializer(builtin.Endian.Big, .Byte);
547	try testSerializerDeserializer(builtin.Endian.Little, .Byte);
548	try testSerializerDeserializer(builtin.Endian.Big, .Bit);
549	try testSerializerDeserializer(builtin.Endian.Little, .Bit);
550	}
551
552	fn testBadData(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
553	const E = enum(u14) {
554	One = 1,
555	Two = 2,
556	};
557
558	const A = struct {
559	e: E,
560	};
561
562	const C = union(E) {
563	One: u14,
564	Two: f16,
565	};
566
567	var data_mem: [4]u8 = undefined;
568	var out = io.SliceOutStream.init(data_mem[0..]);
569	const OutError = io.SliceOutStream.Error;
570	var out_stream = &out.stream;
571	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
572
573	var in = io.SliceInStream.init(data_mem[0..]);
574	const InError = io.SliceInStream.Error;
575	var in_stream = &in.stream;
576	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
577
578	try serializer.serialize(u14(3));
579	expectError(error.InvalidEnumTag, deserializer.deserialize(A));
580	out.pos = 0;
581	try serializer.serialize(u14(3));
582	try serializer.serialize(u14(88));
583	expectError(error.InvalidEnumTag, deserializer.deserialize(C));
584	}
585
586	test "Deserializer bad data" {
587	try testBadData(.Big, .Byte);
588	try testBadData(.Little, .Byte);
589	try testBadData(.Big, .Bit);
590	try testBadData(.Little, .Bit);
591	}
592
593	test "c out stream" {
594	if (!builtin.link_libc) return error.SkipZigTest;
595
596	const filename = c"tmp_io_test_file.txt";
597	const out_file = std.c.fopen(filename, c"w") orelse return error.UnableToOpenTestFile;
598	defer std.os.deleteFileC(filename) catch {};
599
600	const out_stream = &io.COutStream.init(out_file).stream;
601	try out_stream.print("hi: {}\n", i32(123));
602	}

std/io_test.zig deleted-591

...	@@ -1,591 +0,0 @@
1	const std = @import("std.zig");
2	const io = std.io;
3	const meta = std.meta;
4	const trait = std.trait;
5	const DefaultPrng = std.rand.DefaultPrng;
6	const expect = std.testing.expect;
7	const expectError = std.testing.expectError;
8	const mem = std.mem;
9	const os = std.os;
10	const builtin = @import("builtin");
11
12	test "write a file, read it, then delete it" {
13	var raw_bytes: [200 * 1024]u8 = undefined;
14	var allocator = &std.heap.FixedBufferAllocator.init(raw_bytes[0..]).allocator;
15
16	var data: [1024]u8 = undefined;
17	var prng = DefaultPrng.init(1234);
18	prng.random.bytes(data[0..]);
19	const tmp_file_name = "temp_test_file.txt";
20	{
21	var file = try os.File.openWrite(tmp_file_name);
22	defer file.close();
23
24	var file_out_stream = file.outStream();
25	var buf_stream = io.BufferedOutStream(os.File.WriteError).init(&file_out_stream.stream);
26	const st = &buf_stream.stream;
27	try st.print("begin");
28	try st.write(data[0..]);
29	try st.print("end");
30	try buf_stream.flush();
31	}
32
33	{
34	// make sure openWriteNoClobber doesn't harm the file
35	if (os.File.openWriteNoClobber(tmp_file_name, os.File.default_mode)) \|file\| {
36	unreachable;
37	} else \|err\| {
38	std.debug.assert(err == os.File.OpenError.PathAlreadyExists);
39	}
40	}
41
42	{
43	var file = try os.File.openRead(tmp_file_name);
44	defer file.close();
45
46	const file_size = try file.getEndPos();
47	const expected_file_size = "begin".len + data.len + "end".len;
48	expect(file_size == expected_file_size);
49
50	var file_in_stream = file.inStream();
51	var buf_stream = io.BufferedInStream(os.File.ReadError).init(&file_in_stream.stream);
52	const st = &buf_stream.stream;
53	const contents = try st.readAllAlloc(allocator, 2 * 1024);
54	defer allocator.free(contents);
55
56	expect(mem.eql(u8, contents[0.."begin".len], "begin"));
57	expect(mem.eql(u8, contents["begin".len .. contents.len - "end".len], data));
58	expect(mem.eql(u8, contents[contents.len - "end".len ..], "end"));
59	}
60	try os.deleteFile(tmp_file_name);
61	}
62
63	test "BufferOutStream" {
64	var bytes: [100]u8 = undefined;
65	var allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
66
67	var buffer = try std.Buffer.initSize(allocator, 0);
68	var buf_stream = &std.io.BufferOutStream.init(&buffer).stream;
69
70	const x: i32 = 42;
71	const y: i32 = 1234;
72	try buf_stream.print("x: {}\ny: {}\n", x, y);
73
74	expect(mem.eql(u8, buffer.toSlice(), "x: 42\ny: 1234\n"));
75	}
76
77	test "SliceInStream" {
78	const bytes = []const u8{ 1, 2, 3, 4, 5, 6, 7 };
79	var ss = io.SliceInStream.init(bytes);
80
81	var dest: [4]u8 = undefined;
82
83	var read = try ss.stream.read(dest[0..4]);
84	expect(read == 4);
85	expect(mem.eql(u8, dest[0..4], bytes[0..4]));
86
87	read = try ss.stream.read(dest[0..4]);
88	expect(read == 3);
89	expect(mem.eql(u8, dest[0..3], bytes[4..7]));
90
91	read = try ss.stream.read(dest[0..4]);
92	expect(read == 0);
93	}
94
95	test "PeekStream" {
96	const bytes = []const u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
97	var ss = io.SliceInStream.init(bytes);
98	var ps = io.PeekStream(2, io.SliceInStream.Error).init(&ss.stream);
99
100	var dest: [4]u8 = undefined;
101
102	ps.putBackByte(9);
103	ps.putBackByte(10);
104
105	var read = try ps.stream.read(dest[0..4]);
106	expect(read == 4);
107	expect(dest[0] == 10);
108	expect(dest[1] == 9);
109	expect(mem.eql(u8, dest[2..4], bytes[0..2]));
110
111	read = try ps.stream.read(dest[0..4]);
112	expect(read == 4);
113	expect(mem.eql(u8, dest[0..4], bytes[2..6]));
114
115	read = try ps.stream.read(dest[0..4]);
116	expect(read == 2);
117	expect(mem.eql(u8, dest[0..2], bytes[6..8]));
118
119	ps.putBackByte(11);
120	ps.putBackByte(12);
121
122	read = try ps.stream.read(dest[0..4]);
123	expect(read == 2);
124	expect(dest[0] == 12);
125	expect(dest[1] == 11);
126	}
127
128	test "SliceOutStream" {
129	var buffer: [10]u8 = undefined;
130	var ss = io.SliceOutStream.init(buffer[0..]);
131
132	try ss.stream.write("Hello");
133	expect(mem.eql(u8, ss.getWritten(), "Hello"));
134
135	try ss.stream.write("world");
136	expect(mem.eql(u8, ss.getWritten(), "Helloworld"));
137
138	expectError(error.OutOfSpace, ss.stream.write("!"));
139	expect(mem.eql(u8, ss.getWritten(), "Helloworld"));
140
141	ss.reset();
142	expect(ss.getWritten().len == 0);
143
144	expectError(error.OutOfSpace, ss.stream.write("Hello world!"));
145	expect(mem.eql(u8, ss.getWritten(), "Hello worl"));
146	}
147
148	test "BitInStream" {
149	const mem_be = []u8{ 0b11001101, 0b00001011 };
150	const mem_le = []u8{ 0b00011101, 0b10010101 };
151
152	var mem_in_be = io.SliceInStream.init(mem_be[0..]);
153	const InError = io.SliceInStream.Error;
154	var bit_stream_be = io.BitInStream(builtin.Endian.Big, InError).init(&mem_in_be.stream);
155
156	var out_bits: usize = undefined;
157
158	expect(1 == try bit_stream_be.readBits(u2, 1, &out_bits));
159	expect(out_bits == 1);
160	expect(2 == try bit_stream_be.readBits(u5, 2, &out_bits));
161	expect(out_bits == 2);
162	expect(3 == try bit_stream_be.readBits(u128, 3, &out_bits));
163	expect(out_bits == 3);
164	expect(4 == try bit_stream_be.readBits(u8, 4, &out_bits));
165	expect(out_bits == 4);
166	expect(5 == try bit_stream_be.readBits(u9, 5, &out_bits));
167	expect(out_bits == 5);
168	expect(1 == try bit_stream_be.readBits(u1, 1, &out_bits));
169	expect(out_bits == 1);
170
171	mem_in_be.pos = 0;
172	bit_stream_be.bit_count = 0;
173	expect(0b110011010000101 == try bit_stream_be.readBits(u15, 15, &out_bits));
174	expect(out_bits == 15);
175
176	mem_in_be.pos = 0;
177	bit_stream_be.bit_count = 0;
178	expect(0b1100110100001011 == try bit_stream_be.readBits(u16, 16, &out_bits));
179	expect(out_bits == 16);
180
181	_ = try bit_stream_be.readBits(u0, 0, &out_bits);
182
183	expect(0 == try bit_stream_be.readBits(u1, 1, &out_bits));
184	expect(out_bits == 0);
185	expectError(error.EndOfStream, bit_stream_be.readBitsNoEof(u1, 1));
186
187	var mem_in_le = io.SliceInStream.init(mem_le[0..]);
188	var bit_stream_le = io.BitInStream(builtin.Endian.Little, InError).init(&mem_in_le.stream);
189
190	expect(1 == try bit_stream_le.readBits(u2, 1, &out_bits));
191	expect(out_bits == 1);
192	expect(2 == try bit_stream_le.readBits(u5, 2, &out_bits));
193	expect(out_bits == 2);
194	expect(3 == try bit_stream_le.readBits(u128, 3, &out_bits));
195	expect(out_bits == 3);
196	expect(4 == try bit_stream_le.readBits(u8, 4, &out_bits));
197	expect(out_bits == 4);
198	expect(5 == try bit_stream_le.readBits(u9, 5, &out_bits));
199	expect(out_bits == 5);
200	expect(1 == try bit_stream_le.readBits(u1, 1, &out_bits));
201	expect(out_bits == 1);
202
203	mem_in_le.pos = 0;
204	bit_stream_le.bit_count = 0;
205	expect(0b001010100011101 == try bit_stream_le.readBits(u15, 15, &out_bits));
206	expect(out_bits == 15);
207
208	mem_in_le.pos = 0;
209	bit_stream_le.bit_count = 0;
210	expect(0b1001010100011101 == try bit_stream_le.readBits(u16, 16, &out_bits));
211	expect(out_bits == 16);
212
213	_ = try bit_stream_le.readBits(u0, 0, &out_bits);
214
215	expect(0 == try bit_stream_le.readBits(u1, 1, &out_bits));
216	expect(out_bits == 0);
217	expectError(error.EndOfStream, bit_stream_le.readBitsNoEof(u1, 1));
218	}
219
220	test "BitOutStream" {
221	var mem_be = []u8{0} ** 2;
222	var mem_le = []u8{0} ** 2;
223
224	var mem_out_be = io.SliceOutStream.init(mem_be[0..]);
225	const OutError = io.SliceOutStream.Error;
226	var bit_stream_be = io.BitOutStream(builtin.Endian.Big, OutError).init(&mem_out_be.stream);
227
228	try bit_stream_be.writeBits(u2(1), 1);
229	try bit_stream_be.writeBits(u5(2), 2);
230	try bit_stream_be.writeBits(u128(3), 3);
231	try bit_stream_be.writeBits(u8(4), 4);
232	try bit_stream_be.writeBits(u9(5), 5);
233	try bit_stream_be.writeBits(u1(1), 1);
234
235	expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001011);
236
237	mem_out_be.pos = 0;
238
239	try bit_stream_be.writeBits(u15(0b110011010000101), 15);
240	try bit_stream_be.flushBits();
241	expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001010);
242
243	mem_out_be.pos = 0;
244	try bit_stream_be.writeBits(u32(0b110011010000101), 16);
245	expect(mem_be[0] == 0b01100110 and mem_be[1] == 0b10000101);
246
247	try bit_stream_be.writeBits(u0(0), 0);
248
249	var mem_out_le = io.SliceOutStream.init(mem_le[0..]);
250	var bit_stream_le = io.BitOutStream(builtin.Endian.Little, OutError).init(&mem_out_le.stream);
251
252	try bit_stream_le.writeBits(u2(1), 1);
253	try bit_stream_le.writeBits(u5(2), 2);
254	try bit_stream_le.writeBits(u128(3), 3);
255	try bit_stream_le.writeBits(u8(4), 4);
256	try bit_stream_le.writeBits(u9(5), 5);
257	try bit_stream_le.writeBits(u1(1), 1);
258
259	expect(mem_le[0] == 0b00011101 and mem_le[1] == 0b10010101);
260
261	mem_out_le.pos = 0;
262	try bit_stream_le.writeBits(u15(0b110011010000101), 15);
263	try bit_stream_le.flushBits();
264	expect(mem_le[0] == 0b10000101 and mem_le[1] == 0b01100110);
265
266	mem_out_le.pos = 0;
267	try bit_stream_le.writeBits(u32(0b1100110100001011), 16);
268	expect(mem_le[0] == 0b00001011 and mem_le[1] == 0b11001101);
269
270	try bit_stream_le.writeBits(u0(0), 0);
271	}
272
273	test "BitStreams with File Stream" {
274	const tmp_file_name = "temp_test_file.txt";
275	{
276	var file = try os.File.openWrite(tmp_file_name);
277	defer file.close();
278
279	var file_out = file.outStream();
280	var file_out_stream = &file_out.stream;
281	const OutError = os.File.WriteError;
282	var bit_stream = io.BitOutStream(builtin.endian, OutError).init(file_out_stream);
283
284	try bit_stream.writeBits(u2(1), 1);
285	try bit_stream.writeBits(u5(2), 2);
286	try bit_stream.writeBits(u128(3), 3);
287	try bit_stream.writeBits(u8(4), 4);
288	try bit_stream.writeBits(u9(5), 5);
289	try bit_stream.writeBits(u1(1), 1);
290	try bit_stream.flushBits();
291	}
292	{
293	var file = try os.File.openRead(tmp_file_name);
294	defer file.close();
295
296	var file_in = file.inStream();
297	var file_in_stream = &file_in.stream;
298	const InError = os.File.ReadError;
299	var bit_stream = io.BitInStream(builtin.endian, InError).init(file_in_stream);
300
301	var out_bits: usize = undefined;
302
303	expect(1 == try bit_stream.readBits(u2, 1, &out_bits));
304	expect(out_bits == 1);
305	expect(2 == try bit_stream.readBits(u5, 2, &out_bits));
306	expect(out_bits == 2);
307	expect(3 == try bit_stream.readBits(u128, 3, &out_bits));
308	expect(out_bits == 3);
309	expect(4 == try bit_stream.readBits(u8, 4, &out_bits));
310	expect(out_bits == 4);
311	expect(5 == try bit_stream.readBits(u9, 5, &out_bits));
312	expect(out_bits == 5);
313	expect(1 == try bit_stream.readBits(u1, 1, &out_bits));
314	expect(out_bits == 1);
315
316	expectError(error.EndOfStream, bit_stream.readBitsNoEof(u1, 1));
317	}
318	try os.deleteFile(tmp_file_name);
319	}
320
321	fn testIntSerializerDeserializer(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
322	//@NOTE: if this test is taking too long, reduce the maximum tested bitsize
323	const max_test_bitsize = 128;
324
325	const total_bytes = comptime blk: {
326	var bytes = 0;
327	comptime var i = 0;
328	while (i <= max_test_bitsize) : (i += 1) bytes += (i / 8) + @boolToInt(i % 8 > 0);
329	break :blk bytes * 2;
330	};
331
332	var data_mem: [total_bytes]u8 = undefined;
333	var out = io.SliceOutStream.init(data_mem[0..]);
334	const OutError = io.SliceOutStream.Error;
335	var out_stream = &out.stream;
336	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
337
338	var in = io.SliceInStream.init(data_mem[0..]);
339	const InError = io.SliceInStream.Error;
340	var in_stream = &in.stream;
341	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
342
343	comptime var i = 0;
344	inline while (i <= max_test_bitsize) : (i += 1) {
345	const U = @IntType(false, i);
346	const S = @IntType(true, i);
347	try serializer.serializeInt(U(i));
348	if (i != 0) try serializer.serializeInt(S(-1)) else try serializer.serialize(S(0));
349	}
350	try serializer.flush();
351
352	i = 0;
353	inline while (i <= max_test_bitsize) : (i += 1) {
354	const U = @IntType(false, i);
355	const S = @IntType(true, i);
356	const x = try deserializer.deserializeInt(U);
357	const y = try deserializer.deserializeInt(S);
358	expect(x == U(i));
359	if (i != 0) expect(y == S(-1)) else expect(y == 0);
360	}
361
362	const u8_bit_count = comptime meta.bitCount(u8);
363	//0 + 1 + 2 + ... n = (n * (n + 1)) / 2
364	//and we have each for unsigned and signed, so * 2
365	const total_bits = (max_test_bitsize * (max_test_bitsize + 1));
366	const extra_packed_byte = @boolToInt(total_bits % u8_bit_count > 0);
367	const total_packed_bytes = (total_bits / u8_bit_count) + extra_packed_byte;
368
369	expect(in.pos == if (packing == .Bit) total_packed_bytes else total_bytes);
370
371	//Verify that empty error set works with serializer.
372	//deserializer is covered by SliceInStream
373	const NullError = io.NullOutStream.Error;
374	var null_out = io.NullOutStream.init();
375	var null_out_stream = &null_out.stream;
376	var null_serializer = io.Serializer(endian, packing, NullError).init(null_out_stream);
377	try null_serializer.serialize(data_mem[0..]);
378	try null_serializer.flush();
379	}
380
381	test "Serializer/Deserializer Int" {
382	try testIntSerializerDeserializer(.Big, .Byte);
383	try testIntSerializerDeserializer(.Little, .Byte);
384	// TODO these tests are disabled due to tripping an LLVM assertion
385	// https://github.com/ziglang/zig/issues/2019
386	//try testIntSerializerDeserializer(builtin.Endian.Big, true);
387	//try testIntSerializerDeserializer(builtin.Endian.Little, true);
388	}
389
390	fn testIntSerializerDeserializerInfNaN(
391	comptime endian: builtin.Endian,
392	comptime packing: io.Packing,
393	) !void {
394	const mem_size = (16 * 2 + 32 * 2 + 64 * 2 + 128 * 2) / comptime meta.bitCount(u8);
395	var data_mem: [mem_size]u8 = undefined;
396
397	var out = io.SliceOutStream.init(data_mem[0..]);
398	const OutError = io.SliceOutStream.Error;
399	var out_stream = &out.stream;
400	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
401
402	var in = io.SliceInStream.init(data_mem[0..]);
403	const InError = io.SliceInStream.Error;
404	var in_stream = &in.stream;
405	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
406
407	//@TODO: isInf/isNan not currently implemented for f128.
408	try serializer.serialize(std.math.nan(f16));
409	try serializer.serialize(std.math.inf(f16));
410	try serializer.serialize(std.math.nan(f32));
411	try serializer.serialize(std.math.inf(f32));
412	try serializer.serialize(std.math.nan(f64));
413	try serializer.serialize(std.math.inf(f64));
414	//try serializer.serialize(std.math.nan(f128));
415	//try serializer.serialize(std.math.inf(f128));
416	const nan_check_f16 = try deserializer.deserialize(f16);
417	const inf_check_f16 = try deserializer.deserialize(f16);
418	const nan_check_f32 = try deserializer.deserialize(f32);
419	const inf_check_f32 = try deserializer.deserialize(f32);
420	const nan_check_f64 = try deserializer.deserialize(f64);
421	const inf_check_f64 = try deserializer.deserialize(f64);
422	//const nan_check_f128 = try deserializer.deserialize(f128);
423	//const inf_check_f128 = try deserializer.deserialize(f128);
424	expect(std.math.isNan(nan_check_f16));
425	expect(std.math.isInf(inf_check_f16));
426	expect(std.math.isNan(nan_check_f32));
427	expect(std.math.isInf(inf_check_f32));
428	expect(std.math.isNan(nan_check_f64));
429	expect(std.math.isInf(inf_check_f64));
430	//expect(std.math.isNan(nan_check_f128));
431	//expect(std.math.isInf(inf_check_f128));
432	}
433
434	test "Serializer/Deserializer Int: Inf/NaN" {
435	try testIntSerializerDeserializerInfNaN(.Big, .Byte);
436	try testIntSerializerDeserializerInfNaN(.Little, .Byte);
437	try testIntSerializerDeserializerInfNaN(.Big, .Bit);
438	try testIntSerializerDeserializerInfNaN(.Little, .Bit);
439	}
440
441	fn testAlternateSerializer(self: var, serializer: var) !void {
442	try serializer.serialize(self.f_f16);
443	}
444
445	fn testSerializerDeserializer(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
446	const ColorType = enum(u4) {
447	RGB8 = 1,
448	RA16 = 2,
449	R32 = 3,
450	};
451
452	const TagAlign = union(enum(u32)) {
453	A: u8,
454	B: u8,
455	C: u8,
456	};
457
458	const Color = union(ColorType) {
459	RGB8: struct {
460	r: u8,
461	g: u8,
462	b: u8,
463	a: u8,
464	},
465	RA16: struct {
466	r: u16,
467	a: u16,
468	},
469	R32: u32,
470	};
471
472	const PackedStruct = packed struct {
473	f_i3: i3,
474	f_u2: u2,
475	};
476
477	//to test custom serialization
478	const Custom = struct {
479	f_f16: f16,
480	f_unused_u32: u32,
481
482	pub fn deserialize(self: *@This(), deserializer: var) !void {
483	try deserializer.deserializeInto(&self.f_f16);
484	self.f_unused_u32 = 47;
485	}
486
487	pub const serialize = testAlternateSerializer;
488	};
489
490	const MyStruct = struct {
491	f_i3: i3,
492	f_u8: u8,
493	f_tag_align: TagAlign,
494	f_u24: u24,
495	f_i19: i19,
496	f_void: void,
497	f_f32: f32,
498	f_f128: f128,
499	f_packed_0: PackedStruct,
500	f_i7arr: [10]i7,
501	f_of64n: ?f64,
502	f_of64v: ?f64,
503	f_color_type: ColorType,
504	f_packed_1: PackedStruct,
505	f_custom: Custom,
506	f_color: Color,
507	};
508
509	const my_inst = MyStruct{
510	.f_i3 = -1,
511	.f_u8 = 8,
512	.f_tag_align = TagAlign{ .B = 148 },
513	.f_u24 = 24,
514	.f_i19 = 19,
515	.f_void = {},
516	.f_f32 = 32.32,
517	.f_f128 = 128.128,
518	.f_packed_0 = PackedStruct{ .f_i3 = -1, .f_u2 = 2 },
519	.f_i7arr = [10]i7{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
520	.f_of64n = null,
521	.f_of64v = 64.64,
522	.f_color_type = ColorType.R32,
523	.f_packed_1 = PackedStruct{ .f_i3 = 1, .f_u2 = 1 },
524	.f_custom = Custom{ .f_f16 = 38.63, .f_unused_u32 = 47 },
525	.f_color = Color{ .R32 = 123822 },
526	};
527
528	var data_mem: [@sizeOf(MyStruct)]u8 = undefined;
529	var out = io.SliceOutStream.init(data_mem[0..]);
530	const OutError = io.SliceOutStream.Error;
531	var out_stream = &out.stream;
532	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
533
534	var in = io.SliceInStream.init(data_mem[0..]);
535	const InError = io.SliceInStream.Error;
536	var in_stream = &in.stream;
537	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
538
539	try serializer.serialize(my_inst);
540
541	const my_copy = try deserializer.deserialize(MyStruct);
542	expect(meta.eql(my_copy, my_inst));
543	}
544
545	test "Serializer/Deserializer generic" {
546	try testSerializerDeserializer(builtin.Endian.Big, .Byte);
547	try testSerializerDeserializer(builtin.Endian.Little, .Byte);
548	try testSerializerDeserializer(builtin.Endian.Big, .Bit);
549	try testSerializerDeserializer(builtin.Endian.Little, .Bit);
550	}
551
552	fn testBadData(comptime endian: builtin.Endian, comptime packing: io.Packing) !void {
553	const E = enum(u14) {
554	One = 1,
555	Two = 2,
556	};
557
558	const A = struct {
559	e: E,
560	};
561
562	const C = union(E) {
563	One: u14,
564	Two: f16,
565	};
566
567	var data_mem: [4]u8 = undefined;
568	var out = io.SliceOutStream.init(data_mem[0..]);
569	const OutError = io.SliceOutStream.Error;
570	var out_stream = &out.stream;
571	var serializer = io.Serializer(endian, packing, OutError).init(out_stream);
572
573	var in = io.SliceInStream.init(data_mem[0..]);
574	const InError = io.SliceInStream.Error;
575	var in_stream = &in.stream;
576	var deserializer = io.Deserializer(endian, packing, InError).init(in_stream);
577
578	try serializer.serialize(u14(3));
579	expectError(error.InvalidEnumTag, deserializer.deserialize(A));
580	out.pos = 0;
581	try serializer.serialize(u14(3));
582	try serializer.serialize(u14(88));
583	expectError(error.InvalidEnumTag, deserializer.deserialize(C));
584	}
585
586	test "Deserializer bad data" {
587	try testBadData(.Big, .Byte);
588	try testBadData(.Little, .Byte);
589	try testBadData(.Big, .Bit);
590	try testBadData(.Little, .Bit);
591	}