This is the mail archive of the gcc@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: PR68425 warn message enhancement


On 19 September 2017 at 01:35, Martin Sebor <msebor@gmail.com> wrote:
> On 09/18/2017 01:06 PM, Prasad Ghangal wrote:
>>
>> Hi,
>>
>> This was discussed a few time ago in this email thread :
>> https://gcc.gnu.org/ml/gcc/2016-02/msg00235.html
>>
>> As per the discussion, the attached patch produces warning message for
>> excess elements in array initialization along with number of expected
>> and extra elements and underlined extra elements ranges.
>
>
> I like the additional detail and the underlining of all the excess
> elements when the whole initializer list is on the same line.  I'm
> not sure it's a good idea to underline all the excess elements when
> they are on separate lines.  That could make the warning really long.
>
> For some additional improvements I would suggest either eliminating
> the note (it serves no useful purpose anymore) or replacing it with
> the element count(s).  The message printing the element counter
> should also be adjusted to be correct for zero-length arrays as in:
>
>   int a[0] = { 1 };
>
> Alternatively, change the message to say just:
>
>   warning: X excess elements in an initializer for 'int a[N]'
>
> and when the line the caret is on is not the same as the object
> being initialized, print a note pointing to the declaration as
> is done by some other warnings:
>
>   note: array 'a' declared here
>
> As an additional improvement, string initializers with excessive
> elements would benefit from the same underlining/element counts.
>
> The C++ front end will need similar changes.
>
> Finally, it would be nice to also be able to control the warning
> (i.e., provide an option to turn it on and off).
>
Currently gcc raises warning for excess elements in an initializer by default.
Should we introduce new flag/option (like
Wextra-elements-initializers) or use any existing one?

> Martin
>
> PS Please send patches to gcc-patches.
>
>
>>
>> e.g for following testcases:
>>
>> int foo()
>> {
>>   int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
>>   int b[0] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
>>   int c[5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
>>   int d[5][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9,
>> 10};
>>   int e[5][0] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9,
>> 10};
>>   int f[5][2][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6,
>> 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9,
>> 10};
>>   int h[3][2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5,
>> 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7};
>>   return 0;
>> }
>>
>>
>> It produces (gmail may mess up with spaces):
>>
>> ./gcc/cc1 ../tests/test.c
>>  foo
>> ../tests/test.c: In function ‘foo’:
>> ../tests/test.c:4:15: warning: excess elements in array initializer
>> (10 elements, 0 expected)
>>    int b[0] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
>>                    ^~~~~~~~~~~~~~~~~~~
>> ../tests/test.c:4:15: note: (near initialization for ‘b’)
>> ../tests/test.c:5:30: warning: excess elements in array initializer
>> (10 elements, 5 expected)
>>    int c[5] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
>>                                    ^~~~~~~~~~~
>> ../tests/test.c:5:30: note: (near initialization for ‘c’)
>> ../tests/test.c:6:49: warning: excess elements in array initializer
>> (20 elements, 10 expected)
>>    int d[5][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8,
>> 9, 10};
>>
>> ^~~~~~~~~~~~~~~~~~~
>> ../tests/test.c:6:49: note: (near initialization for ‘d[5]’)
>> ../tests/test.c:7:18: warning: excess elements in array initializer
>> (20 elements, 0 expected)
>>    int e[5][0] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8,
>> 9, 10};
>>                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>> ../tests/test.c:7:18: note: (near initialization for ‘e[5]’)
>> ../tests/test.c:8:114: warning: excess elements in array initializer
>> (40 elements, 30 expected)
>>    int f[5][2][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6,
>> 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9,
>> 10};
>>
>> ^~~~~~~~~~~~~~~~~~~
>> ../tests/test.c:8:114: note: (near initialization for ‘f[5][1]’)
>> ../tests/test.c:9:135: warning: excess elements in array initializer
>> (37 elements, 36 expected)
>>    int h[3][2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5,
>> 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7};
>>
>>                  ^
>> ../tests/test.c:9:135: note: (near initialization for ‘h[3][0][0]’)
>>
>>
>> Any thoughts?
>>
>>
>> Thanks,
>> Prasad
>>
>


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]