cexp.cc

/*
 * kate: default-dictionary en_US; tab-width 4; tab-indents true;
 *
 *	C Expression Evaluator
 *
 *	This program is distributed under the terms of the GPL v3.0 or later
 *	Download the GNU Public License (GPL) from <https://www.gnu.org>
 *
 *	Copyright(C) 2025, Free Software Foundation, Inc.
 *	Written by Nicholas Christopoulos <mailto:netnic@proton.me>
 */

#ifndef CEXP_H
#define CEXP_H 		0x10000

#include <cstring>
#include <cstdarg>
#include <string>
#include <vector>
#include <stack>
#include <unordered_map>

#ifndef CEXP_USE_PROPS
	#define CEXP_USE_PROPS
#endif

/*
 * Default data types
 */
#ifndef CEXP_DATA_T
#define CEXP_DATA_T
typedef ssize_t		int_t;
typedef size_t		uint_t;
typedef double		real_t;
#endif

#include "cvar.cc"		// variant variables

/*
 * 	Function definitions
 */
typedef struct cexp_func_s {
	int n_args;								// number of arguments, -1 for unknown
	real_t (*std_math_1)(real_t);			// pointer to standard math library routine
	real_t (*std_math_2)(real_t,real_t);	// pointer to standard math library routine
	int (*custom_N)(const std::vector<CVar>&, CVar *);	// pointer to function with variable number of arguments
	} cexp_func_t;

// error codes, defined by developer
// user must only use E_SUCCESS or !E_SUCCESS
typedef enum { E_SUCCESS,
		E_DIV_ZERO,
		E_SYNTAX, E_TYPE_MM, E_NO_OP, E_OP_FOUND,
		E_STACK_UNDERFLOW_V, E_STACK_UNDERFLOW_OP, E_OUT_OF_INDEX,
		E_FUNC_NOT_FOUND, E_FUNC_ERROR, E_EXCEPTION = 666
		} cexp_error_t;

/*
 *	Evaluator - main class
 */
class CExp {
public:
	int verbose; 	// print debug messages - ignore it
	cexp_error_t error_code;	// error code
	std::string  error_message;	// error message

protected:
	std::unordered_map<std::string,cexp_func_t> funcs; // functions
	std::unordered_map<std::string,CVar> vars;	// variables
	
public:
	CExp();
	virtual ~CExp() { }

	// -- functions management ---

	// add a standard math function
	void add_func(const char *name, real_t (*f)(real_t));
	// add a standard math function with two double parameters
	void add_func(const char *name, real_t (*f)(real_t,real_t));
	// add a function with `n` number of variant parameters
	void add_func(const char *name, int n, int (*f)(const std::vector<CVar>& args, CVar *result));
	// add a function with unlimited number of variant parameters
	void add_func(const char *name, int (*f)(const std::vector<CVar>& args, CVar *result))
		{ add_func(name, -1, f); }

	// --- variables management ---

	// get variant, on error exception will be thrown
	const CVar& getvar(const char *name, const char *prop = NULL) const;
	CVar& getvar(const char *name, const char *prop = NULL);

	// get variable pointer or NULL if not found
	const CVar *getvar_p(const char *name, const char *prop = NULL) const;
	CVar *getvar_p(const char *name, const char *prop = NULL);

	// set the value of the variable
	void setvar(const char *name, const CVar& data);
	void setvar(const char *name, real_t n);
	void setvar(const char *name, int_t n);
	void setvar(const char *name, const char *s);

	// remove the variable
	bool unsetvar(const char *name);

	// --- main routine ---

	// execute the expression `source` and get the result in the
	// `result` variable.
	// On success returns zero; otherwise returns the error code.
	cexp_error_t evaluate(const char *source, CVar *result);

	// execute the expressions in `source` and get the multiple results
	// in the `result` vector<>.
	// On success returns zero; otherwise returns the error code.
	cexp_error_t evaluate(const char *source, std::vector<CVar> *result);

protected:
	// set error
	void set_error(cexp_error_t code, const char *fmt, ...);

	// string utils
	int  is_opchar(int c) const;
	int  is_keyword(int c) const;
	int  c_esc_char(const char *s, size_t *count) const;
	char *remove_spaces(const char *src) const;

	// operator utilities
	int  find_opcode(int op) const;
	int  find_assign_opcode(int op) const;
	int  find_op(const char *src, bool is_assign_op) const;
	int  find_unary(const char *src) const;
	int  precedence(int op) const;

	// evaluator utilities
	static int eval(const std::vector<CVar>& args, CVar *result);
	CVar apply_op(const CVar& a, const CVar& b, int op) const;
	CVar apply_unary(const CVar& v, int op) const;
	const char *parse_num(const char *p, real_t *val) const;
	const char *parse_function(const char *p, const char *name, CVar *r);
	const char *parse_string(const char *p, CVar *r) const;
	const char *parse_keyword(const char *p, char *buf, size_t len) const;
	// create variable / property if does not exist
	CVar *mkvar_p(const char *name, const char *prop);
	// assign value to variable and/or property based on operator code `op`
	void var_assign(int op, const char *name, const char *prop, CVar& value);
	const char *evaluate_p(const char *tokens, CVar *result,
					const char *xset, std::vector<CVar> *rstk = NULL);
	};

#endif

// --- implamentation --------------------------------------------------------- */
#ifdef CEXP_IMPL

#include <cassert>
#include <cstdint>
#include <climits>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cstdarg>
#include <ctime>
#include <cmath>
#include <stdexcept>
using namespace std;

// matrices
#include "cmatrix.cc"

// variant variables
#define CVAR_IMPL	// include the implamentation
#include "cvar.cc"

// additional math functions
#include "cexp-lib.cc"

#define M_PHI	1.61803398874989484820

#define UNARY_BIT	0x80000000
#define UNARY_MASK	0x7fffffff

#if !defined(MAX)
	#define MAX(a,b)	((a)>(b) ? (a) : (b))
#endif

#define OP2(a,b)	(((b)<<8)|(a))
#define OP3(a,b,c)	(((c)<<16)|((b)<<8)|(a))
#define OPSIZE(x)	( (((x) & 0xff0000) ? 3 : (((x) & 0xff00) ? 2 : (((x) & 0xff) ? 1 : 0) ) ) )

// returns true if 'c' is an octal-digit character
static inline int isoctal(int c)
	{ return ((c >= '0') && (c <= '7')); }

// returns the value of hexadecimal-digit 'c'
static inline int hex_digit_val(int c) {
	if      ( c >= 'a' ) return (c - 'a') + 10;
	else if ( c >= 'A' ) return (c - 'A') + 10;
	return (c - '0');
	}

/*
 * returns the ASCII value of escaped string 's'
 * in 'count' returned the bytes of 's' that used
 */
int CExp::c_esc_char(const char *s, size_t *count) const {
	const char *p = s;
	int         c = *p, n, i, cnt;
	*count = 1;
	switch ( *p ) {
	case '\n': return ' ';	// error, continue to the next line
	case 'a': return 7;
	case 'b': return '\b';
	case 'n': return '\n';
	case 'r': return '\r';
	case 't': return '\t';
	case 'v': return '\v';
	case 'f': return '\f';
	case 'e': return '\033';
	case '0': case '1': case '2': case '3':
	case '4': case '5': case '6': case '7':
		n = 0;
		n |= (*p - '0') << 6;
		if ( !isoctal(* ++p) ) return *p;
		n |= (*p - '0') << 3; (*count) ++;
		if ( !isoctal(* ++p) ) return *p;
		n |= (*p - '0'); (*count) ++;
		return n;
	case 'x': // hexadecimal
		cnt = 2; goto hexinp;
	case 'u': // unicode 16bit
		cnt = 4; goto hexinp;
	case 'U': // unicode 32bit
		cnt = 8;
hexinp:
		n = 0;
		for ( i = 0; i < cnt; i ++ ) {
			if ( !isxdigit(* ++p) ) return *p;
			(*count) ++;
			n = (n << 4) | hex_digit_val(*p);
			}
		return n;
		}
	return c;
	}

/* -------------------------------------------------------------------------------- */

// utility function, removes all spaces from string src
// returns a newly allocated string with the results
char *CExp::remove_spaces(const char *src) const {
	char *base = strdup(src);
	char *p = base;
	char *d, *dest = (char *) malloc(strlen(base)+1);
	int  dq = 0, sq = 0;

	d = dest;
	while ( *p ) {
		if ( *p == '\'' ) {
			// toggle single quotes block
			sq = !sq;
			*d ++ = *p ++;
			continue;
			}
		if ( sq ) {
			// inside single quotes block
			*d ++ = *p ++;
			continue;
			}
		
		if ( *p == '\\' ) {
			// escape character
			size_t count;
			p ++;
			*d ++ = c_esc_char(p, &count);
			p += count;
			continue;
			}
		
		if ( *p == '$' ) {
			// environment variable or shell command
			char buf[1024], *t = buf,  *e = NULL;
			FILE *fp;
			p ++;
			if ( *p == '{' ) {
				p ++;
				while ( *p && *p != '}' && (t - buf) < 1023 )
					*t ++ = *p ++;
				*t = '\0';
				if ( *p ) p ++;
				if ( getenv(buf) )
					e = strdup(getenv(buf));
				}
			else if ( *p == '(' ) {
				p ++;
				while ( *p && *p != ')' && (t - buf) < 1023 )
					*t ++ = *p ++;
				*t = '\0';
				if ( *p ) p ++;
				// run command
				if ( (fp = popen(buf, "r")) != NULL ) {
					char line[1024];
					while ( fgets(line, 1024, fp) ) {
						if ( e ) {
							e = (char *) realloc(e, strlen(e) + strlen(line) + 1);
							strcat(e, line);
							}
						else {
							e = (char *) malloc(strlen(line) + 1);
							strcpy(e, line);
							}
						}
					if ( e ) {
						size_t len = strlen(e);
						while ( *e && e[-- len] == '\n' )
							e[len] = '\0';
						}
					pclose(fp);
					}
				}
			else if ( isalpha(*p) || *p == '_' ) {
				while ( (isalnum(*p) || *p == '_') && (t - buf) < 1023 )
					*t ++ = *p ++;
				*t = '\0';
				if ( getenv(buf) )
					e = strdup(getenv(buf));
				}
			else {
				// itsnt valid 
				p --; // back, point to '$'
				goto noenv_var;
				}

			// copy the result
			if ( e ) {
/* copy to destination buffer
				if ( strlen(buf) < strlen(e) ) {
					size_t	pos = d - dest;
					*d = '\0';
					dest = (char *) realloc(dest, strlen(dest) + strlen(e) + 1);
					d = dest + pos;
					}
				while ( *e )
					*d ++ = *e ++; */
/* copy to source buffer */
				size_t	ppos = p - base;
				base = (char *) realloc(base, strlen(base) + strlen(e) + 1);
				p = base + ppos;
				memcpy(base+ppos+strlen(e), p, strlen(p)+1);
				memcpy(base+ppos, e, strlen(e));
				p = base + ppos;

				// resize destination
				size_t	dpos = d - dest;
				*d = '\0';
				dest = (char *) realloc(dest, strlen(dest) + strlen(p) + 1);
				d = dest + dpos;
				
				// free $$ results buffer
				free(e);
				}
			continue;
			}
noenv_var:
		
		if ( *p == '"' ) {
			// toggle real_t quotes block
			dq = !dq;
			*d ++ = *p ++;
			continue;
			}
		if ( dq ) {
			// inside real_t quotes block
			*d ++ = *p ++;
			continue;
			}
		
		if ( isspace(*p) )
			p ++;
		else
			*d ++ = *p ++;
		}
	*d = '\0';
	free(base);
	return dest;
	}

// --------------------------------------------------------------------------------

/* static */ int CExp::eval(const vector<CVar>& args, CVar *result) {
	CExp cexp;
	if ( args.size() != 1 ) throw runtime_error("eval(): wrong number of parameters");
	if ( args[0].type != v_str ) throw runtime_error("eval(): parameter is not string");
	try { return cexp.evaluate(args[0].gets().c_str(), result); }
	catch ( ... ) { throw; }
	}

CExp::CExp() {
	CVar r;
	verbose = 0;
	error_code = E_SUCCESS;
	srand(clock() % RAND_MAX);
	
	// add constants
	setvar("pi",     M_PI);
	setvar("e",      M_E);
	setvar("phi",    M_PHI);
	setvar("log2e",  M_LOG2E);
	setvar("log10e", M_LOG10E);
	setvar("ln2",    M_LN2);
	setvar("ln10",   M_LN10);

	// add default functions
	add_func("abs", fabs);
	add_func("dim", fdim);
	add_func("sin", sin);
	add_func("sinh", sinh);
	add_func("cos",  cos);
	add_func("cosh", cosh);
	add_func("tan",  tan);
	add_func("tanh", tanh);
	add_func("log10", log10);
	add_func("log",  log);
	add_func("exp",  exp);
	add_func("log2",  log2);
	add_func("exp2",  exp2);
	add_func("asin",  asin);
	add_func("asinh", asinh);
	add_func("acos",  acos);
	add_func("acosh", acosh);
	add_func("atan",  atan);
	add_func("atanh", atanh);
	add_func("atan2", atan2);
	add_func("pow",   pow);
	add_func("sqrt",  sqrt);
	add_func("cbrt",  cbrt);
	add_func("rint",  rint);
	add_func("round", round);
	add_func("trunc", trunc);
	add_func("floor", floor);
	add_func("ceil",  ceil);
	add_func("mod",   fmod);
	add_func("rem",   remainder);
	add_func("hypot", hypot);

	add_func("deg", deg);
	add_func("rad", rad);
	add_func("sgn", sgn);
	add_func("rnd", rnd);
	add_func("inv", 1, inv);
	add_func("t", 1, transp);
	add_func("i", 1, identity);
	add_func("det", 1, det);

	add_func("eval",  1, eval);
	add_func("min", -1, vmin);
	add_func("max", -1, vmax);	
	add_func("pf",  -1, pf);
	add_func("if",   3, iff);
	}

void  CExp::add_func(const char *name, real_t (*f)(real_t)) {
	cexp_func_t p = {};
	p.n_args = 1;
	p.std_math_1 = f;
	funcs.insert_or_assign(name, p);
	}
void  CExp::add_func(const char *name, real_t (*f)(real_t,real_t)) {
	cexp_func_t p = {};
	p.n_args = 2;
	p.std_math_2 = f;
	funcs.insert_or_assign(name, p);
	}
void  CExp::add_func(const char *name, int n, int (*f)(const vector<CVar>& args, CVar *result)) {
	cexp_func_t p = {};
	p.n_args = n;
	p.custom_N = f;
	funcs.insert_or_assign(string(name), p);
	}

// returns pointer to the variable `name`
const CVar *CExp::getvar_p(const char *name, const char *prop) const {
    auto it_var = vars.find(name);
    if ( it_var != vars.end() ) {
		const CVar *v = &(it_var->second);
#ifdef CEXP_USE_PROPS
		if ( prop ) {
		    auto it = v->props.find(prop);
			if ( it != v->props.end() )
				return &(it->second);
			}
		else
#endif
			return v;
		}
	return NULL;
	}
CVar *CExp::getvar_p(const char *name, const char *prop) {
    auto it_var = vars.find(name);
    if ( it_var != vars.end() ) {
		CVar *v = &(it_var->second);
#ifdef CEXP_USE_PROPS
		if ( prop ) {
		    auto it = v->props.find(prop);
			if ( it != v->props.end() )
				return &(it->second);
			}
		else
#endif
			return v;
		}
	return NULL;
	}
CVar *CExp::mkvar_p(const char *name, const char *prop) {
    auto it_var = vars.find(name);
    if ( it_var == vars.end() ) {
		if ( vars.insert_or_assign(name, CVar()).second )
			it_var = vars.find(name);
		}
#ifdef CEXP_USE_PROPS
	if ( prop ) {
		CVar *v = &(it_var->second);
	    auto it_pro = v->props.find(prop);
	    if ( it_pro == v->props.end() ) {
			if ( v->props.insert_or_assign(prop, CVar()).second )
				it_pro = v->props.find(prop);
			}
		return &(it_pro->second);
		}
#endif
	return &(it_var->second);
	}

const CVar& CExp::getvar(const char *name, const char *prop) const {
    auto it_var = vars.find(name);
	if ( it_var != vars.end() ) {
#ifdef CEXP_USE_PROPS
		const CVar *v = &(it_var->second);
		if ( prop ) {
			auto it = v->props.find(prop);
			if ( it != v->props.end() )
				return it->second;
			throw runtime_error("property not found"); // error
			}
#endif
		return it_var->second;
		}
	throw runtime_error("variable not found"); // error
	}
CVar& CExp::getvar(const char *name, const char *prop) {
    auto it_var = vars.find(name);
	if ( it_var != vars.end() ) {
#ifdef CEXP_USE_PROPS
		CVar *v = &(it_var->second);
		if ( prop ) {
			auto it = v->props.find(prop);
			if ( it != v->props.end() )
				return it->second;
			throw runtime_error("property not found"); // error
			}
#endif
		return it_var->second;
		}
	throw runtime_error("variable not found"); // error
	}

// creates a new variable with `name` and the values of `v` and store it
// in the engine. returns pointer to the newly created variable.
void CExp::setvar(const char *name, const CVar& data)
	{ vars.insert_or_assign(name, data); }
void CExp::setvar(const char *name, real_t n)
	{ vars.insert_or_assign(name, CVar(n)); }
void CExp::setvar(const char *name, int_t n)
	{ vars.insert_or_assign(name, CVar(n)); }
void CExp::setvar(const char *name, const char *s)
	{ vars.insert_or_assign(name, CVar(s)); }

// removes the variable `name` from the engine's memory.
bool CExp::unsetvar(const char *name) {
	auto it = vars.find(name);
    if ( it != vars.end() ) {
		vars.erase(it);
		return true;
		}
	return false;
	}

// handle errors 
void CExp::set_error(cexp_error_t code, const char *fmt, ...) {
	int		n;
	size_t	size;
	char	*buf;
	va_list	ap;
	
	error_code = code;
	va_start(ap, fmt);
	n = vsnprintf(NULL, 0, fmt, ap);	
	va_end(ap);
	assert(n > 0);
	if ( n < 0 ) return;
	size = (size_t) n + 1;
	buf = (char *) malloc(size);
	assert(buf);
	va_start(ap, fmt);
	n = vsnprintf(buf, size, fmt, ap);	
	va_end(ap);
	assert(n > 0);
	error_message = string(buf);
	free(buf);
	}

// returns true if `c` belongs to operators class
int CExp::is_opchar(int c) const {
	if ( isgraph(c) && !isalnum(c)
		 && c != '_' && c < 127
	   	&& c != ',' && c != '"' && c != '\'' )
		return 1;
	return 0;
	}

// returns true if `c` belongs to keyword class
int CExp::is_keyword(int c) const {
	if ( isalnum(c) || (c == '_') )
		return 1;
	return 0;
	}

// find precedence of operators.
int CExp::precedence(int op) const {
	switch ( op ) {
	case OP2('|','|'):
		return 2;
	case OP2('&','&'):
		return 3;
	case '|':
		return 4;
	case '#':
		return 5;
	case '&':
		return 6;
	case OP2('=','='):
	case OP2('!','='):
		return 7;
	case OP2('>','='):
	case OP2('<','='):
	case '>': case '<':
		return 8;
	case OP2('<','<'):
	case OP2('>','>'):
		return 9;
	case '+': case '-':
		return 10;
	case '*': case '/': case '%':
		return 11;
	case '^':
	case OP2('*','*'):
		return 12;
	case '[': case '(': case '{':
	case ']': case ')': case '}': case ',':
		return 200;
	default:
		if ( op & UNARY_BIT )
			return 100;
		}
	return 0;
	}

// perform arithmetic operations.
CVar CExp::apply_op(const CVar& a, const CVar& b, int op) const {
	if ( verbose )
		printf("eval: apply operator %g %d %g\n", a.getf(), op, b.getf());

	try {
		switch ( op ) {
		case '+': return a + b;
		case '-': return a - b;
		case '*': return a * b;
		case '/': return a / b;
		case '%': return a % b;
		case '^': case OP2('*','*'):
			if ( a.type == v_matrix )
				return (a.m.power(b.geti()));
			if ( a.type <= v_str && b.type <= v_str )
				return pow(a.getf(), b.getf());
			throw runtime_error("Type mismatch");
		case OP2('<','<'): return (a.geti() << b.geti());
		case OP2('>','>'): return (a.geti() >> b.geti());
		case OP2('=','='): return ((a.getf() == b.getf()) ? 1 : 0);
		case OP2('!','='): return ((a.getf() != b.getf()) ? 1 : 0);
		case OP2('>','='): return ((a.getf() >= b.getf()) ? 1 : 0);
		case OP2('<','='): return ((a.getf() <= b.getf()) ? 1 : 0);
		case '>': return ((a.getf() > b.getf()) ? 1 : 0);
		case '<': return ((a.getf() < b.getf()) ? 1 : 0);
		case '&': return (a.geti() & b.geti());
		case '|': return (a.geti() | b.geti());
		case '#': return (a.geti() ^ b.geti());
		case OP2('&','&'):
			if ( a.getf() && b.getf() ) return 1;
			return 0;
		case OP2('|','|'):
			if ( a.getf() || b.getf() ) return 1;
			return 0;
			}
		}
	catch(...) { throw; };
	throw runtime_error("Missing operator (contact to creator)");
	}

// part of find_op
int CExp::find_opcode(int op) const {
	switch ( op ) {
	case OP2('*','*'):
	case OP2('=','='): case OP2('!','='):
	case OP2('>','='): case OP2('<','='):
	case OP2('<','<'): case OP2('>','>'):
	case OP2('&','&'): case OP2('|','|'):
	case '+': case '-':
	case '*': case '/': case '%': case '^':
	case '>': case '<':
	case '&': case '|': case '#':
		return op;
		}
	return 0;
	}

// part of find_op; assignment operators
int  CExp::find_assign_opcode(int op) const {
	switch ( op ) {
//	case OP3('<','<','='): case OP3('>','>','='):
	case OP2('+','='):	case OP2('-','='):
	case OP2('*','='): case OP2('/','='): case OP2('%','='):
//	case OP2('&','='): case OP2('|','='): case OP2('#','='):
	case OP2(':','='): case '=': 
		return op;
		}
	return 0;
	}

// returns the operator if src points to operator (1-3 chars)
// otherwise returns 0
int	CExp::find_op(const char *src, bool is_assign_op) const {
	int op, r = 0;
	
	if ( src[0] && is_opchar(src[1]) && is_opchar(src[2]) ) {
		op = OP3(src[0], src[1], src[2]);
		r = ( is_assign_op ) ? find_assign_opcode(op) : find_opcode(op);
		}
	if ( r == 0 && src[0] && is_opchar(src[1]) ) {
		op = OP2(src[0], src[1]);
		r = ( is_assign_op ) ? find_assign_opcode(op) : find_opcode(op);
		}
	if ( r == 0 && src[0] ) {
		op = src[0];
		r = ( is_assign_op ) ? find_assign_opcode(op) : find_opcode(op);
		}
	
	return r;
	}

// perform unary operations.
CVar CExp::apply_unary(const CVar& v, int op) const {
	op &= UNARY_MASK;
	switch ( op ) {
	case '+':
		return v;
	case '-':
		if ( v.type == v_int )
			return -v.geti();
		if ( v.type <= v_str )
			return -v.getf();
		if ( v.type == v_matrix )
			return -v.m;
		break;
	case '!':
		if ( v.type == v_int )
			return ( v.geti() ) ? 0 : -1;
		if ( v.type <= v_str )
			return ( v.getf() ) ? 0 : -1;
		break;
	case '~':
		if ( v.type <= v_str )
			return ~v.geti();
		break;
		}
	throw runtime_error("Type mismatch");
	}

// returns the prefix [unary] operator if src points to operator (1-3 chars)
// otherwise returns 0
int CExp::find_unary(const char *src) const {
	int op = src[0];
	switch ( op ) {
		case '+': case '-':
		case '!': case '~':
			return op;
		}
	return 0;
	}

// parse number and return it to `val`
// on input `p` must points the first digit.
const char *CExp::parse_num(const char *p, real_t *val) const {
	*val = 0.0;
	if ( *p == '0' ) {
		if ( *(p+1) == '.' ) { // decimal / float
			p += 2;
			real_t l = 1;
			while ( isdigit(*p) ) {
				*val += (*p - '0') * (l *= 0.1);
				p ++;
				}
			// exponent format
			if ( toupper(p[0]) == 'E' && (p[1] == '+' || p[1] == '-') ) {
				char buf[64], *t = buf;
				p ++;	// E
				*t ++ = *p ++; // sign
				if ( *p == '0' ) p ++; // at least two digit, the first may be zero
				while ( isdigit(*p) && (t - buf) < 63 )
					*t ++ = *p ++;
				*t = '\0';
				*val = *val * pow(10, atoi(buf));
				}
			}
		else if ( *(p+1) == 'x' ) { // hexadecimal
			p += 2;
			while ( isxdigit(*p) ) {
				if ( *p >= 'A' )
					*val = (*val * 16) + ((toupper(*p) - 'A') + 10);
				else
					*val = (*val * 16) + (*p - '0');
				p ++;
				}
			}
		else { // octal
			p ++;
			while ( isoctal(*p) ) {
				*val = (*val * 8) + (*p - '0');
				p ++;
				}
			}
		}
	else { // decimal
		int intpart = 1;
		real_t l = 1;
		while ( isdigit(*p) || *p == '.' ) {
			if ( *p == '.' )
				intpart = 0;
			else if ( intpart )
				*val = (*val * 10) + (*p - '0');
			else
				*val += (*p - '0') * (l *= 0.1);
			p ++;
			}
		// exponent format
		if ( toupper(p[0]) == 'E' && (p[1] == '+' || p[1] == '-') ) {
			char buf[64], *t = buf;
			p ++;	// E
			*t ++ = *p ++; // sign
			if ( *p == '0' ) p ++; // at least two digit, the first may be zero
			while ( isdigit(*p) && (t - buf) < 63 )
				*t ++ = *p ++;
			*t = '\0';
			*val = *val * pow(10, atoi(buf));
			}
		}
	return p;
	}

// parse function's parameters, execute and return the result.
// on input `p` must points to '('
const char *CExp::parse_function(const char *p, const char *name, CVar *r) {
	cexp_func_t *f;
	
	p ++;
	auto it = funcs.find(name);
	if ( it != funcs.end() ) {
		vector<CVar> args;
		f = &(it->second);

		if ( f->n_args >= 0 ) {
			for ( int i = 0; i < f->n_args; i ++ ) {
				p = evaluate_p(p, r, ((i == f->n_args - 1) ? ")" : ","));
				args.push_back(*r);
				}
			}
		else { // unlimited mode
			do {
				p = evaluate_p(p, r, ",)");
				args.push_back(*r);
				} while ( *p && *(p-1) != ')' );
			}
		
		if ( f->std_math_1 )
			r->setf(f->std_math_1(args[0].getf()));
		else if ( f->std_math_2 )
			r->setf(f->std_math_2(args[0].getf(), args[1].getf()));
		else if ( f->custom_N ) {
			int e;
			if ( (e = f->custom_N(args, r)) != 0 )
				set_error(E_FUNC_ERROR, "Custom function `%s` error: `%d`", name, e);
			}
		}
	else
		set_error(E_FUNC_NOT_FOUND, "Function `%s` not found", name);
	
	return p;
	}

// parse string
const char *CExp::parse_string(const char *p, CVar *val) const {
	char *dest = (char *) malloc(strlen(p) + 1);
	char *d = dest;
	char q = *p ++;
	while ( *p ) {
		if ( *p == q )
			break;
		*d ++ = *p ++;
		}
	*d = '\0';
	if ( *p ) p ++;
	val->sets(dest);
	free(dest);
	return p;
	}

// store the keyword to buf of len
const char *CExp::parse_keyword(const char *p, char *kwbuf, size_t len) const {
	char	*t = kwbuf;

	len --;
	while ( is_keyword(*p) && (size_t)(t - kwbuf) < len )
		*t ++ = *p ++;
	*t = '\0';
	return p;
	}

// assign to value to variable and/or property
// op is the assignment operator ('=', '+='. etc)
// returns the value of the variable/property
void CExp::var_assign(int op, const char *name, const char *prop, CVar &v) {
	CVar *data = NULL;

	if ( (data = getvar_p(name, prop)) == NULL )
		data = mkvar_p(name, prop);
	
	//
	switch ( op ) {
	case '=':
	case OP2(':','='):
		break;
	case OP2('+','='):
		if ( data->type == v_int && v.type == v_int )
			v.seti(data->geti() + v.geti());
		else if ( data->type == v_matrix && v.type <= v_str )
			v.setm(data->m + v.getf());
		else if ( data->type == v_matrix && v.type == v_matrix )
			v.setm(data->m + v.m);
		else if ( data->type == v_str && v.type == v_str )
			v.sets(data->s + v.s);
		else if ( v.type <= v_str )
			v.setf(data->getf() + v.getf());
		else
			set_error(E_TYPE_MM, "Type mismatch");
		break;
	case OP2('-','='):
		if ( data->type == v_int && v.type == v_int )
			v.setf(data->getf() - v.getf());
		else if ( data->type == v_matrix && v.type <= v_str )
			v.setm(data->m - v.getf());
		else if ( data->type == v_matrix && v.type == v_matrix )
			v.setm(data->m - v.m);
		else if ( v.type <= v_str )
			v.setf(-v.getf());
		else
			set_error(E_TYPE_MM, "Type mismatch");
		break;
	case OP2('*','='):
		if ( data->type == v_int && v.type == v_int )
			v.seti(data->geti() * v.geti());
		else if ( data->type == v_matrix && v.type <= v_str )
			v.setm(data->m * v.getf());
		else if ( data->type == v_matrix && v.type == v_matrix )
			v.setm(data->m * v.m);
		else if ( data->type <= v_str && v.type <= v_str )
			v.setf(data->getf() * v.getf());
		else
			set_error(E_TYPE_MM, "Type mismatch");
		break;
	case OP2('/','='):
		if ( v.getf() ) {
			if ( data->type <= v_str && v.type <= v_str )
				v.setf(data->getf() / v.getf());
			else if ( data->type == v_matrix && v.type <= v_str )
				v.setm(data->m / v.getf());
			else
				set_error(E_TYPE_MM, "Type mismatch");
			}
		else
			set_error(E_DIV_ZERO, "Division by zero");
		break;
	case OP2('%','='):
		if ( v.geti() ) {
			if ( data->type <= v_str && v.type <= v_str )
				v.seti(data->geti() % v.geti());
			else
				set_error(E_TYPE_MM, "Type mismatch");
			}
		else
			set_error(E_DIV_ZERO, "Division by zero");
		break;
		}

	// store variable
	*data = v;
	}

// returns value of the expression 'tokens' in 'result' and
// the pointer to the next part of the expression
const char *CExp::evaluate_p(const char *tokens, CVar *result, const char *xset, vector<CVar>* rstk) {
	int		op, un, op2, b_exit = 0, b_redo = 0;
	const char *p = tokens;
	CVar v2, v1;
	stack<CVar> v_stk;	// values stack
	stack<int>  o_stk;	// operators stack
	static int level = 0;

	level ++;
	if ( verbose )
		printf("enter with %s exit codes\n", xset);

unary_check:	
	if ( (un = find_unary(p)) != 0 ) {
		p += OPSIZE(un);
		o_stk.push(un | UNARY_BIT);
		}

	while ( *p ) {
		if ( error_code )
			goto eval_exit;
		
		// parenthesis, recursive
		if ( (*p == '(') || (*p == '[') || (*p == '{') ) {
			CVar v;
			
			switch ( *p ) {
			// parenthesis
			case '(': p = evaluate_p(p+1, &v, ")"); break;

			// matrix
			case '[': {
					vector<vector<CVar>> mat;
					size_t	rows = 0, cols = 0;
					p ++;

					// collect the numbers and find the size of matrix
					vector<CVar> nums;
					while ( *p ) {
						CVar z;
						p = evaluate_p(p, &z, ",;]");
						nums.push_back(z);
						
						if ( *(p-1) == ';' || *(p-1) == ']' ) {
							cols = MAX(cols, nums.size());
							rows ++;
							mat.push_back(nums);
							nums.clear();
							}
						if ( *(p-1) == ']' ) 
							break;
						}
					assert(*(p-1) == ']');

					// create array and fill it
					if ( verbose )
						printf("rows=%ld - cols=%ld\n", rows, cols);

					assert(rows*cols > 0);
					CMatrix m(rows, cols);
					for ( size_t r = 0; r < rows; r ++ )
						for ( size_t c = 0; c < cols; c ++ )
							m.set(r, c, mat[r][c].getf());

					// clean up
					v_stk.push(CVar(m));
					continue;
					}

			// undefined block
			case '{': p = evaluate_p(p+1, &v, "}"); break;

				};
			v_stk.push(v);
			continue;
			}

		// end of expression
		else if ( xset && strchr(xset, *p) ) {
			b_exit = 1;
			p ++;
			goto eval_exit;
			}

		// expression separator
		else if ( *p == ';' || *p == ',' ) { // end this expr and go to next
			b_redo = 1;
			p ++;
			goto eval_exit;
			}

		// keyword
		else if ( isalpha(*p) || *p == '_' ) {
			char	name[64];
			int		op = 0;
			CVar	v, *vp; // the return value to stack
			p = parse_keyword(p, name, 64);

			// name(...) -> its a function
			if ( *p == '(' )
				p = parse_function(p, name, &v);
			
			// name.prop = value; its property
#ifdef CEXP_USE_PROPS
			else if ( *p == '.' ) {
				char prop[64];
				p = parse_keyword(p+1, prop, 64);
				if ( strlen(prop) == 0 )
					{ set_error(E_SYNTAX, "Missing property name"); continue; }				
				if ( (op = find_op(p, 1)) != 0 ) { // its assignment
					p += OPSIZE(op);
					p = evaluate_p(p, &v, ",;");
					var_assign(op, name, prop, v);
					}
				else // just push the value in the stack
					if ( (vp = getvar_p(name, prop)) != NULL ) v = *vp;
				}
#endif

			// name[...] = value; its an array
			else if ( *p == '[' ) {
				bool b_mat = false; // is matrix ?

				if ( (vp = getvar_p(name)) != NULL )
					b_mat = (vp->type == v_matrix);

				if ( b_mat ) {
					CVar vr, vc;
					ssize_t r, c;

					p = evaluate_p(p+1, &vr, ",");
					if ( error_code ) continue;
					p = evaluate_p(p, &vc, "]");
					if ( error_code ) continue;
					r = vr.geti(); c = vc.geti();

					if ( r < 1 || r > (ssize_t)vp->m.rows() ) {
						set_error(E_OUT_OF_INDEX, "%s[%zd,%zd] .. row out of index", name, r, c);
						continue;
						}
					if ( c < 1 || c > (ssize_t)vp->m.cols() ) {
						set_error(E_OUT_OF_INDEX, "%s[%zd,%zd] .. column out of index", name, r, c);
						continue;
						}
					r --; c --;

					if ( (op = find_op(p, 1)) != 0 ) { // its assignment
						p += OPSIZE(op);
						p = evaluate_p(p, &v, ",;");
						if ( error_code ) continue;
						if ( v.type > v_str ) {
							set_error(E_TYPE_MM, "%s[%zd,%zd] <- R, type mismatch", name, r+1, c+1);
							continue;
							}
						// vp->m(r, c) = v.getf();
						switch ( op ) {
						case '=': case OP2(':', '='):
							vp->m(r, c) = v.getf(); break;
						case OP2('+', '='):
							vp->m(r, c) += v.getf(); break;
						case OP2('-', '='):
							vp->m(r, c) -= v.getf(); break;
						case OP2('*', '='):
							vp->m(r, c) *= v.getf(); break;
						case OP2('/', '='):
							vp->m(r, c) += v.getf(); break;
						case OP2('%', '='):
							vp->m(r, c) += v.getf(); break;
						default:
							set_error(E_SYNTAX, "Operator not supported");
							};
						v.setf(vp->m(r, c)); // returned to stack
						}
					else // just push the value in the stack
						v.setf(vp->m(r, c)); // returned to stack
					}
#ifdef CEXP_USE_PROPS
				else {
					CVar index;
					char prop[64];
					p = evaluate_p(p+1, &index, "]");
					if ( index.type == v_str )
						strncpy(prop, index.gets().c_str(), 63);
					else
						snprintf(prop, 64, "${%zd}", index.geti());
					if ( (op = find_op(p, 1)) != 0 ) { // its assignment
						p += OPSIZE(op);
						p = evaluate_p(p, &v, ",;");
						var_assign(op, name, prop, v);
						}
					else // just push the value in the stack
						if ( (vp = getvar_p(name, prop)) != NULL ) v = *vp;
					}
#endif
				}

			// name = value; its a variable
			else {
				// its assignment
				if ( (op = find_op(p, 1)) != 0 ) {
					p += OPSIZE(op);
					p = evaluate_p(p, &v, ",;");
					var_assign(op, name, NULL, v);
					}
				// get value
				else
					if ( (vp = getvar_p(name)) != NULL ) v = *vp;
				}

			v_stk.push(v);
			if ( op )
				goto unary_check;
			continue;
			}
		
		// number
		else if ( isdigit(*p) ) {
			real_t n;
			p = parse_num(p, &n);
			v_stk.push(CVar(n));
			continue; // `p` points to the next character
			}

		// string
		else if ( *p == '"' || *p == '\'' ) {
			CVar v;
			p = parse_string(p, &v);
			v_stk.push(v);
			continue; // `p` points to the next character
			}

		// operator
		else {
			if ( (op = find_op(p, 0)) != 0 ) p += OPSIZE(op);
			if ( (un = find_unary(p)) != 0 ) p += OPSIZE(un);

			if ( is_opchar(*p) ) {
				if ( (*p != '(') && (*p != '[') && (*p != '"') ) {
					set_error(E_OP_FOUND, "Additional operator found at %ld: [%s]", p-tokens, p);
					result->clear();
					return p;
					}
				}
			if ( op == 0 && un == 0 ) {
				set_error(E_NO_OP, "No operator at %ld: [%s]", p-tokens, p);
				result->clear();
				return p;
				}

			while ( (!o_stk.empty()) && precedence(o_stk.top()) >= precedence(op)) {
				if ( v_stk.empty() )
					{ set_error(E_STACK_UNDERFLOW_V, "Values stack underflow"); goto eval_exit; }
				v2 = v_stk.top(); v_stk.pop();
				op2 = o_stk.top(); o_stk.pop();
				if ( (op2 & UNARY_BIT) == 0 ) {
					if ( v_stk.empty() )
						{ set_error(E_STACK_UNDERFLOW_V, "Values stack underflow");
						goto eval_exit; }
					v1 = v_stk.top(); v_stk.pop();
					try { v_stk.push(apply_op(v1, v2, op2)); }
					catch (const exception& e) { set_error(E_EXCEPTION, "%s", e.what()); goto eval_exit; }
					}
				else { // unary
					try { v_stk.push(apply_unary(v2, op2)); }
					catch (const exception& e) { set_error(E_EXCEPTION, "%s", e.what()); goto eval_exit; }
					}
				}
			
			if ( op ) o_stk.push(op);
			if ( un ) o_stk.push(un | UNARY_BIT);
			continue; // `p` points to the next character
			}
		
		p ++;
		}

eval_exit:
	if ( verbose ) printf("eval_exit:\n");
	
	// apply remaining ops to remaining values.
	if ( !error_code ) {
		while ( !o_stk.empty() ) {
			if ( v_stk.empty() ) { set_error(E_STACK_UNDERFLOW_V, "Values stack underflow"); break; }
			v2 = v_stk.top(); v_stk.pop();
			op2 = o_stk.top(); o_stk.pop();
			if ( (op2 & UNARY_BIT) == 0 ) {
				if ( v_stk.empty() ) { set_error(E_STACK_UNDERFLOW_V, "Values stack underflow"); break; }
				v1 = v_stk.top(); v_stk.pop();
				try { v_stk.push(apply_op(v1, v2, op2)); }
				catch (const exception& e) { set_error(E_EXCEPTION, "%s", e.what()); break; }
				}
			else { // unary
				try { v_stk.push(apply_unary(v2, op2)); }
				catch (const exception& e) { set_error(E_EXCEPTION, "%s", e.what()); break; }
				}
			}
		}

	// store the result & update 'ans'
	if ( rstk && level == 1 ) {
		if ( !v_stk.empty() )
			rstk->push_back(v_stk.top());
		else
			rstk->push_back(CVar(0));
		setvar("ans", rstk->back());
		}

	// this section finished but there are more commands (';')
	if ( !error_code && !b_exit && b_redo ) {
		b_redo = 0;
		goto unary_check;
		}
	
	// top of 'values' contains result, return it.
	result->clear();
	if ( !v_stk.empty() )
		{ *result = move(v_stk.top()); v_stk.pop(); }
	if ( verbose ) printf("\n");
	level --;
	return p;
	}

// main routine
// evaluate the expression `source` and return the result and error code or zero
cexp_error_t CExp::evaluate(const char *source, CVar *result) {
	char *tokens = remove_spaces(source);
	error_code = E_SUCCESS;
	error_message = string("");
	if ( verbose )
		printf("expression: [%s]\n", tokens);
	evaluate_p(tokens, result, NULL);
	free(tokens);
	return error_code;
	}

// main routine - get multiple results
// evaluate the expression `source` and return the results in rstk and error code or zero
cexp_error_t CExp::evaluate(const char *source, vector<CVar> *rstk) {
	char *tokens = remove_spaces(source);
	CVar result;
	error_code = E_SUCCESS;
	error_message = string("");
	if ( verbose )
		printf("expression: [%s]\n", tokens);
	evaluate_p(tokens, &result, NULL, rstk);
	free(tokens);
	return error_code;
	}

#endif