expr.c 38.2 KB
Newer Older
Miguel de Icaza's avatar
Miguel de Icaza committed
1
/*
Morten Welinder's avatar
Morten Welinder committed
2
 * expr.c: Expression evaluation in Gnumeric
Miguel de Icaza's avatar
Miguel de Icaza committed
3 4 5 6
 *
 * Author:
 *   Miguel de Icaza (miguel@gnu.org).
 */
7
#include <config.h>
Arturo Espinosa's avatar
Arturo Espinosa committed
8
#include <gnome.h>
Arturo Espinosa's avatar
Arturo Espinosa committed
9
#include <math.h>
10
#include <string.h>
11
#include <locale.h>
Arturo Espinosa's avatar
Arturo Espinosa committed
12
#include "gnumeric.h"
Arturo Espinosa's avatar
Arturo Espinosa committed
13
#include "expr.h"
Arturo Espinosa's avatar
Arturo Espinosa committed
14
#include "eval.h"
Miguel de Icaza's avatar
Today:  
Miguel de Icaza committed
15
#include "format.h"
16
#include "func.h"
17
#include "utils.h"
18
#include "ranges.h"
19

20
EvalPosition *
21
eval_pos_init (EvalPosition *eval_pos, Sheet *sheet, int col, int row)
22
{
23 24 25 26 27
	g_return_val_if_fail (sheet != NULL, NULL);
	g_return_val_if_fail (eval_pos != NULL, NULL);
	g_return_val_if_fail (IS_SHEET (sheet), NULL);

	eval_pos->sheet = sheet;
Jody Goldberg's avatar
Jody Goldberg committed
28 29
	eval_pos->eval.col = col;
	eval_pos->eval.row = row;
30

31
	return eval_pos;
32
}
33

34 35 36 37 38 39 40 41 42 43 44 45 46
ParsePosition *
parse_pos_init (ParsePosition *pp, Workbook *wb, int col, int row)
{
	g_return_val_if_fail (wb != NULL, NULL);
	g_return_val_if_fail (pp != NULL, NULL);

	pp->wb  = wb;
	pp->col = col;
	pp->row = row;

	return pp;
}

47
EvalPosition *
48
eval_pos_cell (EvalPosition *eval_pos, Cell *cell)
49
{
50 51 52
	g_return_val_if_fail (eval_pos != NULL, NULL);
	g_return_val_if_fail (cell != NULL, NULL);
	g_return_val_if_fail (cell->sheet != NULL, NULL);
53 54
	g_return_val_if_fail (IS_SHEET (cell->sheet), NULL);

55 56 57 58 59
	return eval_pos_init (
		eval_pos,
		cell->sheet,
		cell->col->pos,
		cell->row->pos);
60
}
61

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
ParsePosition *
parse_pos_cell (ParsePosition *pp, Cell *cell)
{
	g_return_val_if_fail (pp != NULL, NULL);
	g_return_val_if_fail (cell != NULL, NULL);
	g_return_val_if_fail (cell->sheet != NULL, NULL);
	g_return_val_if_fail (IS_SHEET (cell->sheet), NULL);
	g_return_val_if_fail (cell->sheet->workbook != NULL, NULL);

	return parse_pos_init (
		pp,
		cell->sheet->workbook,
		cell->col->pos,
		cell->row->pos);
}

78
ExprTree *
Morten Welinder's avatar
Morten Welinder committed
79
expr_tree_new_constant (Value *v)
80
{
81 82 83
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
84 85 86 87 88 89 90
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_CONSTANT;
	ans->u.constant = v;

Morten Welinder's avatar
Morten Welinder committed
91 92 93 94 95 96 97 98 99
	return ans;
}

ExprTree *
expr_tree_new_unary  (Operation op, ExprTree *e)
{
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
100 101 102 103 104 105 106
	if (!ans)
		return NULL;

	ans->ref_count = 1;
	ans->oper = op;
	ans->u.value = e;

Morten Welinder's avatar
Morten Welinder committed
107 108 109 110 111 112 113 114 115 116
	return ans;
}


ExprTree *
expr_tree_new_binary (ExprTree *l, Operation op, ExprTree *r)
{
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
117 118 119 120 121 122 123 124
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = op;
	ans->u.binary.value_a = l;
	ans->u.binary.value_b = r;

Morten Welinder's avatar
Morten Welinder committed
125 126 127 128 129 130 131 132 133 134
	return ans;
}

ExprTree *
expr_tree_new_funcall (Symbol *sym, GList *args)
{
	ExprTree *ans;
	g_return_val_if_fail (sym, NULL);

	ans = g_new (ExprTree, 1);
135 136 137 138 139 140 141 142
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_FUNCALL;
	ans->u.function.symbol = sym;;
	ans->u.function.arg_list = args;

Morten Welinder's avatar
Morten Welinder committed
143 144
	return ans;
}
145
       
146 147 148 149 150 151 152 153 154 155 156
int
expr_tree_get_const_int (ExprTree const * const expr)
{
	g_return_val_if_fail (expr != NULL, 0);
	g_return_val_if_fail (expr->oper == OPER_CONSTANT, 0);
	g_return_val_if_fail (expr->u.constant, 0);
	g_return_val_if_fail (expr->u.constant->type == VALUE_INTEGER, 0);

	return expr->u.constant->v.v_int;
}

157 158 159 160 161 162 163 164 165 166 167
char const *
expr_tree_get_const_str (ExprTree const *const expr)
{
	g_return_val_if_fail (expr != NULL, NULL);
	g_return_val_if_fail (expr->oper == OPER_CONSTANT, NULL);
	g_return_val_if_fail (expr->u.constant, NULL);
	g_return_val_if_fail (expr->u.constant->type == VALUE_STRING, NULL);

	return expr->u.constant->v.str->str;
}

168
ExprTree *
169
expr_parse_string (const char *expr, const ParsePosition *pp,
Morten Welinder's avatar
Morten Welinder committed
170
		   char **desired_format, char **error_msg)
171 172 173 174
{
	ExprTree *tree;
	g_return_val_if_fail (expr != NULL, NULL);

175
	switch (gnumeric_expr_parser (expr, pp, desired_format, &tree)) {
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	case PARSE_OK:
		*error_msg = NULL;
		return tree;

	case PARSE_ERR_SYNTAX:
		*error_msg = _("Syntax error");
		break;

	case PARSE_ERR_NO_QUOTE:
		*error_msg = _("Missing quote");
		break;
	default:
		g_assert_not_reached ();
		*error_msg = _("Impossible!");
		break;
	}
	return NULL;
}

Michael Meeks's avatar
Michael Meeks committed
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
ExprTree *
expr_tree_new_name (const ExprName *name)
{
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_NAME;
	ans->u.name = name;

	return ans;
}
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224

/*ExprTree *
expr_tree_new (void)
{
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_CONSTANT;
	ans->u.constant = NULL;
	return ans;
}*/
Morten Welinder's avatar
Morten Welinder committed
225 226 227 228 229 230 231

ExprTree *
expr_tree_new_var (const CellRef *cr)
{
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
232 233 234 235 236 237 238
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_VAR;
	ans->u.ref = *cr;

239 240 241
	return ans;
}

Morten Welinder's avatar
Morten Welinder committed
242 243 244 245
ExprTree *
expr_tree_new_error (const char *txt)
{
	Symbol *func;
Morten Welinder's avatar
Morten Welinder committed
246 247 248 249 250 251 252 253 254
	GList *args = NULL;

	if (strcmp (txt, gnumeric_err_NA) == 0) {
		func = symbol_lookup (global_symbol_table, "NA");
	} else {
		func = symbol_lookup (global_symbol_table, "ERROR");
		args = g_list_prepend (NULL,
				       expr_tree_new_constant (value_new_string (txt)));
	}
Morten Welinder's avatar
Morten Welinder committed
255 256

	symbol_ref (func);
Morten Welinder's avatar
Morten Welinder committed
257
	return expr_tree_new_funcall (func, args);
Morten Welinder's avatar
Morten Welinder committed
258 259
}

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
ExprTree *
expr_tree_array_formula (int const x, int const y, int const rows, int const cols)
{
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
	if (ans == NULL)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_ARRAY;
	ans->u.array.x = x;
	ans->u.array.y = y;
	ans->u.array.rows = rows;
	ans->u.array.cols = cols;
	ans->u.array.corner.func.value = NULL;
	ans->u.array.corner.func.expr = NULL;
	ans->u.array.corner.cell = NULL;
	return ans;
}


static ExprTree *
283
expr_tree_array_formula_corner (ExprTree const *expr, EvalPosition const *pos)
284
{
285
	Cell * corner = expr->u.array.corner.cell;
286

287 288 289 290 291 292
	/* Attempt to set the corner if it is not already set */
	if (corner == NULL) {
		g_return_val_if_fail (pos != NULL, NULL);
		g_return_val_if_fail (pos->sheet != NULL, NULL);

		corner = sheet_cell_get (pos->sheet,
Jody Goldberg's avatar
Jody Goldberg committed
293 294
					 pos->eval.col - expr->u.array.x,
					 pos->eval.row - expr->u.array.y);
295 296 297 298
		((ExprTree *)expr)->u.array.corner.cell = corner;
	}

	g_return_val_if_fail (corner != NULL, NULL);
299 300 301 302 303
	g_return_val_if_fail (corner->parsed_node != NULL, NULL);

	/* Sanity check incase the corner gets removed for some reason */
	g_return_val_if_fail (corner->parsed_node != (void *)0xdeadbeef, NULL);
	g_return_val_if_fail (corner->parsed_node->oper == OPER_ARRAY, NULL);
304 305
	g_return_val_if_fail (corner->parsed_node->u.array.x == 0, NULL);
	g_return_val_if_fail (corner->parsed_node->u.array.y == 0, NULL);
306 307 308 309

	return corner->parsed_node;
}

Arturo Espinosa's avatar
Arturo Espinosa committed
310 311 312 313
/*
 * expr_tree_ref:
 * Increments the ref_count for part of a tree
 */
314 315 316 317 318 319
void
expr_tree_ref (ExprTree *tree)
{
	g_return_if_fail (tree != NULL);
	g_return_if_fail (tree->ref_count > 0);

Morten Welinder's avatar
Morten Welinder committed
320
	tree->ref_count++;
Arturo Espinosa's avatar
Arturo Espinosa committed
321 322 323 324 325
}

static void
do_expr_tree_unref (ExprTree *tree)
{
Morten Welinder's avatar
Morten Welinder committed
326 327 328
	if (--tree->ref_count > 0)
		return;

Arturo Espinosa's avatar
Arturo Espinosa committed
329
	switch (tree->oper){
330
	case OPER_VAR:
Arturo Espinosa's avatar
Arturo Espinosa committed
331
		break;
332

333
	case OPER_CONSTANT:
Morten Welinder's avatar
Morten Welinder committed
334
		value_release (tree->u.constant);
Arturo Espinosa's avatar
Arturo Espinosa committed
335
		break;
336

Morten Welinder's avatar
Morten Welinder committed
337 338 339 340 341 342 343
	case OPER_FUNCALL: {
		GList *l;

		for (l = tree->u.function.arg_list; l; l = l->next)
			do_expr_tree_unref (l->data);
		g_list_free (tree->u.function.arg_list);
		symbol_unref (tree->u.function.symbol);
Arturo Espinosa's avatar
Arturo Espinosa committed
344
		break;
Morten Welinder's avatar
Morten Welinder committed
345
	}
Arturo Espinosa's avatar
Arturo Espinosa committed
346

Michael Meeks's avatar
Michael Meeks committed
347 348 349
	case OPER_NAME:
		break;

350
	case OPER_ANY_BINARY:
Arturo Espinosa's avatar
Arturo Espinosa committed
351 352 353 354
		do_expr_tree_unref (tree->u.binary.value_a);
		do_expr_tree_unref (tree->u.binary.value_b);
		break;

355
	case OPER_ANY_UNARY:
Arturo Espinosa's avatar
Arturo Espinosa committed
356 357
		do_expr_tree_unref (tree->u.value);
		break;
358
	case OPER_ARRAY:
359 360 361
		if (tree->u.array.x == 0 && tree->u.array.y == 0) {
			if (tree->u.array.corner.func.value)
				value_release (tree->u.array.corner.func.value);
362
			do_expr_tree_unref (tree->u.array.corner.func.expr);
363
		}
364
		break;
365 366 367
	default:
		g_warning ("do_expr_tree_unref error\n");
		break;
Arturo Espinosa's avatar
Arturo Espinosa committed
368
	}
369

Morten Welinder's avatar
Morten Welinder committed
370
	g_free (tree);
371 372
}

Morten Welinder's avatar
Morten Welinder committed
373 374 375 376 377 378
/*
 * expr_tree_unref:
 * Decrements the ref_count for part of a tree.  (All trees are expected
 * to have been created with a ref-count of one, so when we hit zero, we
 * go down over the tree and unref the tree and its leaves stuff.)
 */
379 380 381 382 383 384
void
expr_tree_unref (ExprTree *tree)
{
	g_return_if_fail (tree != NULL);
	g_return_if_fail (tree->ref_count > 0);

Arturo Espinosa's avatar
Arturo Espinosa committed
385
	do_expr_tree_unref (tree);
386 387
}

388
static Value *
389
eval_funcall (EvalPosition const * const pos, ExprTree const *tree)
Arturo Espinosa's avatar
Arturo Espinosa committed
390
{
391
	FunctionEvalInfo ei;
392
	const Symbol *sym;
Arturo Espinosa's avatar
Arturo Espinosa committed
393
	FunctionDefinition *fd;
Michael Meeks's avatar
Michael Meeks committed
394
	GList *args;
395

396
	g_return_val_if_fail (pos != NULL, NULL);
Michael Meeks's avatar
Michael Meeks committed
397
	g_return_val_if_fail (tree != NULL, NULL);
398

399
	sym = tree->u.function.symbol;
400 401

	if (sym->type != SYMBOL_FUNCTION)
402
		return value_new_error (pos, _("Internal error"));
403

404
	fd = (FunctionDefinition *)sym->data;
405 406
	ei.func_def = fd;
	ei.pos = pos;
Michael Meeks's avatar
Michael Meeks committed
407
	args = tree->u.function.arg_list;
408

409
	return function_call_with_list (&ei, args);
Arturo Espinosa's avatar
Arturo Espinosa committed
410 411
}

Jody Goldberg's avatar
Jody Goldberg committed
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
/**
 * expr_implicit_intersection :
 * @ei: EvalInfo containing valid fd!
 * @v: a VALUE_CELLRANGE
 * 
 * Attempt to find the intersection between the calling cell and
 * some element of the 1 one unit wide or tall range.
 *
 * Always release the value passed in.
 *
 * Return value: 
 *     If the intersection succeeded return a duplicate of the value
 *     at the intersection point.  This value needs to be freed.
 **/
Value *
expr_implicit_intersection (EvalPosition const * const pos,
			    Value * const v)
{
	/*
	 * Handle the implicit union of a single row or
	 * column with the eval position.
	 * NOTE : We do not need to know if this is expression is
	 * being evaluated as an array or not because we can differentiate
	 * based on the required type for the argument.
	 */
	Value *res = NULL;
	CellRef const * const a = & v->v.cell_range.cell_a;
	CellRef const * const b = & v->v.cell_range.cell_b;

	if (a->sheet == b->sheet) {
		int a_col, a_row, b_col, b_row;
		cell_get_abs_col_row (a, &pos->eval, &a_col, &a_row);
		cell_get_abs_col_row (b, &pos->eval, &b_col, &b_row);
		if (a_row == b_row) {
			int const c = pos->eval.col;
			if (a_col <= c && c <= b_col)
				res = value_duplicate (value_area_get_x_y (pos, v, c - a_col, 0));
		}

		if (a_col == b_col) {
			int const r = pos->eval.row;
			if (a_row <= r && r <= b_row)
				res = value_duplicate (value_area_get_x_y (pos, v, 0, r - a_row));
		}
	}
	value_release (v);
	return res;
}

461
typedef enum {
Arturo Espinosa's avatar
Arturo Espinosa committed
462 463
	IS_EQUAL,
	IS_LESS,
464
	IS_GREATER,
465
	TYPE_MISMATCH
466 467 468
} compare_t;

static compare_t
469
compare_bool_bool (Value const * const va, Value const * const vb)
470
{
471 472 473 474 475 476 477 478 479 480 481 482 483
	gboolean err; /* Ignored */
	gboolean const a = value_get_as_bool (va, &err);
	gboolean const b = value_get_as_bool (vb, &err);
	if (a)
		return b ? IS_EQUAL : IS_GREATER;
	return b ? IS_LESS : IS_EQUAL;
}

static compare_t
compare_int_int (Value const * const va, Value const * const vb)
{
	int const a = value_get_as_int (va);
	int const b = value_get_as_int (vb);
484 485 486 487 488 489 490 491 492
	if (a == b)
		return IS_EQUAL;
	else if (a < b)
		return IS_LESS;
	else
		return IS_GREATER;
}

static compare_t
493
compare_float_float (Value const * const va, Value const * const vb)
494
{
495 496
	float_t const a = value_get_as_float (va);
	float_t const b = value_get_as_float (vb);
497 498 499 500 501 502 503
	if (a == b)
		return IS_EQUAL;
	else if (a < b)
		return IS_LESS;
	else
		return IS_GREATER;
}
Arturo Espinosa's avatar
Arturo Espinosa committed
504

505 506
/*
 * Compares two (Value *) and returns one of compare_t
Jody Goldberg's avatar
Jody Goldberg committed
507 508 509
 *
 * if pos is non null it will perform implict intersection for
 * cellranges.
510 511
 */
static compare_t
Jody Goldberg's avatar
Jody Goldberg committed
512
compare (Value const * const a, Value const * const b)
Arturo Espinosa's avatar
Arturo Espinosa committed
513
{
514 515
	ValueType ta, tb;

516 517 518 519
	/* Handle trivial and double NULL case */
	if (a == b)
		return IS_EQUAL;

520 521
	ta = value_is_empty_cell (a) ? VALUE_EMPTY : a->type;
	tb = value_is_empty_cell (b) ? VALUE_EMPTY : b->type;
522

523 524 525 526 527 528
	/* string > empty */
	if (ta == VALUE_STRING) {
		switch (tb) {
		/* Strings are > (empty, or number) */
		case VALUE_EMPTY : case VALUE_INTEGER : case VALUE_FLOAT :
			return IS_GREATER;
529

530 531 532
		/* Strings are < FALSE ?? */
		case VALUE_BOOLEAN :
			return IS_LESS;
533

534 535 536 537 538 539 540 541 542 543 544 545
		/* If both are strings compare as string */
		case VALUE_STRING :
		{
			int const t = strcasecmp (a->v.str->str, b->v.str->str);
			if (t == 0)
				return IS_EQUAL;
			else if (t > 0)
				return IS_GREATER;
			else
				return IS_LESS;
		}
		default :
546
			return TYPE_MISMATCH;
547
		}
548 549 550 551 552
	} else if (tb == VALUE_STRING) {
		switch (ta) {
		/* (empty, or number) < String */
		case VALUE_EMPTY : case VALUE_INTEGER : case VALUE_FLOAT :
			return IS_LESS;
553

554 555 556
		/* Strings are < FALSE ?? */
		case VALUE_BOOLEAN :
			return IS_GREATER;
557

558
		default :
559
			return TYPE_MISMATCH;
560 561 562
		}
	}

563 564 565 566 567 568
	/* Booleans > all numbers (Why did excel do this ??) */
	if (ta == VALUE_BOOLEAN && (tb == VALUE_INTEGER || tb == VALUE_FLOAT))
		return IS_GREATER;
	if (tb == VALUE_BOOLEAN && (ta == VALUE_INTEGER || ta == VALUE_FLOAT))
		return IS_LESS;

569 570 571
	switch ((ta > tb) ? ta : tb) {
	case VALUE_EMPTY:	/* Empty Empty compare */
		return IS_EQUAL;
572

573 574
	case VALUE_BOOLEAN:
		return compare_bool_bool (a, b);
575

576 577 578 579 580 581 582 583
	case VALUE_INTEGER:
		return compare_int_int (a, b);

	case VALUE_FLOAT:
		return compare_float_float (a, b);
	default:
		return TYPE_MISMATCH;
	}
Arturo Espinosa's avatar
Arturo Espinosa committed
584 585
}

586 587 588 589 590
/*
 * Utility routine to ensure that all elements of a range are recalced as
 * necessary.
 */
static void
591
eval_range (EvalPosition const * const pos, Value *v)
592 593 594 595
{
	int start_col, start_row, end_col, end_row;
	CellRef * a = &v->v.cell_range.cell_a;
	CellRef * b = &v->v.cell_range.cell_b;
596
	Sheet * sheet = a->sheet ? a->sheet : pos->sheet;
597 598
	Cell * cell;
	int r, c;
599
	int const gen = pos->sheet->workbook->generation;
600

601 602
	cell_get_abs_col_row (a, &pos->eval, &start_col, &start_row);
	cell_get_abs_col_row (b, &pos->eval, &end_col, &end_row);
603

Michael Meeks's avatar
Michael Meeks committed
604
	if (b->sheet && a->sheet != b->sheet) {
605 606 607 608 609 610 611 612 613
		g_warning ("3D references not-fully supported.\n"
			   "Recalc may be incorrect");
		return;
	}

	for (r = start_row; r <= end_row; ++r)
		for (c = start_col; c <= end_col; ++c) {
			if ((cell = sheet_cell_get (sheet, c, r)) == NULL)
				continue;
614 615
			if (cell->generation != gen)
				cell_eval (cell);
616 617 618
		}
}

619
static Value *
620
eval_expr_real (EvalPosition const * const pos, ExprTree const * const tree)
Arturo Espinosa's avatar
Arturo Espinosa committed
621
{
622
	Value *res = NULL, *a = NULL, *b = NULL;
623
	
Arturo Espinosa's avatar
Arturo Espinosa committed
624
	g_return_val_if_fail (tree != NULL, NULL);
625
	g_return_val_if_fail (pos != NULL, NULL);
626

627
	switch (tree->oper){
628 629 630 631 632 633
	case OPER_EQUAL:
	case OPER_NOT_EQUAL:
	case OPER_GT:
	case OPER_GTE:
	case OPER_LT:
	case OPER_LTE: {
Arturo Espinosa's avatar
Arturo Espinosa committed
634
		int comp;
635

636
		a = eval_expr_real (pos, tree->u.binary.value_a);
Jody Goldberg's avatar
Jody Goldberg committed
637 638
		if (a != NULL) {
			if (a->type == VALUE_CELLRANGE) {
639
				a = expr_implicit_intersection (pos, a);
Jody Goldberg's avatar
Jody Goldberg committed
640
				if (a == NULL)
641
					return value_new_error (pos, gnumeric_err_VALUE);
Jody Goldberg's avatar
Jody Goldberg committed
642 643 644
			} else if (a->type == VALUE_ERROR)
				return a;
		}
Morten Welinder's avatar
Morten Welinder committed
645

646
		b = eval_expr_real (pos, tree->u.binary.value_b);
Jody Goldberg's avatar
Jody Goldberg committed
647 648 649
		if (b != NULL) {
			Value *res = NULL;
			if (b->type == VALUE_CELLRANGE) {
650
				b = expr_implicit_intersection (pos, b);
Jody Goldberg's avatar
Jody Goldberg committed
651
				if (b == NULL)
652
					res = value_new_error (pos, gnumeric_err_VALUE);
Jody Goldberg's avatar
Jody Goldberg committed
653 654 655 656 657 658 659 660
			} else if (b->type == VALUE_ERROR)
				res = b;

			if (res != NULL) {
				if (a != NULL)
					value_release (a);
				return res;
			}
Morten Welinder's avatar
Morten Welinder committed
661
		}
662

Arturo Espinosa's avatar
Arturo Espinosa committed
663 664
		comp = compare (a, b);

665 666 667 668
		if (a != NULL)
			value_release (a);
		if (b != NULL)
			value_release (b);
669

Michael Meeks's avatar
Michael Meeks committed
670
		if (comp == TYPE_MISMATCH) {
671 672 673 674 675 676 677 678 679
			/* TODO TODO TODO : Make error more informative
			 *    regarding what is comparing to what
			 */
			/* For equality comparisons even errors are ok */
			if (tree->oper == OPER_EQUAL)
				return value_new_bool (FALSE);
			if (tree->oper == OPER_NOT_EQUAL)
				return value_new_bool (TRUE);

680
			return value_new_error (pos, gnumeric_err_VALUE);
681
		}
682

Michael Meeks's avatar
Michael Meeks committed
683
		switch (tree->oper) {
684
		case OPER_EQUAL:
685
			res = value_new_bool (comp == IS_EQUAL);
Arturo Espinosa's avatar
Arturo Espinosa committed
686 687
			break;

688
		case OPER_GT:
689
			res = value_new_bool (comp == IS_GREATER);
Arturo Espinosa's avatar
Arturo Espinosa committed
690 691
			break;

692
		case OPER_LT:
693
			res = value_new_bool (comp == IS_LESS);
Arturo Espinosa's avatar
Arturo Espinosa committed
694 695
			break;

696 697
		case OPER_NOT_EQUAL:
			res = value_new_bool (comp != IS_EQUAL);
Arturo Espinosa's avatar
Arturo Espinosa committed
698 699
			break;

700 701
		case OPER_LTE:
			res = value_new_bool (comp != IS_GREATER);
Arturo Espinosa's avatar
Arturo Espinosa committed
702 703
			break;

704 705
		case OPER_GTE:
			res = value_new_bool (comp != IS_LESS);
Arturo Espinosa's avatar
Arturo Espinosa committed
706
			break;
707

Arturo Espinosa's avatar
Arturo Espinosa committed
708
		default:
709
			g_assert_not_reached ();
710
			res = value_new_error (pos,
711
						_("Internal type error"));
Arturo Espinosa's avatar
Arturo Espinosa committed
712
		}
Morten Welinder's avatar
Morten Welinder committed
713
		return res;
Arturo Espinosa's avatar
Arturo Espinosa committed
714
	}
715

716 717 718 719 720
	case OPER_ADD:
	case OPER_SUB:
	case OPER_MULT:
	case OPER_DIV:
	case OPER_EXP:
721 722 723 724 725 726 727 728 729
		/*
		 * Priority
		 * 1) Error from A
		 * 2) #!VALUE error if A is not a number
		 * 3) Error from B
		 * 4) #!VALUE error if B is not a number
		 * 5) result of operation, or error specific to the operation
		 */

Jody Goldberg's avatar
Jody Goldberg committed
730
	        /* Garantees that a != NULL */
731
		a = eval_expr (pos, tree->u.binary.value_a);
Jody Goldberg's avatar
Jody Goldberg committed
732 733 734

		/* Handle implicit intersection */
		if (a->type == VALUE_CELLRANGE) {
735
			a = expr_implicit_intersection (pos, a);
Jody Goldberg's avatar
Jody Goldberg committed
736
			if (a == NULL)
737
				return value_new_error (pos, gnumeric_err_VALUE);
Jody Goldberg's avatar
Jody Goldberg committed
738 739
		}

740 741
		/* 1) Error from A */
		if (a->type == VALUE_ERROR)
742
			return a;
743

744 745 746
		/* 2) #!VALUE error if A is not a number */
		if (!VALUE_IS_NUMBER (a)) {
			value_release (a);
747
			return value_new_error (pos, gnumeric_err_VALUE);
748 749 750
		}

	        /* Garantees that b != NULL */
751
		b = eval_expr (pos, tree->u.binary.value_b);
Arturo Espinosa's avatar
Arturo Espinosa committed
752

Jody Goldberg's avatar
Jody Goldberg committed
753 754
		/* Handle implicit intersection */
		if (b->type == VALUE_CELLRANGE) {
755
			b = expr_implicit_intersection (pos, a);
Jody Goldberg's avatar
Jody Goldberg committed
756
			if (b == NULL)
757
				return value_new_error (pos, gnumeric_err_VALUE);
Jody Goldberg's avatar
Jody Goldberg committed
758 759
		}

760 761
		/* 3) Error from B */
		if (b->type == VALUE_ERROR) {
762
			value_release (a);
763
			return b;
Arturo Espinosa's avatar
Arturo Espinosa committed
764
		}
765

766 767
		/* 4) #!VALUE error if B is not a number */
		if (!VALUE_IS_NUMBER (b)) {
768 769
			value_release (a);
			value_release (b);
770
			return value_new_error (pos, gnumeric_err_VALUE);
Arturo Espinosa's avatar
Arturo Espinosa committed
771
		}
772

773
		if (a->type != VALUE_FLOAT && b->type != VALUE_FLOAT){
Morten Welinder's avatar
Morten Welinder committed
774
			int ia = value_get_as_int (a);
775
			int ib = value_get_as_int (b);
776 777 778
			double dres;
			int ires;

Morten Welinder's avatar
Morten Welinder committed
779 780
			value_release (a);
			value_release (b);
781

782 783
			/* FIXME: we could use simple (cheap) heuristics to
			   catch most cases where overflow will not happen.  */
784
			switch (tree->oper){
785 786 787 788 789 790 791 792
			case OPER_ADD:
				dres = (double)ia + (double)ib;
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);

793
			case OPER_SUB:
794 795 796 797 798 799
				dres = (double)ia - (double)ib;
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);
800

801
			case OPER_MULT:
802 803 804 805 806 807
				dres = (double)ia * (double)ib;
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);
Arturo Espinosa's avatar
Arturo Espinosa committed
808

809
			case OPER_DIV:
810
				if (ib == 0)
811
					return value_new_error (pos, gnumeric_err_DIV0);
812 813 814 815 816 817
				dres = (double)ia / (double)ib;
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);
818 819

			case OPER_EXP:
820
				if (ia == 0 && ib <= 0)
821
					return value_new_error (pos, gnumeric_err_NUM);
822 823 824 825 826 827 828
				dres = pow ((double)ia, (double)ib);
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);

Arturo Espinosa's avatar
Arturo Espinosa committed
829
			default:
830
				abort ();
Arturo Espinosa's avatar
Arturo Espinosa committed
831 832
			}
		} else {
Arturo Espinosa's avatar
Arturo Espinosa committed
833 834
			float_t const va = value_get_as_float (a);
			float_t const vb = value_get_as_float (b);
835 836
			value_release (a);
			value_release (b);
837

838
			switch (tree->oper){
839
			case OPER_ADD:
Arturo Espinosa's avatar
Arturo Espinosa committed
840
				return value_new_float (va + vb);
841

842
			case OPER_SUB:
Arturo Espinosa's avatar
Arturo Espinosa committed
843
				return value_new_float (va - vb);
844

845
			case OPER_MULT:
Arturo Espinosa's avatar
Arturo Espinosa committed
846
				return value_new_float (va * vb);
847

848
			case OPER_DIV:
849
				return (vb == 0.0)
850
				    ? value_new_error (pos,
851
						       gnumeric_err_DIV0)
Arturo Espinosa's avatar
Arturo Espinosa committed
852
				    : value_new_float (va / vb);
853

854
			case OPER_EXP:
855 856
				if ((va == 0 && vb <= 0) ||
				    (va < 0 && vb != (int)vb))
857
					return value_new_error (pos, gnumeric_err_NUM);
Arturo Espinosa's avatar
Arturo Espinosa committed
858
				return value_new_float (pow (va, vb));
859

Arturo Espinosa's avatar
Arturo Espinosa committed
860
			default:
861
				break;
Arturo Espinosa's avatar
Arturo Espinosa committed
862 863
			}
		}
864
		return value_new_error (pos, _("Unknown operator"));
865

Jody Goldberg's avatar
Jody Goldberg committed
866
	case OPER_PERCENT:
Jody Goldberg's avatar
Jody Goldberg committed
867 868
	case OPER_UNARY_NEG:
	case OPER_UNARY_PLUS:
869
	        /* Garantees that a != NULL */
870
		a = eval_expr (pos, tree->u.value);
Jody Goldberg's avatar
Jody Goldberg committed
871 872 873

		/* Handle implicit intersection */
		if (a->type == VALUE_CELLRANGE) {
874
			a = expr_implicit_intersection (pos, a);
Jody Goldberg's avatar
Jody Goldberg committed
875
			if (a == NULL)
876
				return value_new_error (pos, gnumeric_err_VALUE);
Jody Goldberg's avatar
Jody Goldberg committed
877 878
		}

879 880
		if (a->type == VALUE_ERROR)
			return a;
Jody Goldberg's avatar
Jody Goldberg committed
881

Jody Goldberg's avatar
Jody Goldberg committed
882 883 884
		if (tree->oper == OPER_UNARY_PLUS)
			return a;

885 886
		if (!VALUE_IS_NUMBER (a)){
			value_release (a);
887
			return value_new_error (pos, gnumeric_err_VALUE);
888
		}
Jody Goldberg's avatar
Jody Goldberg committed
889
		if (tree->oper == OPER_UNARY_NEG) {
Jody Goldberg's avatar
Jody Goldberg committed
890 891 892 893 894 895 896 897
			if (a->type == VALUE_INTEGER)
				res = value_new_int (-a->v.v_int);
			else if (a->type == VALUE_FLOAT)
				res = value_new_float (-a->v.v_float);
			else
				res = value_new_bool (!a->v.v_float);
		} else
			res = value_new_float (value_get_as_float (a) * .01);
898
		value_release (a);
Morten Welinder's avatar
Morten Welinder committed
899
		return res;
900

901
	case OPER_CONCAT: {
902 903
		char *sa, *sb, *tmp;

904
		a = eval_expr_real (pos, tree->u.binary.value_a);
905
		if (a != NULL && a->type == VALUE_ERROR)
906
			return a;
907
		b = eval_expr_real (pos, tree->u.binary.value_b);
908 909 910
		if (b != NULL && b->type == VALUE_ERROR) {
			if (a != NULL)
				value_release (a);
911
			return b;
912 913
		}

Michael Meeks's avatar
Michael Meeks committed
914 915
		sa = value_get_as_string (a);
		sb = value_get_as_string (b);
Jeff Garzik's avatar
Jeff Garzik committed
916
		tmp = g_strconcat (sa, sb, NULL);
Morten Welinder's avatar
Morten Welinder committed
917 918
		res = value_new_string (tmp);

919 920 921 922
		g_free (sa);
		g_free (sb);
		g_free (tmp);

923
		if (a != NULL)
924
		value_release (a);
925
		if (b != NULL)
926
		value_release (b);
Morten Welinder's avatar
Morten Welinder committed
927
		return res;
928
	}
Arturo Espinosa's avatar
Arturo Espinosa committed
929

930
	case OPER_FUNCALL:
931
		return eval_funcall (pos, tree);
Arturo Espinosa's avatar
Arturo Espinosa committed
932

Michael Meeks's avatar
Michael Meeks committed
933
	case OPER_NAME:
934
		return eval_expr_name (pos, tree->u.name);
Michael Meeks's avatar
Michael Meeks committed
935

936
	case OPER_VAR: {
937
		Sheet *cell_sheet;
938
		CellRef const *ref;
Arturo Espinosa's avatar
Arturo Espinosa committed
939 940
		Cell *cell;
		int col, row;
941

942
		if (pos->sheet == NULL) {
Arturo Espinosa's avatar
Arturo Espinosa committed
943
			/* Only the test program requests this */
Morten Welinder's avatar
Morten Welinder committed
944
			return value_new_float (3.14);
Arturo Espinosa's avatar
Arturo Espinosa committed
945 946
		}

947
		ref = &tree->u.ref;
948
		cell_get_abs_col_row (ref, &pos->eval, &col, &row);
Arturo Espinosa's avatar
Today:  
Arturo Espinosa committed
949

950
		cell_sheet = eval_sheet (ref->sheet, pos->sheet);
951
		cell = sheet_cell_get (cell_sheet, col, row);
952 953
		if (cell == NULL)
			return NULL;
954

955
		if (cell->generation != pos->sheet->workbook->generation)
956
			cell_eval (cell);
957

958
		return value_duplicate (cell->value);
Arturo Espinosa's avatar
Arturo Espinosa committed
959
	}
960

961
	case OPER_CONSTANT:
962 963
		res = tree->u.constant;
		if (res->type == VALUE_CELLRANGE)
964
			eval_range (pos, res);
965
		return value_duplicate (res);
966

967 968 969
	case OPER_ARRAY:
	{
		/* The upper left corner manages the recalc of the expr */
970 971
		int x = tree->u.array.x;
		int y = tree->u.array.y;
972
		if (x == 0 && y == 0){
973 974 975 976 977 978
			/* Release old value if necessary */
			a = tree->u.array.corner.func.value;
			if (a != NULL)
				value_release (a);

			/* Store real result (cast away const)*/
Jody Goldberg's avatar
Jody Goldberg committed
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
			/* FIXME : Call a wrapper routine that will iterate over the
			 * the array and evaluate the expression for all elements
			 *
			 * Figure out when to iterate and when to do array operations.
			 * ie
			 * A1:A3 = '=B1:B3^2'  Will iterate over all the elements and
			 *     re-evaluate.
			 * whereas
			 * A1:A3 = '=bob(B1:B3)'  Will call bob once if it returns an
			 *     array.
			 *
			 * This may be as simple as evaluating the corner.  If that is
			 * is an array return the result, else build an array and
			 * iterate over the elements, but that theory needs validation.
			 */
994
			a = eval_expr_real (pos, tree->u.array.corner.func.expr);
995
			*((Value **)&(tree->u.array.corner.func.value)) = a;
996
		} else {
997
			ExprTree const * const array =
998
			    expr_tree_array_formula_corner (tree, pos);
999 1000 1001 1002
			if (array)
				a = array->u.array.corner.func.value;
			else
				a = NULL;
1003
		}
1004

1005 1006
		if (a != NULL &&
		    (a->type == VALUE_CELLRANGE || a->type == VALUE_ARRAY)) {
1007 1008
			int const num_x = value_area_get_width (pos, a);
			int const num_y = value_area_get_height (pos, a);
1009

1010
			/* Evaluate relative to the upper left corner */
1011
			EvalPosition tmp_ep = *pos;
Jody Goldberg's avatar
Jody Goldberg committed
1012 1013
			tmp_ep.eval.col -= x;
			tmp_ep.eval.row -= y;
1014 1015 1016 1017 1018 1019 1020

			/* If the src array is 1 element wide or tall we wrap */
			if (x >= 1 && num_x == 1)
				x = 0;
			if (y >= 1 && num_y == 1)
				y = 0;
			if (x >= num_x || y >= num_y)
1021
				return value_new_error (pos, gnumeric_err_NA);
1022 1023 1024

			a = (Value *)value_area_get_x_y (&tmp_ep, a, x, y);
		}
1025 1026 1027

		if (a == NULL)
			return NULL;
1028 1029
		return value_duplicate (a);
	}
1030
	}
1031

1032
	return value_new_error (pos, _("Unknown evaluation error"));
1033 1034 1035
}

Value *
1036
eval_expr (EvalPosition const * const pos, ExprTree const *tree)
1037
{
1038
	Value * res = eval_expr_real (pos, tree);
1039 1040 1041 1042 1043 1044 1045 1046
	if (res == NULL)
		return value_new_int (0);

	if (res->type == VALUE_EMPTY) {
		value_release (res);
		return value_new_int (0);
	}
	return res;
1047
}
Arturo Espinosa's avatar
Arturo Espinosa committed
1048

Morten Welinder's avatar
Morten Welinder committed
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
Value *
eval_expr_empty (EvalPosition const * const pos, ExprTree const * const tree)
{
	Value * res = eval_expr_real (pos, tree);

	if (res && res->type == VALUE_EMPTY) {
		value_release (res);
		res = NULL;
	}

	return res;
}


1063
int
Jody Goldberg's avatar
Jody Goldberg committed
1064
cell_ref_get_abs_col (CellRef const * const ref, EvalPosition const * const pos)
1065 1066 1067 1068 1069
{
	g_return_val_if_fail (ref != NULL, 0);
	g_return_val_if_fail (pos != NULL, 0);

	if (ref->col_relative)
Jody Goldberg's avatar
Jody Goldberg committed
1070
		return pos->eval.col + ref->col;
1071 1072 1073 1074 1075
	return ref->col;

}

int
Jody Goldberg's avatar
Jody Goldberg committed
1076
cell_ref_get_abs_row (CellRef const * const ref, EvalPosition const * const pos)
1077 1078 1079 1080 1081
{
	g_return_val_if_fail (ref != NULL, 0);
	g_return_val_if_fail (pos != NULL, 0);

	if (ref->row_relative)
Jody Goldberg's avatar
Jody Goldberg committed
1082
		return pos->eval.row + ref->row;
1083 1084 1085 1086
	return ref->row;
}


Arturo Espinosa's avatar
Arturo Espinosa committed
1087
void
Jody Goldberg's avatar
Jody Goldberg committed
1088 1089 1090
cell_get_abs_col_row (CellRef const * const cell_ref,
		      CellPos const * const pos,
		      int * const col, int * const row)
Arturo Espinosa's avatar
Arturo Espinosa committed
1091 1092 1093 1094
{
	g_return_if_fail (cell_ref != NULL);

	if (cell_ref->col_relative)
Jody Goldberg's avatar
Jody Goldberg committed
1095
		*col = pos->col + cell_ref->col