/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * This file is part of xlslib -- A multiplatform, C/C++ library
 * for dynamic generation of Excel(TM) files.
 *
 * Copyright 2010-2013 Ger Hobbelt All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY David Hoerl ''AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL David Hoerl OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "../xlslib/formula_expr.h"
#include "../xlslib/globalrec.h"
#include "../xlslib/datast.h"
#include "../xlslib/formula_estimate.h"
#include "../xlslib/formula_cell.h"
#include "../xlslib/formula.h"
#include "../xlslib/common.h"
#include "../xlslib/sheetrec.h"

#ifdef __BCPLUSPLUS__
#include <malloc.h>
// malloc.h needed for calloc. RLN 111208
#include <memory.h>
// memory.h needed for memset. RLN 111215
// These may be needed for other compilers as well.
#endif

using namespace xlslib_core;
using namespace xlslib_strings;

expression_node_t::expression_node_t(CGlobalRecords& gRecords)
{
	(void)gRecords;
}

expression_node_t::~expression_node_t()
{
}

expression_node_t* expression_node_t::GetChild(unsigned16_t index) const
{
	(void)index;
	return NULL;
}

unsigned16_t expression_node_t::GetNumberOfChilds(void) const
{
	return 0;
}

void expression_node_t::DestroyAST(void)
{
	// first destroy the children, bottom-up recursively.
	unsigned16_t chn = GetNumberOfChilds();
	while (chn-- > 0) {
		expression_node_t* ch = GetChild(chn);

		XL_ASSERT(ch);
		if (ch)	{
			ch->DestroyAST();
		}
	}

	// then destroy this instance itself
	delete this;
}

void expression_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	(void)dst;
	XL_ASSERTS("Should never get here! MUST be handled by the derived class' method of similar name!");

	// do nothing: propagate the currently set expected value.
}

size_t expression_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	XL_ASSERTS("Should never get here! MUST be handled by the derived class' method of similar name!");
	return 0;
}

signed8_t expression_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)stack;
	(void)include_subtree;
	XL_ASSERTS("Should never get here! MUST be handled by the derived class' method of similar name!");
	return NO_ERRORS;
}

terminal_node_t::terminal_node_t(CGlobalRecords& gRecords) :
	expression_node_t(gRecords)
{
}

terminal_node_t::~terminal_node_t()
{
}

boolean_value_node_t::boolean_value_node_t(CGlobalRecords& gRecords, bool v) :
	terminal_node_t(gRecords),
	value(v)
{
}

boolean_value_node_t::~boolean_value_node_t()
{
}

void boolean_value_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	dst.SetBoolean(value);
}

size_t boolean_value_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 2;
}

signed8_t boolean_value_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;

    return stack.PushBoolean(value);
}

integer_value_node_t::integer_value_node_t(CGlobalRecords& gRecords, signed32_t v) :
	terminal_node_t(gRecords),
	value(v)
{
}

integer_value_node_t::~integer_value_node_t()
{
}

void integer_value_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	dst.SetInteger(value);
}

size_t integer_value_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	if (value >= 0 && value <= 65535) {
		return 2+1; // ptgInt
	}
	return 8+1; // ptgNum
}

signed8_t integer_value_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;
    return stack.PushInteger(value);
}

float_value_node_t::float_value_node_t(CGlobalRecords& gRecords, double v) :
	terminal_node_t(gRecords),
	value(v)
{
}

float_value_node_t::~float_value_node_t()
{
}

void float_value_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	dst.SetFloatingPoint(value);
}

size_t float_value_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 8+1;
}

signed8_t float_value_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;
    return stack.PushFloatingPoint(value);
}

error_value_node_t::error_value_node_t(CGlobalRecords& gRecords, errcode_t v) :
	terminal_node_t(gRecords),
	value(v)
{
}

error_value_node_t::~error_value_node_t()
{
}

void error_value_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	dst.SetErrorCode(value);
}

size_t error_value_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 1+1;
}

signed8_t error_value_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;
    return stack.PushError(value);
}

missing_arg_node_t::missing_arg_node_t(CGlobalRecords& gRecords) :
	terminal_node_t(gRecords)
{
}

missing_arg_node_t::~missing_arg_node_t()
{
}

void missing_arg_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	dst.SetErrorCode(XLERR_N_A);
}

size_t missing_arg_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 1;
}

signed8_t missing_arg_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;
    return stack.PushMissingArgument();
}

text_value_node_t::text_value_node_t(CGlobalRecords& gRecords, const std::string& v) :
	terminal_node_t(gRecords),
	m_GlobalRecords(gRecords)
{
	m_GlobalRecords.char2str16(v, this->value);
}

text_value_node_t::text_value_node_t(CGlobalRecords& gRecords, const ustring& v) :
	terminal_node_t(gRecords),
	m_GlobalRecords(gRecords)
{
	m_GlobalRecords.wide2str16(v, this->value);
}

#ifndef __FRAMEWORK__
text_value_node_t::text_value_node_t(CGlobalRecords& gRecords, const u16string& v) :
	terminal_node_t(gRecords),
	value(v),
	m_GlobalRecords(gRecords)
{
}

#endif
text_value_node_t::~text_value_node_t()
{
}

text_value_node_t& text_value_node_t::operator =(const text_value_node_t &src)
{
	(void)src;
	throw std::string("Should never have invoked the text_value_node_t copy operator!");
}

void text_value_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	dst.SetText(value);
}

size_t text_value_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 1 + 1 + CGlobalRecords::IsASCII(value) * value.length() + value.length();
}

signed8_t text_value_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;
    return stack.PushText(value);
}

cell_deref_node_t::cell_deref_node_t(CGlobalRecords& gRecords, const cell_t& v, cell_addr_mode_t opt, cell_op_class_t opclass) :
	terminal_node_t(gRecords),
	row_(v.GetRow()),
	col_(v.GetCol()),
	idx_(v.GetWorksheet() ? v.GetWorksheet()->GetIndex() : invalidIndex),
	//worksheet_ref(NULL),
	attr(opt),
	operand_class(opclass)
{
}

/* Ger had something in mind, but this is not needed for multi-sheet references. If we ever figure out the intent, turn it back on
cell_deref_node_t::cell_deref_node_t(CGlobalRecords& gRecords, const cell_t& v, const worksheet* ws, cell_addr_mode_t opt, cell_op_class_t opclass) :
	terminal_node_t(gRecords),
	row_(v.GetRow()),
	col_(v.GetCol()),
	idx_(v.GetWorksheet() ? v.GetWorksheet()->GetIndex() : invalidIndex),
	worksheet_ref(ws),
	attr(opt),
	operand_class(opclass)
{
}
*/

cell_deref_node_t::~cell_deref_node_t()
{
}

void cell_deref_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	/*
	 *  We don't want to spend the effort to 'know' (~ make this code aware) which cell reference produces what result, neither in value nor in type, so we
	 *  fake it and make it easy to ourselves: we 'guestimate' the cell/reference will return an
	 *  error code and we mark the expression as 'calc on load' to mask our ignorance.
	 */
	dst.SetCalcOnLoad();
	dst.SetErrorCode(XLERR_VALUE);
}

size_t cell_deref_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 1+2+2;
}

signed8_t cell_deref_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree;
    return stack.PushReference(row_, col_, idx_, attr, operand_class);
}

cellarea_deref_node_t::cellarea_deref_node_t(CGlobalRecords& gRecords, const cell_t& u_l_c, const cell_t& l_r_c, cell_addr_mode_t attr,
											 cell_op_class_t opclass) :
	cell_deref_node_t(gRecords, u_l_c, attr, opclass),
	lrrow_(l_r_c.GetRow()),
	lrcol_(l_r_c.GetCol()),
	lridx_(l_r_c.GetWorksheet() ? l_r_c.GetWorksheet()->GetIndex() : invalidIndex)
{
}

/* See other Ger comment
cellarea_deref_node_t::cellarea_deref_node_t(CGlobalRecords& gRecords, const cell_t& u_l_c, const cell_t& l_r_c, const worksheet* ws, cell_addr_mode_t attr,
											 cell_op_class_t opclass) :
	cell_deref_node_t(gRecords, u_l_c, ws, attr, opclass),
	lrrow_(l_r_c.GetRow()),
	lrcol_(l_r_c.GetCol()),
	lridx_(l_r_c.GetWorksheet() ? l_r_c.GetWorksheet()->GetIndex() : invalidIndex)
{
}
*/

cellarea_deref_node_t::~cellarea_deref_node_t()
{
}

size_t cellarea_deref_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;

	return 1+2*(2+2);
}

signed8_t cellarea_deref_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)include_subtree; // stop warning
    return stack.PushAreaReference(row_, col_, idx_, lrrow_, lrcol_, lridx_, attr, operand_class);
}

void cellarea_deref_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	/*
	 *  We don't want to spend the effort to 'know' (~ make this code aware) which cell reference produces what result, neither in value nor in type, so we
	 *  fake it and make it easy to ourselves: we 'guestimate' the cell/reference will return an
	 *  error code and we mark the expression as 'calc on load' to mask our ignorance.
	 */
	dst.SetCalcOnLoad();
	dst.SetErrorCode(XLERR_VALUE);
}

operator_basenode_t::operator_basenode_t(CGlobalRecords& gRecords, expr_operator_code_t o) :
	expression_node_t(gRecords),
	op(o)
{
}

operator_basenode_t::~operator_basenode_t()
{
}

void operator_basenode_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	/*
	 *  We don't want to spend the effort to 'know' (~ make this code aware) which operation produces what result, neither in value nor in type, so we
	 *  fake it and make it easy to ourselves: we 'guestimate' the operation will return an
	 *  error code and we mark the expression as 'calc on load' to mask our ignorance.
	 *
	 *  Remark: there's just a few operations we care about: those we are willing to take to the dance.
	 */
	dst.SetCalcOnLoad();
	dst.SetErrorCode(XLERR_VALUE);
}

unary_op_node_t::unary_op_node_t(CGlobalRecords& gRecords, expr_operator_code_t op, expression_node_t* a) :
	operator_basenode_t(gRecords, op),
	arg(a)
{
	XL_ASSERT(a);

	switch (op)	{
	default:
		throw std::string("Not a valid unary operator");

	case OP_UPLUS: // Unary Plus
	case OP_UMINUS: // Unary Minus
	case OP_PERCENT: // Percent Sign
	case OP_PAREN:  // Enclose into parentheses
		// okay
		break;
	}
}

unary_op_node_t::~unary_op_node_t()
{
}

expression_node_t* unary_op_node_t::GetChild(unsigned16_t index) const
{
	if (index == 0) {
		return arg;
	}
	return NULL;
}

unsigned16_t unary_op_node_t::GetNumberOfChilds(void) const
{
	return 1;
}

size_t unary_op_node_t::GetSize(bool include_subtree) const
{
	size_t len = 1;

	if (include_subtree) {
		XL_ASSERT(GetChild(0));
		len += GetChild(0)->GetSize(include_subtree);
	}
	return len;
}

signed8_t unary_op_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	signed8_t errcode = NO_ERRORS;

	if (include_subtree) {
		XL_ASSERT(GetChild(0));
		errcode |= GetChild(0)->DumpData(stack, include_subtree);
	}

	errcode |= stack.PushOperator(op);

#ifdef XL_WITH_ASSERTIONS
	switch (op)	{
	default:
		XL_ASSERTS("Should never get here!");

	case OP_UPLUS: // Unary Plus
	case OP_UMINUS: // Unary Minus
	case OP_PERCENT: // Percent Sign
	case OP_PAREN: // Enclose into parentheses
		// okay
		break;
	}
#endif

	return errcode;
}

binary_op_node_t::binary_op_node_t(CGlobalRecords& gRecords, expr_operator_code_t op, expression_node_t* arg1, expression_node_t* arg2) :
	operator_basenode_t(gRecords, op)
{
	args[0] = arg1;
	args[1] = arg2;

	switch (op)	{
	default:
		throw std::string("Not a valid binary operator");

	case OP_ADD:
	case OP_SUB:
	case OP_MUL:
	case OP_DIV:
	case OP_POWER:
	case OP_CONCAT:
	case OP_LE:
	case OP_LT:
	case OP_EQ:
	case OP_GE:
	case OP_GT:
	case OP_NE:
	case OP_ISECT:  // intersection ~ Excel 'space' operator
	case OP_UNION:  // union ~ Excel 'comma' operator
	case OP_RANGE:  // minimal bounding rectangle ~ Excel 'colon' operator
		// okay
		break;
	}
}

binary_op_node_t::~binary_op_node_t()
{
}

expression_node_t* binary_op_node_t::GetChild(unsigned16_t index) const
{
	if (index <= 1) {
		return args[index];
	}
	return NULL;
}

unsigned16_t binary_op_node_t::GetNumberOfChilds(void) const
{
	return 2;
}

size_t binary_op_node_t::GetSize(bool include_subtree) const
{
	size_t len = 1;

	if (include_subtree) {
		XL_ASSERT(GetChild(0));
		len += GetChild(0)->GetSize(include_subtree);
		XL_ASSERT(GetChild(1));
		len += GetChild(1)->GetSize(include_subtree);
	}
	return len;
}

signed8_t binary_op_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	signed8_t errcode = NO_ERRORS;

	if (include_subtree) {
		XL_ASSERT(GetChild(0));
		errcode |= GetChild(0)->DumpData(stack, include_subtree);
		XL_ASSERT(GetChild(1));
		errcode |= GetChild(1)->DumpData(stack, include_subtree);
	}

	errcode |= stack.PushOperator(op);

#ifdef XL_WITH_ASSERTIONS
	switch (op)	{
	default:
		XL_ASSERTS("Not a valid binary operator");

	case OP_ADD:
	case OP_SUB:
	case OP_MUL:
	case OP_DIV:
	case OP_POWER:
	case OP_CONCAT:
	case OP_LE:
	case OP_LT:
	case OP_EQ:
	case OP_GE:
	case OP_GT:
	case OP_NE:
	case OP_ISECT:  // intersection ~ Excel 'space' operator
	case OP_UNION:  // union ~ Excel 'comma' operator
	case OP_RANGE:  // minimal bounding rectangle ~ Excel 'colon' operator
		// okay
		break;
	}
#endif

	return errcode;
}

function_basenode_t::function_basenode_t(CGlobalRecords& gRecords, expr_function_code_t f, cell_op_class_t op_c) :
	expression_node_t(gRecords),
	func(f),
	op_class(op_c)
{
}

function_basenode_t::~function_basenode_t()
{
}

// Note: commented out case statements because code is too new for older Excel programs
void function_basenode_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	/*
	 *  We don't want to spend the effort to 'know' (~ make this code aware) which function produces what result, neither in value nor in type, so we
	 *  fake it and make it easy to ourselves: we 'guestimate' the UDF will return an
	 *  error code and we mark the expression as 'calc on load' to mask our ignorance.
	 *
	 *  Remark: there's just a few functions we care about: RANDOM() and a few others, which we are willing to take to the dance.
	 */
	switch (func) {
	default:
		dst.SetCalcOnLoad();
		dst.SetErrorCode(XLERR_VALUE);
		break;

	case FUNC_UDF:
		XL_ASSERTS("Should've been handled by the udf class!");

	case FUNC_IF:
	case FUNC_ISNA:
	case FUNC_ISERROR:
	case FUNC_TRUE:
	case FUNC_FALSE:
	case FUNC_AND:
	case FUNC_OR:
	case FUNC_NOT:
	case FUNC_ISREF:
	case FUNC_ISERR:
	case FUNC_ISTEXT:
	case FUNC_ISNUMBER:
	case FUNC_ISBLANK:
	case FUNC_T:
	case FUNC_N:
	case FUNC_ISNONTEXT:
	case FUNC_ISLOGICAL:
	case FUNC_ISPMT:
	case FUNC_ISTHAIDIGIT:
		dst.SetCalcOnLoad();
		dst.SetBoolean(false);     // faked value estimate!
		break;

	case FUNC_COUNT:
	case FUNC_ROW:
	case FUNC_COLUMN:
	case FUNC_DCOUNT:
	case FUNC_DAY:
	case FUNC_MONTH:
	case FUNC_YEAR:
	case FUNC_WEEKDAY:
	case FUNC_HOUR:
	case FUNC_MINUTE:
	case FUNC_SECOND:
	case FUNC_COUNTA:
	case FUNC_DCOUNTA:
	case FUNC_COUNTIF:
	case FUNC_COUNTBLANK:
	case FUNC_WEEKNUM:
	case FUNC_COUNTIFS:
		dst.SetCalcOnLoad();
		dst.SetInteger(42);     // faked value estimate!
		break;

	case FUNC_PI:
		dst.SetCalcOnLoad();
		dst.SetFloatingPoint(3.1415);     // faked value estimate!
		break;

	case FUNC_SUM:
	case FUNC_AVERAGE:
	case FUNC_MIN:
	case FUNC_MAX:
	case FUNC_STDEV:
	case FUNC_SIN:
	case FUNC_COS:
	case FUNC_TAN:
	case FUNC_ATAN:
	case FUNC_SQRT:
	case FUNC_EXP:
	case FUNC_LN:
	case FUNC_LOG10:
	case FUNC_ABS:
	case FUNC_ROUND:
	case FUNC_MOD:
	case FUNC_DSUM:
	case FUNC_DAVERAGE:
	case FUNC_DMIN:
	case FUNC_DMAX:
	case FUNC_DSTDEV:
	case FUNC_VAR:
	case FUNC_DVAR:
	case FUNC_DATE:
	case FUNC_TIME:
	case FUNC_ATAN2:
	case FUNC_ASIN:
	case FUNC_ACOS:
	case FUNC_LOG:
	case FUNC_PRODUCT:
	case FUNC_FACT:
	case FUNC_STDEVP:
	case FUNC_VARP:
	case FUNC_DSTDEVP:
	case FUNC_ROUNDUP:
	case FUNC_ROUNDDOWN:
	case FUNC_DAYS360:
	case FUNC_MEDIAN:
	case FUNC_SUMPRODUCT:
	case FUNC_SINH:
	case FUNC_COSH:
	case FUNC_TANH:
	case FUNC_ASINH:
	case FUNC_ACOSH:
	case FUNC_ATANH:
	case FUNC_FLOOR:
	case FUNC_KURT:
	case FUNC_SKEW:
	case FUNC_POWER:
	case FUNC_RADIANS:
	case FUNC_DEGREES:
	case FUNC_SUMIF:
	case FUNC_AVERAGEA:
	case FUNC_MAXA:
	case FUNC_MINA:
	case FUNC_STDEVPA:
	case FUNC_VARPA:
	case FUNC_STDEVA:
	case FUNC_VARA:
	case FUNC_SERIESSUM:
	case FUNC_ERF:
	case FUNC_ERFC:
	case FUNC_WORKDAY:
	case FUNC_NETWORKDAYS:
	case FUNC_GCD:
	case FUNC_SUMIFS:
	case FUNC_AVERAGEIF:
	case FUNC_AVERAGEIFS:
#if 0
	// these should not be provided to an older excel
	case FUNC_ERF_PRECISE:
	case FUNC_ERFC_PRECISE:
	case FUNC_GAMMALN_PRECISE:
	case FUNC_CEILING_PRECISE:
	case FUNC_FLOOR_PRECISE:
#endif
		dst.SetCalcOnLoad();
		dst.SetFloatingPoint(42.0);     // faked value estimate!
		break;

	case FUNC_LOWER:
	case FUNC_UPPER:
	case FUNC_LEFT:
	case FUNC_RIGHT:
	case FUNC_TRIM:
	case FUNC_REPLACE:
	case FUNC_CONCATENATE:
	case FUNC_DATESTRING:
	case FUNC_NUMBERSTRING:
	case FUNC_ROMAN:
	case FUNC_HYPERLINK:
	case FUNC_PHONETIC:
	case FUNC_BAHTTEXT:
	case FUNC_HEX2BIN:
	case FUNC_HEX2DEC:
	case FUNC_HEX2OCT:
	case FUNC_DEC2BIN:
	case FUNC_DEC2HEX:
	case FUNC_DEC2OCT:
	case FUNC_OCT2BIN:
	case FUNC_OCT2HEX:
	case FUNC_OCT2DEC:
	case FUNC_BIN2DEC:
	case FUNC_BIN2OCT:
	case FUNC_BIN2HEX:
		dst.SetCalcOnLoad();
		dst.SetText("???");     // faked value estimate!
		break;

	case FUNC_NOW:
	case FUNC_TODAY:
	case FUNC_RAND:
	case FUNC_VOLATILE:
	case FUNC_RANDBETWEEN:
		dst.SetCalcAlways();
		dst.SetCalcOnLoad();
		dst.SetFloatingPoint(0.5);     // faked random value estimate!
		break;

	case FUNC_OFFSET:
	case FUNC_INDIRECT:
		dst.SetCalcAlways();
		dst.SetCalcOnLoad();
		dst.SetInteger(42);     // faked value estimate!
		break;

	case FUNC_CELL:
		dst.SetCalcAlways();
		dst.SetCalcOnLoad();
		dst.SetText("???");     // faked value estimate!
		break;
	}
}

size_t function_basenode_t::GetSize(bool include_subtree) const
{
	size_t len = 1+2; // OP_FUNC
	unsigned32_t argcntmask = NumberOfArgsForExcelFunction(func);
	size_t chcnt = GetNumberOfChilds();

	// XL_ASSERT(argcntmask & (1U << (chcnt > 15 ? 15 : chcnt)));
	// if the function allows more than one possible argument count
	if (argcntmask == A_UNKNOWN || (argcntmask & ~(1U << chcnt))) {
		len += 1;	// with the Function with variable args, we push ONE additional byte
	}

	if (include_subtree) {
		while (chcnt-- > 0)	{
			XL_ASSERT(GetChild((unsigned16_t)chcnt));
			len += GetChild((unsigned16_t)chcnt)->GetSize(include_subtree);
		}
	}
	return len;
}

signed8_t function_basenode_t::DumpData(formula_t &stack, bool include_subtree) const
{
	signed8_t errcode = NO_ERRORS;
	unsigned32_t argcntmask = NumberOfArgsForExcelFunction(func);
	size_t chcnt = GetNumberOfChilds();

	if (include_subtree) {
		size_t idx;

		for (idx = 0; idx < chcnt; idx++) {
			XL_ASSERT(GetChild((unsigned16_t)idx));
			errcode |= GetChild((unsigned16_t)idx)->DumpData(stack, include_subtree);
		}
	}

	// XL_ASSERT(argcntmask & (1U << (chcnt > 15 ? 15 : chcnt)));
	// if the function allows more than one possible argument count
	if (argcntmask == A_UNKNOWN || (argcntmask & ~(1U << chcnt))) {
        errcode |= stack.PushFunction(func, chcnt, op_class);
	} else {
        errcode |= stack.PushFunction(func, op_class);
	}

	return errcode;
}

z_ary_func_node_t::z_ary_func_node_t(CGlobalRecords& gRecords, expr_function_code_t func, cell_op_class_t op_c) :
	function_basenode_t(gRecords, func, op_c)
{
}

z_ary_func_node_t::~z_ary_func_node_t()
{
}

unary_func_node_t::unary_func_node_t(CGlobalRecords& gRecords, expr_function_code_t op, cell_op_class_t op_c, expression_node_t* a) :
	function_basenode_t(gRecords, op, op_c),
	arg(a)
{
}

unary_func_node_t::~unary_func_node_t()
{
}

expression_node_t* unary_func_node_t::GetChild(unsigned16_t index) const
{
	(void)index; // stop warning
	return arg;
}

unsigned16_t unary_func_node_t::GetNumberOfChilds(void) const
{
	return 1;
}

binary_func_node_t::binary_func_node_t(CGlobalRecords& gRecords, expr_function_code_t op, cell_op_class_t op_c, expression_node_t* arg1, expression_node_t* arg2) :
	function_basenode_t(gRecords, op, op_c)
{
	args[0] = arg1;
	args[1] = arg2;
}

binary_func_node_t::~binary_func_node_t()
{
}

expression_node_t* binary_func_node_t::GetChild(unsigned16_t index) const
{
	return args[index];
}

unsigned16_t binary_func_node_t::GetNumberOfChilds(void) const
{
	return 2;
}

n_ary_func_node_t::n_ary_func_node_t(CGlobalRecords& gRecords, expr_function_code_t func, cell_op_class_t op_c, size_t count, expression_node_t** arr) :
	function_basenode_t(gRecords, func, op_c),
	arg_arrsize((unsigned16_t)count),
	arg_count(0),
	arg_arr(NULL)
{
	if (count > 0) {
		//XL_ASSERT(arr);
		arg_arr = (expression_node_t **)calloc(count, sizeof(arg_arr[0]));
		//arg_arrsize = count;

		if (arr) {
			arg_count = (unsigned16_t)count;

			while (count-- > 0)	{
				arg_arr[count] = arr[count];
			}
		}
	}
}

n_ary_func_node_t::~n_ary_func_node_t()
{
	if (arg_arr) {
		free((void *)arg_arr);
	}
}

expression_node_t* n_ary_func_node_t::GetChild(unsigned16_t index) const
{
	return arg_arr[index];
}

unsigned16_t n_ary_func_node_t::GetNumberOfChilds(void) const
{
	return arg_count;
}

function_basenode_t& n_ary_func_node_t::PushArg(expression_node_t* arg)
{
	if (arg_arr == NULL) {
		arg_arrsize = 2;
		XL_ASSERT(arg_count == 0);
		arg_arr = (expression_node_t **)calloc(2, sizeof(arg_arr[0]));
	} else
	if (arg_count >= arg_arrsize) {
		while (arg_count >= arg_arrsize) {
			arg_arrsize += 2;
		}
		arg_arr = (expression_node_t **)realloc((void *)arg_arr, arg_arrsize * sizeof(arg_arr[0]));
		for (int i = arg_count; i < arg_arrsize; i++) {
			arg_arr[i] = NULL;
		}
	}

	arg_arr[arg_count++] = arg;

	return *this;
}

#if 0
	// Requires the addition of VBA (which is HUGE)

userdef_func_node_t::userdef_func_node_t(CGlobalRecords& gRecords, int udf_num, cell_op_class_t op_class, size_t count, expression_node_t** arr) :
	n_ary_func_node_t(gRecords, FUNC_UDF, op_class, count, arr),
	expr_user_function_code(udf_num)
{
}

userdef_func_node_t::~userdef_func_node_t()
{
}

void userdef_func_node_t::GetResultEstimate(estimated_formula_result_t &dst) const
{
	/*
	 *  We don't know what the heck a UDF will spit out as a result, not in value nor in type, so we
	 *  take a pod shot at this and make it easy to ourselves: we 'guestimate' the UDF will return an
	 *  error code and we mark the expression as 'calc on load' to mask our ignorance.
	 */
	dst.SetCalcOnLoad();
	dst.SetErrorCode(XLERR_VALUE);
}

size_t userdef_func_node_t::GetSize(bool include_subtree) const
{
	(void)include_subtree;
	return 0;
}

signed8_t userdef_func_node_t::DumpData(formula_t &stack, bool include_subtree) const
{
	(void)stack; // stop warnings
	(void)include_subtree;
	//signed8_t errcode = NO_ERRORS;

	/*
	 *  looks like the UDF is encoded like this:
	 *
	 *  first argument is a ptgNameX record pointing at the name of the UDF, then
	 *  followed by the arguments pushed onto the stack, and then at the
	 *  very end the ptgFuncVarV record with function id 0x00FF (UDF) and the total number
	 *  of arguments there INCLUDING that extra ptgNameX argument at the start.
	 *
	 *  In other words: UDF is a single function, which does indirection through the initial
	 *  argument to the actual user defined function, i.e. UDF(<referenced_user_function_name>, <arguments>...)
	 */

	return GENERAL_ERROR; // not supported yet...
}
#endif

expression_node_factory_t::expression_node_factory_t(CGlobalRecords& glbl) :
	m_GlobalRecords(glbl)
{
}

expression_node_factory_t::~expression_node_factory_t()
{
}

expression_node_factory_t &expression_node_factory_t::operator =(const expression_node_factory_t &src)
{
	(void)src; // stop warning
	throw std::string("Should never have invoked the expression_node_factory_t copy operator!");
}

boolean_value_node_t *expression_node_factory_t::boolean(bool value)
{
	return new boolean_value_node_t(m_GlobalRecords, value);
}

integer_value_node_t *expression_node_factory_t::integer(signed32_t value)
{
	return new integer_value_node_t(m_GlobalRecords, value);
}

float_value_node_t *expression_node_factory_t::floating_point(double value)
{
	return new float_value_node_t(m_GlobalRecords, value);
}

error_value_node_t *expression_node_factory_t::error_value(errcode_t value)
{
	return new error_value_node_t(m_GlobalRecords, value);
}

missing_arg_node_t *expression_node_factory_t::missing_arg(void)
{
	return new missing_arg_node_t(m_GlobalRecords);
}

text_value_node_t *expression_node_factory_t::text(const std::string& value)
{
	return new text_value_node_t(m_GlobalRecords, value);
}

text_value_node_t *expression_node_factory_t::text(const u16string& value)
{
	return new text_value_node_t(m_GlobalRecords, value);
}

cell_deref_node_t *expression_node_factory_t::cell(const cell_t& cellref, cell_addr_mode_t attr, cell_op_class_t opclass)
{
	return new cell_deref_node_t(m_GlobalRecords, cellref, attr, opclass);
}

/* Ger had something in mind
cell_deref_node_t *expression_node_factory_t::cell(const cell_t& cellref, const worksheet* ws, cell_addr_mode_t attr, cell_op_class_t opclass)
{
	return new cell_deref_node_t(m_GlobalRecords, cellref, ws, attr, opclass);
}
*/
cellarea_deref_node_t *expression_node_factory_t::area(const cell_t& upper_left_corner, const cell_t& lower_right_corner, cell_addr_mode_t attr,
							  cell_op_class_t opclass)
{
	return new cellarea_deref_node_t(m_GlobalRecords, upper_left_corner, lower_right_corner, attr, opclass);
}

/* Ger had something in mind
cellarea_deref_node_t *expression_node_factory_t::area(const cell_t& upper_left_corner, const cell_t& lower_right_corner, const worksheet* ws,
							  cell_addr_mode_t attr, cell_op_class_t opclass)
{
	return new cellarea_deref_node_t(m_GlobalRecords, upper_left_corner, lower_right_corner, ws, attr, opclass);
}
*/

unary_op_node_t *expression_node_factory_t::op(expr_operator_code_t op, expression_node_t* arg)
{
	return new unary_op_node_t(m_GlobalRecords, op, arg);
}

binary_op_node_t *expression_node_factory_t::op(expr_operator_code_t op, expression_node_t* arg1, expression_node_t* arg2)
{
	return new binary_op_node_t(m_GlobalRecords, op, arg1, arg2);
}

z_ary_func_node_t *expression_node_factory_t::f(expr_function_code_t func, cell_op_class_t op_class)
{
	return new z_ary_func_node_t(m_GlobalRecords, func, op_class);
}

unary_func_node_t *expression_node_factory_t::f(expr_function_code_t func, expression_node_t* arg, cell_op_class_t op_class)
{
	return new unary_func_node_t(m_GlobalRecords, func, op_class, arg);
}

binary_func_node_t *expression_node_factory_t::f(expr_function_code_t func, expression_node_t* arg1, expression_node_t* arg2, cell_op_class_t op_class)
{
	return new binary_func_node_t(m_GlobalRecords, func, op_class, arg1, arg2);
}

n_ary_func_node_t *expression_node_factory_t::f(expr_function_code_t func, size_t argcount, expression_node_t** arg_arr, cell_op_class_t op_class)
{
	return new n_ary_func_node_t(m_GlobalRecords, func, op_class, argcount, arg_arr);
}

#if 0
userdef_func_node_t *expression_node_factory_t::udf(int expr_user_function, size_t argcount, expression_node_t** arg_arr, cell_op_class_t op_class)
{
	return new userdef_func_node_t(m_GlobalRecords, expr_user_function, op_class, argcount, arg_arr);
}
#endif