C: parser failing to see an error

jr_bob_dobbs · 01-09-2022, 01:11 PM

Code:

#include <stdio.h>

void knurl();

void knurl()
{
}


int main()
{
  knurl(27, 82, 14);
}

In the above .c source code you can see a standard include, a forward reference to a subroutine, the actual subroutine, then a call to the subroutine. As you can see, in the above program, I call the subroutine incorrectly, by giving it parameters. That subroutine takes no parameters and returns no parameters. The compiler ignores this error and continues blithely on its way. To the best of my knowledge, this is wrong. The compiler should flag that as an error! Can someone please clue me in on this matter?

Thank you very much.

p.s. I'm using gcc version 10.2.1 20201203 (GCC) on (Void Linux if it makes any difference).

NevemTeve · 01-09-2022, 01:24 PM

Maybe you forgot to enable warnings, such as `function call without prototype`.
In C (unliky C++) this is not a prototype:

Code:

void knurl();

This is:

Code:

void knurl(void);

rtmistler · 01-09-2022, 02:21 PM

(I wasn't sure if the new C standard allowed function overloading.)

Same thought as NevemTeve, what compile flags did you use, excepting just a default compile.

Also what compile did you use, while gcc seems reasonable, I think you can also use c++, maybe even g++

astrogeek · 01-09-2022, 03:39 PM

As suggested by posts above, void knurl(); is not the same as void knurl(void);.

The difference may be stated as follows: the first declaration (i.e. not a prototype) does not specify a paramater list while the second declaration which is a prototype specifies an empty parameter list.

Because the first does not specify a parameter list no checks of parameter types are made by the compiler when the function is called. This behavior may be overridden by suitable compiler warning flags as NevemTeve notes.

The reasons for this behavior are discussed here, from which:

Quote:

The reason for supporting the notation is historical. Before the first C standard (C89/C90), you couldn't use prototypes in C; prototypes were one of the biggest and most important features of Standard C. All function declarations, therefore, were written the 'empty parentheses' style (when they were written at all; most functions that returned int were not declared at all). The type void was also added in C89/C90, though some compilers supported it before the standard was finalized.

Because it was crucial to the success of C89/C90 that existing code should mostly continue to work, the empty parentheses style had to be allowed by the standard.

UPDATE: I found this related reference in the GNU GCC documentation, Certain Changes We Don't Want to Make:

Quote:

Checking the number and type of arguments to a function which has an old-fashioned definition and no prototype.

Such a feature would work only occasionally—only for calls that appear in the same file as the called function, following the definition. The only way to check all calls reliably is to add a prototype for the function. But adding a prototype eliminates the motivation for this feature. So the feature is not worthwhile.

You can make these visible with -Wstrict-prototypes compile time option.

The above is correct through at least gcc-10.3.0 and C17. A change being considered for C2x is to make empty parenthesis equivalent to (void) in function declarations, but I am unsure of the details and status at this time.

dugan · 01-09-2022, 04:18 PM

Okay, this is terrifying...

I don't get any warnings when compiling with gcc and "-Wall and -Wextra".

I did get a warning from clang-tidy:

Code:

kurl.c:11:21: warning: too many arguments in call to 'knurl' [clang-diagnostic-warning]

EdGr · 01-09-2022, 07:15 PM

Use the C++ compiler even if you are writing C. C++ will flag the error.
Ed

pan64 · 01-10-2022, 01:08 AM

You can check -Wstrict-prototypes for example.
https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html (look for prototypes and declaration related options)

NevemTeve · 01-10-2022, 01:21 AM

Seems like I was wrong; now I think in C void knurl(); is a prototype -- a prototype that allows arbitrary parameters.

Not true for C++, where it means no parameters (which is void knurl(void); in C).

astrogeek · 01-10-2022, 01:34 AM

Quote:

Originally Posted by NevemTeve

Seems like I was wrong; now I think in C void knurl(); is a prototype -- a prototype that allows arbitrary parameters.

Not true for C++, where it means no parameters (which is void knurl(void); in C).

I bounced between thinking of it as a prototype or a non-prototype declaration, never having thought much about it before now.

I have seen it referred to both ways in references I have read while considering this question. Because the behavior in ANSI C was intended to preserve behavior that predates any support for function prototypes, I have decided to think of it as a non-prototype declaration. That is not authoritative!

UPDATE: When compiling with -Wstrict-prototypes the message produced is:

Code:

gcc prog.c -Wstrict-prototypes
prog.c:3:1: warning: function declaration isn’t a prototype [-Wstrict-prototypes]
    3 | void knurl();

I'll take that as authoritative... enough, and you were right the first time!

jr_bob_dobbs · 01-12-2022, 02:28 PM

Holy cow, thanks for the all of the replies.

I find myself a bit bewildered. I'm just wondering why behavior described the Kernighan & Ritchie C book is now incorrect?

I guess the impression I'm getting is ... things got changed that break backwards compatibility with (what used to be) correct C.

Anyway, the immediate fix of

Code:

/* cc -o test_delete test_delete.c */
#include <stdio.h>

void knurl(void);

void knurl(void)
{
}


int main()
{
  knurl(27, 82, 14);
}

now correctly sees the call to knurl as an error, So thank you all for that.

NevemTeve · 01-12-2022, 02:37 PM

Regarding KR-C: let's not forget it has been written some 40 years ago.
https://en.m.wikipedia.org/wiki/The_...mming_Language

dugan · 01-12-2022, 05:33 PM

Also, there were two editions of K&R, and C had been around for a long time when the C89 standard came out.

The first C book I read was very old, and it did show the pattern where you declare a function without parameter types, and then define it with the types.

pan64 · 01-13-2022, 01:18 AM

Quote:

Originally Posted by jr_bob_dobbs

I'm just wondering why behavior described the Kernighan & Ritchie C book is now incorrect?

Fortunately we have a lot of different standards and also a lot of different compilers which may try to follow [largely] those standards (with more or less success).