reduce_general_bad_result.rs revision 2d7f3f95947889e1ea48b0e925c5929af4fbf6b4
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