expr.c 38.4 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
FunctionEvalInfo *
79
func_eval_info_init (FunctionEvalInfo *eval_info, Sheet *sheet, int col, int row)
80
{
81
	g_return_val_if_fail (eval_info != NULL, NULL);
82
       
83 84
	eval_pos_init (&eval_info->pos, sheet, col, row);
	eval_info->func_def = 0;
85

86
	return eval_info;
87 88
}

89
FunctionEvalInfo *
90
func_eval_info_cell (FunctionEvalInfo *eval_info, Cell *cell)
91
{
92 93
	g_return_val_if_fail (eval_info != NULL, NULL);
	g_return_val_if_fail (cell != NULL, NULL);
94

95 96 97
	return func_eval_info_init (
		eval_info, cell->sheet,
		cell->col->pos, cell->row->pos);
98 99
}

100 101
FunctionEvalInfo *
func_eval_info_pos (FunctionEvalInfo *eval_info, const EvalPosition *eval_pos)
102
{
103 104
	g_return_val_if_fail (eval_info != NULL, NULL);
	g_return_val_if_fail (eval_pos != NULL, NULL);
105

106 107 108
	return func_eval_info_init (
		eval_info,
		eval_pos->sheet,
Jody Goldberg's avatar
Jody Goldberg committed
109 110
		eval_pos->eval.col,
		eval_pos->eval.row);
111 112
}

113
ExprTree *
Morten Welinder's avatar
Morten Welinder committed
114
expr_tree_new_constant (Value *v)
115
{
116 117 118
	ExprTree *ans;

	ans = g_new (ExprTree, 1);
119 120 121 122 123 124 125
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_CONSTANT;
	ans->u.constant = v;

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

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

	ans = g_new (ExprTree, 1);
135 136 137 138 139 140 141
	if (!ans)
		return NULL;

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

Morten Welinder's avatar
Morten Welinder committed
142 143 144 145 146 147 148 149 150 151
	return ans;
}


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

	ans = g_new (ExprTree, 1);
152 153 154 155 156 157 158 159
	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
160 161 162 163 164 165 166 167 168 169
	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);
170 171 172 173 174 175 176 177
	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
178 179
	return ans;
}
180
       
181 182 183 184 185 186 187 188 189 190 191
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;
}

192 193 194 195 196 197 198 199 200 201 202
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;
}

203
ExprTree *
204
expr_parse_string (const char *expr, const ParsePosition *pp,
205 206 207 208 209
		   const char **desired_format, char **error_msg)
{
	ExprTree *tree;
	g_return_val_if_fail (expr != NULL, NULL);

210
	switch (gnumeric_expr_parser (expr, pp, desired_format, &tree)) {
211 212
	case PARSE_OK:
		*error_msg = NULL;
213 214
		/* What kind of joke is this?  -- MW.  */
		/* tree->ref_count = 1; */
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
		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
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
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;
}
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261

/*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
262 263 264 265 266 267 268

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

	ans = g_new (ExprTree, 1);
269 270 271 272 273 274 275
	if (!ans)
		return NULL;
	
	ans->ref_count = 1;
	ans->oper = OPER_VAR;
	ans->u.ref = *cr;

276 277 278
	return ans;
}

Morten Welinder's avatar
Morten Welinder committed
279 280 281 282
ExprTree *
expr_tree_new_error (const char *txt)
{
	Symbol *func;
Morten Welinder's avatar
Morten Welinder committed
283 284 285 286 287 288 289 290 291
	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
292 293

	symbol_ref (func);
Morten Welinder's avatar
Morten Welinder committed
294
	return expr_tree_new_funcall (func, args);
Morten Welinder's avatar
Morten Welinder committed
295 296
}

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
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 *
320
expr_tree_array_formula_corner (ExprTree const *expr, EvalPosition const *pos)
321
{
322
	Cell * corner = expr->u.array.corner.cell;
323

324 325 326 327 328 329
	/* 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
330 331
					 pos->eval.col - expr->u.array.x,
					 pos->eval.row - expr->u.array.y);
332 333 334 335
		((ExprTree *)expr)->u.array.corner.cell = corner;
	}

	g_return_val_if_fail (corner != NULL, NULL);
336 337 338 339 340
	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);
341 342
	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);
343 344 345 346

	return corner->parsed_node;
}

Arturo Espinosa's avatar
Arturo Espinosa committed
347 348 349 350
/*
 * expr_tree_ref:
 * Increments the ref_count for part of a tree
 */
351 352 353 354 355 356
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
357
	tree->ref_count++;
Arturo Espinosa's avatar
Arturo Espinosa committed
358 359 360 361 362
}

static void
do_expr_tree_unref (ExprTree *tree)
{
Morten Welinder's avatar
Morten Welinder committed
363 364 365
	if (--tree->ref_count > 0)
		return;

Arturo Espinosa's avatar
Arturo Espinosa committed
366
	switch (tree->oper){
367
	case OPER_VAR:
Arturo Espinosa's avatar
Arturo Espinosa committed
368
		break;
369

370
	case OPER_CONSTANT:
Morten Welinder's avatar
Morten Welinder committed
371
		value_release (tree->u.constant);
Arturo Espinosa's avatar
Arturo Espinosa committed
372
		break;
373

Morten Welinder's avatar
Morten Welinder committed
374 375 376 377 378 379 380
	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
381
		break;
Morten Welinder's avatar
Morten Welinder committed
382
	}
Arturo Espinosa's avatar
Arturo Espinosa committed
383

Michael Meeks's avatar
Michael Meeks committed
384 385 386
	case OPER_NAME:
		break;

387
	case OPER_ANY_BINARY:
Arturo Espinosa's avatar
Arturo Espinosa committed
388 389 390 391
		do_expr_tree_unref (tree->u.binary.value_a);
		do_expr_tree_unref (tree->u.binary.value_b);
		break;

392
	case OPER_ANY_UNARY:
Arturo Espinosa's avatar
Arturo Espinosa committed
393 394
		do_expr_tree_unref (tree->u.value);
		break;
395
	case OPER_ARRAY:
396 397 398
		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);
399
			do_expr_tree_unref (tree->u.array.corner.func.expr);
400
		}
401
		break;
402 403 404
	default:
		g_warning ("do_expr_tree_unref error\n");
		break;
Arturo Espinosa's avatar
Arturo Espinosa committed
405
	}
406

Morten Welinder's avatar
Morten Welinder committed
407
	g_free (tree);
408 409
}

Morten Welinder's avatar
Morten Welinder committed
410 411 412 413 414 415
/*
 * 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.)
 */
416 417 418 419 420 421
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
422
	do_expr_tree_unref (tree);
423 424
}

425
static Value *
Michael Meeks's avatar
Michael Meeks committed
426
eval_funcall (FunctionEvalInfo *ei, ExprTree const *tree)
Arturo Espinosa's avatar
Arturo Espinosa committed
427
{
428
	const Symbol *sym;
Arturo Espinosa's avatar
Arturo Espinosa committed
429
	FunctionDefinition *fd;
Michael Meeks's avatar
Michael Meeks committed
430
	GList *args;
431

Michael Meeks's avatar
Michael Meeks committed
432 433
	g_return_val_if_fail (ei != NULL, NULL);
	g_return_val_if_fail (tree != NULL, NULL);
434

435
	sym = tree->u.function.symbol;
436 437

	if (sym->type != SYMBOL_FUNCTION)
Michael Meeks's avatar
Michael Meeks committed
438
		return value_new_error (&ei->pos, _("Internal error"));
439

440
	fd = (FunctionDefinition *)sym->data;
Michael Meeks's avatar
Michael Meeks committed
441 442
	ei->func_def = fd;
	args = tree->u.function.arg_list;
443

Michael Meeks's avatar
Michael Meeks committed
444
	return function_call_with_list (ei, args);
Arturo Espinosa's avatar
Arturo Espinosa committed
445 446
}

Jody Goldberg's avatar
Jody Goldberg committed
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
/**
 * 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;
}

496
typedef enum {
Arturo Espinosa's avatar
Arturo Espinosa committed
497 498
	IS_EQUAL,
	IS_LESS,
499
	IS_GREATER,
500
	TYPE_MISMATCH
501 502 503
} compare_t;

static compare_t
504
compare_bool_bool (Value const * const va, Value const * const vb)
505
{
506 507 508 509 510 511 512 513 514 515 516 517 518
	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);
519 520 521 522 523 524 525 526 527
	if (a == b)
		return IS_EQUAL;
	else if (a < b)
		return IS_LESS;
	else
		return IS_GREATER;
}

static compare_t
528
compare_float_float (Value const * const va, Value const * const vb)
529
{
530 531
	float_t const a = value_get_as_float (va);
	float_t const b = value_get_as_float (vb);
532 533 534 535 536 537 538
	if (a == b)
		return IS_EQUAL;
	else if (a < b)
		return IS_LESS;
	else
		return IS_GREATER;
}
Arturo Espinosa's avatar
Arturo Espinosa committed
539

540 541
/*
 * Compares two (Value *) and returns one of compare_t
Jody Goldberg's avatar
Jody Goldberg committed
542 543 544
 *
 * if pos is non null it will perform implict intersection for
 * cellranges.
545 546
 */
static compare_t
Jody Goldberg's avatar
Jody Goldberg committed
547
compare (Value const * const a, Value const * const b)
Arturo Espinosa's avatar
Arturo Espinosa committed
548
{
549 550
	ValueType ta, tb;

551 552 553 554
	/* Handle trivial and double NULL case */
	if (a == b)
		return IS_EQUAL;

555 556
	ta = value_is_empty_cell (a) ? VALUE_EMPTY : a->type;
	tb = value_is_empty_cell (b) ? VALUE_EMPTY : b->type;
557

558 559 560 561 562 563
	/* 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;
564

565 566 567
		/* Strings are < FALSE ?? */
		case VALUE_BOOLEAN :
			return IS_LESS;
568

569 570 571 572 573 574 575 576 577 578 579 580
		/* 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 :
581
			return TYPE_MISMATCH;
582
		}
583 584 585 586 587
	} else if (tb == VALUE_STRING) {
		switch (ta) {
		/* (empty, or number) < String */
		case VALUE_EMPTY : case VALUE_INTEGER : case VALUE_FLOAT :
			return IS_LESS;
588

589 590 591
		/* Strings are < FALSE ?? */
		case VALUE_BOOLEAN :
			return IS_GREATER;
592

593
		default :
594
			return TYPE_MISMATCH;
595 596 597
		}
	}

598 599 600 601 602 603
	/* 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;

604 605 606
	switch ((ta > tb) ? ta : tb) {
	case VALUE_EMPTY:	/* Empty Empty compare */
		return IS_EQUAL;
607

608 609
	case VALUE_BOOLEAN:
		return compare_bool_bool (a, b);
610

611 612 613 614 615 616 617 618
	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
619 620
}

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
/*
 * Utility routine to ensure that all elements of a range are recalced as
 * necessary.
 */
static void
eval_range (FunctionEvalInfo *s, Value *v)
{
	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;
	Sheet * sheet = a->sheet ? a->sheet : s->pos.sheet;
	Cell * cell;
	int r, c;
	int const gen = s->pos.sheet->workbook->generation;

Jody Goldberg's avatar
Jody Goldberg committed
636 637
	cell_get_abs_col_row (a, &s->pos.eval, &start_col, &start_row);
	cell_get_abs_col_row (b, &s->pos.eval, &end_col, &end_row);
638 639 640 641 642 643 644 645 646 647 648

	if (a->sheet != b->sheet) {
		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;
649 650
			if (cell->generation != gen)
				cell_eval (cell);
651 652 653
		}
}

654
static Value *
Jody Goldberg's avatar
Jody Goldberg committed
655
eval_expr_real (FunctionEvalInfo * const s, ExprTree const * const tree)
Arturo Espinosa's avatar
Arturo Espinosa committed
656
{
657
	Value *res = NULL, *a = NULL, *b = NULL;
658
	
Arturo Espinosa's avatar
Arturo Espinosa committed
659
	g_return_val_if_fail (tree != NULL, NULL);
660
	g_return_val_if_fail (s != NULL, NULL);
661

662
	switch (tree->oper){
663 664 665 666 667 668
	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
669
		int comp;
670

671
		a = eval_expr_real (s, tree->u.binary.value_a);
Jody Goldberg's avatar
Jody Goldberg committed
672 673 674 675 676 677 678 679
		if (a != NULL) {
			if (a->type == VALUE_CELLRANGE) {
				a = expr_implicit_intersection (&s->pos, a);
				if (a == NULL)
					return value_new_error (&s->pos, gnumeric_err_VALUE);
			} else if (a->type == VALUE_ERROR)
				return a;
		}
Morten Welinder's avatar
Morten Welinder committed
680

681
		b = eval_expr_real (s, tree->u.binary.value_b);
Jody Goldberg's avatar
Jody Goldberg committed
682 683 684 685 686 687 688 689 690 691 692 693 694 695
		if (b != NULL) {
			Value *res = NULL;
			if (b->type == VALUE_CELLRANGE) {
				b = expr_implicit_intersection (&s->pos, b);
				if (b == NULL)
					res = value_new_error (&s->pos, gnumeric_err_VALUE);
			} 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
696
		}
697

Arturo Espinosa's avatar
Arturo Espinosa committed
698 699
		comp = compare (a, b);

700 701 702 703
		if (a != NULL)
			value_release (a);
		if (b != NULL)
			value_release (b);
704

Michael Meeks's avatar
Michael Meeks committed
705
		if (comp == TYPE_MISMATCH) {
706 707 708 709 710 711 712 713 714
			/* 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);

715
			return value_new_error (&s->pos, gnumeric_err_VALUE);
716
		}
717

Michael Meeks's avatar
Michael Meeks committed
718
		switch (tree->oper) {
719
		case OPER_EQUAL:
720
			res = value_new_bool (comp == IS_EQUAL);
Arturo Espinosa's avatar
Arturo Espinosa committed
721 722
			break;

723
		case OPER_GT:
724
			res = value_new_bool (comp == IS_GREATER);
Arturo Espinosa's avatar
Arturo Espinosa committed
725 726
			break;

727
		case OPER_LT:
728
			res = value_new_bool (comp == IS_LESS);
Arturo Espinosa's avatar
Arturo Espinosa committed
729 730
			break;

731 732
		case OPER_NOT_EQUAL:
			res = value_new_bool (comp != IS_EQUAL);
Arturo Espinosa's avatar
Arturo Espinosa committed
733 734
			break;

735 736
		case OPER_LTE:
			res = value_new_bool (comp != IS_GREATER);
Arturo Espinosa's avatar
Arturo Espinosa committed
737 738
			break;

739 740
		case OPER_GTE:
			res = value_new_bool (comp != IS_LESS);
Arturo Espinosa's avatar
Arturo Espinosa committed
741
			break;
742

Arturo Espinosa's avatar
Arturo Espinosa committed
743
		default:
744
			g_assert_not_reached ();
745 746
			res = value_new_error (&s->pos,
						_("Internal type error"));
Arturo Espinosa's avatar
Arturo Espinosa committed
747
		}
Morten Welinder's avatar
Morten Welinder committed
748
		return res;
Arturo Espinosa's avatar
Arturo Espinosa committed
749
	}
750

751 752 753 754 755
	case OPER_ADD:
	case OPER_SUB:
	case OPER_MULT:
	case OPER_DIV:
	case OPER_EXP:
756 757 758 759 760 761 762 763 764
		/*
		 * 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
765 766 767 768 769 770 771 772 773 774
	        /* Garantees that a != NULL */
		a = eval_expr (s, tree->u.binary.value_a);

		/* Handle implicit intersection */
		if (a->type == VALUE_CELLRANGE) {
			a = expr_implicit_intersection (&s->pos, a);
			if (a == NULL)
				return value_new_error (&s->pos, gnumeric_err_VALUE);
		}

775 776
		/* 1) Error from A */
		if (a->type == VALUE_ERROR)
777
			return a;
778

779 780 781 782 783 784 785 786
		/* 2) #!VALUE error if A is not a number */
		if (!VALUE_IS_NUMBER (a)) {
			value_release (a);
			return value_new_error (&s->pos, gnumeric_err_VALUE);
		}

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

Jody Goldberg's avatar
Jody Goldberg committed
788 789 790 791 792 793 794
		/* Handle implicit intersection */
		if (b->type == VALUE_CELLRANGE) {
			b = expr_implicit_intersection (&s->pos, a);
			if (b == NULL)
				return value_new_error (&s->pos, gnumeric_err_VALUE);
		}

795 796
		/* 3) Error from B */
		if (b->type == VALUE_ERROR) {
797
			value_release (a);
798
			return b;
Arturo Espinosa's avatar
Arturo Espinosa committed
799
		}
800

801 802
		/* 4) #!VALUE error if B is not a number */
		if (!VALUE_IS_NUMBER (b)) {
803 804
			value_release (a);
			value_release (b);
805
			return value_new_error (&s->pos, gnumeric_err_VALUE);
Arturo Espinosa's avatar
Arturo Espinosa committed
806
		}
807

808
		if (a->type != VALUE_FLOAT && b->type != VALUE_FLOAT){
Morten Welinder's avatar
Morten Welinder committed
809
			int ia = value_get_as_int (a);
810
			int ib = value_get_as_int (b);
811 812 813
			double dres;
			int ires;

Morten Welinder's avatar
Morten Welinder committed
814 815
			value_release (a);
			value_release (b);
816

817 818
			/* FIXME: we could use simple (cheap) heuristics to
			   catch most cases where overflow will not happen.  */
819
			switch (tree->oper){
820 821 822 823 824 825 826 827
			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);

828
			case OPER_SUB:
829 830 831 832 833 834
				dres = (double)ia - (double)ib;
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);
835

836
			case OPER_MULT:
837 838 839 840 841 842
				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
843

844
			case OPER_DIV:
845 846 847 848 849 850 851 852
				if (ib == 0)
					return value_new_error (&s->pos, gnumeric_err_DIV0);
				dres = (double)ia / (double)ib;
				ires = (int)dres;
				if (dres == ires)
					return value_new_int (ires);
				else
					return value_new_float ((float_t) dres);
853 854

			case OPER_EXP:
855
				if (ia == 0 && ib <= 0)
856 857 858 859 860 861 862 863
					return value_new_error (&s->pos, gnumeric_err_NUM);
				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
864
			default:
865
				abort ();
Arturo Espinosa's avatar
Arturo Espinosa committed
866 867
			}
		} else {
Arturo Espinosa's avatar
Arturo Espinosa committed
868 869
			float_t const va = value_get_as_float (a);
			float_t const vb = value_get_as_float (b);
870 871
			value_release (a);
			value_release (b);
872

873
			switch (tree->oper){
874
			case OPER_ADD:
Arturo Espinosa's avatar
Arturo Espinosa committed
875
				return value_new_float (va + vb);
876

877
			case OPER_SUB:
Arturo Espinosa's avatar
Arturo Espinosa committed
878
				return value_new_float (va - vb);
879

880
			case OPER_MULT:
Arturo Espinosa's avatar
Arturo Espinosa committed
881
				return value_new_float (va * vb);
882

883
			case OPER_DIV:
884 885 886
				return (vb == 0.0)
				    ? value_new_error (&s->pos,
						       gnumeric_err_DIV0)
Arturo Espinosa's avatar
Arturo Espinosa committed
887
				    : value_new_float (va / vb);
888

889
			case OPER_EXP:
890 891
				if ((va == 0 && vb <= 0) ||
				    (va < 0 && vb != (int)vb))
892
					return value_new_error (&s->pos, gnumeric_err_NUM);
Arturo Espinosa's avatar
Arturo Espinosa committed
893
				return value_new_float (pow (va, vb));
894

Arturo Espinosa's avatar
Arturo Espinosa committed
895
			default:
896
				break;
Arturo Espinosa's avatar
Arturo Espinosa committed
897 898
			}
		}
899 900
		return value_new_error (&s->pos, _("Unknown operator"));

Jody Goldberg's avatar
Jody Goldberg committed
901
	case OPER_PERCENT:
902 903 904
	case OPER_NEG:
	        /* Garantees that a != NULL */
		a = eval_expr (s, tree->u.value);
Jody Goldberg's avatar
Jody Goldberg committed
905 906 907 908 909 910 911 912

		/* Handle implicit intersection */
		if (a->type == VALUE_CELLRANGE) {
			a = expr_implicit_intersection (&s->pos, a);
			if (a == NULL)
				return value_new_error (&s->pos, gnumeric_err_VALUE);
		}

913 914
		if (a->type == VALUE_ERROR)
			return a;
Jody Goldberg's avatar
Jody Goldberg committed
915

916 917 918 919
		if (!VALUE_IS_NUMBER (a)){
			value_release (a);
			return value_new_error (&s->pos, gnumeric_err_VALUE);
		}
Jody Goldberg's avatar
Jody Goldberg committed
920 921 922 923 924 925 926 927 928
		if (tree->oper == OPER_NEG) {
			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);
929
		value_release (a);
Morten Welinder's avatar
Morten Welinder committed
930
		return res;
931

932
	case OPER_CONCAT: {
933 934
		char *sa, *sb, *tmp;

935
		a = eval_expr_real (s, tree->u.binary.value_a);
936
		if (a != NULL && a->type == VALUE_ERROR)
937
			return a;
938
		b = eval_expr_real (s, tree->u.binary.value_b);
939 940 941
		if (b != NULL && b->type == VALUE_ERROR) {
			if (a != NULL)
				value_release (a);
942
			return b;
943 944
		}

Michael Meeks's avatar
Michael Meeks committed
945 946
		sa = value_get_as_string (a);
		sb = value_get_as_string (b);
Jeff Garzik's avatar
Jeff Garzik committed
947
		tmp = g_strconcat (sa, sb, NULL);
Morten Welinder's avatar
Morten Welinder committed
948 949
		res = value_new_string (tmp);

950 951 952 953
		g_free (sa);
		g_free (sb);
		g_free (tmp);

954
		if (a != NULL)
955
		value_release (a);
956
		if (b != NULL)
957
		value_release (b);
Morten Welinder's avatar
Morten Welinder committed
958
		return res;
959
	}
Arturo Espinosa's avatar
Arturo Espinosa committed
960

961
	case OPER_FUNCALL:
962
		return eval_funcall (s, tree);
Arturo Espinosa's avatar
Arturo Espinosa committed
963

Michael Meeks's avatar
Michael Meeks committed
964 965 966
	case OPER_NAME:
		return eval_expr_name (s, tree->u.name);

967
	case OPER_VAR: {
968
		Sheet *cell_sheet;
969
		CellRef const *ref;
Arturo Espinosa's avatar
Arturo Espinosa committed
970 971
		Cell *cell;
		int col, row;
972

973
		if (s->pos.sheet == NULL) {
Arturo Espinosa's avatar
Arturo Espinosa committed
974
			/* Only the test program requests this */
Morten Welinder's avatar
Morten Welinder committed
975
			return value_new_float (3.14);
Arturo Espinosa's avatar
Arturo Espinosa committed
976 977
		}

978
		ref = &tree->u.ref;
Jody Goldberg's avatar
Jody Goldberg committed
979
		cell_get_abs_col_row (ref, &s->pos.eval, &col, &row);
Arturo Espinosa's avatar
Today:  
Arturo Espinosa committed
980

981
		cell_sheet = eval_sheet (ref->sheet, s->pos.sheet);
982
		cell = sheet_cell_get (cell_sheet, col, row);
983 984
		if (cell == NULL)
			return NULL;
985

986 987
		if (cell->generation != s->pos.sheet->workbook->generation)
			cell_eval (cell);
988

989
		return value_duplicate (cell->value);
Arturo Espinosa's avatar
Arturo Espinosa committed
990
	}
991

992
	case OPER_CONSTANT:
993 994 995 996
		res = tree->u.constant;
		if (res->type == VALUE_CELLRANGE)
			eval_range (s, res);
		return value_duplicate (res);
997

998 999 1000
	case OPER_ARRAY:
	{
		/* The upper left corner manages the recalc of the expr */
1001 1002
		int x = tree->u.array.x;
		int y = tree->u.array.y;
1003
		if (x == 0 && y == 0){
1004 1005 1006 1007 1008 1009
			/* 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
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
			/* 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.
			 */
1025
			a = eval_expr_real (s, tree->u.array.corner.func.expr);
1026
			*((Value **)&(tree->u.array.corner.func.value)) = a;
1027
		} else {
1028
			ExprTree const * const array =
1029
			    expr_tree_array_formula_corner (tree, &s->pos);
1030 1031 1032 1033
			if (array)
				a = array->u.array.corner.func.value;
			else
				a = NULL;
1034
		}
1035

1036 1037
		if (a != NULL &&
		    (a->type == VALUE_CELLRANGE || a->type == VALUE_ARRAY)) {
1038 1039
			int const num_x = value_area_get_width (&s->pos, a);
			int const num_y = value_area_get_height (&s->pos, a);
1040

1041 1042
			/* Evaluate relative to the upper left corner */
			EvalPosition tmp_ep = s->pos;
Jody Goldberg's avatar
Jody Goldberg committed
1043 1044
			tmp_ep.eval.col -= x;
			tmp_ep.eval.row -= y;
1045 1046 1047 1048 1049 1050 1051

			/* 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)
1052
				return value_new_error (&s->pos, gnumeric_err_NA);
1053 1054 1055

			a = (Value *)value_area_get_x_y (&tmp_ep, a, x, y);
		}
1056 1057 1058

		if (a == NULL)
			return NULL;
1059 1060
		return value_duplicate (a);
	}
1061
	}
1062

1063
	return value_new_error (&s->pos, _("Unknown evaluation error"));
1064 1065 1066
}

Value *
1067
eval_expr (FunctionEvalInfo *s, ExprTree const *tree)
1068 1069
{
	Value * res = eval_expr_real (s, tree);
1070 1071 1072 1073 1074 1075 1076 1077
	if (res == NULL)
		return value_new_int (0);

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

1080
int
Jody Goldberg's avatar
Jody Goldberg committed
1081
cell_ref_get_abs_col (CellRef const * const ref, EvalPosition const * const pos)
1082 1083 1084 1085 1086
{
	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
1087
		return pos->eval.col + ref->col;
1088 1089 1090 1091 1092
	return ref->col;

}

int
Jody Goldberg's avatar
Jody Goldberg committed
1093
cell_ref_get_abs_row (CellRef const * const ref, EvalPosition const * const pos)
1094 1095 1096 1097 1098
{
	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
1099
		return pos->eval.row + ref->row;
1100 1101 1102 1103
	return ref->row;
}


Arturo Espinosa's avatar
Arturo Espinosa committed
1104
void
Jody Goldberg's avatar
Jody Goldberg committed
1105 1106 1107
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
1108 1109 1110 1111
{
	g_return_if_fail (cell_ref != NULL);

	if (cell_ref->col_relative)
Jody Goldberg's avatar
Jody Goldberg committed
1112
		*col = pos->col + cell_ref->col;
Arturo Espinosa's avatar
Arturo Espinosa committed
1113 1114 1115 1116
	else
		*col = cell_ref->col;

	if (cell_ref->row_relative)
Jody Goldberg's avatar
Jody Goldberg committed
1117
		*row = pos->row + cell_ref->row;
Arturo Espinosa's avatar
Arturo Espinosa committed
1118 1119 1120 1121
	else
		*row = cell_ref->row;
}

1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
/*
 * Escapes all backslashes and quotes in a string. It is based on glib's
 * g_strescape.
 */
static char * 
strescape (char *string)
{
	char *q;
	char *escaped;
	int escapechars = 0;
	char *p = string;

	g_return_val_if_fail (string != NULL, NULL);

	while (*p != '\000') {
		if (*p == '\\' || *p == '\"')
			escapechars++;
		p++;
	}

	if (!escapechars)
		return g_strdup (string);

	escaped = g_new (char, strlen (string) + escapechars + 1);

	p = string;
	q = escaped;

	while (*p != '\000'){
		if (*p == '\\' || *p == '\"')
			*q++ = '\\';
		*q++ = *p++;
	}
	*q = '\000';

	return escaped;
}
 
1160 1161
/*
 * Converts a parsed tree into its string representation
1162
 * assuming that we are evaluating at col, row
1163 1164
 *
 * This routine is pretty simple: it walks the ExprTree and
1165
 * creates a string representation.
1166
 */
1167
static char *
Jody Goldberg's avatar
Jody Goldberg committed
1168
do_expr_decode_tree (ExprTree *tree, ParsePosition const *pp,
1169
		     int paren_level)
1170
{
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
	static struct {
		const char *name;
		int prec;	              /* Precedences -- should match parser.y  */
		int assoc_left, assoc_right;  /* 0: no, 1: yes.  */
	} operations [] = {
		{ "=",  1, 1, 0 },