/*
 *  Command line utility for making sense of C declarations.
 *  Copyright © 2011 Nick Bowler
 *
 *  This program 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
 *  (at your option) any later version.
 *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <locale.h>
#include <getopt.h>
#include <gettext.h>
#include "readline.h"
#include "cdecl.h"

static const char *progname = "cdecl99";
static const char sopts[] = "qbif:e:VH";
static const struct option lopts[] = {
	{ "quiet",       0, NULL, 'q' },
	{ "batch",       0, NULL, 'b' },
	{ "interactive", 0, NULL, 'i' },
	{ "file",        1, NULL, 'f' },
	{ "execute",     1, NULL, 'e' },
	{ "version",     0, NULL, 'V' },
	{ "help",        0, NULL, 'H' },
	{ 0 }
};

static void print_version(void)
{
	puts(PACKAGE_STRING);
	/* TRANSLATORS: (C) must *always* be translated as ©. */
	printf("Copyright %s 2011 Nick Bowler.\n", gettext("(C)"));
	puts("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.");
	puts("This is free software: you are free to change and redistribute it.");
	puts("There is NO WARRANTY, to the extent permitted by law.");
}

static void print_usage(FILE *f)
{
	fprintf(f, "Usage: %s [options]\n", progname);
}

static void print_help(void)
{
	print_usage(stdout);
	puts("Detailed help coming soon.");
}

/*
 * Format a declaration according to the given function and return a pointer
 * to the formatted string.  The returned pointer remains valid until the
 * next call, after which it must not be re-used.
 *
 * Returns NULL on failure.
 */
static const char *
do_format(size_t func(char *, size_t, struct cdecl *), struct cdecl *decl)
{
	static size_t bufsz;
	static char *buf;

	size_t rc;

retry:
	rc = func(buf, bufsz, decl);
	if (rc >= bufsz) {
		char *tmp;

		tmp = realloc(buf, rc + 1);
		if (!tmp) {
			fprintf(stderr, "failed to allocate memory\n");
			return NULL;
		}

		buf = tmp;
		bufsz = rc + 1;
		goto retry;
	}

	return buf;
}

static int cmd_explain(const char *cmd, const char *arg)
{
	const struct cdecl_error *err;
	struct cdecl *decl;
	const char *str;
	int ret = -1;

	decl = cdecl_parse_decl(arg);
	if (!decl) {
		err = cdecl_get_error();
		fprintf(stderr, "%s\n", err->str);
		goto out;
	}

	for (struct cdecl *i = decl; i; i = i->next) {
		str = do_format(cdecl_explain, i);
		if (!str)
			goto out;

		printf("%s\n", str);
	}

	ret = 1;
out:
	cdecl_free(decl);
	return ret;
}

static int cmd_simplify(const char *cmd, const char *arg)
{
	const struct cdecl_error *err;
	struct cdecl *decl;
	const char *str;
	int ret = -1;

	decl = cdecl_parse_decl(arg);
	if (!decl) {
		err = cdecl_get_error();
		fprintf(stderr, "%s\n", err->str);
		goto out;
	}

	for (struct cdecl *i = decl; i; i = i->next) {
		struct cdecl_declspec *s = i->specifiers;

		if (i != decl) {
			i->specifiers = NULL;
			printf(", ");
		}

		str = do_format(cdecl_declare, i);
		i->specifiers = s;

		if (!str)
			goto out;

		printf("%s", str);
	}

	putchar('\n');

	ret = 1;
out:
	cdecl_free(decl);
	return ret;
}

static int cmd_declare(const char *cmd, const char *arg)
{
	const struct cdecl_error *err;
	struct cdecl *decl;
	const char *str;
	int ret = -1;

	/* The name of the command is significant here. */
	decl = cdecl_parse_english(cmd);
	if (!decl) {
		err = cdecl_get_error();
		fprintf(stderr, "%s\n", err->str);
		goto out;
	}

	/*
	 * English parses have at most one full declarator, so no loop is
	 * needed here.
	 */
	str = do_format(cdecl_declare, decl);
	if (!str)
		goto out;

	printf("%s\n", str);
	ret = 1;
out:
	cdecl_free(decl);
	return ret;
}

static int cmd_quit(const char *cmd, const char *arg)
{
	return 0;
}

static int cmd_help(const char *cmd, const char *arg);

static const struct command {
	char name[16];
	int (*func)(const char *cmd, const char *arg);
	const char *blurb;
} commands[] = {
	{ "explain",  cmd_explain,  "Explain a C declaration." },
	{ "simplify", cmd_simplify, "Simplify a C declaration." },
	{ "declare",  cmd_declare,  "Construct a C declaration." },
	{ "type",     cmd_declare,  "Construct a C type name." },
	{ "help",     cmd_help,     "Print this list of commands." },
	{ "quit",     cmd_quit,     "Quit the program." },
	{ "exit",     cmd_quit,     NULL }
};
static const size_t ncommands = sizeof commands / sizeof commands[0];

static int cmd_help(const char *cmd, const char *arg)
{
	for (size_t i = 0; i < ncommands; i++) {
		if (!commands[i].blurb)
			continue;

		printf("%s -- %s\n", commands[i].name, commands[i].blurb);
	}

	return 1;
}

/*
 * Ensure that the first n characters of str equal the entire (null-terminated)
 * string cmd.
 */
static int cmd_cmp(const char *str, const char *cmd, size_t n)
{
	size_t cmdlen = strlen(cmd);

	if (n < cmdlen)
		return -1;
	if (n > cmdlen)
		return 1;
	return memcmp(str, cmd, n);
}

static int run_command(const char *line)
{
	const char *cmd = line + strspn(line, " \t");
	const char *arg = cmd  + strcspn(cmd, " \t");

	if (cmd[0] == '\0')
		return 1;

	for (size_t i = 0; i < ncommands; i++) {
		if (cmd_cmp(cmd, commands[i].name, arg-cmd) != 0)
			continue;

		return commands[i].func(cmd, arg);
	}

	fprintf(stderr, "Undefined command: %.*s\n", (int)(arg-cmd), cmd);
	return -1;
}

static int repl(void)
{
	char *line;

	for (; (line = readline("> ")); free(line)) {
		if (!run_command(line))
			break;
	}

	free(line);
	return 0;
}

static int repl_cmdline(int argc, char **argv)
{
	int opt, rc, ret = 0;

	optind = 1;
	while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
		if (opt != 'e')
			continue;

		rc = run_command(optarg);
		if (rc < 0)
			ret = -1;
		else if (rc == 0)
			break;
	}

	return ret;
}

static int repl_noninteractive(void)
{
	int rc, ret = 0, saved_errno;
	char *line = NULL;
	size_t n;

	while (getline(&line, &n, stdin) >= 0) {
		char *c = strchr(line, '\n');
		if (c)
			*c = '\0';

		rc = run_command(line);
		if (rc < 0)
			ret = -1;
		else if (rc == 0)
			break;
	}

	saved_errno = errno;
	free(line);

	if (ferror(stdin)) {
		errno = saved_errno;
		perror("read error");
		return -1;
	}

	return ret;
}

int main(int argc, char **argv)
{
	bool show_intro = true, interactive = true, execute = false;
	const char *filename = NULL;
	int opt, rc;

	if (argc > 0)
		progname = argv[0];

	/* Initialize gettext. */
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);

	while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
		switch (opt) {
		case 'q':
			show_intro = false;
			break;
		case 'b':
			interactive = false;
			break;
		case 'i':
			interactive = true;
			break;
		case 'f':
			filename = optarg;
			break;
		case 'e':
			execute = true;
			break;
		case 'V':
			print_version();
			return EXIT_SUCCESS;
		case 'H':
			print_help();
			return EXIT_SUCCESS;
		default:
			print_usage(stderr);
			return EXIT_FAILURE;
		}
	}

	/* --filename and --execute imply --batch. */
	if (filename || execute)
		interactive = false;

	/* --batch implies --quiet */
	if (interactive && show_intro)
		print_version();

	/* --execute supersedes --filename */
	if (filename && !execute) {
		if (!freopen(filename, "r", stdin)) {
			perror(filename);
			return EXIT_FAILURE;
		}
	}

	if (interactive)
		rc = repl();
	else if (execute)
		rc = repl_cmdline(argc, argv);
	else
		rc = repl_noninteractive();

	if (rc != 0)
		return EXIT_FAILURE;
	return EXIT_SUCCESS;
}