/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */


/*
 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdlib.h>
#include <regexpr.h>
#include <locale.h>
#include <string.h>
#include <unistd.h>
#include <regex.h>
#include <limits.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>

#define A_STRING 258
#define NOARG 259
#define OR 260
#define AND 261
#define EQ 262
#define LT 263
#define GT 264
#define GEQ 265
#define LEQ 266
#define NEQ 267
#define ADD 268
#define SUBT 269
#define MULT 270
#define DIV 271
#define REM 272
#define MCH 273
#define MATCH 274
#define SUBSTR 275
#define LENGTH 276
#define INDEX  277

/* size of subexpression array */
#define MSIZE   LINE_MAX
#define error(c)        errxx()
#define EQL(x, y) (strcmp(x, y) == 0)

#define ERROR(c)        errxx()
#define MAX_MATCH 20
static int ematch(char *, char *);
static void yyerror(char *);
static void errxx();
static void *exprmalloc(size_t size);

static char *ltoa();
static char *lltoa();
static char     **Av;
static char *buf;
static int      Ac;
static int      Argi;
static int noarg;
static int paren;
/*
 *      Array used to store subexpressions in regular expressions
 *      Only one subexpression allowed per regular expression currently
 */
static char Mstring[1][MSIZE];


static char *operator[] = {
        "|", "&", "+", "-", "*", "/", "%", ":",
        "=", "==", "<", "<=", ">", ">=", "!=",
        "match",
        "substr", "length", "index",
        "\0" };
static  int op[] = {
        OR, AND, ADD,  SUBT, MULT, DIV, REM, MCH,
        EQ, EQ, LT, LEQ, GT, GEQ, NEQ,
        MATCH,
        SUBSTR, LENGTH, INDEX
        };
static  int pri[] = {
        1, 2, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 6, 7,
        7, 7, 7
        };


/*
 * clean_buf - XCU4 mod to remove leading zeros from negative signed
 *              numeric output, e.g., -00001 becomes -1
 */
static void
clean_buf(char *buf)
{
        int i = 0;
        int is_a_num = 1;
        int len;
        long long num;

        if (buf[0] == '\0')
                return;
        len = strlen(buf);
        if (len <= 0)
                return;

        if (buf[0] == '-') {
                i++;            /* Skip the leading '-' see while loop */
                if (len <= 1)   /* Is it a '-' all by itself? */
                        return; /* Yes, so return */

                while (i < len) {
                        if (! isdigit(buf[i])) {
                                is_a_num = 0;
                                break;
                        }
                        i++;
                }
                if (is_a_num) {
                        (void) sscanf(buf, "%lld", &num);
                        (void) sprintf(buf, "%lld", num);
                }
        }
}

/*
 * End XCU4 mods.
 */

static int
yylex(void)
{
        char *p;
        int i;

        if (Argi >= Ac)
                return (NOARG);

        p = Av[Argi];

        if ((*p == '(' || *p == ')') && p[1] == '\0')
                return ((int)*p);
        for (i = 0; *operator[i]; ++i)
                if (EQL(operator[i], p))
                        return (op[i]);


        return (A_STRING);
}

static char *
rel(int oper, char *r1, char *r2)
{
        long long i, l1, l2;

        if (ematch(r1, "-\\{0,1\\}[0-9]*$") &&
            ematch(r2, "-\\{0,1\\}[0-9]*$")) {
                errno = 0;
                l1 = strtoll(r1, (char **)NULL, 10);
                l2 = strtoll(r2, (char **)NULL, 10);
                if (errno) {
#ifdef XPG6
                /* XPG6: stdout will always contain newline even on error */
                        (void) write(1, "\n", 1);
#endif
                        if (errno == ERANGE) {
                                (void) fprintf(stderr, gettext(
                                    "expr: Integer argument too large\n"));
                                exit(3);
                        } else {
                                perror("expr");
                                exit(3);
                        }
                }
                switch (oper) {
                case EQ:
                        i = (l1 == l2);
                        break;
                case GT:
                        i = (l1 > l2);
                        break;
                case GEQ:
                        i = (l1 >= l2);
                        break;
                case LT:
                        i = (l1 < l2);
                        break;
                case LEQ:
                        i = (l1 <= l2);
                        break;
                case NEQ:
                        i = (l1 != l2);
                        break;
                }
        }
        else
        {
                        i = strcoll(r1, r2);
                switch (oper) {
                case EQ:
                        i = i == 0;
                        break;
                case GT:
                        i = i > 0;
                        break;
                case GEQ:
                        i = i >= 0;
                        break;
                case LT:
                        i = i < 0;
                        break;
                case LEQ:
                        i = i <= 0;
                        break;
                case NEQ:
                        i = i != 0;
                        break;
                }
        }
        return (i ? "1": "0");
}

static char *
arith(int oper, char *r1, char *r2)
{
        long long i1, i2;
        char *rv;

        if (!(ematch(r1, "-\\{0,1\\}[0-9]*$") &&
            ematch(r2, "-\\{0,1\\}[0-9]*$")))
                yyerror("non-numeric argument");
        errno = 0;
        i1 = strtoll(r1, (char **)NULL, 10);
        i2 = strtoll(r2, (char **)NULL, 10);
        if (errno) {
#ifdef XPG6
        /* XPG6: stdout will always contain newline even on error */
                (void) write(1, "\n", 1);
#endif
                if (errno == ERANGE) {
                        (void) fprintf(stderr, gettext(
                            "expr: Integer argument too large\n"));
                        exit(3);
                } else {
                        perror("expr");
                        exit(3);
                }
        }

        switch (oper) {
        case ADD:
                i1 = i1 + i2;
                break;
        case SUBT:
                i1 = i1 - i2;
                break;
        case MULT:
                i1 = i1 * i2;
                break;
        case DIV:
                if (i2 == 0)
                        yyerror("division by zero");
                i1 = i1 / i2;
                break;
        case REM:
                if (i2 == 0)
                        yyerror("division by zero");
                i1 = i1 % i2;
                break;
        }
        rv = exprmalloc(25);
        (void) strcpy(rv, lltoa(i1));
        return (rv);
}

static char
*conj(int oper, char *r1, char *r2)
{
        char *rv;

        switch (oper) {

        case OR:
                if (EQL(r1, "0") || EQL(r1, "")) {
                        if (EQL(r2, "0") || EQL(r2, ""))
                                rv = "0";
                        else
                                rv = r2;
                } else
                        rv = r1;
                break;
        case AND:
                if (EQL(r1, "0") || EQL(r1, ""))
                        rv = "0";
                else if (EQL(r2, "0") || EQL(r2, ""))
                        rv = "0";
                else
                        rv = r1;
                break;
        }
        return (rv);
}

char *
substr(char *v, char *s, char *w)
{
        int si, wi;
        char *res;

        si = atol(s);
        wi = atol(w);
        while (--si)
                if (*v) ++v;

        res = v;

        while (wi--)
                if (*v) ++v;

        *v = '\0';
        return (res);
}

char *
index(char *s, char *t)
{
        long i, j;
        char *rv;

        for (i = 0; s[i]; ++i)
                for (j = 0; t[j]; ++j)
                        if (s[i] == t[j]) {
                                (void) strcpy(rv = exprmalloc(8), ltoa(++i));
                                return (rv);
                        }
        return ("0");
}

char *
length(char *s)
{
        long i = 0;
        char *rv;

        while (*s++) ++i;

        rv = exprmalloc(8);
        (void) strcpy(rv, ltoa(i));
        return (rv);
}

static char *
match(char *s, char *p)
{
        char *rv;
        long val;                       /* XCU4 */

        (void) strcpy(rv = exprmalloc(8), ltoa(val = (long)ematch(s, p)));
        if (nbra /* && val != 0 */) {
                rv = exprmalloc((unsigned)strlen(Mstring[0]) + 1);
                (void) strcpy(rv, Mstring[0]);
        }
        return (rv);
}


/*
 * ematch       - XCU4 mods involve calling compile/advance which simulate
 *                the obsolete compile/advance functions using regcomp/regexec
 */
static int
ematch(char *s, char *p)
{
        static char *expbuf;
        char *nexpbuf;
        int num;
#ifdef XPG4
        int nmatch;             /* number of matched bytes */
        char tempbuf[256];
        char *tmptr1 = 0;       /* If tempbuf is not large enough */
        char *tmptr;
        int nmbchars;           /* number characters in multibyte string */
#endif

        nexpbuf = compile(p, (char *)0, (char *)0);     /* XCU4 regex mod */
        if (0 /* XXX nbra > 1*/)
                yyerror("Too many '\\('s");
        if (regerrno) {
                if (regerrno != 41 || expbuf == NULL)
                        errxx();
        } else {
                if (expbuf)
                        free(expbuf);
                expbuf = nexpbuf;
        }
        if (advance(s, expbuf)) {
                if (nbra > 0) {
                        p = braslist[0];
                        num = braelist[0] - p;
                        if ((num > MSIZE - 1) || (num < 0))
                                yyerror("string too long");
                        (void) strncpy(Mstring[0], p, num);
                        Mstring[0][num] = '\0';
                }
#ifdef XPG4
                /*
                 *  Use mbstowcs to find the number of multibyte characters
                 *  in the multibyte string beginning at s, and
                 *  ending at loc2.  Create a separate string
                 *  of the substring, so it can be passed to mbstowcs.
                 */
                nmatch = loc2 - s;
                if (nmatch > ((sizeof (tempbuf) / sizeof (char)) - 1)) {
                        tmptr1 = exprmalloc(nmatch + 1);
                        tmptr = tmptr1;
                } else {
                        tmptr = tempbuf;
                }
                memcpy(tmptr, s, nmatch);
                *(tmptr + nmatch) = '\0';
                if ((nmbchars = mbstowcs(NULL, tmptr, 0)) == -1) {
                        yyerror("invalid multibyte character encountered");
                        if (tmptr1 != NULL)
                                free(tmptr1);
                        return (0);
                }
                if (tmptr1 != NULL)
                        free(tmptr1);
                return (nmbchars);
#else
                return (loc2-s);
#endif
        }
        return (0);
}

static void
errxx()
{
        yyerror("RE error");
}

static void
yyerror(char *s)
{
#ifdef XPG6
        /* XPG6: stdout will always contain newline even on error */
        (void) write(1, "\n", 1);
#endif
        (void) write(2, "expr: ", 6);
        (void) write(2, gettext(s), (unsigned)strlen(gettext(s)));
        (void) write(2, "\n", 1);
        exit(2);
        /* NOTREACHED */
}

static char *
ltoa(long l)
{
        static char str[20];
        char *sp = &str[18];    /* u370 */
        int i;
        int neg = 0;

        if ((unsigned long)l == 0x80000000UL)
                return ("-2147483648");
        if (l < 0)
                ++neg, l = -l;
        str[19] = '\0';
        do {
                i = l % 10;
                *sp-- = '0' + i;
                l /= 10;
        } while (l);
        if (neg)
                *sp-- = '-';
        return (++sp);
}

static char *
lltoa(long long l)
{
        static char str[25];
        char *sp = &str[23];
        int i;
        int neg = 0;

        if (l == 0x8000000000000000ULL)
                return ("-9223372036854775808");
        if (l < 0)
                ++neg, l = -l;
        str[24] = '\0';
        do {
                i = l % 10;
                *sp-- = '0' + i;
                l /= 10;
        } while (l);
        if (neg)
                *sp-- = '-';
        return (++sp);
}

static char *
expres(int prior, int par)
{
        int ylex, temp, op1;
        char *r1, *ra, *rb, *rc;
        ylex = yylex();
        if (ylex >= NOARG && ylex < MATCH) {
                yyerror("syntax error");
        }
        if (ylex == A_STRING) {
                r1 = Av[Argi++];
                temp = Argi;
        } else {
                if (ylex == '(') {
                        paren++;
                        Argi++;
                        r1 = expres(0, Argi);
                        Argi--;
                }
        }
lop:
        ylex = yylex();
        if (ylex > NOARG && ylex < MATCH) {
                op1 = ylex;
                Argi++;
                if (pri[op1-OR] <= prior)
                        return (r1);
                else {
                        switch (op1) {
                        case OR:
                        case AND:
                                r1 = conj(op1, r1, expres(pri[op1-OR], 0));
                                break;
                        case EQ:
                        case LT:
                        case GT:
                        case LEQ:
                        case GEQ:
                        case NEQ:
                                r1 = rel(op1, r1, expres(pri[op1-OR], 0));
                                break;
                        case ADD:
                        case SUBT:
                        case MULT:
                        case DIV:
                        case REM:
                                r1 = arith(op1, r1, expres(pri[op1-OR], 0));
                                break;
                        case MCH:
                                r1 = match(r1, expres(pri[op1-OR], 0));
                                break;
                        }
                        if (noarg == 1) {
                                return (r1);
                        }
                        Argi--;
                        goto lop;
                }
        }
        ylex = yylex();
        if (ylex == ')') {
                if (par == Argi) {
                        yyerror("syntax error");
                }
                if (par != 0) {
                        paren--;
                        Argi++;
                }
                Argi++;
                return (r1);
        }
        ylex = yylex();
        if (ylex > MCH && ylex <= INDEX) {
                if (Argi == temp) {
                        return (r1);
                }
                op1 = ylex;
                Argi++;
                switch (op1) {
                case MATCH:
                        rb = expres(pri[op1-OR], 0);
                        ra = expres(pri[op1-OR], 0);
                        break;
                case SUBSTR:
                        rc = expres(pri[op1-OR], 0);
                        rb = expres(pri[op1-OR], 0);
                        ra = expres(pri[op1-OR], 0);
                        break;
                case LENGTH:
                        ra = expres(pri[op1-OR], 0);
                        break;
                case INDEX:
                        rb = expres(pri[op1-OR], 0);
                        ra = expres(pri[op1-OR], 0);
                        break;
                }
                switch (op1) {
                case MATCH:
                        r1 = match(rb, ra);
                        break;
                case SUBSTR:
                        r1 = substr(rc, rb, ra);
                        break;
                case LENGTH:
                        r1 = length(ra);
                        break;
                case INDEX:
                        r1 = index(rb, ra);
                        break;
                }
                if (noarg == 1) {
                        return (r1);
                }
                Argi--;
                goto lop;
        }
        ylex = yylex();
        if (ylex == NOARG) {
                noarg = 1;
        }
        return (r1);
}

void *
exprmalloc(size_t size)
{
        void *rv;

        if ((rv = malloc(size)) == NULL) {
                char *s = gettext("malloc error");

                (void) write(2, "expr: ", 6);
                (void) write(2, s, (unsigned)strlen(s));
                (void) write(2, "\n", 1);
                exit(3);
        }
        return (rv);
}

int
main(int argc, char **argv)
{
        /*
         * XCU4 allow "--" as argument
         */
        if (argc > 1 && strcmp(argv[1], "--") == 0)
                argv++, argc--;
        /*
         * XCU4 - print usage message when invoked without args
         */
        if (argc < 2) {
#ifdef XPG6
        /* XPG6: stdout will always contain newline even on error */
                (void) write(1, "\n", 1);
#endif
                (void) fprintf(stderr, gettext("Usage: expr expression\n"));
                exit(3);
        }
        Ac = argc;
        Argi = 1;
        noarg = 0;
        paren = 0;
        Av = argv;

        (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif
        (void) textdomain(TEXT_DOMAIN);
        buf = expres(0, 1);
        if (Ac != Argi || paren != 0) {
                yyerror("syntax error");
        }
        /*
         * XCU4 - strip leading zeros from numeric output
         */
        clean_buf(buf);
        (void) write(1, buf, (unsigned)strlen(buf));
        (void) write(1, "\n", 1);
        return ((strcmp(buf, "0") == 0 || buf[0] == 0) ? 1 : 0);
}