// math.c - mathematical expression evaluation

//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1992-1997 Paul Falstad

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Paul Falstad or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Paul Falstad and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Paul Falstad and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Paul Falstad and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zsh.mdh"

#include "math.pro"

#include <math.h>

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* nonzero means we are not evaluating, just parsing */

/**/

int noeval;

/* integer zero */

/**/

mod_export mnumber zero_mnumber;

/* last input base we used */

/**/

int lastbase;

static char *ptr;

static mnumber yyval;

static char *yylval;

#define MAX_MLEVEL 256

static int mlevel = 0;

/* != 0 means recognize unary plus, minus, etc. */

static int unary = 1;

/* LR = left-to-right associativity *

 * RL = right-to-left associativity *

 * BOOL = short-circuiting boolean   */

#define LR   0x0000

#define RL   0x0001

#define BOOL 0x0002

#define MTYPE(x)  ((x) & 3)

/*

 * OP_A2    2 arguments

 * OP_A2IR  2 arguments, return integer

 * OP_A2IO  2 arguments, must be integer, return integer

 * OP_E2    2 arguments with assignment

 * OP_E2IO  2 arguments with assignment, must be integer, return integer

 * OP_OP    None of the above, but occurs where we are expecting an operator

 *          rather than an operand.

 * OP_OPF   Followed by an operator, not an operand.

 *

 * OP_A2*, OP_E2*, OP_OP*:

 *   Occur when we need an operator; the next object must be an operand,

 *   unless OP_OPF is also supplied.

 *

 * Others:

 *   Occur when we need an operand; the next object must also be an operand,

 *   unless OP_OPF is also supplied.

 */

#define OP_A2   0x0004

#define OP_A2IR 0x0008

#define OP_A2IO 0x0010

#define OP_E2   0x0020

#define OP_E2IO 0x0040

#define OP_OP   0x0080

#define OP_OPF  0x0100

#define M_INPAR 0

#define M_OUTPAR 1

#define NOT 2

#define COMP 3

#define POSTPLUS 4

#define POSTMINUS 5

#define UPLUS 6

#define UMINUS 7

#define AND 8

#define XOR 9

#define OR 10

#define MUL 11

#define DIV 12

#define MOD 13

#define PLUS 14

#define MINUS 15

#define SHLEFT 16

#define SHRIGHT 17

#define LES 18

#define LEQ 19

#define GRE 20

#define GEQ 21

#define DEQ 22

#define NEQ 23

#define DAND 24

#define DOR 25

#define DXOR 26

#define QUEST 27

#define COLON 28

#define EQ 29

#define PLUSEQ 30

#define MINUSEQ 31

#define MULEQ 32

#define DIVEQ 33

#define MODEQ 34

#define ANDEQ 35

#define XOREQ 36

#define OREQ 37

#define SHLEFTEQ 38

#define SHRIGHTEQ 39

#define DANDEQ 40

#define DOREQ 41

#define DXOREQ 42

#define COMMA 43

#define EOI 44

#define PREPLUS 45

#define PREMINUS 46

#define NUM 47

#define ID 48

#define POWER 49

#define CID 50

#define POWEREQ 51

#define FUNC 52

#define TOKCOUNT 53

/* precedences */

static int prec[TOKCOUNT] =

{

     1, 137,  2,  2,   2,

     2,   2,  2,  4,   5,

     6,   8,  8,  8,   9,

     9,   3,  3, 10,  10,

    10,  10, 11, 11,  12,

    13,  13, 14, 15,  16,

    16,  16, 16, 16,  16,

    16,  16, 16, 16,  16,

    16,  16, 16, 17, 200,

     2,   2,  0,  0,   7,

     0,  16, 0

};

#define TOPPREC 18

#define ARGPREC 16

static int type[TOKCOUNT] =

{

/*  0 */  LR, LR|OP_OP|OP_OPF, RL, RL, RL|OP_OP|OP_OPF,

/*  5 */  RL|OP_OP|OP_OPF, RL, RL, LR|OP_A2IO, LR|OP_A2IO,

/* 10 */  LR|OP_A2IO, LR|OP_A2, LR|OP_A2, LR|OP_A2IO, LR|OP_A2,

/* 15 */  LR|OP_A2, LR|OP_A2IO, LR|OP_A2IO, LR|OP_A2IR, LR|OP_A2IR,

/* 20 */  LR|OP_A2IR, LR|OP_A2IR, LR|OP_A2IR, LR|OP_A2IR, BOOL|OP_A2IO,

/* 25 */  BOOL|OP_A2IO, LR|OP_A2IO, RL|OP_OP, RL|OP_OP, RL|OP_E2,

/* 30 */  RL|OP_E2, RL|OP_E2, RL|OP_E2, RL|OP_E2, RL|OP_E2IO,

/* 35 */  RL|OP_E2IO, RL|OP_E2IO, RL|OP_E2IO, RL|OP_E2IO, RL|OP_E2IO,

/* 40 */  BOOL|OP_E2IO, BOOL|OP_E2IO, RL|OP_A2IO, RL|OP_A2, RL|OP_OP,

/* 45 */  RL, RL, LR|OP_OPF, LR|OP_OPF, RL|OP_A2,

/* 50 */  LR|OP_OPF, RL|OP_E2, LR|OP_OPF

};

static int

lexconstant(void)

{

#ifdef USE_LOCALE

    char *prev_locale;

#endif

    char *nptr;

    nptr = ptr;

    if (*nptr == '-')

	nptr++;

    if (*nptr == '0')

    {

	nptr++;

	if (*nptr == 'x' || *nptr == 'X') {

	    /* Let zstrtol parse number with base */

	    yyval.u.l = zstrtol(ptr, &ptr, 0);

	    /* Should we set lastbase here? */

	    lastbase = 16;

	    return NUM;

	}

	else if (isset(OCTALZEROES) &&

		 (memchr(nptr, '.', strlen(nptr)) == NULL) &&

		 idigit(*nptr)) {

	    yyval.u.l = zstrtol(ptr, &ptr, 0);

	    lastbase = 8;

	    return NUM;

	}

    }

    while (idigit(*nptr))

	nptr++;

    if (*nptr == '.' || *nptr == 'e' || *nptr == 'E') {

	/* it's a float */

	yyval.type = MN_FLOAT;

#ifdef USE_LOCALE

	prev_locale = dupstring(setlocale(LC_NUMERIC, NULL));

	setlocale(LC_NUMERIC, "POSIX");

#endif

	yyval.u.d = strtod(ptr, &nptr);

#ifdef USE_LOCALE

	if (prev_locale) setlocale(LC_NUMERIC, prev_locale);

#endif

	if (ptr == nptr || *nptr == '.') {

	    zerr("bad floating point constant", NULL, 0);

	    return EOI;

	}

	ptr = nptr;

    } else {

	/* it's an integer */

	yyval.u.l = zstrtol(ptr, &ptr, 10);

	if (*ptr == '#') {

	    ptr++;

	    yyval.u.l = zstrtol(ptr, &ptr, lastbase = yyval.u.l);

	}

    }

    return NUM;

}

/**/

int outputradix;

/**/

static int

zzlex(void)

{

    int cct = 0;

    yyval.type = MN_INTEGER;

    for (;; cct = 0)

	switch (*ptr++) {

	case '+':

	    if (*ptr == '+' && (unary || !ialnum(*ptr))) {

		ptr++;

		return (unary) ? PREPLUS : POSTPLUS;

	    }

	    if (*ptr == '=') {

		ptr++;

		return PLUSEQ;

	    }

	    return (unary) ? UPLUS : PLUS;

	case '-':

	    if (*ptr == '-' && (unary || !ialnum(*ptr))) {

		ptr++;

		return (unary) ? PREMINUS : POSTMINUS;

	    }

	    if (*ptr == '=') {

		ptr++;

		return MINUSEQ;

	    }

	    if (unary) {

		if (idigit(*ptr) || *ptr == '.') {

		    ptr--;

		    return lexconstant();

		} else

		    return UMINUS;

	    } else

		return MINUS;

	case '(':

	    return M_INPAR;

	case ')':

	    return M_OUTPAR;

	case '!':

	    if (*ptr == '=') {

		ptr++;

		return NEQ;

	    }

	    return NOT;

	case '~':

	    return COMP;

	case '&':

	    if (*ptr == '&') {

		if (*++ptr == '=') {

		    ptr++;

		    return DANDEQ;

		}

		return DAND;

	    } else if (*ptr == '=') {

		ptr++;

		return ANDEQ;

	    }

	    return AND;

	case '|':

	    if (*ptr == '|') {

		if (*++ptr == '=') {

		    ptr++;

		    return DOREQ;

		}

		return DOR;

	    } else if (*ptr == '=') {

		ptr++;

		return OREQ;

	    }

	    return OR;

	case '^':

	    if (*ptr == '^') {

		if (*++ptr == '=') {

		    ptr++;

		    return DXOREQ;

		}

		return DXOR;

	    } else if (*ptr == '=') {

		ptr++;

		return XOREQ;

	    }

	    return XOR;

	case '*':

	    if (*ptr == '*') {

		if (*++ptr == '=') {

		    ptr++;

		    return POWEREQ;

		}

		return POWER;

	    }

	    if (*ptr == '=') {

		ptr++;

		return MULEQ;

	    }

	    return MUL;

	case '/':

	    if (*ptr == '=') {

		ptr++;

		return DIVEQ;

	    }

	    return DIV;

	case '%':

	    if (*ptr == '=') {

		ptr++;

		return MODEQ;

	    }

	    return MOD;

	case '<':

	    if (*ptr == '<') {

		if (*++ptr == '=') {

		    ptr++;

		    return SHLEFTEQ;

		}

		return SHLEFT;

	    } else if (*ptr == '=') {

		ptr++;

		return LEQ;

	    }

	    return LES;

	case '>':

	    if (*ptr == '>') {

		if (*++ptr == '=') {

		    ptr++;

		    return SHRIGHTEQ;

		}

		return SHRIGHT;

	    } else if (*ptr == '=') {

		ptr++;

		return GEQ;

	    }

	    return GRE;

	case '=':

	    if (*ptr == '=') {

		ptr++;

		return DEQ;

	    }

	    return EQ;

	case '$':

	    yyval.u.l = mypid;

	    return NUM;

	case '?':

	    if (unary) {

		yyval.u.l = lastval;

		return NUM;

	    }

	    return QUEST;

	case ':':

	    return COLON;

	case ',':

	    return COMMA;

	case '\0':

	    ptr--;

	    return EOI;

	case '[':

	    {

		int n;

		if (idigit(*ptr)) {

		    n = zstrtol(ptr, &ptr, 10);

		    if (*ptr != ']' || !idigit(*++ptr)) {

			zerr("bad base syntax", NULL, 0);

			return EOI;

		    }

		    yyval.u.l = zstrtol(ptr, &ptr, lastbase = n);

		    return NUM;

		}

		if (*ptr == '#') {

		    n = 1;

		    if (*++ptr == '#') {

			n = -1;

			ptr++;

		    }

		    if (!idigit(*ptr))

			goto bofs;

		    outputradix = n * zstrtol(ptr, &ptr, 10);

		} else {

		    bofs:

		    zerr("bad output format specification", NULL, 0);

		    return EOI;

		}

		if(*ptr != ']')

			goto bofs;

		ptr++;

		break;

	    }

	case ' ':

	case '\t':

	case '\n':

	    break;

	/* Fall through! */

	default:

	    if (idigit(*--ptr) || *ptr == '.')

		return lexconstant();

	    if (*ptr == '#') {

		if (*++ptr == '\\' || *ptr == '#') {

		    int v;

		    ptr++;

		    if (!*ptr) {

			zerr("character missing after ##", NULL, 0);

			return EOI;

		    }

		    ptr = getkeystring(ptr, NULL, 6, &v);

		    yyval.u.l = v;

		    return NUM;

		}

		cct = 1;

	    }

	    if (iident(*ptr)) {

		int func = 0;

		char *p;

		p = ptr;

		while (iident(*++ptr));

		if (*ptr == '[' || (!cct && *ptr == '(')) {

		    char op = *ptr, cp = ((*ptr == '[') ? ']' : ')');

		    int l;

		    func = (op == '(');

		    for (ptr++, l = 1; *ptr && l; ptr++) {

			if (*ptr == op)

			    l++;

			if (*ptr == cp)

			    l--;

			if (*ptr == '\\' && ptr[1])

			    ptr++;

		    }

		}

		yylval = dupstrpfx(p, ptr - p);

		return (func ? FUNC : (cct ? CID : ID));

	    }

	    else if (cct) {

		yyval.u.l = poundgetfn(NULL);

		return NUM;

	    }

	    return EOI;

	}

}

/* the value stack */

#define STACKSZ 100

static int mtok;			/* last token */

static int sp = -1;			/* stack pointer */

struct mathvalue {

    char *lval;

    mnumber val;

};

static struct mathvalue *stack;

/**/

static void

push(mnumber val, char *lval, int getme)

{

    if (sp == STACKSZ - 1)

	zerr("stack overflow", NULL, 0);

    else

	sp++;

    stack[sp].val = val;

    stack[sp].lval = lval;

    if (getme)

	stack[sp].val.type = MN_UNSET;

}