1// -Wall
2#pragma version(1)
3#pragma rs java_package_name(export)
4
5// trivial accumulator for use multiple times later
6static void AccumInt(int *accum, int val) { }
7
8// NOTE: union and bitfield errors are only emitted once per type, so
9//       we have multiple types here to ensure that we issue errors
10//       in multiple contexts.
11
12// NOTE: accumulator data type is restricted in certain ways regardless
13//       of result type; we do not test that here.  This is covered
14//       in the test case reduce_general_bad_accumulator.rs.
15
16/////////////////////////////////////////////////////////////////////////
17
18typedef unsigned int UIntA916[9][16];
19
20// result type cannot be multidimensional array
21#pragma rs reduce(redUInt2dA) accumulator(AccumUInt2dA) combiner(CombUInt2dA)
22static void AccumUInt2dA(UIntA916 *accum, int val) { }
23static void CombUInt2dA(UIntA916 *accum, const UIntA916 *val) { }
24
25// problem is result type, not accumulator type, so outconverter can fix this
26#pragma rs reduce(redUInt2dAOutFix) accumulator(AccumUInt2dA) combiner(CombUInt2dA) \
27  outconverter(OutUInt2dAFix)
28static void OutUInt2dAFix(uint *out, const UIntA916 *val) { }
29
30// problem is result type, not accumulator type, so outconverter can break this
31#pragma rs reduce(redUInt2dAOutBreak) accumulator(AccumInt) outconverter(OutUInt2dABreak)
32static void OutUInt2dABreak(UIntA916 *out, const int *val) { }
33
34/////////////////////////////////////////////////////////////////////////
35
36union UnionShortDouble {
37  short s;
38  double d;
39};
40
41union UnionCharInt {
42  char c;
43  int i;
44};
45
46union UnionLongFloat {
47  long l;
48  float f;
49};
50
51// result type cannot be union
52#pragma rs reduce(redUnionShortDouble) accumulator(AccumUnionShortDouble) \
53  combiner(CombineUnionShortDouble)
54static void AccumUnionShortDouble(union UnionShortDouble *accum, short s, double d) { }
55static void CombineUnionShortDouble(union UnionShortDouble *accum,
56                                    const union UnionShortDouble *other) { }
57
58// problem is result type, not accumulator type, so outconverter can fix this
59#pragma rs reduce(redUnionCharIntOutFix) accumulator(AccumUnionCharInt) \
60  combiner(CombineUnionCharInt) outconverter(OutUnionCharIntFix)
61static void AccumUnionCharInt(union UnionCharInt *accum, short s, double d) { }
62static void CombineUnionCharInt(union UnionCharInt *accum, const union UnionCharInt *other) { }
63static void OutUnionCharIntFix(int *out, const union UnionCharInt *val) { }
64
65// problem is result type, not accumulator type, so outconverter can break this
66#pragma rs reduce(redUnionLongFloatOutBreak) accumulator(AccumInt) \
67  outconverter(OutUnionLongFloatBreak)
68static void OutUnionLongFloatBreak(union UnionLongFloat *out, const int *val) { }
69
70/////////////////////////////////////////////////////////////////////////
71
72union UnionIntFloat {
73  short s;
74  double d;
75};
76typedef union UnionIntFloat UnionIntFloatArray[10];
77
78union UnionDoubleFloat {
79  double d;
80  float f;
81};
82typedef union UnionDoubleFloat UnionDoubleFloatArray[10];
83
84union UnionCharLong {
85  char c;
86  long l;
87};
88typedef union UnionCharLong UnionCharLongArray[10];
89
90// cannot export array of union
91#pragma rs reduce(redUnionIntFloatArray) accumulator(AccumUnionIntFloatArray) \
92  combiner(CombineUnionIntFloatArray)
93static void AccumUnionIntFloatArray(UnionIntFloatArray *accum, int val) { }
94static void CombineUnionIntFloatArray(UnionIntFloatArray *accum,
95                                      const UnionIntFloatArray *other) { }
96
97// problem is result type, not accumulator type, so outconverter can fix this
98#pragma rs reduce(redUnionDoubleFloatArrayOutFix) accumulator(AccumUnionDoubleFloatArray) \
99  combiner(CombineUnionDoubleFloatArray) outconverter(OutUnionDoubleFloatArrayFix)
100static void AccumUnionDoubleFloatArray(UnionDoubleFloatArray *accum, short s, double d) { }
101static void CombineUnionDoubleFloatArray(UnionDoubleFloatArray *accum,
102                                           const UnionDoubleFloatArray *other) { }
103static void OutUnionDoubleFloatArrayFix(int *out, const UnionDoubleFloatArray *val) { }
104
105// problem is result type, not accumulator type, so outconverter can break this
106#pragma rs reduce(redUnionCharLongArrayOutBreak) accumulator(AccumInt) \
107  outconverter(OutUnionCharLongArrayBreak)
108static void OutUnionCharLongArrayBreak(UnionCharLongArray *out, const int *val) { }
109
110/////////////////////////////////////////////////////////////////////////
111
112struct Bits1 {
113  int b:1;
114};
115
116struct Bits11 {
117  int c:1;
118  int d:1;
119};
120
121struct Bits111 {
122  int e:1;
123  int f:1;
124  int g:1;
125};
126
127// cannot export struct with bitfield
128#pragma rs reduce(redBits) accumulator(AccumBits) combiner(CombineBits)
129static void AccumBits(struct Bits1 *accum, int val) { }
130static void CombineBits(struct Bits1 *accum, const struct Bits1 *other) { }
131
132// problem is result type, not accumulator type, so outconverter can fix this
133#pragma rs reduce(redBitsOutFix) accumulator(AccumBitsOutFix) combiner(CombineBitsOutFix) \
134  outconverter(OutBitsFix)
135static void AccumBitsOutFix(struct Bits11 *accum, int val) { }
136static void CombineBitsOutFix(struct Bits11 *accum, const struct Bits11 *other) { }
137static void OutBitsFix(int *out, const struct Bits11 *val) { }
138
139// problem is result type, not accumulator type, so outconverter can break this
140#pragma rs reduce(redBitsOutBreak) accumulator(AccumInt) outconverter(OutBitsBreak)
141static void OutBitsBreak(struct Bits111 *out, const int *val) { }
142
143/////////////////////////////////////////////////////////////////////////
144
145struct Bits2 {
146  int b:2;
147};
148typedef struct Bits2 Bits2Array[10];
149
150struct Bits22 {
151  int c:2;
152  int d:2;
153};
154typedef struct Bits22 Bits22Array[10];
155
156struct Bits222 {
157  int e:2;
158  int f:2;
159  int g:2;
160};
161typedef struct Bits222 Bits222Array[10];
162
163// cannot export array of struct with bitfield
164#pragma rs reduce(redBitsArray) accumulator(AccumBitsArray) combiner(CombineBitsArray)
165static void AccumBitsArray(Bits2Array *accum, int val) { }
166static void CombineBitsArray(Bits2Array *accum, const Bits2Array *other) { }
167
168// problem is result type, not accumulator type, so outconverter can fix this
169#pragma rs reduce(redBitsArrayOutFix) accumulator(AccumBitsArrayOutFix) \
170  combiner(CombineBitsArrayOutFix) outconverter(OutBitsArrayFix)
171static void AccumBitsArrayOutFix(Bits22Array *accum, int val) { }
172static void CombineBitsArrayOutFix(Bits22Array *accum, const Bits22Array *other) { }
173static void OutBitsArrayFix(int *out, const Bits22Array *val) { }
174
175// problem is result type, not accumulator type, so outconverter can break this
176#pragma rs reduce(redBitsArrayOutBreak) accumulator(AccumInt) outconverter(OutBitsArrayBreak)
177static void OutBitsArrayBreak(Bits222Array *out, const int *val) { }
178
179/////////////////////////////////////////////////////////////////////////
180
181// result type cannot be matrix
182#pragma rs reduce(redMat) accumulator(AccumMat)
183static void AccumMat(rs_matrix2x2 *accum, rs_matrix2x2 val) { }
184
185// problem is result type, not accumulator type, so outconverter can fix this
186#pragma rs reduce(redMatOutFix) accumulator(AccumMat) outconverter(OutMatFix)
187static void OutMatFix(int *out, const rs_matrix2x2 *val) { }
188
189// problem is result type, not accumulator type, so outconverter can break this
190#pragma rs reduce(redMatOutBreak) accumulator(AccumInt) outconverter(OutMatBreak)
191static void OutMatBreak(rs_matrix2x2 *out, const int *val) { }
192
193/////////////////////////////////////////////////////////////////////////
194
195typedef rs_matrix2x2 ArrayMatrix2x2[10];
196
197// result type cannot be array of matrix
198#pragma rs reduce(redMatArray) accumulator(AccumMatArray) combiner(CombineMatArray)
199static void AccumMatArray(ArrayMatrix2x2 *accum, rs_matrix2x2 val) { }
200static void CombineMatArray(ArrayMatrix2x2 *accum, const ArrayMatrix2x2 *other) { }
201
202// problem is result type, not accumulator type, so outconverter can fix this
203#pragma rs reduce(redMatArrayOutFix) accumulator(AccumMatArray) combiner(CombineMatArray) \
204  outconverter(OutMatArrayFix)
205static void OutMatArrayFix(int *out, const ArrayMatrix2x2 *val) { }
206
207// problem is result type, not accumulator type, so outconverter can break this
208#pragma rs reduce(redMatArrayOutBreak) accumulator(AccumInt) outconverter(OutMatArrayBreak)
209static void OutMatArrayBreak(ArrayMatrix2x2 *out, const int *val) { }
210
211/////////////////////////////////////////////////////////////////////////
212
213// result type cannot be object type
214#pragma rs reduce(redAlloc) accumulator(AccumInt) outconverter(OutAlloc)
215static void OutAlloc(rs_allocation *out, const int *val) { }
216
217/////////////////////////////////////////////////////////////////////////
218
219typedef rs_allocation AllocArray[10];
220
221// result type cannot be array of object type
222#pragma rs reduce(redAllocArray) accumulator(AccumAllocArray) outconverter(OutAllocArray)
223static void AccumAllocArray(int *accum, int val) { }
224static void OutAllocArray(AllocArray *out, const int *val) { }
225
226/////////////////////////////////////////////////////////////////////////
227
228struct StructObj1 {
229  int f;
230  rs_element e;
231};
232
233// result type cannot be struct containing object type
234#pragma rs reduce(redStructObj) accumulator(AccumStructObj) outconverter(OutStructObj)
235static void AccumStructObj(int *accum, int val) { }
236static void OutStructObj(struct StructObj1 *out, const int *val) { }
237
238/////////////////////////////////////////////////////////////////////////
239
240struct StructObj2 {
241  rs_type t;
242  float f;
243};
244typedef struct StructObj2 StructObj2Array[10];
245
246// result type cannot be array of struct containing object type
247#pragma rs reduce(redStructObjArray) accumulator(AccumStructObjArray) \
248  outconverter(OutStructObjArray)
249static void AccumStructObjArray(int *accum, int val) { }
250static void OutStructObjArray(StructObj2Array *out, const int *val) { }
251
252/////////////////////////////////////////////////////////////////////////
253
254typedef char *Ptr;
255
256// result type cannot be pointer
257#pragma rs reduce(redPtr) accumulator(AccumPtr) combiner(CombPtr)
258static void AccumPtr(Ptr *accum, char val) { }
259static void CombPtr(Ptr *accum, const Ptr *other) { }
260
261// problem is result type, not accumulator type, so outconverter can fix this
262#pragma rs reduce(redPtrOutFix) accumulator(AccumPtr) combiner(CombPtr) \
263  outconverter(OutPtrFix)
264static void OutPtrFix(int *out, const Ptr *val) { }
265
266// problem is result type, not accumulator type, so outconverter can break this
267#pragma rs reduce(redPtrOutBreak) accumulator(AccumInt) outconverter(OutPtrBreak)
268static void OutPtrBreak(Ptr *out, const int *val) { }
269
270/////////////////////////////////////////////////////////////////////////
271
272typedef Ptr PtrArray7[7];
273
274// cannot export array of pointer
275#pragma rs reduce(redPtrArray7) accumulator(AccumPtrArray7) combiner(CombPtrArray7)
276static void AccumPtrArray7(PtrArray7 *accum, int val) { }
277static void CombPtrArray7(PtrArray7 *accum, const PtrArray7 *other) { }
278
279// problem is result type, not accumulator type, so outconverter can fix this
280#pragma rs reduce(redPtrArray7OutFix) accumulator(AccumPtrArray7) combiner(CombPtrArray7) \
281  outconverter(OutPtrArray7Fix)
282static void OutPtrArray7Fix(int *out, const PtrArray7 *val) { }
283
284// problem is result type, not accumulator type, so outconverter can break this
285#pragma rs reduce(redPtrArray7OutBreak) accumulator(AccumInt) outconverter(OutPtrArray7Break)
286static void OutPtrArray7Break(PtrArray7 *out, const int *val) { }
287
288/////////////////////////////////////////////////////////////////////////
289
290struct StructPtr1 {
291  Ptr p;
292  double d;
293};
294
295struct StructPtr11 {
296  Ptr p;
297  double d;
298  int i;
299};
300
301struct StructPtr111 {
302  Ptr p;
303  double d;
304  int i;
305  float f;
306};
307
308// cannot export struct containing pointer
309#pragma rs reduce(redStructPtr) accumulator(AccumStructPtr) combiner(CombStructPtr)
310static void AccumStructPtr(struct StructPtr1 *accum, int val) { }
311static void CombStructPtr(struct StructPtr1 *accum, const struct StructPtr1 *other) { }
312
313// problem is result type, not accumulator type, so outconverter can fix this
314#pragma rs reduce(redStructPtrOutFix) accumulator(AccumStructPtrOutFix) \
315  combiner(CombStructPtrOutFix) outconverter(OutStructPtrFix)
316static void AccumStructPtrOutFix(struct StructPtr11 *accum, int val) { }
317static void CombStructPtrOutFix(struct StructPtr11 *accum, const struct StructPtr11 *other) { }
318static void OutStructPtrFix(int *out, const struct StructPtr11 *val) { }
319
320// problem is result type, not accumulator type, so outconverter can break this
321#pragma rs reduce(redStructPtrOutBreak) accumulator(AccumInt) outconverter(OutStructPtrBreak)
322static void OutStructPtrBreak(struct StructPtr111 *out, const int *val) { }
323
324/////////////////////////////////////////////////////////////////////////
325
326struct StructPtr2 {
327  float f;
328  Ptr p;
329};
330typedef struct StructPtr2 StructPtr2Array[7];
331
332struct StructPtr22 {
333  float f;
334  Ptr p;
335  char c;
336};
337typedef struct StructPtr22 StructPtr22Array[7];
338
339struct StructPtr222 {
340  float f;
341  Ptr p;
342  char c;
343  double d;
344};
345typedef struct StructPtr222 StructPtr222Array[7];
346
347// cannot export struct containing pointer
348#pragma rs reduce(redStructPtrArray) accumulator(AccumStructPtrArray) combiner(CombStructPtrArray)
349static void AccumStructPtrArray(StructPtr2Array *accum, int val) { }
350static void CombStructPtrArray(StructPtr2Array *accum, const StructPtr2Array *other) { }
351
352// problem is result type, not accumulator type, so outconverter can fix this
353#pragma rs reduce(redStructPtrArrayOutFix) accumulator(AccumStructPtrArrayOutFix) \
354  combiner(CombStructPtrArrayOutFix) outconverter(OutStructPtrArrayFix)
355static void AccumStructPtrArrayOutFix(StructPtr22Array *accum, int val) { }
356static void CombStructPtrArrayOutFix(StructPtr22Array *accum, const StructPtr22Array *other) { }
357static void OutStructPtrArrayFix(int *out, const StructPtr22Array *val) { }
358
359// problem is result type, not accumulator type, so outconverter can break this
360#pragma rs reduce(redStructPtrArrayOutBreak) accumulator(AccumInt) \
361  outconverter(OutStructPtrArrayBreak)
362static void OutStructPtrArrayBreak(StructPtr22Array *out, const int *val) { }
363
364/////////////////////////////////////////////////////////////////////////
365
366typedef void Fn(void);
367
368// cannot export function type
369//
370// NOTE: Not suitable as accumulator data type, regardless of whether
371//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
372#pragma rs reduce(redFn) accumulator(AccumInt) outconverter(OutFn)
373static void OutFn(Fn *out, const int *val) { }
374
375/////////////////////////////////////////////////////////////////////////
376
377struct Incomplete;
378
379// result type cannot be incomplete type
380//
381// NOTE: Not suitable as accumulator data type, regardless of whether
382//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
383#pragma rs reduce(redStructIncomplete) accumulator(AccumInt) outconverter(OutStructIncomplete)
384static void OutStructIncomplete(struct Incomplete *out, const int *val) { }
385
386/////////////////////////////////////////////////////////////////////////
387
388typedef int IntA[]; // incomplete (unknown element count)
389
390// result type cannot be incomplete type
391//
392// NOTE: Not suitable as accumulator data type, regardless of whether
393//       we have outconverter; that's tested in reduce_general_bad_accumulator.rs.
394#pragma rs reduce(redArrayIncomplete) accumulator(AccumInt) outconverter(OutArrayIncomplete)
395static void OutArrayIncomplete(IntA *out, const int *val) { }
396