/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "options.h"

/*
 * options
 *
 * Overview
 *   sort(1) supports two methods for specifying the sort key:  the original,
 *   now-obsolete, +n -m form and the POSIX -k n,m form.  We refer to the former
 *   as "old specifiers" and the latter as "new specifiers".  The options()
 *   function parses the command line arguments given to sort, placing the sort
 *   key specifiers in the internal representation used in fields.c.
 *
 * Equivalence of specifiers
 *   One of sort(1)'s standard peculiarities is the transformation of the
 *   character offsets and field numbering between the new and old style field
 *   specifications.  We simply quote from the Single Unix standard:
 *
 *      +w.xT -y.zU
 *
 *   is equivalent to
 *
 *      undefined               when z == 0, U contains b, and -t is set
 *      -k w+1.x+1T,y.0U        when z == 0 otherwise
 *      -k w+1.x+1T,y+1.zU      when z > 0
 *
 *   Undoubtedly, this seemed logical at the time.  (Using only the field head
 *   as the coordinate, as done in the obsolete version, seems much simpler.)
 *   The reverse map is where the key specifier
 *
 *      -k w.xT,y.zU
 *
 *   is equivalent to
 *
 *      undefined               when z == 0, U contains b, and -t is set
 *      +w-1.x-1T,y.0U          when z == 0 otherwise
 *      +w-1.x-1T,y-1.z         when z > 0
 *
 *   in the obsolete syntax.  Because the original key specifiers lead to a
 *   simpler implementation, the internal representation of a field in this
 *   implementation of sort is mostly that given by the obsolete syntax.
 */

/*
 * While a key specifier in the obsolete +m ... -n form is being defined (that
 * is, before the closing -n is seen), a narrower set of options is permitted.
 * We specify this smaller set of options in OLD_SPEC_OPTIONS_STRING.
 */
#define OPTIONS_STRING          "cmuo:T:z:dfiMnrbt:k:S:0123456789"
#define OLD_SPEC_OPTIONS_STRING "bdfiMnrcmuo:T:z:t:k:S:"

#define OPTIONS_OLDSPEC         0x1     /* else new-style spec */
#define OPTIONS_STARTSPEC       0x2     /* else end spec */

static int
is_number(char *C)
{
        size_t  i;

        for (i = 0; i < strlen(C); i++)
                if (!isdigit((uchar_t)C[i]))
                        return (0);

        return (1);
}

/*
 * If a field specified by the -k option or by the +n syntax contains any
 * modifiers, then the current global field modifiers are not inherited.
 */
static int
field_spec_has_modifiers(char *C, int length)
{
        int p_nonmodifiers = strspn(C, ",.1234567890");

        if (p_nonmodifiers == length)
                return (0);

        return (1);
}

static void
field_apply_all(field_t *fc, flag_t flags)
{
        field_t *f;

        for (f = fc; f; f = f->f_next)
                if ((f->f_options & FIELD_MODIFIERS_DEFINED) == 0)
                        f->f_options |= flags;
}

static int
parse_field_spec(field_t *F, char *C, int flags, int length)
{
        int p_period = MIN(length, strcspn(C, "."));
        int p_modifiers = MIN(length, strspn(C, ".1234567890"));
        int p_boundary = MIN(p_period, p_modifiers);
        int field = 0;
        int offset = 0;
        int offset_seen = 0;
        int i;
        int blanks_flag = 0;

        for (i = 0; i < p_boundary; i++) {
                if (isdigit((uchar_t)C[i]))
                        field = (10 * field) + (C[i] - '0');
                else
                        return (1);
        }

        if (p_period < p_modifiers) {
                for (i = p_period + 1; i < p_modifiers; i++) {
                        if (isdigit((uchar_t)C[i])) {
                                offset_seen++;
                                offset = (10 * offset) + (C[i] - '0');
                        } else {
                                return (1);
                        }
                }
        }

        if (p_modifiers < length) {
                for (i = p_modifiers; i < length; i++) {
                        switch (C[i]) {
                                case 'b':
                                        blanks_flag = 1;
                                        break;
                                case 'd':
                                        F->f_options |= FIELD_DICTIONARY_ORDER;
                                        break;
                                case 'f':
                                        F->f_options |= FIELD_FOLD_UPPERCASE;
                                        break;
                                case 'i':
                                        F->f_options |=
                                            FIELD_IGNORE_NONPRINTABLES;
                                        break;
                                case 'M':
                                        F->f_species = MONTH;
                                        break;
                                case 'n':
                                        F->f_species = NUMERIC;
                                        break;
                                case 'r':
                                        F->f_options |=
                                            FIELD_REVERSE_COMPARISONS;
                                        break;
                                default:
                                        usage();
                                        break;
                        }
                }
        }

        if (flags & OPTIONS_STARTSPEC) {
                F->f_start_field = field;
                F->f_start_offset = offset;
                if ((flags & OPTIONS_OLDSPEC) != OPTIONS_OLDSPEC) {
                        F->f_start_field--;
                        if (offset_seen)
                                F->f_start_offset--;
                }
                F->f_options |= blanks_flag ? FIELD_IGNORE_BLANKS_START : 0;
        } else {
                F->f_end_field = field;
                F->f_end_offset = offset;
                if ((flags & OPTIONS_OLDSPEC) != OPTIONS_OLDSPEC &&
                    offset_seen && offset != 0)
                        F->f_end_field--;
                F->f_options |= blanks_flag ? FIELD_IGNORE_BLANKS_END : 0;
        }

        return (0);
}

static void
parse_new_field_spec(sort_t *S, char *arg)
{
        int length = strlen(arg);
        int p_comma = MIN(length, strcspn(arg, ","));
        field_t *nF;
        int p;

        /*
         * New field specifiers do not inherit from the general specifier if
         * they have any modifiers set.  (This is specifically tested in the VSC
         * test suite, assertion 32 for POSIX.cmd/sort.)
         */
        if (field_spec_has_modifiers(arg, length)) {
                nF = field_new(NULL);
                nF->f_options = FIELD_MODIFIERS_DEFINED;
        } else {
                nF = field_new(S);
        }
        p = parse_field_spec(nF, arg, OPTIONS_STARTSPEC, p_comma);

        if (p != 0)
                usage();

        if (p_comma < length) {
                p = parse_field_spec(nF, &(arg[p_comma + 1]), 0,
                    strlen(&(arg[p_comma + 1])));
                if (p != 0)
                        usage();
        }

        if (nF->f_start_field < 0 || nF->f_start_offset < 0) {
                if (S->m_verbose)
                        warn("-k %s is not a supported field specifier\n", arg);
        }
        nF->f_start_field = MAX(nF->f_start_field, 0);
        nF->f_start_offset = MAX(nF->f_start_offset, 0);

        /*
         * If the starting field exceeds a defined ending field, convention
         * dictates that the field is ignored.
         */
        if (nF->f_end_field == -1 || nF->f_start_field < nF->f_end_field ||
            (nF->f_start_field == nF->f_end_field &&
            nF->f_start_offset < nF->f_end_offset)) {
                field_add_to_chain(&(S->m_fields_head), nF);
        } else if (S->m_verbose) {
                warn("illegal field -k %s omitted", arg);
        }
}

/*
 * parse_old_field_spec() is getopt()-aware; it may modify the values of optind,
 * optarg, and so forth, to correctly determine the characteristics being
 * assigned to the current field.
 */
static int
parse_old_field_spec(sort_t *S, int argc, char *argv[])
{
        field_t *nF;
        int c, p;
        char *arg = argv[optind];

        if (field_spec_has_modifiers(arg + 1, strlen(arg + 1))) {
                nF = field_new(NULL);
                nF->f_options = FIELD_MODIFIERS_DEFINED;
        } else {
                nF = field_new(S);
        }

        p = parse_field_spec(nF, arg + 1, OPTIONS_OLDSPEC | OPTIONS_STARTSPEC,
            strlen(arg + 1));

        if (p != 0) {
                field_delete(nF);
                return (0);
        }

        /*
         * In the case that getopt() returns '?' (unrecognized option) or EOF
         * (non-option argument), the field is considered closed.
         */
        for (arg = argv[++optind]; optind < argc; arg = argv[optind]) {
                if (strlen(arg) >= 2 && *arg == '-' &&
                    isdigit(*(uchar_t *)(arg + 1))) {
                        (void) parse_field_spec(nF, arg + 1,
                            OPTIONS_OLDSPEC, strlen(arg) - 1);
                        field_add_to_chain(&(S->m_fields_head), nF);
                        optind++;
                        return (1);
                }

                if ((c = getopt(argc, argv, OLD_SPEC_OPTIONS_STRING)) != EOF) {
                        switch (c) {
                        case 'b':
                                nF->f_options |= FIELD_IGNORE_BLANKS_START;
                                break;
                        case 'd':
                                nF->f_options |= FIELD_DICTIONARY_ORDER;
                                break;
                        case 'f':
                                nF->f_options |= FIELD_FOLD_UPPERCASE;
                                break;
                        case 'i':
                                nF->f_options |= FIELD_IGNORE_NONPRINTABLES;
                                break;
                        case 'M':
                                nF->f_species = MONTH;
                                break;
                        case 'n':
                                nF->f_species = NUMERIC;
                                break;
                        case 'r':
                                nF->f_options |= FIELD_REVERSE_COMPARISONS;
                                break;
                        case '?':
                        case 'c':
                        case 'm':
                        case 'u':
                                /*
                                 * Options without arguments.
                                 */
                                optind -= 1;
                                field_add_to_chain(&(S->m_fields_head), nF);
                                return (1);
                                /*NOTREACHED*/
                        case 'o':
                        case 'T':
                        case 'z':
                        case 't':
                        case 'k':
                        case 'S':
                                /*
                                 * Options with arguments.
                                 */
                                if (optarg == argv[optind - 1] + 2) {
                                        optind -= 1;
                                } else {
                                        optind -= 2;
                                }
                                field_add_to_chain(&(S->m_fields_head), nF);
                                return (1);
                                /*NOTREACHED*/
                        default:
                                die(EMSG_UNKN_OPTION);
                                /*NOTREACHED*/
                        }
                } else {
                        break;
                }
        }

        field_add_to_chain(&(S->m_fields_head), nF);
        return (1);
}

int
options(sort_t *S, int argc, char *argv[])
{
        int c;

        optind = 1;
        while (optind < argc) {
                if (strncmp("-y", argv[optind], strlen("-y")) == 0) {
                        /*
                         * The -y [kmem] option violates the standard syntax
                         * outlined in intro(1).  we have to be a little fancy
                         * to determine if the next argument is a valid integer.
                         * (note, of course, that the previous sort(1) had no
                         * mechanism to resolve a final
                         *      -y 99999
                         * into
                         *      -y, file 99999
                         * or
                         *      -y 99999, file stdin
                         *
                         * Now one can unambiguously use
                         *      -y -- 99999
                         * and
                         *      -y 99999 -
                         * to distinguish these cases.
                         *
                         * That said, we do not use the information passed using
                         * -y option in sort(1); we provide the argument to
                         * preserve compatibility for existing scripts.
                         */
                        if (strlen(argv[optind]) == strlen("-y") &&
                            optind + 1 < argc &&
                            is_number(argv[optind + 1]))
                                optind += 2;
                        else
                                optind += 1;
                }

                if ((c = getopt(argc, argv, OPTIONS_STRING)) != EOF) {
                        switch (c) {
                        case 'c':
                                S->m_check_if_sorted_only = 1;
                                break;

                        case 'm':
                                S->m_merge_only = 1;
                                break;

                        case 'u':
                                S->m_unique_lines = 1;
                                break;

                        case 'o':
                                S->m_output_filename = optarg;
                                break;

                        case 'T':
                                S->m_tmpdir_template = optarg;
                                break;

                        case 'z':
                                /*
                                 * ignore optarg -- obsolete
                                 */
                                break;

                        case 'd':
                                S->m_field_options |= FIELD_DICTIONARY_ORDER;
                                field_apply_all(S->m_fields_head,
                                    FIELD_DICTIONARY_ORDER);
                                break;

                        case 'f':
                                S->m_field_options |= FIELD_FOLD_UPPERCASE;
                                field_apply_all(S->m_fields_head,
                                    FIELD_FOLD_UPPERCASE);
                                break;

                        case 'i':
                                S->m_field_options |=
                                    FIELD_IGNORE_NONPRINTABLES;
                                field_apply_all(S->m_fields_head,
                                    FIELD_IGNORE_NONPRINTABLES);
                                break;

                        case 'M':
                                S->m_default_species = MONTH;
                                S->m_field_options &=
                                    ~FIELD_IGNORE_BLANKS_START;
                                break;

                        case 'n':
                                S->m_default_species = NUMERIC;
                                {
                                        field_t *f;

                                        for (f = S->m_fields_head; f;
                                            f = f->f_next)
                                                if ((f->f_options &
                                                    FIELD_MODIFIERS_DEFINED) ==
                                                    0)
                                                        f->f_species = NUMERIC;
                                }
                                break;

                        case 'b':
                                S->m_field_options |=
                                    FIELD_IGNORE_BLANKS_START |
                                    FIELD_IGNORE_BLANKS_END;
                                break;

                        case 'r':
                                S->m_field_options |=
                                    FIELD_REVERSE_COMPARISONS;
                                field_apply_all(S->m_fields_head,
                                    FIELD_REVERSE_COMPARISONS);
                                break;

                        case 't':
                                /*
                                 * delimiter
                                 */
                                if (S->m_single_byte_locale) {
                                        /*
                                         * Most debuggers can't take tabs as
                                         * input arguments, so we provide an
                                         * escape sequence to allow testing of
                                         * this special case for the DEBUG
                                         * version.
                                         */
                                        S->m_field_separator.sc =
#ifdef DEBUG
                                            xstreql(optarg, "\\t") ? '\t' :
#endif
                                            optarg[0];
                                } else
                                        (void) mbtowc(&S->m_field_separator.wc,
                                            optarg, MB_CUR_MAX);
                                break;

                        case 'k':
                                /*
                                 * key
                                 */
                                (void) parse_new_field_spec(S, optarg);
                                break;

                        case 'S':
                                S->m_memory_limit = strtomem(optarg);
#ifdef DEBUG
                                (void) fprintf(stderr, CMDNAME
                                    ": limiting size to %d bytes\n",
                                    S->m_memory_limit);
#endif /* DEBUG */
                                break;

                        /*
                         * We never take a naked -999; these should always be
                         * associated with a preceding +000.
                         */
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                                usage();
                                break;
                        case '?':
                                /* error case */
                                usage();
                                break;
                        }

                        /*
                         * Go back for next argument.
                         */
                        continue;
                }

                /*
                 * There are three (interpretable) possibilities for getopt() to
                 * return EOF with arguments on the command line: we have seen
                 * the "end-of-options" token, --, we have encountered the
                 * old-style field definition, +NNN, or we have found a
                 * filename.
                 *
                 * In the second case, we must also search for the optional -NNN
                 * field terminal definition.  (since "+joe", for instance, is
                 * a valid filename, we must handle this pattern as well.)  This
                 * is performed by parse_old_field_spec().
                 */
                if (xstreql(argv[optind - 1], "--")) {
                        /*
                         * Process all arguments following end-of-options token
                         * as filenames.
                         */
                        while (optind < argc) {
                                if (xstreql(argv[optind], "-"))
                                        S->m_input_from_stdin = 1;
                                else
                                        stream_add_file_to_chain(
                                            &(S->m_input_streams),
                                            argv[optind]);
                                optind++;
                        }

                        break;
                }

                if (optind < argc) {
                        if (xstreql(argv[optind], "-")) {
                                S->m_input_from_stdin = 1;
                                optind++;
                        } else if (*(argv[optind]) != '+' ||
                            !parse_old_field_spec(S, argc, argv)) {
                                /*
                                 * It's a filename, because it either doesn't
                                 * start with '+', or if it did, it wasn't an
                                 * actual field specifier.
                                 */
                                stream_add_file_to_chain(&(S->m_input_streams),
                                    argv[optind]);
                                optind++;
                        }
                }
        }

        if (S->m_input_streams == NULL)
                S->m_input_from_stdin = 1;

        if (S->m_output_filename == NULL)
                S->m_output_to_stdout = 1;

        /*
         * If no fields, then one great field.  However, if the -b option was
         * set globally, be sure to ignore it, as per UNIX98.
         */
        if (S->m_fields_head == NULL) {
                S->m_field_options &= ~FIELD_IGNORE_BLANKS_START;

                (void) parse_new_field_spec(S, "1");
                /*
                 * "Entire line" fast path is only valid if no delimiter has
                 * been set and no modifiers have been applied.
                 */
                if (S->m_field_separator.wc == 0 &&
                    S->m_default_species == ALPHA &&
                    S->m_field_options == 0)
                        S->m_entire_line = 1;
        }

        return (0);
}