lib/arglex.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2001, 2003, 2008, 2009, 2011, 2012 Peter Miller
//
// 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 2 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 <lib/ac/string.h>
#include <lib/ac/ctype.h>
#include <lib/ac/errno.h>
#include <lib/ac/stdlib.h>
#include <lib/ac/unistd.h>
#include <libexplain/output.h>
#include <libexplain/program_name.h>

#include <lib/arglex.h>
#include <lib/arglex/source/command_line.h>
#include <lib/arglex/source/file.h>
#include <lib/arglex/source/pushback.h>
#include <lib/configuration.h>
#include <lib/versn_stamp.h>


arglex::~arglex()
{
}


arglex::arglex(int ac, char **av) :
    usage_tail_(0),
    number_of_stdin_references(0),
    number_of_stdout_references(0)
{
    sources.push_back(arglex_source_command_line::create(ac, av));

    static const table_t default_table[] =
    {
        { "-", token_stdio },
        { "-ConFiGuration", token_configuration_file },
        { "-Group_Name_Maximum", token_group_name_maximum },
        { "-Help", token_help },
        { "-LICense", token_license },
        { "-Page_Length", token_page_length },
        { "-Page_Width", token_page_width },
        { "-Passwd_Name_Maximum", token_passwd_name_maximum },
        { "-Quiet", token_verbose_not },
        { "-Not_Verbose", token_verbose_not }, // must be after -quiet
        { "-TRACIng", token_tracing },
        { "-VERSion", token_version },
        { "-Verbose", token_verbose },
        { "-Not_Quiet", token_verbose }, // must be after -Verbose
        { "-Warnings", token_warning },
        { "-Not_Warnings", token_warning_not },
        ARGLEX_END_MARKER
    };

    table_set(default_table);
    explain_option_hanging_indent_set(4);
}


void
arglex::table_set(const table_t *tp)
{
    tables.push_back(tp);
}


static const char *partial;

bool
arglex::compare(const char *formal, const char *actual)
{
    for (;;)
    {
        unsigned char ac = *actual++;
        if (isupper(ac))
            ac = tolower(ac);
        unsigned char fc = *formal++;
        switch (fc)
        {
        case 0:
            return !ac;

        case '_':
            if (ac == '-')
                break;
            // fall through...

        case 'a': case 'b': case 'c': case 'd': case 'e':
        case 'f': case 'g': case 'h': case 'i': case 'j':
        case 'k': case 'l': case 'm': case 'n': case 'o':
        case 'p': case 'q': case 'r': case 's': case 't':
        case 'u': case 'v': case 'w': case 'x': case 'y':
        case 'z':
            //
            // optional characters
            //
            if (ac == fc && arglex::compare(formal, actual))
                return true;
            //
            // skip forward to next
            // mandatory character, or after '_'
            //
            while (islower(*formal))
                ++formal;
            if (*formal == '_')
            {
                ++formal;
                if (ac == '_' || ac == '-')
                    ++actual;
            }
            --actual;
            break;

        case '*':
            //
            // This is a hack, it should really
            // check for a match match the stuff after
            // the '*', too, a la glob.
            //
            if (!ac)
                return false;
            partial = actual - 1;
            return true;

        case '\\':
            if (actual[-1] != *formal++)
                return false;
            break;

        case 'A': case 'B': case 'C': case 'D': case 'E':
        case 'F': case 'G': case 'H': case 'I': case 'J':
        case 'K': case 'L': case 'M': case 'N': case 'O':
        case 'P': case 'Q': case 'R': case 'S': case 'T':
        case 'U': case 'V': case 'W': case 'X': case 'Y':
        case 'Z':
            fc = tolower(fc);
            // fall through...

        default:
            //
            // mandatory characters
            //
            if (fc != ac)
                return false;
            break;
        }
    }
}


static bool
is_a_number(const rcstring &text, long &n)
{
    const char *s = text.c_str();
    char *ep = 0;
    n = strtol(s, &ep, 0);
    assert(ep);
    return (ep != s && !*ep);
}


void
arglex::push_arg_back(const char *value)
{
    sources.push_back(arglex_source_pushback::create(token_locn, value));
}


int
arglex::token_next(void)
{
    for (;;)
    {
        // no sources means "end of line"
        if (sources.empty())
        {
            token_locn = source_location("command line", 666);
            value_string = "";
            token = token_eoln;
            return token;
        }

        // see if we can get another token from this source
        if (!sources.back()->next(token_locn, value_string))
        {
            if (sources.size() == 1)
            {
                // Special case the actual command line,
                // this will give better error messages.
                value_string = "";
                token = token_eoln;
                return token;
            }
            sources.pop_back();
            continue;
        }

        // see if it is a "@filename" include
        if (value_string.front() == '@' && value_string.size() >= 2)
        {
            rcstring filename =
                value_string.substr(1, value_string.size() - 1);
            if (filename == "-")
                check_stdin_references();
            sources.push_back(arglex_source_file::create(filename));
            continue;
        }

        // found our argument
        break;
    }

    //
    // See if it looks like a GNU "-foo=bar" option.
    // Split it at the '=' to make it something the
    // rest of the code understands.
    //
    if (value_string[0] == '-' && value_string[1] != '=')
    {
        const char *cp = value_string.c_str();
        const char *eqp = strchr(cp, '=');
        if (eqp)
        {
            push_arg_back(eqp + 1);
            value_string = value_string.substr(0, eqp - cp);
        }
    }

    //
    // Turn the GNU-style leading "--"
    // into "-" if necessary.
    //
    if
    (
        value_string.size() > 2
    &&
        value_string[0] == '-'
    &&
        value_string[1] == '-'
    )
    {
        rcstring s = value_string.substr(1, value_string.size() - 1);
        long dummy;
        if (!is_a_number(s, dummy))
        {
            value_string = s;
        }
    }

    //
    // see if it is a number
    //
    if (is_a_number(value_string, value_number))
    {
        token = arglex::token_number;
        return token;
    }

    //
    // scan the tables to see what it matches
    //
    typedef std::vector<const table_t *> hits_t;
    hits_t hits;
    partial = 0;
    for
    (
        tables_t::iterator it = tables.begin();
        it != tables.end();
        ++it
    )
    {
        for (const table_t *tp = *it; tp->name; tp++)
        {
            if (arglex::compare(tp->name, value_string.c_str()))
                hits.push_back(tp);
        }
    }

    //
    // If all the hits are the same token value, the token is not ambiguous.
    // This happens if you have two spellings for the same token,
    // e.g. Standard English vs American.
    //
    while (hits.size() >= 2 && hits.front()->token == hits.back()->token)
        hits.pop_back();

    //
    // deal with unknown or ambiguous options
    //
    switch (hits.size())
    {
    case 0:
        //
        // not found in the tables
        //
        if (value_string.front() == '-')
            token = arglex::token_option;
        else
            token = arglex::token_string;
        break;

    case 1:
        if (partial)
        {
            push_arg_back(partial);
        }
        value_string = hits.front()->name;
        token = hits.front()->token;
        break;

    default:
        {
            rcstring candidates;
            for
            (
                hits_t::const_iterator it = hits.begin();
                it != hits.end();
                ++it
            )
            {
                if (!candidates.empty())
                    candidates += ", ";
                candidates += (*it)->name;
            }
            explain_output_error_and_die
            (
                "option %s is ambiguous (%s)",
                value_string.quote_c().c_str(),
                candidates.c_str()
            );
        }
    }
    return token;
}


const char *
arglex::token_name(int n)
    const
{
    switch (n)
    {
    case token_eoln:
        return "end of command line";

    case token_number:
        return "number";

    case token_option:
        return "option";

    case token_stdio:
        return "standard input or output";

    case token_string:
        return "string";

    default:
        break;
    }
    for
    (
        tables_t::const_iterator it = tables.begin();
        it != tables.end();
        ++it
    )
    {
        for (const table_t *tp = *it; tp->name; tp++)
        {
            if (tp->token == n)
                return tp->name;
        }
    }
    return "unknown command line token";
}


void
arglex::help(const char *name)
    const
{
    if (!name)
        name = explain_program_name_get();
    const char *cmd[3] = { "man", name, 0 };
    execvp(cmd[0], (char *const *)cmd);
    std::cerr << cmd[0] << ": " << strerror(errno) << std::endl;
    exit(1);
}


void
arglex::version(void)
    const
{
    const char *prog = explain_program_name_get();
    std::cout
        << prog << " version " << version_stamp() << std::endl
        << "Copyright (C) " << copyright_years() << " Peter Miller" << std::endl
        << std::endl
        << "The " << prog << " program comes with ABSOLUTELY NO WARRANTY; for "
           "details use" << std::endl
        << "the '" << prog << " -LICense' command.  The " << prog << " program "
           "is free" << std::endl
        << "software, and you are welcome to redistribute it under certain "
           "conditions;" << std::endl
        << "for details use the '" << prog << " -LICense' command."
        << std::endl;
    exit(0);
}


void
arglex::license(void)
    const
{
    help("nis-util-license");
}


void
arglex::bad_argument(void)
    const
{
    switch (token_cur())
    {
    case token_string:
        explain_output_error
        (
            "%s: misplaced file name %s",
            get_source_location().get_both().c_str(),
            get_string_value().quote_c().c_str()
        );
        break;

    case token_number:
        explain_output_error
        (
            "%s: misplaced number %s",
            get_source_location().get_both().c_str(),
            get_string_value().quote_c().c_str()
        );
        break;

    case token_option:
        explain_output_error
        (
            "%s: unknown %s option",
            get_source_location().get_both().c_str(),
            get_string_value().quote_c().c_str()
        );
        break;

    case token_eoln:
        explain_output_error
        (
            "%s: command line too short",
            get_source_location().get_both().c_str()
        );
        break;

    default:
        explain_output_error
        (
            "%s: misplaced %s option",
            get_source_location().get_both().c_str(),
            get_string_value().quote_c().c_str()
        );
        break;
    }
    usage();
    exit(1);
}


int
arglex::token_first(void)
{
    switch (token_next())
    {
    default:
        return token_cur();

    case token_help:
        if (token_next() != token_eoln)
            bad_argument();
        help();
        break;

    case token_version:
        if (token_next() != token_eoln)
            bad_argument();
        version();
        break;

    case token_license:
        if (token_next() != token_eoln)
            bad_argument();
        license();
        break;
    }
    exit(0);
}


void
arglex::usage_tail_set(const char *s)
{
    usage_tail_ = s;
}


const char *
arglex::usage_tail_get(void)
    const
{
    return (usage_tail_ ? usage_tail_ : "<filename>...");
}


void
arglex::usage(void)
    const
{
    const char *prog = explain_program_name_get();
    std::cerr << "Usage: " << prog << " [ <option>... ] " << usage_tail_get()
        << std::endl;
    std::cerr << "       " << prog << " -Help" << std::endl;
    std::cerr << "       " << prog << " -VERSion" << std::endl;
    std::cerr << "       " << prog << " -LICense" << std::endl;
    exit(1);
}


void
arglex::check_stdin_references(void)
{
    ++number_of_stdin_references;
    if (number_of_stdin_references > 1)
    {
        explain_output_error_and_die
        (
            "%s: too many references to stdin, it may only be used once",
            get_source_location().get_both().c_str()
        );
    }
}


rcstring
arglex::get_filename_or_stdin(void)
{
    int t = token;
    switch (token_next())
    {
    default:
        explain_output_error
        (
            "%s: the %s option requires a <filename> argument, "
                "or \"-\" to indicate the standard input",
            get_source_location().get_both().c_str(),
            token_name(t)
        );
        usage();
        // NOTREACHED

    case token_string:
        if (value_string.empty())
        {
            explain_output_error_and_die
            (
                "%s: you may not give the empty string as the argument to "
                    "the %s option",
                get_source_location().get_both().c_str(),
                token_name(t)
            );
        }
        return get_string_value();

    case token_stdio:
        check_stdin_references();
        return "-";
    }
}


void
arglex::get_filename_or_stdin(rcstring &fnvar)
{
    if (!fnvar.empty())
    {
        explain_output_error
        (
            "%s: too many %s options specified",
            get_source_location().get_both().c_str(),
            token_name(token)
        );
        usage();
    }
    fnvar = get_filename_or_stdin();
}


void
arglex::check_stdout_references(void)
{
    ++number_of_stdout_references;
    if (number_of_stdout_references > 1)
    {
        explain_output_error_and_die
        (
            "%s: too many references to stdout, it may only be used once",
            get_source_location().get_both().c_str()
        );
    }
}


rcstring
arglex::get_filename_or_stdout(void)
{
    int t = token;
    switch (token_next())
    {
    default:
        explain_output_error
        (
            "%s: the %s option requires a <filename> argument, "
                "or \"-\" to indicate the standard output",
            get_source_location().get_both().c_str(),
            token_name(t)
        );
        usage();
        // NOTREACHED

    case token_string:
        if (value_string.empty())
        {
            explain_output_error_and_die
            (
                "%s: you may not give the empty string as the argument to "
                    "the %s option",
                get_source_location().get_both().c_str(),
                token_name(t)
            );
        }
        return get_string_value();

    case token_stdio:
        check_stdout_references();
        return "-";
    }
}


void
arglex::get_filename_or_stdout(rcstring &fnvar)
{
    if (!fnvar.empty())
    {
        explain_output_error
        (
            "%s: too many %s options specified",
            get_source_location().get_both().c_str(),
            token_name(token)
        );
        usage();
    }
    fnvar = get_filename_or_stdout();
}


const source_location &
arglex::get_source_location(void)
    const
{
    return token_locn;
}


// vim: set ts=8 sw=4 et :