/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2020 Joyent, Inc.
 */

#include <ctype.h>
#include <demangle-sys.h>
#include <err.h>
#include <errno.h>
#include <libcustr.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>

#define _(x) gettext(x)

locale_t c_locale;

static int do_symbols(sysdem_lang_t, int, char * const *);
static int do_input(sysdem_lang_t, FILE *restrict, FILE *restrict);
static int do_demangle(const char *, sysdem_lang_t, FILE *);
static void appendc(custr_t *, char);
static void xputc(int, FILE *);

static void
usage(void)
{
        (void) fprintf(stderr, _("Usage: %s [-l lang] [sym...]\n"),
            getprogname());
        exit(2);
}

int
main(int argc, char * const *argv)
{
        sysdem_lang_t lang = SYSDEM_LANG_AUTO;
        int c;
        int ret;

        (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
        (void) textdomain(TEXT_DOMAIN);

        /*
         * For detecting symbol boundaries, we want to use the C locale
         * definitions for use in isalnum_l().
         */
        if ((c_locale = newlocale(LC_CTYPE_MASK, "C", NULL)) == NULL)
                err(EXIT_FAILURE, _("failed to construct C locale"));

        while ((c = getopt(argc, argv, "hl:")) != -1) {
                switch (c) {
                case 'l':
                        if (sysdem_parse_lang(optarg, &lang))
                                break;

                        errx(EXIT_FAILURE, _("Unsupported language '%s'\n"),
                            optarg);
                case 'h':
                case '?':
                        usage();
                }
        }

        argc -= optind;
        argv += optind;

        if (argc > 0)
                ret = do_symbols(lang, argc, argv);
        else
                ret = do_input(lang, stdin, stdout);

        return ((ret < 0) ? EXIT_FAILURE : EXIT_SUCCESS);
}

static int
do_symbols(sysdem_lang_t lang, int argc, char * const *argv)
{
        int ret = 0;

        for (int i = 0; i < argc; i++) {
                if (do_demangle(argv[i], lang, stdout) < 0)
                        ret = -1;
                else
                        xputc('\n', stdout);
        }

        return (ret);
}

static int
do_input(sysdem_lang_t lang, FILE *restrict in, FILE *restrict out)
{
        custr_t *word = NULL;
        int c;
        int ret = 0;
        boolean_t in_symbol = B_FALSE;

        if (custr_alloc(&word) != 0)
                err(EXIT_FAILURE, _("failed to allocate memory"));

        while ((c = fgetc(in)) != EOF) {
                if (in_symbol) {
                        /*
                         * All currently supported mangling formats only use
                         * alphanumeric characters, '.', '_', or '$' in
                         * mangled names. Once we've seen the potential start
                         * of a symbol ('_'), we accumulate subsequent
                         * charaters into 'word'. If we encounter a character
                         * that is not a part of that set ([A-Za-z0-9._$]), we
                         * treat it as a delimiter, we stop accumulating
                         * characters into word, and we attempt to demangle the
                         * accumulated string in 'word' by calling
                         * demangle_custr().
                         *
                         * Similar utilities like c++filt behave in a similar
                         * fashion when reading from stdin to allow for
                         * demangling of symbols embedded in surrounding text.
                         */
                        if (isalnum_l(c, c_locale) || c == '.' || c == '_' ||
                            c == '$') {
                                appendc(word, c);
                                continue;
                        }

                        /*
                         * Hit a symbol boundary, attempt to demangle what
                         * we've accumulated in word and reset word.
                         */
                        if (do_demangle(custr_cstr(word), lang, out) < 0)
                                ret = -1;

                        custr_reset(word);
                        in_symbol = B_FALSE;
                }

                if (c != '_') {
                        xputc(c, out);
                } else {
                        in_symbol = B_TRUE;
                        appendc(word, c);
                }
        }

        if (ferror(in))
                err(EXIT_FAILURE, _("error reading input"));

        /*
         * If we were accumulating characters for a symbol and hit EOF,
         * attempt to demangle what we accumulated.
         */
        if (custr_len(word) > 0 && do_demangle(custr_cstr(word), lang, out) < 0)
                ret = -1;

        custr_free(word);
        return (ret);
}

/*
 * Attempt to demangle 'sym' as a symbol for 'lang' and write the result
 * to 'out'. If 'sym' could not be demangled as 'lang' symbol, the original
 * string is output instead.
 *
 * If an error other than 'not a mangled symbol' is encountered (e.g. ENOMEM),
 * a warning is sent to stderr and -1 is returned. Otherwise, 0 is returned
 * (including when 'sym' is merely not a mangled symbol of 'lang').
 */
static int
do_demangle(const char *sym, sysdem_lang_t lang, FILE *out)
{
        char *demangled = sysdemangle(sym, lang, NULL);

        if (demangled == NULL && errno != EINVAL && errno != ENOTSUP) {
                warn(_("error while demangling '%s'"), sym);
                return (-1);
        }

        if (fprintf(out, "%s", (demangled != NULL) ? demangled : sym) < 0)
                err(EXIT_FAILURE, _("failed to write to output"));

        free(demangled);
        return (0);
}

static void
appendc(custr_t *cus, char c)
{
        if (custr_appendc(cus, c) == 0)
                return;
        err(EXIT_FAILURE, _("failed to save character from input"));
}

static void
xputc(int c, FILE *out)
{
        if (fputc(c, out) < 0)
                err(EXIT_FAILURE, _("failed to write output"));
}