Thread: Using argc without argv. (-Wfatal-errors)

Hi,

I'm starting to notice how much I reuse certain code. For instance, this is a common `test` in many of my programs:

Code:

if(SOME_TEST == FAILED)
{
    fprintf(stderr, "%s: FUNCTION_NAME error: LAST_COMMAND failed (%s)\n", program_name, strerror(errno));
    exit(EXIT_FAILURE);
}

I recently learned about some gcc variables, namely `program_invocation_short_name` which give the basename of the called program, and `__func__` which gives the name of the called function.

Now, `program_invocation_short_name` is useful to me as in the main function of every program, I do the following to get the program name (`program_name` being a global variable):

Code:

int main (int argc, char *argv[])
{
// Get program name for error reporting.
    strcpy(program_name, basename(argv[0]));

// Check number of arguments.
    if(argc != 1)
    {
        fprintf(stderr, "Usage: %s\n", program_name);
        exit(EXIT_FAILURE);
    }

// Run process.
    run_process();

// Exit cleanly.
    exit(EXIT_SUCCESS);
}

So using `program_invocation_short_name` stops me from having a global variable and I don't have to load `libgen.h`. The problem I'm running into is needing to test the number of variables from the command line, but no longer needed any of the `argv` arguments.

I also try to program with a lot of gcc flags to make my programming better. But the `-Wfatal-errors` flag won't allow unused variables. If I don't use `basename(argv[0])` to get the program name, the compiler complains that `argv` is unused. If I try to remove just the `argv` declaration from the main function, then gcc complains with a lie to me:

Code:

dea_template.c:28:5: error: ‘main’ takes only zero or two arguments [-Werror=mai
   28 | int main (int argc)
      |     ^~~~
compilation terminated due to -Wfatal-errors.
cc1: all warnings being treated as errors

I say that what gcc reports is a lie, because the following generates zero errors:

Code:

int main(int argc, char * argv[], char *envp[])

So is there a way to stop the compiler from complaining without removing the `-Wfatal-errors` flag or by adding:

Code:

if(argv[0])
    {;}

? My ultimate goal is to try to make my `tests` into a macro to reduce the clutter of my programs.

How about

Code:

strcpy(program_name, argc ? basename(argv[0]) : "");

If you want to ignore a parameter:

Code:

#include <stdio.h>
 
int main(int argc, char **argv) {
    (void)argv;
    printf("%d\n", argc);
    return 0;
}

Or perhaps:

Code:

#include <stdio.h>
 
#define UNUSED(x) (void)(x)
 
int main(int argc, char **argv) {
    UNUSED(argv);
    printf("%d\n", argc);
    return 0;
}

Originally Posted by Yonut

But the `-Wfatal-errors` flag won't allow unused variables.

Not quite: -Wfatal-errors "causes the compiler to abort compilation on the first error occurred rather than trying to keep going and printing further error messages". What you're thinking of is -Wunused-parameter, which you probably enabled by using -Wextra with -Wall.

Originally Posted by Yonut

I recently learned about some gcc variables, namely `program_invocation_short_name` which give the basename of the called program, and `__func__` which gives the name of the called function.

__func__ is part of the C standard, so you can freely use it in portable code.

Incidentally, if you intend to use compiler-specific stuff, then there's another option for declaring that a variable is meant to be possibly unused:

Code:

int main(int argc, char *argv[] __attribute__((unused)))

This is good because it explicitly documents the parameter as unused, but if you're trying to write portable code then john.c's suggestion of using void is better: the macro version might be overkill especially if only used once; a comment will do in case someone hasn't seen this method of suppressing a possible compile warning/error.

Originally Posted by Hodor

On a tangent and just out of interest, given:

Code:

int main (int argc, char *argv[])

{
// Get program name for error reporting.

    strcpy(program_name, basename(argv[0]));

What happens if argc == 0 (and argv[0] is therefore NULL; i.e. is it ok to pass NULL as the src pointer for strcpy)?

I'd say that the behaviour is undefined, and it would likely happen with the call to basename first rather than to strcpy.

Originally Posted by Hodor

On a tangent and just out of interest, given:

Code:

int main (int argc, char *argv[])

{
// Get program name for error reporting.

    strcpy(program_name, basename(argv[0]));

What happens if argc == 0 (and argv[0] is therefore NULL; i.e. is it ok to pass NULL as the src pointer for strcpy)?

I have no idea how to invoke a program without using it's filename. It's my understanding that argv[0], when declared in the main function header, will always contain the program filename.

Originally Posted by Yonut

I have no idea how to invoke a program without using it's filename. It's my understanding that argv[0], when declared in the main function header, will always contain the program filename.

I concede that if you run the program on a modern desktop OS then, yes, it's very unlikely that argc will be 0, but the C standard allows for it to be 0 (and if it's 0 then argv[0] will be NULL). That said I think it's worth remembering that it might be 0

Edit: I don't have a copy of the C standard handy but I think (only think, I'm not 100% positive) that even if argc is > 0 argv[0] can be an empty string (not NULL as the case is when argc == 0, but "\0") if the program name is for whatever reason not available... but an empty string is much less likely to cause issues compared to it being NULL and assuming that it's not

Page 13 of N1570 says

If the value of argc is greater than zero, the string pointed to by argv[0]
represents the program name; argv[0][0] shall be the null character if the
program name is not available from the host environment.