Skeleton for a command-line program that takes files in C

Question

First. If this question is not allowed, I am sorry. Please, tell me so, and I will try to delete this. If it is, I will delete this paragraph.

Personal-ish note/Motivation

I was studying assembly because of Tanenbaum and C, and decided to make a "graduation" project from the book: a C compiler for AVR and x86 ISAs, using the C standard with no external source on compilers! For fun, or suffering... and to make my first C "project", not only scripts. So, I wrote a skeleton program that takes files and options ("switches"). So, the file can really grow to any place.

It also means it haunts me at night, with so many design decisions, like enum for errors and so many static functions; besides features ideas... I always think something is wrong and there will be pain in growing the project, because it will be unreadable, consequentially buggy.

Explanation

Like GCC, any input argument that is not an option is a file name. Unlike GCC, it calls options switches, because Windows does it, and I am using Windows. This is all. It is mostly a skeleton for a program that takes files from the user.

/*
 * This file contains the entry function (main) for the SSGCompiler.
 * The SSGCompiler is a compiler done as a challenge from the author
 * to the author. More information may be found on the GitHub
 * repository [REDACTED].
 *
 * This was originally written at 05/06/2023.
 */

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

#define EXECUTABLE_NAME "ssgcompiler"
#define SWITCH_PREFIX '/'

enum error {
    FATAL_ERROR,
    NOT_FATAL_ERROR
};

/* Prints the preamble of an error appended with a message. */
static void print_error_message(enum error err, const char *msg)
{
        fputs(EXECUTABLE_NAME, stdout);

        if (err == FATAL_ERROR)
                fputs(". Fatal error: ", stdout);
        else
                fputs(". Error: ", stdout);

        fputs(msg, stdout);
}

/* Returns whether the switch is a help switch */
static bool switch_is_help(const char *opt)
{
        if (    !strcmp(opt, "/?")      ||  !strcmp(opt, "--help")
            ||  !strcmp(opt, "-help")   ||  !strcmp(opt, "--h")
            ||  !strcmp(opt, "-h")      ||  !strcmp(opt, "help")) {
                return true;
        }

        return false;
}

/* Returns whether the argument array has the help switch. */
static bool args_contain_help_switch(const char **argv, const int argLen)
{
        for (int i = 0; i < argLen; i++) {
                if (switch_is_help(argv[i]))
                        return true;
        }

        return false;
}

int main(const int argc, const char **argv)
{
        if (argc < 2) {
                print_error_message(FATAL_ERROR, "no input files.\n");
                printf("See '" EXECUTABLE_NAME " /?' for help.\n");
                return 1;
        }

        if (args_contain_help_switch(argv, argc)) {
                fputs(  "Usage: ssgcompiler [switches] file...\n"
                        "Switches:\n"
                        "       /? Displays this help message (also --help, "
                        "-help, --h, -h, help)\n", stdout);

                return 0;
        }

        for (size_t i = 1; i < argc; i++) {
                if (!strlen(argv[i]) || argv[i][0] != SWITCH_PREFIX)
                        continue;
            
                print_error_message(NOT_FATAL_ERROR, "Unrecognized switch: ");
                printf("'%s'.\n", argv[i] + 1);
        }

        return 1;
}

Answer 1

Use getopt_long() to parse the command line

Parsing a command line quickly becomes more complex if you want to allow a combination of regular arguments (like filenames), and switches with and without extra arguments. You want your program to parse options the same way as other programs do, as this will less likely confuse your users.

On any UNIX-like operating system, the de-facto standard is to use GNU's getopt_long(). On Windows, I would try to find a drop-in replacement library for it. While it does not conform with how Microsoft's programs work, it's not uncommon on Windows to have programs use the UNIX style of command line flags, and it is better if your program behaves the same way on all operating systems.

Print warnings and error messages to stderr

Standard output is for the regular, expected output of your program. Use stderr when printing warnings and error messages. The benefit is that they stay visible even if the user redirected the standard output of your program to a file or to another program.

Note that if the user passed the --help flag, print that help message to stdout; it was after all explicitly requested by the user so it is expected, and then they can easily pipe long help messages through a pager like less.

Don't hardcode the name of the program

You don't have to hardcode the name of the program; it's actually passed to the program in argv[0]. So you'd typically write something like:

int main(const int argc, const char **argv)
{
    …
    fprintf(stderr, "See '%s --help' for help.\n", argv[0]);
    …
}

If the program was called using an explicit path, like ./ssgcompiler ..., then this will also end up in the help message:

See './ssgcompiler --help' for help.

This way it's even a valid command the user can copy&paste.

Make help discoverable

In case the user did not provide any arguments, you print an error message and a helpful line that says how to get more help. That's great! However, you should do this consistently. For example, also if an unrecognized switch was passed. Also consider the case where switches were passed but no filenames: argc will be >= 2 in that case, so your check at the beginning of the program is not correct.

Answer 2

Not much to add after @G. Sliepen.

Avoid manual formatting

Save time. Avoid manual formatting and use the auto formatting available via various tool chains.

Why check program name?

In args_contain_help_switch(const char **argv, const int argLen), code unnecessarily checks argv[0].

    // for (int i = 0; i < argLen; i++) {
    for (int i = 1; i < argLen; i++) {

Non-standard main() signature

main() is a special function - it has specifications that differ from other functions. For maximum portability, avoid any non-standard aspects with main() unless you have a compelling reason. I recommend using the form from the C spec. At least it is easier to review your code.

// int main(const int argc, const char **argv)
int main(int argc, char *argv[])  // C17dr § 5.1.2.2.1 1

Main allows changing the strings pointed to by argv[i], so using const in const char ** is not needed.

Minor: Avoid mixing sign-ness

argc is an int. Iterate likewise:

    // for (size_t i = 1; i < argc; i++) {
    for (int i = 1; i < argc; i++) {