xref: /petsc/src/sys/tests/linter/output/testValidPointers.out (revision 21e3ffae2f3b73c0bd738cf6d0a809700fc04bb0) 
1<--- FIXED --->
2--------------------------------------------------------------------------------------------
3ERROR 0: ./src/sys/tests/linter/testValidPointers.c:6:25
4'a' of type 'void *'
5  4: {
6  5:   /* incorrect */
7> 6:   PetscValidCharPointer(a, 2);
8                             ^
9  7:   PetscValidIntPointer(b, 3);
10  8:   PetscValidBoolPointer(c, 4);
11
12Incorrect use of PetscValidCharPointer(), use PetscValidPointer() instead [-fincompatible-function]
13
14ERROR 1: ./src/sys/tests/linter/testValidPointers.c:6:28
15'2' of type 'int'
16  4: {
17  5:   /* incorrect */
18> 6:   PetscValidCharPointer(a, 2);
19                                ^
20  7:   PetscValidIntPointer(b, 3);
21  8:   PetscValidBoolPointer(c, 4);
22
23Argument number doesn't match for 'a'. Expected '1', found '2' [-fmatching-arg-num]
24
25./src/sys/tests/linter/testValidPointers.c:3:34 Note: 'a' is traceable to argument #1 'a' in enclosing function here:
26  1: #include <petsc/private/petscimpl.h>
27  2:
28> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
29                                      ^^^^^^^
30  4: {
31  5:   /* incorrect */
32
33ERROR 2: ./src/sys/tests/linter/testValidPointers.c:7:24
34'b' of type 'char *'
35  5: /* incorrect */
36  6: PetscValidCharPointer(a, 2);
37> 7: PetscValidIntPointer(b, 3);
38                          ^
39  8: PetscValidBoolPointer(c, 4);
40  9: PetscValidRealPointer(d, 5);
41
42Incorrect use of PetscValidIntPointer(), use PetscValidCharPointer() instead [-fincompatible-function]
43
44ERROR 3: ./src/sys/tests/linter/testValidPointers.c:7:27
45'3' of type 'int'
46  5: /* incorrect */
47  6: PetscValidCharPointer(a, 2);
48> 7: PetscValidIntPointer(b, 3);
49                             ^
50  8: PetscValidBoolPointer(c, 4);
51  9: PetscValidRealPointer(d, 5);
52
53Argument number doesn't match for 'b'. Expected '2', found '3' [-fmatching-arg-num]
54
55./src/sys/tests/linter/testValidPointers.c:3:43 Note: 'b' is traceable to argument #2 'b' in enclosing function here:
56  1: #include <petsc/private/petscimpl.h>
57  2:
58> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
59                                               ^^^^^^^
60  4: {
61  5:   /* incorrect */
62
63ERROR 4: ./src/sys/tests/linter/testValidPointers.c:8:25
64'c' of type 'PetscInt *' (a.k.a. 'int *')
65  6 : PetscValidCharPointer(a, 2);
66  7 : PetscValidIntPointer(b, 3);
67> 8 : PetscValidBoolPointer(c, 4);
68                            ^
69  9 : PetscValidRealPointer(d, 5);
70  10: PetscValidScalarPointer(e, 6);
71
72Incorrect use of PetscValidBoolPointer(), use PetscValidIntPointer() instead [-fincompatible-function]
73
74ERROR 5: ./src/sys/tests/linter/testValidPointers.c:8:28
75'4' of type 'int'
76  6 : PetscValidCharPointer(a, 2);
77  7 : PetscValidIntPointer(b, 3);
78> 8 : PetscValidBoolPointer(c, 4);
79                               ^
80  9 : PetscValidRealPointer(d, 5);
81  10: PetscValidScalarPointer(e, 6);
82
83Argument number doesn't match for 'c'. Expected '3', found '4' [-fmatching-arg-num]
84
85./src/sys/tests/linter/testValidPointers.c:3:52 Note: 'c' is traceable to argument #3 'c' in enclosing function here:
86  1: #include <petsc/private/petscimpl.h>
87  2:
88> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
89                                                        ^^^^^^^^^^^
90  4: {
91  5:   /* incorrect */
92
93ERROR 6: ./src/sys/tests/linter/testValidPointers.c:9:25
94'd' of type 'PetscMPIInt *' (a.k.a. 'int *')
95  7 : PetscValidIntPointer(b, 3);
96  8 : PetscValidBoolPointer(c, 4);
97> 9 : PetscValidRealPointer(d, 5);
98                            ^
99  10: PetscValidScalarPointer(e, 6);
100  11: PetscValidIntPointer(f, 7);
101
102Incorrect use of PetscValidRealPointer(), use PetscValidIntPointer() instead [-fincompatible-function]
103
104ERROR 7: ./src/sys/tests/linter/testValidPointers.c:9:28
105'5' of type 'int'
106  7 : PetscValidIntPointer(b, 3);
107  8 : PetscValidBoolPointer(c, 4);
108> 9 : PetscValidRealPointer(d, 5);
109                               ^
110  10: PetscValidScalarPointer(e, 6);
111  11: PetscValidIntPointer(f, 7);
112
113Argument number doesn't match for 'd'. Expected '4', found '5' [-fmatching-arg-num]
114
115./src/sys/tests/linter/testValidPointers.c:3:65 Note: 'd' is traceable to argument #4 'd' in enclosing function here:
116  1: #include <petsc/private/petscimpl.h>
117  2:
118> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
119                                                                     ^^^^^^^^^^^^^^
120  4: {
121  5:   /* incorrect */
122
123ERROR 8: ./src/sys/tests/linter/testValidPointers.c:10:27
124'e' of type 'PetscInt *' (a.k.a. 'int *')
125  8 : PetscValidBoolPointer(c, 4);
126  9 : PetscValidRealPointer(d, 5);
127> 10: PetscValidScalarPointer(e, 6);
128                              ^
129  11: PetscValidIntPointer(f, 7);
130  12: PetscValidRealPointer(g, 8);
131
132Incorrect use of PetscValidScalarPointer(), use PetscValidIntPointer() instead [-fincompatible-function]
133
134ERROR 9: ./src/sys/tests/linter/testValidPointers.c:10:30
135'6' of type 'int'
136  8 : PetscValidBoolPointer(c, 4);
137  9 : PetscValidRealPointer(d, 5);
138> 10: PetscValidScalarPointer(e, 6);
139                                 ^
140  11: PetscValidIntPointer(f, 7);
141  12: PetscValidRealPointer(g, 8);
142
143Argument number doesn't match for 'e'. Expected '5', found '6' [-fmatching-arg-num]
144
145./src/sys/tests/linter/testValidPointers.c:3:81 Note: 'e' is traceable to argument #5 'e' in enclosing function here:
146  1: #include <petsc/private/petscimpl.h>
147  2:
148> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
149                                                                                     ^^^^^^^^^^^
150  4: {
151  5:   /* incorrect */
152
153ERROR 10: ./src/sys/tests/linter/testValidPointers.c:11:24
154'f' of type 'PetscBool *'
155  9 : PetscValidRealPointer(d, 5);
156  10: PetscValidScalarPointer(e, 6);
157> 11: PetscValidIntPointer(f, 7);
158                           ^
159  12: PetscValidRealPointer(g, 8);
160  13: PetscValidScalarPointer(h, 9);
161
162Incorrect use of PetscValidIntPointer(), use PetscValidBoolPointer() instead [-fincompatible-function]
163
164ERROR 11: ./src/sys/tests/linter/testValidPointers.c:11:27
165'7' of type 'int'
166  9 : PetscValidRealPointer(d, 5);
167  10: PetscValidScalarPointer(e, 6);
168> 11: PetscValidIntPointer(f, 7);
169                              ^
170  12: PetscValidRealPointer(g, 8);
171  13: PetscValidScalarPointer(h, 9);
172
173Argument number doesn't match for 'f'. Expected '6', found '7' [-fmatching-arg-num]
174
175./src/sys/tests/linter/testValidPointers.c:3:94 Note: 'f' is traceable to argument #6 'f' in enclosing function here:
176  1: #include <petsc/private/petscimpl.h>
177  2:
178> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
179                                                                                                  ^^^^^^^^^^^^
180  4: {
181  5:   /* incorrect */
182
183ERROR 12: ./src/sys/tests/linter/testValidPointers.c:12:25
184'g' of type 'PetscScalar *' (a.k.a. 'double *')
185  10: PetscValidScalarPointer(e, 6);
186  11: PetscValidIntPointer(f, 7);
187> 12: PetscValidRealPointer(g, 8);
188                            ^
189  13: PetscValidScalarPointer(h, 9);
190  14:
191
192Incorrect use of PetscValidRealPointer(), use PetscValidScalarPointer() instead [-fincompatible-function]
193
194ERROR 13: ./src/sys/tests/linter/testValidPointers.c:12:28
195'8' of type 'int'
196  10: PetscValidScalarPointer(e, 6);
197  11: PetscValidIntPointer(f, 7);
198> 12: PetscValidRealPointer(g, 8);
199                               ^
200  13: PetscValidScalarPointer(h, 9);
201  14:
202
203Argument number doesn't match for 'g'. Expected '7', found '8' [-fmatching-arg-num]
204
205./src/sys/tests/linter/testValidPointers.c:3:108 Note: 'g' is traceable to argument #7 'g' in enclosing function here:
206  1: #include <petsc/private/petscimpl.h>
207  2:
208> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
209                                                                                                                ^^^^^^^^^^^^^^
210  4: {
211  5:   /* incorrect */
212
213ERROR 14: ./src/sys/tests/linter/testValidPointers.c:13:27
214'h' of type 'PetscReal *' (a.k.a. 'double *')
215  11: PetscValidIntPointer(f, 7);
216  12: PetscValidRealPointer(g, 8);
217> 13: PetscValidScalarPointer(h, 9);
218                              ^
219  14:
220  15: /* correct */
221
222Incorrect use of PetscValidScalarPointer(), use PetscValidRealPointer() instead [-fincompatible-function]
223
224ERROR 15: ./src/sys/tests/linter/testValidPointers.c:13:30
225'9' of type 'int'
226  11: PetscValidIntPointer(f, 7);
227  12: PetscValidRealPointer(g, 8);
228> 13: PetscValidScalarPointer(h, 9);
229                                 ^
230  14:
231  15: /* correct */
232
233Argument number doesn't match for 'h'. Expected '8', found '9' [-fmatching-arg-num]
234
235./src/sys/tests/linter/testValidPointers.c:3:124 Note: 'h' is traceable to argument #8 'h' in enclosing function here:
236  1: #include <petsc/private/petscimpl.h>
237  2:
238> 3: PetscErrorCode testValidPointers(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
239                                                                                                                                ^^^^^^^^^^^^
240  4: {
241  5:   /* incorrect */
242
243ERROR 16: ./src/sys/tests/linter/testValidPointers.c:30:25
244'a' of type 'void *'
245  28: {
246  29:   /* incorrect */
247> 30:   PetscValidCharPointer(a, 2);
248                              ^
249  31:   PetscValidPointer(b, 3);
250  32:   PetscValidPointer(c, 4);
251
252Incorrect use of PetscValidCharPointer(), use PetscValidPointer() instead [-fincompatible-function]
253
254ERROR 17: ./src/sys/tests/linter/testValidPointers.c:30:28
255'2' of type 'int'
256  28: {
257  29:   /* incorrect */
258> 30:   PetscValidCharPointer(a, 2);
259                                 ^
260  31:   PetscValidPointer(b, 3);
261  32:   PetscValidPointer(c, 4);
262
263Argument number doesn't match for 'a'. Expected '1', found '2' [-fmatching-arg-num]
264
265./src/sys/tests/linter/testValidPointers.c:27:25 Note: 'a' is traceable to argument #1 'a' in enclosing function here:
266  25: }
267  26:
268> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
269                              ^^^^^^^
270  28: {
271  29:   /* incorrect */
272
273ERROR 18: ./src/sys/tests/linter/testValidPointers.c:31:21
274'b' of type 'char *'
275  29: /* incorrect */
276  30: PetscValidCharPointer(a, 2);
277> 31: PetscValidPointer(b, 3);
278                        ^
279  32: PetscValidPointer(c, 4);
280  33: PetscValidPointer(d, 5);
281
282Incorrect use of PetscValidPointer(), use PetscValidCharPointer() instead [-fincompatible-function]
283
284ERROR 19: ./src/sys/tests/linter/testValidPointers.c:31:24
285'3' of type 'int'
286  29: /* incorrect */
287  30: PetscValidCharPointer(a, 2);
288> 31: PetscValidPointer(b, 3);
289                           ^
290  32: PetscValidPointer(c, 4);
291  33: PetscValidPointer(d, 5);
292
293Argument number doesn't match for 'b'. Expected '2', found '3' [-fmatching-arg-num]
294
295./src/sys/tests/linter/testValidPointers.c:27:34 Note: 'b' is traceable to argument #2 'b' in enclosing function here:
296  25: }
297  26:
298> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
299                                       ^^^^^^^
300  28: {
301  29:   /* incorrect */
302
303ERROR 20: ./src/sys/tests/linter/testValidPointers.c:32:21
304'c' of type 'PetscInt *' (a.k.a. 'int *')
305  30: PetscValidCharPointer(a, 2);
306  31: PetscValidPointer(b, 3);
307> 32: PetscValidPointer(c, 4);
308                        ^
309  33: PetscValidPointer(d, 5);
310  34: PetscValidPointer(e, 6);
311
312Incorrect use of PetscValidPointer(), use PetscValidIntPointer() instead [-fincompatible-function]
313
314ERROR 21: ./src/sys/tests/linter/testValidPointers.c:32:24
315'4' of type 'int'
316  30: PetscValidCharPointer(a, 2);
317  31: PetscValidPointer(b, 3);
318> 32: PetscValidPointer(c, 4);
319                           ^
320  33: PetscValidPointer(d, 5);
321  34: PetscValidPointer(e, 6);
322
323Argument number doesn't match for 'c'. Expected '3', found '4' [-fmatching-arg-num]
324
325./src/sys/tests/linter/testValidPointers.c:27:43 Note: 'c' is traceable to argument #3 'c' in enclosing function here:
326  25: }
327  26:
328> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
329                                                ^^^^^^^^^^^
330  28: {
331  29:   /* incorrect */
332
333ERROR 22: ./src/sys/tests/linter/testValidPointers.c:33:21
334'd' of type 'PetscMPIInt *' (a.k.a. 'int *')
335  31: PetscValidPointer(b, 3);
336  32: PetscValidPointer(c, 4);
337> 33: PetscValidPointer(d, 5);
338                        ^
339  34: PetscValidPointer(e, 6);
340  35: PetscValidPointer(f, 7);
341
342Incorrect use of PetscValidPointer(), use PetscValidIntPointer() instead [-fincompatible-function]
343
344ERROR 23: ./src/sys/tests/linter/testValidPointers.c:33:24
345'5' of type 'int'
346  31: PetscValidPointer(b, 3);
347  32: PetscValidPointer(c, 4);
348> 33: PetscValidPointer(d, 5);
349                           ^
350  34: PetscValidPointer(e, 6);
351  35: PetscValidPointer(f, 7);
352
353Argument number doesn't match for 'd'. Expected '4', found '5' [-fmatching-arg-num]
354
355./src/sys/tests/linter/testValidPointers.c:27:56 Note: 'd' is traceable to argument #4 'd' in enclosing function here:
356  25: }
357  26:
358> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
359                                                             ^^^^^^^^^^^^^^
360  28: {
361  29:   /* incorrect */
362
363ERROR 24: ./src/sys/tests/linter/testValidPointers.c:34:21
364'e' of type 'PetscInt *' (a.k.a. 'int *')
365  32: PetscValidPointer(c, 4);
366  33: PetscValidPointer(d, 5);
367> 34: PetscValidPointer(e, 6);
368                        ^
369  35: PetscValidPointer(f, 7);
370  36: PetscValidPointer(g, 8);
371
372Incorrect use of PetscValidPointer(), use PetscValidIntPointer() instead [-fincompatible-function]
373
374ERROR 25: ./src/sys/tests/linter/testValidPointers.c:34:24
375'6' of type 'int'
376  32: PetscValidPointer(c, 4);
377  33: PetscValidPointer(d, 5);
378> 34: PetscValidPointer(e, 6);
379                           ^
380  35: PetscValidPointer(f, 7);
381  36: PetscValidPointer(g, 8);
382
383Argument number doesn't match for 'e'. Expected '5', found '6' [-fmatching-arg-num]
384
385./src/sys/tests/linter/testValidPointers.c:27:72 Note: 'e' is traceable to argument #5 'e' in enclosing function here:
386  25: }
387  26:
388> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
389                                                                             ^^^^^^^^^^^
390  28: {
391  29:   /* incorrect */
392
393ERROR 26: ./src/sys/tests/linter/testValidPointers.c:35:21
394'f' of type 'PetscBool *'
395  33: PetscValidPointer(d, 5);
396  34: PetscValidPointer(e, 6);
397> 35: PetscValidPointer(f, 7);
398                        ^
399  36: PetscValidPointer(g, 8);
400  37: PetscValidPointer(h, 9);
401
402Incorrect use of PetscValidPointer(), use PetscValidBoolPointer() instead [-fincompatible-function]
403
404ERROR 27: ./src/sys/tests/linter/testValidPointers.c:35:24
405'7' of type 'int'
406  33: PetscValidPointer(d, 5);
407  34: PetscValidPointer(e, 6);
408> 35: PetscValidPointer(f, 7);
409                           ^
410  36: PetscValidPointer(g, 8);
411  37: PetscValidPointer(h, 9);
412
413Argument number doesn't match for 'f'. Expected '6', found '7' [-fmatching-arg-num]
414
415./src/sys/tests/linter/testValidPointers.c:27:85 Note: 'f' is traceable to argument #6 'f' in enclosing function here:
416  25: }
417  26:
418> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
419                                                                                          ^^^^^^^^^^^^
420  28: {
421  29:   /* incorrect */
422
423ERROR 28: ./src/sys/tests/linter/testValidPointers.c:36:21
424'g' of type 'PetscScalar *' (a.k.a. 'double *')
425  34: PetscValidPointer(e, 6);
426  35: PetscValidPointer(f, 7);
427> 36: PetscValidPointer(g, 8);
428                        ^
429  37: PetscValidPointer(h, 9);
430  38:
431
432Incorrect use of PetscValidPointer(), use PetscValidScalarPointer() instead [-fincompatible-function]
433
434ERROR 29: ./src/sys/tests/linter/testValidPointers.c:36:24
435'8' of type 'int'
436  34: PetscValidPointer(e, 6);
437  35: PetscValidPointer(f, 7);
438> 36: PetscValidPointer(g, 8);
439                           ^
440  37: PetscValidPointer(h, 9);
441  38:
442
443Argument number doesn't match for 'g'. Expected '7', found '8' [-fmatching-arg-num]
444
445./src/sys/tests/linter/testValidPointers.c:27:99 Note: 'g' is traceable to argument #7 'g' in enclosing function here:
446  25: }
447  26:
448> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
449                                                                                                        ^^^^^^^^^^^^^^
450  28: {
451  29:   /* incorrect */
452
453ERROR 30: ./src/sys/tests/linter/testValidPointers.c:37:21
454'h' of type 'PetscReal *' (a.k.a. 'double *')
455  35: PetscValidPointer(f, 7);
456  36: PetscValidPointer(g, 8);
457> 37: PetscValidPointer(h, 9);
458                        ^
459  38:
460  39: /* correct */
461
462Incorrect use of PetscValidPointer(), use PetscValidRealPointer() instead [-fincompatible-function]
463
464ERROR 31: ./src/sys/tests/linter/testValidPointers.c:37:24
465'9' of type 'int'
466  35: PetscValidPointer(f, 7);
467  36: PetscValidPointer(g, 8);
468> 37: PetscValidPointer(h, 9);
469                           ^
470  38:
471  39: /* correct */
472
473Argument number doesn't match for 'h'. Expected '8', found '9' [-fmatching-arg-num]
474
475./src/sys/tests/linter/testValidPointers.c:27:115 Note: 'h' is traceable to argument #8 'h' in enclosing function here:
476  25: }
477  26:
478> 27: void testValidPointers2(void *a, char *b, PetscInt *c, PetscMPIInt *d, PetscInt *e, PetscBool *f, PetscScalar *g, PetscReal *h)
479                                                                                                                        ^^^^^^^^^^^^
480  28: {
481  29:   /* incorrect */
482
483ERROR 32: ./src/sys/tests/linter/testValidPointers.c:54:25
484'a' of type 'void **'
485  52: {
486  53:   /* incorrect */
487> 54:   PetscValidCharPointer(a, 1);
488                              ^
489  55:   PetscValidCharPointer(b, 2);
490  56:   PetscValidIntPointer(c, 3);
491
492Incorrect use of PetscValidCharPointer(), use PetscValidPointer() instead [-fincompatible-function]
493
494ERROR 33: ./src/sys/tests/linter/testValidPointers.c:55:25
495'b' of type 'char **'
496  53: /* incorrect */
497  54: PetscValidCharPointer(a, 1);
498> 55: PetscValidCharPointer(b, 2);
499                            ^
500  56: PetscValidIntPointer(c, 3);
501  57: PetscValidIntPointer(d, 4);
502
503Incorrect use of PetscValidCharPointer(), use PetscValidPointer() instead [-fincompatible-function]
504
505ERROR 34: ./src/sys/tests/linter/testValidPointers.c:56:24
506'c' of type 'PetscInt **' (a.k.a. 'int **')
507  54: PetscValidCharPointer(a, 1);
508  55: PetscValidCharPointer(b, 2);
509> 56: PetscValidIntPointer(c, 3);
510                           ^
511  57: PetscValidIntPointer(d, 4);
512  58: PetscValidIntPointer(e, 5);
513
514Incorrect use of PetscValidIntPointer(), use PetscValidPointer() instead [-fincompatible-function]
515
516ERROR 35: ./src/sys/tests/linter/testValidPointers.c:57:24
517'd' of type 'PetscMPIInt **' (a.k.a. 'int **')
518  55: PetscValidCharPointer(b, 2);
519  56: PetscValidIntPointer(c, 3);
520> 57: PetscValidIntPointer(d, 4);
521                           ^
522  58: PetscValidIntPointer(e, 5);
523  59: PetscValidBoolPointer(f, 6);
524
525Incorrect use of PetscValidIntPointer(), use PetscValidPointer() instead [-fincompatible-function]
526
527ERROR 36: ./src/sys/tests/linter/testValidPointers.c:58:24
528'e' of type 'PetscInt **' (a.k.a. 'int **')
529  56: PetscValidIntPointer(c, 3);
530  57: PetscValidIntPointer(d, 4);
531> 58: PetscValidIntPointer(e, 5);
532                           ^
533  59: PetscValidBoolPointer(f, 6);
534  60: PetscValidScalarPointer(g, 7);
535
536Incorrect use of PetscValidIntPointer(), use PetscValidPointer() instead [-fincompatible-function]
537
538ERROR 37: ./src/sys/tests/linter/testValidPointers.c:59:25
539'f' of type 'PetscBool **'
540  57: PetscValidIntPointer(d, 4);
541  58: PetscValidIntPointer(e, 5);
542> 59: PetscValidBoolPointer(f, 6);
543                            ^
544  60: PetscValidScalarPointer(g, 7);
545  61: PetscValidRealPointer(h, 8);
546
547Incorrect use of PetscValidBoolPointer(), use PetscValidPointer() instead [-fincompatible-function]
548
549ERROR 38: ./src/sys/tests/linter/testValidPointers.c:60:27
550'g' of type 'PetscScalar **' (a.k.a. 'double **')
551  58: PetscValidIntPointer(e, 5);
552  59: PetscValidBoolPointer(f, 6);
553> 60: PetscValidScalarPointer(g, 7);
554                              ^
555  61: PetscValidRealPointer(h, 8);
556  62:
557
558Incorrect use of PetscValidScalarPointer(), use PetscValidPointer() instead [-fincompatible-function]
559
560ERROR 39: ./src/sys/tests/linter/testValidPointers.c:61:25
561'h' of type 'PetscReal **' (a.k.a. 'double **')
562  59: PetscValidBoolPointer(f, 6);
563  60: PetscValidScalarPointer(g, 7);
564> 61: PetscValidRealPointer(h, 8);
565                            ^
566  62:
567  63: /* correct */
568
569Incorrect use of PetscValidRealPointer(), use PetscValidPointer() instead [-fincompatible-function]
570--------------------------------------------------------------------------------------------
571<--- LEFT --->
572