trunk/srcproc/srcstats.c

/*
 * srcstats.c -- Source code statistics generator
 *
 * This file is part of OSN Commons.
 * Copyright (C) 2024  OSN Developers.
 *
 * OSN Commons is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * OSN Commons is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OSN Commons.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <getopt.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>

#ifdef HAVE_CONFIG_H
#    include "config.h"
#endif

#define PROG_CANONICAL_NAME "srcstats"
#define PROG_AUTHORS "Ar Rakin <[email protected]>"

/* TODO: Add support for more file types, and
   output statistics separately for each file type. */

static const char *prog_name = NULL;

static struct option const long_options[] = {
    { "help",    no_argument, 0, 'h' },
    { "version", no_argument, 0, 'v' },
    { 0,         0,           0, 0   }
};

static const char *short_options = "hv";

struct codebase_scan_state
{
    char *filename;
    char *directory;
    char *extension;
    char *shebang_prog;
    struct codebase_report *report;
};

struct codebase_report
{
    unsigned long int files;
    unsigned long int ignored;
    unsigned long int directories;
    unsigned long int lines;
    unsigned long int blank_lines;
    unsigned long int comment_lines;
    unsigned long int code_lines;
    char *directory;
};

static void codebase_report_analyze_c (struct codebase_scan_state *state,
                                       FILE *file);
static void codebase_report_analyze_sh (struct codebase_scan_state *state,
                                        FILE *file);

struct codebase_file_handler
{
    void (*handler) (struct codebase_scan_state *, FILE *);
    const char **extensions;
    const char **filenames;
    const char **shebangs;
};

/* clang-format off */
static struct codebase_file_handler codebase_file_handlers[] = {
    { 
        .handler = &codebase_report_analyze_c,  
        .extensions = (const char *[]) { 
            "c", 
            "h", 
            "cpp", 
            "hpp", 
            "cc", 
            "hh", 
            "cxx",
            "hxx", 
            "ts", 
            "js",
            "java",
            NULL 
        },
        .filenames = NULL,
        .shebangs = NULL
    },
    { 
        .handler = &codebase_report_analyze_sh,
        .extensions = (const char *[]) { 
            "sh", 
            "bash", 
            "conf", 
            "fish", 
            "csh", 
            "zsh",
            "am",
            "ac",
            NULL
        },
        .filenames = (const char *[]) { 
            "Makefile",
            "Dockerfile",
            NULL
        },
       .shebangs = (const char *[]) { 
            "sh", 
            "bash", 
            "fish", 
            "zsh",
            "csh",
            NULL
        } 
    },
};
/* clang-format on */

static void
report_error (const char *format, ...)
{
    va_list args;
    va_start (args, format);
    fprintf (stderr, "%s: ", prog_name);
    vfprintf (stderr, format, args);
    fprintf (stderr, ": %s", strerror (errno));
    va_end (args);
    fputc ('\n', stderr);
}

static void *
xrealloc (void *ptr, size_t size)
{
    void *new_ptr = realloc (ptr, size);

    if (new_ptr == NULL)
        {
            report_error ("xrealloc(): failed to reallocate memory");
            exit (EXIT_FAILURE);
        }

    return new_ptr;
}

static char *
path_join (const char *p1, const char *p2, size_t *len)
{
    char *path = NULL;
    size_t length = 0;
    size_t index = 0;

    while (p1[index] != 0)
        {
            length++;
            path = xrealloc (path, length);
            path[index] = p1[index];
            index++;
        }

    path = xrealloc (path, length + 1);
    path[length++] = '/';

    index = 0;

    while (p2[index] != 0)
        {
            length++;
            path = xrealloc (path, length);
            path[length - 1] = p2[index];
            index++;
        }

    path = xrealloc (path, length + 1);
    path[length] = 0;

    if (len)
        *len = length;

    return path;
}

static void
codebase_report_analyze_c (struct codebase_scan_state *state, FILE *file)
{
    char *line = NULL;
    size_t len = 0;
    ssize_t read;
    bool in_comment = false;
    struct codebase_report *report = state->report;

    while ((read = getline (&line, &len, file)) != -1)
        {
            bool comment_line_incremented = false;
            ssize_t i = 0;

            report->lines++;

            if (in_comment)
                {
                    while (i < read)
                        {
                            if (i + 1 < read
                                && (line[i] == '*' && line[i + 1] == '/'))
                                {
                                    in_comment = false;
                                    i += 2;
                                    break;
                                }

                            i++;
                        }

                    report->comment_lines++;
                    comment_line_incremented = true;

                    if (i == read)
                        continue;
                }

            while (i < read && isspace (line[i]))
                i++;

            if (i == read)
                {
                    report->blank_lines++;
                    continue;
                }

            if (i + 1 < read
                && (line[i] == '\'' || line[i] == '"'
                    || ((strcmp (state->extension, "ts") == 0
                         || strcmp (state->extension, "js") == 0)
                        && line[i] == '`')))
                {
                    char quote = line[i];

                    while (i < read)
                        {
                            if (line[i] == '\\')
                                i++;

                            if (i < read && line[i] == quote)
                                {
                                    quote = 0;
                                    break;
                                }

                            if (i < read)
                                i++;
                        }

                    if (quote == '`')
                        {
                            while ((read = getline (&line, &len, file)) != -1)
                                {
                                    report->lines++;

                                    if (line[0] == quote)
                                        break;

                                    report->code_lines++;
                                }

                            continue;
                        }

                    if (i == read)
                        {
                            report->code_lines++;
                            continue;
                        }
                }

            if (i + 1 < read && line[i] == '/' && line[i + 1] == '/')
                {
                    if (!comment_line_incremented)
                        report->comment_lines++;

                    comment_line_incremented = true;
                    continue;
                }

            if (i + 1 < read && line[i] == '/' && line[i + 1] == '*')
                {
                    in_comment = true;

                    if (!comment_line_incremented)
                        report->comment_lines++;

                    comment_line_incremented = true;

                    while (i < read)
                        {
                            if (i + 1 < read
                                && (line[i] == '*' && line[i + 1] == '/'))
                                {
                                    in_comment = false;
                                    i += 2;
                                    break;
                                }

                            i++;
                        }
                }

            while (i < read && isspace (line[i]))
                i++;

            if (!in_comment && i < read)
                report->code_lines++;
        }

    free (line);
}

static void
codebase_report_analyze_sh (struct codebase_scan_state *state, FILE *file)
{
    char *line = NULL;
    size_t len = 0;
    ssize_t read;
    struct codebase_report *report = state->report;

    while ((read = getline (&line, &len, file)) != -1)
        {
            ssize_t i = 0;

            report->lines++;

            while (i < read && isspace (line[i]))
                i++;

            if (i == read)
                {
                    report->blank_lines++;
                    continue;
                }

            if (i + 1 < read && line[i] == '#')
                {
                    if (i + 2 >= read || line[i + 1] != '!')
                        report->comment_lines++;

                    continue;
                }

            if (i + 2 < read && line[i] == '<' && line[i + 1] == '<')
                {
                    char *token = NULL;
                    size_t token_len = 0;

                    while (i < read && isspace (line[i]))
                        i++;

                    while (i < read && !isspace (line[i]))
                        {
                            token = xrealloc (token, ++token_len);
                            token[token_len - 1] = line[i];
                            i++;
                        }

                    token = xrealloc (token, ++token_len);
                    token[token_len - 1] = 0;

                    while ((read = getline (&line, &len, file)) != -1)
                        {
                            report->lines++;

                            if (strcmp (line, token) == 0)
                                break;

                            report->code_lines++;
                        }

                    free (token);
                    continue;
                }

            if (i + 1 < read && (line[i] == '\'' || line[i + 1] == '"'))
                {
                    char quote = line[i];

                    while (i < read)
                        {
                            if (line[i] == '\\')
                                i++;

                            if (i < read && line[i] == quote)
                                {
                                    quote = 0;
                                    break;
                                }

                            if (i < read)
                                i++;
                        }

                    if (quote != 0)
                        {
                            while ((read = getline (&line, &len, file)) != -1)
                                {
                                    report->lines++;

                                    if (line[0] == quote)
                                        break;

                                    report->code_lines++;
                                }

                            continue;
                        }

                    if (i == read)
                        {
                            report->code_lines++;
                            continue;
                        }
                }

            while (i < read && isspace (line[i]))
                i++;

            if (i < read)
                report->code_lines++;
        }

    free (line);
}

static void
codebase_scan_state_free (struct codebase_scan_state *state)
{
    free (state->directory);
    free (state->extension);
    free (state->filename);
    free (state->shebang_prog);
}

static char *
get_file_shebang (FILE *file)
{
    char *line = NULL, *ret = NULL;
    size_t len = 0;
    ssize_t read;
    long pos = ftell (file);

    while ((read = getline (&line, &len, file)) != -1)
        {
            ssize_t index = 0;

            while (index < read && (line[index] == ' ' || line[index] == '\t'))
                index++;

            if (index + 2 >= read)
                continue;

            if (line[index] == '#' && line[index + 1] == '!')
                ret = strndup (line + 2, strlen (line + 2) - 1);

            break;
        }

    fseek (file, pos, SEEK_SET);
    free (line);
    return ret;
}

static void
codebase_report_analyze_file (struct codebase_report *report, const char *path,
                              FILE *file)
{
    const char *extension = strrchr (path, '.');
    const char *filename = strrchr (path, '/');

    extension = extension == NULL ? NULL : extension + 1;
    filename = filename == NULL ? path : filename + 1;

    for (size_t i = 0; i < sizeof (codebase_file_handlers)
                               / sizeof (codebase_file_handlers[0]);
         i++)
        {
            struct codebase_scan_state state = {
                .filename = strdup (filename),
                .directory = strdup (report->directory),
                .extension = NULL,
                .shebang_prog = NULL,
                .report = report,
            };

            if (codebase_file_handlers[i].extensions != NULL)
                {
                    for (size_t j = 0;
                         codebase_file_handlers[i].extensions[j] != NULL; j++)
                        {
                            if (extension != NULL
                                && strcmp (
                                       extension,
                                       codebase_file_handlers[i].extensions[j])
                                       == 0)
                                {
                                    state.extension = strdup (extension);
                                    codebase_file_handlers[i].handler (&state,
                                                                       file);
                                    codebase_scan_state_free (&state);
                                    report->files++;
                                    return;
                                }
                        }
                }

            if (codebase_file_handlers[i].filenames != NULL)
                {
                    for (size_t j = 0;
                         codebase_file_handlers[i].filenames[j] != NULL; j++)
                        {
                            if (strcmp (filename,
                                        codebase_file_handlers[i].filenames[j])
                                == 0)
                                {
                                    codebase_file_handlers[i].handler (&state,
                                                                       file);
                                    codebase_scan_state_free (&state);
                                    report->files++;
                                    return;
                                }
                        }
                }

            char *shebang = get_file_shebang (file);

            if (shebang == NULL || codebase_file_handlers[i].shebangs == NULL)
                {
                    free (shebang);
                    free (state.filename);
                    free (state.directory);
                    continue;
                }

            for (size_t j = 0; codebase_file_handlers[i].shebangs[j] != NULL;
                 j++)
                {
                    const char *prog = codebase_file_handlers[i].shebangs[j];
                    const char *shebang_ptr = shebang;

                    if (strncmp (shebang_ptr, "/usr/bin/", 9) == 0)
                        shebang_ptr += 9;
                    else if (strncmp (shebang_ptr, "/bin/", 5) == 0)
                        shebang_ptr += 5;
                    else if (strncmp (shebang_ptr, "/usr/bin/env ", 14) == 0)
                        {
                            shebang_ptr += 14;

                            while (*shebang_ptr == ' ' || *shebang_ptr == '\t')
                                shebang_ptr++;
                        }

                    if (strcmp (prog, shebang_ptr) == 0)
                        {
                            state.extension = strdup (prog);
                            codebase_file_handlers[i].handler (&state, file);
                            codebase_scan_state_free (&state);
                            free (shebang);
                            report->files++;
                            return;
                        }
                }

            free (shebang);
            free (state.filename);
            free (state.directory);
        }

    report->ignored++;
}

static void
codebase_report_free (struct codebase_report *report)
{
    free ((void *) report->directory);
}

static bool
codebase_report_scan (struct codebase_report *report, const char *directory)
{
    DIR *dirstream = opendir (directory);
    struct dirent *entry;
    char **entries = NULL;
    size_t entries_size = 0;

    if (dirstream == NULL)
        {
            report_error ("failed to open directory `%s'", directory);
            return false;
        }

    report->directories++;

    while ((entry = readdir (dirstream)) != NULL)
        {
            if (strcmp (entry->d_name, ".") == 0
                || strcmp (entry->d_name, "..") == 0)
                continue;

            entries = xrealloc (entries, (++entries_size) * sizeof (char *));
            entries[entries_size - 1] = strdup (entry->d_name);
        }

    entries = xrealloc (entries, (++entries_size) * sizeof (char *));
    entries[entries_size - 1] = NULL;
    closedir (dirstream);

    for (size_t i = 0; i < entries_size - 1; i++)
        {
            size_t path_len = 0;
            char *path = path_join (directory, entries[i], &path_len);
            struct stat st;

            if (lstat (path, &st) == -1)
                {
                    report_error ("failed to stat `%s'", path);
                    continue;
                }

            if (S_ISDIR (st.st_mode))
                {
                    codebase_report_scan (report, path);
                }
            else if (S_ISREG (st.st_mode))
                {
                    FILE *file = fopen (path, "r");

                    if (file == NULL)
                        {
                            report_error ("failed to open file `%s'", path);
                            continue;
                        }

                    codebase_report_analyze_file (report, path, file);
                    fclose (file);
                }

            free (path);
        }

    for (size_t i = 0; i < entries_size - 1; i++)
        free (entries[i]);

    free (entries);
    return true;
}

static bool
codebase_report_scan_r (struct codebase_report *report, const char *directory)
{
    report->directory = strdup (directory);
    return codebase_report_scan (report, directory);
}

static void
codebase_report_print (const struct codebase_report *report)
{
    const int widths[] = { 13, 14, 11, 14, 12, 13, 14 };
    const unsigned long int values[]
        = { report->files,     report->ignored,     report->directories,
            report->lines,     report->blank_lines, report->comment_lines,
            report->code_lines };

    printf ("\033[2m** Report for `%s':\033[0m\n", report->directory);

    /* clang-format off */
    printf ("+---------------+----------------+-------------+----------------+--------------+---------------+----------------+\n");
    printf ("| \033[1mFiles\033[0m         | \033[1mIgnored Files\033[0m  | \033[1mDirectories\033[0m | \033[1mLines\033[0m          | \033[1mBlank Lines\033[0m  | \033[1mComment Lines\033[0m | \033[1mCode Lines\033[0m     |\n");
    printf ("+---------------+----------------+-------------+----------------+--------------+---------------+----------------+\n|");
    /* clang-format on */

    for (size_t i = 0; i < sizeof (values) / sizeof (values[0]); i++)
        {
            const int width = widths[i];
            const long unsigned int value = values[i];
            printf (" \033[1;%sm%-*lu\033[0m |",
                    i < 3    ? "1"
                    : i == 3 ? "34"
                    : i == 4 ? "2"
                    : i == 5 ? "2"
                    : i == 6 ? "32"
                             : "1",
                    width, value);
        }

    /* clang-format off */
    printf ("\n+---------------+----------------+-------------+----------------+--------------+---------------+----------------+\n");
    /* clang-format on */
}

[[noreturn]]
static void
usage (bool error)
{
    FILE *stream = error ? stderr : stdout;
    fprintf (stream, "Usage: %s [OPTION]... <DIRECTORY>...\n", prog_name);
    fputs ("Show statistics for the given codebase.\n", stream);
    fputc ('\n', stream);
    fputs ("  -h, --help      Display this help and exit\n", stream);
    fputs ("  -v, --version   Output version information and exit\n", stream);
    fputc ('\n', stream);
    fputs ("Bug reports and feedback should be sent to \n<" PACKAGE_BUGREPORT
           ">.\n",
           stream);
    exit (error ? EXIT_FAILURE : EXIT_SUCCESS);
}

static void
show_version (void)
{
    printf (PROG_CANONICAL_NAME " (" PACKAGE_FULLNAME ") v" PACKAGE_VERSION
                                "\n");
    fputc ('\n', stdout);
    printf ("License GPLv3+: GNU GPL version 3 or later "
            "<http://gnu.org/licenses/gpl.html>.\n");
    printf (
        "This is free software: you are free to change and redistribute it.\n");
    printf ("There is NO WARRANTY, to the extent permitted by law.\n");
    fputc ('\n', stdout);
    printf ("Written by " PROG_AUTHORS ".\n");
}

[[noreturn]]
static void
invalid_usage (const char *msg)
{
    fprintf (stderr, "%s: %s\n", prog_name, msg);
    fprintf (stderr, "Try `%s --help' for more information.\n", prog_name);
    exit (EXIT_FAILURE);
}

int
main (int argc, char **argv)
{
    prog_name = argv[0];
    int opt;

    while ((opt = getopt_long (argc, argv, short_options, long_options, NULL))
           != -1)
        {
            switch (opt)
                {
                case 'h':
                    usage (false);
                case 'v':
                    show_version ();
                    exit (EXIT_SUCCESS);
                case '?':
                    fprintf (stderr, "Try `%s --help' for more information.\n",
                             prog_name);
                    exit (EXIT_FAILURE);
                default:
                    abort ();
                }
        }

    if (optind == argc)
        invalid_usage ("missing directory operand");

    bool success = false;

    for (int i = optind; i < argc; i++)
        {
            struct codebase_report report = { 0 };

            if (!codebase_report_scan_r (&report, argv[i]))
                {
                    continue;
                }

            codebase_report_print (&report);
            codebase_report_free (&report);
            success = true;
        }

    return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
1	/*
2	* srcstats.c -- Source code statistics generator
3	*
4	* This file is part of OSN Commons.
5	* Copyright (C) 2024 OSN Developers.
6	*
7	* OSN Commons is free software: you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License as published by
9	* the Free Software Foundation, either version 3 of the License, or
10	* any later version.
11	*
12	* OSN Commons is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with OSN Commons. If not, see <http://www.gnu.org/licenses/>.
19	*/
20
21	#include <ctype.h>
22	#include <dirent.h>
23	#include <errno.h>
24	#include <getopt.h>
25	#include <pthread.h>
26	#include <stdarg.h>
27	#include <stdbool.h>
28	#include <stdio.h>
29	#include <stdlib.h>
30	#include <string.h>
31	#include <sys/stat.h>
32	#include <sys/types.h>
33
34	#ifdef HAVE_CONFIG_H
35	# include "config.h"
36	#endif
37
38	#define PROG_CANONICAL_NAME "srcstats"
39	#define PROG_AUTHORS "Ar Rakin <[email protected]>"
40
41	/* TODO: Add support for more file types, and
42	output statistics separately for each file type. */
43
44	static const char *prog_name = NULL;
45
46	static struct option const long_options[] = {
47	{ "help", no_argument, 0, 'h' },
48	{ "version", no_argument, 0, 'v' },
49	{ 0, 0, 0, 0 }
50	};
51
52	static const char *short_options = "hv";
53
54	struct codebase_scan_state
55	{
56	char *filename;
57	char *directory;
58	char *extension;
59	char *shebang_prog;
60	struct codebase_report *report;
61	};
62
63	struct codebase_report
64	{
65	unsigned long int files;
66	unsigned long int ignored;
67	unsigned long int directories;
68	unsigned long int lines;
69	unsigned long int blank_lines;
70	unsigned long int comment_lines;
71	unsigned long int code_lines;
72	char *directory;
73	};
74
75	static void codebase_report_analyze_c (struct codebase_scan_state *state,
76	FILE *file);
77	static void codebase_report_analyze_sh (struct codebase_scan_state *state,
78	FILE *file);
79
80	struct codebase_file_handler
81	{
82	void (handler) (struct codebase_scan_state , FILE *);
83	const char **extensions;
84	const char **filenames;
85	const char **shebangs;
86	};
87
88	/* clang-format off */
89	static struct codebase_file_handler codebase_file_handlers[] = {
90	{
91	.handler = &codebase_report_analyze_c,
92	.extensions = (const char *[]) {
93	"c",
94	"h",
95	"cpp",
96	"hpp",
97	"cc",
98	"hh",
99	"cxx",
100	"hxx",
101	"ts",
102	"js",
103	"java",
104	NULL
105	},
106	.filenames = NULL,
107	.shebangs = NULL
108	},
109	{
110	.handler = &codebase_report_analyze_sh,
111	.extensions = (const char *[]) {
112	"sh",
113	"bash",
114	"conf",
115	"fish",
116	"csh",
117	"zsh",
118	"am",
119	"ac",
120	NULL
121	},
122	.filenames = (const char *[]) {
123	"Makefile",
124	"Dockerfile",
125	NULL
126	},
127	.shebangs = (const char *[]) {
128	"sh",
129	"bash",
130	"fish",
131	"zsh",
132	"csh",
133	NULL
134	}
135	},
136	};
137	/* clang-format on */
138
139	static void
140	report_error (const char *format, ...)
141	{
142	va_list args;
143	va_start (args, format);
144	fprintf (stderr, "%s: ", prog_name);
145	vfprintf (stderr, format, args);
146	fprintf (stderr, ": %s", strerror (errno));
147	va_end (args);
148	fputc ('\n', stderr);
149	}
150
151	static void *
152	xrealloc (void *ptr, size_t size)
153	{
154	void *new_ptr = realloc (ptr, size);
155
156	if (new_ptr == NULL)
157	{
158	report_error ("xrealloc(): failed to reallocate memory");
159	exit (EXIT_FAILURE);
160	}
161
162	return new_ptr;
163	}
164
165	static char *
166	path_join (const char p1, const char p2, size_t *len)
167	{
168	char *path = NULL;
169	size_t length = 0;
170	size_t index = 0;
171
172	while (p1[index] != 0)
173	{
174	length++;
175	path = xrealloc (path, length);
176	path[index] = p1[index];
177	index++;
178	}
179
180	path = xrealloc (path, length + 1);
181	path[length++] = '/';
182
183	index = 0;
184
185	while (p2[index] != 0)
186	{
187	length++;
188	path = xrealloc (path, length);
189	path[length - 1] = p2[index];
190	index++;
191	}
192
193	path = xrealloc (path, length + 1);
194	path[length] = 0;
195
196	if (len)
197	*len = length;
198
199	return path;
200	}
201
202	static void
203	codebase_report_analyze_c (struct codebase_scan_state state, FILE file)
204	{
205	char *line = NULL;
206	size_t len = 0;
207	ssize_t read;
208	bool in_comment = false;
209	struct codebase_report *report = state->report;
210
211	while ((read = getline (&line, &len, file)) != -1)
212	{
213	bool comment_line_incremented = false;
214	ssize_t i = 0;
215
216	report->lines++;
217
218	if (in_comment)
219	{
220	while (i < read)
221	{
222	if (i + 1 < read
223	&& (line[i] == '*' && line[i + 1] == '/'))
224	{
225	in_comment = false;
226	i += 2;
227	break;
228	}
229
230	i++;
231	}
232
233	report->comment_lines++;
234	comment_line_incremented = true;
235
236	if (i == read)
237	continue;
238	}
239
240	while (i < read && isspace (line[i]))
241	i++;
242
243	if (i == read)
244	{
245	report->blank_lines++;
246	continue;
247	}
248
249	if (i + 1 < read
250	&& (line[i] == '\'' \|\| line[i] == '"'
251	\|\| ((strcmp (state->extension, "ts") == 0
252	\|\| strcmp (state->extension, "js") == 0)
253	&& line[i] == '`')))
254	{
255	char quote = line[i];
256
257	while (i < read)
258	{
259	if (line[i] == '\\')
260	i++;
261
262	if (i < read && line[i] == quote)
263	{
264	quote = 0;
265	break;
266	}
267
268	if (i < read)
269	i++;
270	}
271
272	if (quote == '`')
273	{
274	while ((read = getline (&line, &len, file)) != -1)
275	{
276	report->lines++;
277
278	if (line[0] == quote)
279	break;
280
281	report->code_lines++;
282	}
283
284	continue;
285	}
286
287	if (i == read)
288	{
289	report->code_lines++;
290	continue;
291	}
292	}
293
294	if (i + 1 < read && line[i] == '/' && line[i + 1] == '/')
295	{
296	if (!comment_line_incremented)
297	report->comment_lines++;
298
299	comment_line_incremented = true;
300	continue;
301	}
302
303	if (i + 1 < read && line[i] == '/' && line[i + 1] == '*')
304	{
305	in_comment = true;
306
307	if (!comment_line_incremented)
308	report->comment_lines++;
309
310	comment_line_incremented = true;
311
312	while (i < read)
313	{
314	if (i + 1 < read
315	&& (line[i] == '*' && line[i + 1] == '/'))
316	{
317	in_comment = false;
318	i += 2;
319	break;
320	}
321
322	i++;
323	}
324	}
325
326	while (i < read && isspace (line[i]))
327	i++;
328
329	if (!in_comment && i < read)
330	report->code_lines++;
331	}
332
333	free (line);
334	}
335
336	static void
337	codebase_report_analyze_sh (struct codebase_scan_state state, FILE file)
338	{
339	char *line = NULL;
340	size_t len = 0;
341	ssize_t read;
342	struct codebase_report *report = state->report;
343
344	while ((read = getline (&line, &len, file)) != -1)
345	{
346	ssize_t i = 0;
347
348	report->lines++;
349
350	while (i < read && isspace (line[i]))
351	i++;
352
353	if (i == read)
354	{
355	report->blank_lines++;
356	continue;
357	}
358
359	if (i + 1 < read && line[i] == '#')
360	{
361	if (i + 2 >= read \|\| line[i + 1] != '!')
362	report->comment_lines++;
363
364	continue;
365	}
366
367	if (i + 2 < read && line[i] == '<' && line[i + 1] == '<')
368	{
369	char *token = NULL;
370	size_t token_len = 0;
371
372	while (i < read && isspace (line[i]))
373	i++;
374
375	while (i < read && !isspace (line[i]))
376	{
377	token = xrealloc (token, ++token_len);
378	token[token_len - 1] = line[i];
379	i++;
380	}
381
382	token = xrealloc (token, ++token_len);
383	token[token_len - 1] = 0;
384
385	while ((read = getline (&line, &len, file)) != -1)
386	{
387	report->lines++;
388
389	if (strcmp (line, token) == 0)
390	break;
391
392	report->code_lines++;
393	}
394
395	free (token);
396	continue;
397	}
398
399	if (i + 1 < read && (line[i] == '\'' \|\| line[i + 1] == '"'))
400	{
401	char quote = line[i];
402
403	while (i < read)
404	{
405	if (line[i] == '\\')
406	i++;
407
408	if (i < read && line[i] == quote)
409	{
410	quote = 0;
411	break;
412	}
413
414	if (i < read)
415	i++;
416	}
417
418	if (quote != 0)
419	{
420	while ((read = getline (&line, &len, file)) != -1)
421	{
422	report->lines++;
423
424	if (line[0] == quote)
425	break;
426
427	report->code_lines++;
428	}
429
430	continue;
431	}
432
433	if (i == read)
434	{
435	report->code_lines++;
436	continue;
437	}
438	}
439
440	while (i < read && isspace (line[i]))
441	i++;
442
443	if (i < read)
444	report->code_lines++;
445	}
446
447	free (line);
448	}
449
450	static void
451	codebase_scan_state_free (struct codebase_scan_state *state)
452	{
453	free (state->directory);
454	free (state->extension);
455	free (state->filename);
456	free (state->shebang_prog);
457	}
458
459	static char *
460	get_file_shebang (FILE *file)
461	{
462	char line = NULL, ret = NULL;
463	size_t len = 0;
464	ssize_t read;
465	long pos = ftell (file);
466
467	while ((read = getline (&line, &len, file)) != -1)
468	{
469	ssize_t index = 0;
470
471	while (index < read && (line[index] == ' ' \|\| line[index] == '\t'))
472	index++;
473
474	if (index + 2 >= read)
475	continue;
476
477	if (line[index] == '#' && line[index + 1] == '!')
478	ret = strndup (line + 2, strlen (line + 2) - 1);
479
480	break;
481	}
482
483	fseek (file, pos, SEEK_SET);
484	free (line);
485	return ret;
486	}
487
488	static void
489	codebase_report_analyze_file (struct codebase_report report, const char path,
490	FILE *file)
491	{
492	const char *extension = strrchr (path, '.');
493	const char *filename = strrchr (path, '/');
494
495	extension = extension == NULL ? NULL : extension + 1;
496	filename = filename == NULL ? path : filename + 1;
497
498	for (size_t i = 0; i < sizeof (codebase_file_handlers)
499	/ sizeof (codebase_file_handlers[0]);
500	i++)
501	{
502	struct codebase_scan_state state = {
503	.filename = strdup (filename),
504	.directory = strdup (report->directory),
505	.extension = NULL,
506	.shebang_prog = NULL,
507	.report = report,
508	};
509
510	if (codebase_file_handlers[i].extensions != NULL)
511	{
512	for (size_t j = 0;
513	codebase_file_handlers[i].extensions[j] != NULL; j++)
514	{
515	if (extension != NULL
516	&& strcmp (
517	extension,
518	codebase_file_handlers[i].extensions[j])
519	== 0)
520	{
521	state.extension = strdup (extension);
522	codebase_file_handlers[i].handler (&state,
523	file);
524	codebase_scan_state_free (&state);
525	report->files++;
526	return;
527	}
528	}
529	}
530
531	if (codebase_file_handlers[i].filenames != NULL)
532	{
533	for (size_t j = 0;
534	codebase_file_handlers[i].filenames[j] != NULL; j++)
535	{
536	if (strcmp (filename,
537	codebase_file_handlers[i].filenames[j])
538	== 0)
539	{
540	codebase_file_handlers[i].handler (&state,
541	file);
542	codebase_scan_state_free (&state);
543	report->files++;
544	return;
545	}
546	}
547	}
548
549	char *shebang = get_file_shebang (file);
550
551	if (shebang == NULL \|\| codebase_file_handlers[i].shebangs == NULL)
552	{
553	free (shebang);
554	free (state.filename);
555	free (state.directory);
556	continue;
557	}
558
559	for (size_t j = 0; codebase_file_handlers[i].shebangs[j] != NULL;
560	j++)
561	{
562	const char *prog = codebase_file_handlers[i].shebangs[j];
563	const char *shebang_ptr = shebang;
564
565	if (strncmp (shebang_ptr, "/usr/bin/", 9) == 0)
566	shebang_ptr += 9;
567	else if (strncmp (shebang_ptr, "/bin/", 5) == 0)
568	shebang_ptr += 5;
569	else if (strncmp (shebang_ptr, "/usr/bin/env ", 14) == 0)
570	{
571	shebang_ptr += 14;
572
573	while (shebang_ptr == ' ' \|\| shebang_ptr == '\t')
574	shebang_ptr++;
575	}
576
577	if (strcmp (prog, shebang_ptr) == 0)
578	{
579	state.extension = strdup (prog);
580	codebase_file_handlers[i].handler (&state, file);
581	codebase_scan_state_free (&state);
582	free (shebang);
583	report->files++;
584	return;
585	}
586	}
587
588	free (shebang);
589	free (state.filename);
590	free (state.directory);
591	}
592
593	report->ignored++;
594	}
595
596	static void
597	codebase_report_free (struct codebase_report *report)
598	{
599	free ((void *) report->directory);
600	}
601
602	static bool
603	codebase_report_scan (struct codebase_report report, const char directory)
604	{
605	DIR *dirstream = opendir (directory);
606	struct dirent *entry;
607	char **entries = NULL;
608	size_t entries_size = 0;
609
610	if (dirstream == NULL)
611	{
612	report_error ("failed to open directory `%s'", directory);
613	return false;
614	}
615
616	report->directories++;
617
618	while ((entry = readdir (dirstream)) != NULL)
619	{
620	if (strcmp (entry->d_name, ".") == 0
621	\|\| strcmp (entry->d_name, "..") == 0)
622	continue;
623
624	entries = xrealloc (entries, (++entries_size) * sizeof (char *));
625	entries[entries_size - 1] = strdup (entry->d_name);
626	}
627
628	entries = xrealloc (entries, (++entries_size) * sizeof (char *));
629	entries[entries_size - 1] = NULL;
630	closedir (dirstream);
631
632	for (size_t i = 0; i < entries_size - 1; i++)
633	{
634	size_t path_len = 0;
635	char *path = path_join (directory, entries[i], &path_len);
636	struct stat st;
637
638	if (lstat (path, &st) == -1)
639	{
640	report_error ("failed to stat `%s'", path);
641	continue;
642	}
643
644	if (S_ISDIR (st.st_mode))
645	{
646	codebase_report_scan (report, path);
647	}
648	else if (S_ISREG (st.st_mode))
649	{
650	FILE *file = fopen (path, "r");
651
652	if (file == NULL)
653	{
654	report_error ("failed to open file `%s'", path);
655	continue;
656	}
657
658	codebase_report_analyze_file (report, path, file);
659	fclose (file);
660	}
661
662	free (path);
663	}
664
665	for (size_t i = 0; i < entries_size - 1; i++)
666	free (entries[i]);
667
668	free (entries);
669	return true;
670	}
671
672	static bool
673	codebase_report_scan_r (struct codebase_report report, const char directory)
674	{
675	report->directory = strdup (directory);
676	return codebase_report_scan (report, directory);
677	}
678
679	static void
680	codebase_report_print (const struct codebase_report *report)
681	{
682	const int widths[] = { 13, 14, 11, 14, 12, 13, 14 };
683	const unsigned long int values[]
684	= { report->files, report->ignored, report->directories,
685	report->lines, report->blank_lines, report->comment_lines,
686	report->code_lines };
687
688	printf ("\033[2m** Report for `%s':\033[0m\n", report->directory);
689
690	/* clang-format off */
691	printf ("+---------------+----------------+-------------+----------------+--------------+---------------+----------------+\n");
692	printf ("\| \033[1mFiles\033[0m \| \033[1mIgnored Files\033[0m \| \033[1mDirectories\033[0m \| \033[1mLines\033[0m \| \033[1mBlank Lines\033[0m \| \033[1mComment Lines\033[0m \| \033[1mCode Lines\033[0m \|\n");
693	printf ("+---------------+----------------+-------------+----------------+--------------+---------------+----------------+\n\|");
694	/* clang-format on */
695
696	for (size_t i = 0; i < sizeof (values) / sizeof (values[0]); i++)
697	{
698	const int width = widths[i];
699	const long unsigned int value = values[i];
700	printf (" \033[1;%sm%-*lu\033[0m \|",
701	i < 3 ? "1"
702	: i == 3 ? "34"
703	: i == 4 ? "2"
704	: i == 5 ? "2"
705	: i == 6 ? "32"
706	: "1",
707	width, value);
708	}
709
710	/* clang-format off */
711	printf ("\n+---------------+----------------+-------------+----------------+--------------+---------------+----------------+\n");
712	/* clang-format on */
713	}
714
715	[[noreturn]]
716	static void
717	usage (bool error)
718	{
719	FILE *stream = error ? stderr : stdout;
720	fprintf (stream, "Usage: %s [OPTION]... <DIRECTORY>...\n", prog_name);
721	fputs ("Show statistics for the given codebase.\n", stream);
722	fputc ('\n', stream);
723	fputs (" -h, --help Display this help and exit\n", stream);
724	fputs (" -v, --version Output version information and exit\n", stream);
725	fputc ('\n', stream);
726	fputs ("Bug reports and feedback should be sent to \n<" PACKAGE_BUGREPORT
727	">.\n",
728	stream);
729	exit (error ? EXIT_FAILURE : EXIT_SUCCESS);
730	}
731
732	static void
733	show_version (void)
734	{
735	printf (PROG_CANONICAL_NAME " (" PACKAGE_FULLNAME ") v" PACKAGE_VERSION
736	"\n");
737	fputc ('\n', stdout);
738	printf ("License GPLv3+: GNU GPL version 3 or later "
739	"<http://gnu.org/licenses/gpl.html>.\n");
740	printf (
741	"This is free software: you are free to change and redistribute it.\n");
742	printf ("There is NO WARRANTY, to the extent permitted by law.\n");
743	fputc ('\n', stdout);
744	printf ("Written by " PROG_AUTHORS ".\n");
745	}
746
747	[[noreturn]]
748	static void
749	invalid_usage (const char *msg)
750	{
751	fprintf (stderr, "%s: %s\n", prog_name, msg);
752	fprintf (stderr, "Try `%s --help' for more information.\n", prog_name);
753	exit (EXIT_FAILURE);
754	}
755
756	int
757	main (int argc, char **argv)
758	{
759	prog_name = argv[0];
760	int opt;
761
762	while ((opt = getopt_long (argc, argv, short_options, long_options, NULL))
763	!= -1)
764	{
765	switch (opt)
766	{
767	case 'h':
768	usage (false);
769	case 'v':
770	show_version ();
771	exit (EXIT_SUCCESS);
772	case '?':
773	fprintf (stderr, "Try `%s --help' for more information.\n",
774	prog_name);
775	exit (EXIT_FAILURE);
776	default:
777	abort ();
778	}
779	}
780
781	if (optind == argc)
782	invalid_usage ("missing directory operand");
783
784	bool success = false;
785
786	for (int i = optind; i < argc; i++)
787	{
788	struct codebase_report report = { 0 };
789
790	if (!codebase_report_scan_r (&report, argv[i]))
791	{
792	continue;
793	}
794
795	codebase_report_print (&report);
796	codebase_report_free (&report);
797	success = true;
798	}
799
800	return success ? EXIT_SUCCESS : EXIT_FAILURE;
801	}