/*
 * awk2 --- gawk parse tree interpreter 
 *
 * $Log:	awk2.c,v $
 * Revision 1.51  89/03/31  13:25:34  david
 * GNU license; MSDOS support
 * 
 * Revision 1.50  89/03/30  20:57:19  david
 * allow for Node_rule_node (a single rule)
 * avoid calling eval_condition for no pattern
 * plug a memory leak in assign_number
 * 
 * Revision 1.49  89/03/29  14:15:07  david
 * delinting
 * 
 * Revision 1.48  89/03/26  17:58:53  david
 * changed return of do_printf to void
 * 
 * Revision 1.47  89/03/22  22:09:50  david
 * a cleaner way to handle assignment to $n where n > 0
 * 
 * Revision 1.46  89/03/22  21:01:14  david
 * delete some obsolete code
 * 
 * Revision 1.45  89/03/21  19:25:37  david
 * minor cleanup
 * 
 * Revision 1.44  89/03/21  18:24:02  david
 * bug fix in cmp_nodes: strings in which one was a prefix of the other compared equal
 * 
 * Revision 1.43  89/03/21  10:55:55  david
 * cleanup and fix of string comparison (0 length was wrong)
 * 
 * Revision 1.42  89/03/15  22:01:17  david
 * old case stuff removed
 * new case stuff added
 * fixed % operator
 * strings with embedded \0 can now be compared
 * 
 * Revision 1.41  89/03/15  21:32:50  david
 * try to free up memory in as many places as possible
 * 
 * Revision 1.40  88/12/15  12:57:31  david
 * make casetable static
 * 
 * Revision 1.39  88/12/14  10:50:51  david
 * dupnode() the return from a function
 * 
 * Revision 1.38  88/12/13  22:27:04  david
 * macro-front-end tree_eval and other optimizations
 * 
 * Revision 1.36  88/12/08  10:51:37  david
 * small correction to source file code
 * 
 * Revision 1.35  88/12/07  20:00:35  david
 * changes for incorporating source filename into error messages
 * 
 * Revision 1.34  88/12/01  15:04:48  david
 * cleanup and additions for source line number printing in error messages
 * 
 * Revision 1.33  88/11/30  15:16:10  david
 * merge FREE_ONE_REFERENCE into do_deref()
 * free more in do_deref
 * in for (i in array) loops, make sure value of i gets freed on each iteration
 * 
 * Revision 1.32  88/11/29  09:55:04  david
 * corrections to code that tracks value of NF -- this needs cleanup
 * 
 * Revision 1.31  88/11/23  21:40:47  david
 * Arnold: comment cleanup
 * 
 * Revision 1.30  88/11/22  13:49:09  david
 * Arnold: changes for case-insensitive matching
 * 
 * Revision 1.29  88/11/15  10:22:42  david
 * Arnold: cleanup of comments and #include's
 * 
 * Revision 1.28  88/11/14  21:55:38  david
 * Arnold: misc. cleanup and error message on bad regexp
 * 
 * Revision 1.27  88/11/14  21:26:52  david
 * update NF on assignment to a field greater than current NF
 * 
 * Revision 1.26  88/11/03  15:26:20  david
 * simplify call to in_array(); extensive revision of cmp_nodes and is_a_number
 * 
 * Revision 1.25  88/11/01  12:11:57  david
 * DEBUG macro becomes DBG_P; added some debugging code; moved all the
 * compound assignments (+= etc.) into op_assign()
 * 
 * Revision 1.24  88/10/25  10:43:05  david
 * intermediate state: more code movement; Node_string et al. -> Node_val;
 * add more debugging code; improve cmp_nodes
 * 
 * Revision 1.22  88/10/19  21:57:41  david
 * replace malloc and realloc with error checking versions
 * start to change handling of $0
 * 
 * Revision 1.21  88/10/17  20:56:13  david
 * Arnold: better error messages for use of a function in the wrong context
 * 
 * Revision 1.20  88/10/13  21:56:41  david
 * cleanup of previous changes
 * change panic() to fatal()
 * detect and bomb on function call with space between name and opening (
 * 
 * Revision 1.19  88/10/11  22:19:20  david
 * cleanup 
 * 
 * Revision 1.18  88/10/04  21:31:33  david
 * minor cleanup
 * 
 * Revision 1.17  88/08/22  14:01:19  david
 * fix to set_field() from Jay Finlayson
 * 
 * Revision 1.16  88/08/09  14:51:34  david
 * removed bad call to obstack_free() -- there is a lot of memory that is
 * not being properly freed -- this area needs major work
 * changed semantics in eval_condition -- if(expr) should test true if
 * expr is a non-null string, even if the num,erical value is zero -- counter-
 * intuitive but that's what's in the book
 * 
 * Revision 1.15  88/06/13  18:02:58  david
 * separate exit value from fact that exit has been called [from Arnold]
 * 
 * Revision 1.14  88/06/07  23:39:48  david
 * insubstantial changes
 * 
 * Revision 1.13  88/06/06  11:26:39  david
 * get rid of some obsolete code
 * change interface of set_field()
 * 
 * Revision 1.12  88/06/05  22:21:36  david
 * local variables are now kept on a stack
 * 
 * Revision 1.11  88/06/01  22:06:50  david
 * make sure incases of Node_param_list that the variable is looked up
 * 
 * Revision 1.10  88/05/31  09:29:47  david
 * expunge Node_local_var
 * 
 * Revision 1.9  88/05/30  09:52:55  david
 * be prepared for NULL return from make_regexp()
 * fix fatal() call
 * 
 * Revision 1.8  88/05/26  22:48:48  david
 * fixed regexp matching code
 * 
 * Revision 1.7  88/05/16  21:27:09  david
 * comment out obstack_free in interpret() -- it is done in do_file() anyway
 * and was definitely free'ing stuff it shouldn't have
 * change call of func_call() a bit
 * allow get_lhs to be called with other Node types -- return 0; used in
 * do_sub()
 * 
 * Revision 1.6  88/05/13  22:00:03  david
 * generalized *_BINDING macros and moved them to awk.h
 * changes to function calling (mostly elsewhere)
 * put into use the Node_var_array type
 * 
 * Revision 1.5  88/05/09  21:22:27  david
 * finally (I hope) got the code right in assign_number
 * 
 * Revision 1.4  88/05/04  12:23:30  david
 * fflush(stdout) on prints if FAST not def'ed
 * all the assign_* cases were returning the wrong thing
 * fixed Node_in_array code
 * code in assign_number was freeing memory it shouldn't have
 * 
 * Revision 1.3  88/04/15  13:12:38  david
 * additional error message
 * 
 * Revision 1.2  88/04/12  16:03:24  david
 * fixed previously intoduced bug: all matches succeeded
 * 
 * Revision 1.1  88/04/08  15:15:01  david
 * Initial revision
 *  Revision 1.7  88/04/08  14:48:33  david changes from
 * Arnold Robbins 
 *
 * Revision 1.6  88/03/28  14:13:50  david *** empty log message *** 
 *
 * Revision 1.5  88/03/23  22:17:37  david mostly delinting -- a couple of bug
 * fixes 
 *
 * Revision 1.4  88/03/18  21:00:10  david Baseline -- hoefully all the
 * functionality of the new awk added. Just debugging and tuning to do. 
 *
 * Revision 1.3  87/11/14  15:16:21  david added user-defined functions with
 * return and do-while loops 
 *
 * Revision 1.2  87/10/29  21:45:44  david added support for array membership
 * test, as in:  if ("yes" in answers) ... this involved one more case: for
 * Node_in_array and rearrangment of the code in assoc_lookup, so that the
 * element can be located without being created 
 *
 * Revision 1.1  87/10/27  15:23:28  david Initial revision 
 *
 */

/* 
 * Copyright (C) 1986, 1988, 1989 the Free Software Foundation, Inc.
 * 
 * This file is part of GAWK, the GNU implementation of the
 * AWK Progamming Language.
 * 
 * GAWK is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 1, or (at your option)
 * any later version.
 * 
 * GAWK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with GAWK; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "awk.h"

extern void do_print();
extern void do_printf();
extern NODE *func_call();
extern NODE *do_match();
extern NODE *do_sub();
extern NODE *do_getline();
extern int in_array();
extern void do_delete();

extern double pow();

static int eval_condition();
static int is_a_number();
static NODE *op_assign();

NODE *_t;		/* used as a temporary in macros */
#ifdef MSDOS
double _msc51bug;	/* to get around a bug in MSC 5.1 */
#endif
NODE *_result;		/* holds result of tree_eval, for possible freeing */
NODE *ret_node;

/* More of that debugging stuff */
#ifdef	DEBUG
#define DBG_P(X) print_debug X
#else
#define DBG_P(X)
#endif

extern jmp_buf func_tag;

/*
 * This table is used by the regexp routines to do case independant
 * matching. Basically, every ascii character maps to itself, except
 * uppercase letters map to lower case ones. This table has 256
 * entries, which may be overkill. Note also that if the system this
 * is compiled on doesn't use 7-bit ascii, casetable[] should not be
 * defined to the linker, so gawk should not load.
 *
 * Do NOT make this array static, it is used in several spots, not
 * just in this file.
 */
#if 'a' == 97	/* it's ascii */
char casetable[] = {
	'\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
	'\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
	'\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
	'\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
	/* ' '     '!'     '"'     '#'     '$'     '%'     '&'     ''' */
	'\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
	/* '('     ')'     '*'     '+'     ','     '-'     '.'     '/' */
	'\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
	/* '0'     '1'     '2'     '3'     '4'     '5'     '6'     '7' */
	'\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
	/* '8'     '9'     ':'     ';'     '<'     '='     '>'     '?' */
	'\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
	/* '@'     'A'     'B'     'C'     'D'     'E'     'F'     'G' */
	'\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
	/* 'H'     'I'     'J'     'K'     'L'     'M'     'N'     'O' */
	'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
	/* 'P'     'Q'     'R'     'S'     'T'     'U'     'V'     'W' */
	'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
	/* 'X'     'Y'     'Z'     '['     '\'     ']'     '^'     '_' */
	'\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
	/* '`'     'a'     'b'     'c'     'd'     'e'     'f'     'g' */
	'\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
	/* 'h'     'i'     'j'     'k'     'l'     'm'     'n'     'o' */
	'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
	/* 'p'     'q'     'r'     's'     't'     'u'     'v'     'w' */
	'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
	/* 'x'     'y'     'z'     '{'     '|'     '}'     '~' */
	'\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
	'\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
	'\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
	'\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
	'\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
	'\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
	'\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
	'\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
	'\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
	'\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
	'\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
	'\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
	'\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
	'\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
	'\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
	'\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
	'\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
};
#else
#include "You lose. You will need a translation table for your character set."
#endif

/*
 * Tree is a bunch of rules to run. Returns zero if it hit an exit()
 * statement 
 */
interpret(tree)
NODE *tree;
{
	register NODE *t = NULL;	/* temporary */

	auto jmp_buf loop_tag_stack;	/* shallow binding stack for loop_tag */
	static jmp_buf loop_tag;/* always the current binding */
	static int loop_tag_valid = 0;	/* nonzero when loop_tag valid */

	static jmp_buf rule_tag;/* tag the rule currently being run, for NEXT
				 * and EXIT statements.  It is static because
				 * there are no nested rules */

	register NODE **lhs;	/* lhs == Left Hand Side for assigns, etc */
	register struct search *l;	/* For array_for */


	extern NODE **fields_arr;
	extern int exiting, exit_val;

	/*
	 * clean up temporary strings created by evaluating expressions in
	 * previous recursive calls 
	 */

	if (tree == NULL)
		return 1;
	sourceline = tree->source_line;
	source = tree->source_file;
	switch (tree->type) {
	case Node_rule_list:
		for (t = tree; t != NULL; t = t->rnode) {
			tree = t->lnode;
		/* FALL THROUGH */
	case Node_rule_node:
			switch (_setjmp(rule_tag)) {
			case 0:	/* normal non-jump */
				/* test pattern, if any */
				if (tree->lnode == NULL 
				    || eval_condition(tree->lnode)) {
					DBG_P(("Found a rule", tree->rnode));
					if (tree->rnode == NULL) {
						/*
						 * special case: pattern with
						 * no action is equivalent to
						 * an action of {print}
						 */
						NODE printnode;

						printnode.type = Node_K_print;
						printnode.lnode = NULL;
						printnode.rnode = NULL;
						do_print(&printnode);
					} else if (tree->rnode->type == Node_illegal) {
						/*
						 * An empty statement
						 * (``{ }'') is different
						 * from a missing statement.
						 * A missing statement is
						 * equal to ``{ print }'' as
						 * above, but an empty
						 * statement is as in C, do
						 * nothing.
						 */
					} else
						(void) interpret(tree->rnode);
				}
				break;
			case TAG_CONTINUE:	/* NEXT statement */
				return 1;
			case TAG_BREAK:
				return 0;
			}
			if (t == NULL)
				break;
		}
		break;

	case Node_statement_list:
		for (t = tree; t != NULL; t = t->rnode) {
			DBG_P(("Statements", t->lnode));
			(void) interpret(t->lnode);
		}
		break;

	case Node_K_if:
		DBG_P(("IF", tree->lnode));
		if (eval_condition(tree->lnode)) {
			DBG_P(("True", tree->rnode->lnode));
			(void) interpret(tree->rnode->lnode);
		} else {
			DBG_P(("False", tree->rnode->rnode));
			(void) interpret(tree->rnode->rnode);
		}
		break;

	case Node_K_while:
		PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);

		DBG_P(("WHILE", tree->lnode));
		while (eval_condition(tree->lnode)) {
			switch (_setjmp(loop_tag)) {
			case 0:	/* normal non-jump */
				DBG_P(("DO", tree->rnode));
				(void) interpret(tree->rnode);
				break;
			case TAG_CONTINUE:	/* continue statement */
				break;
			case TAG_BREAK:	/* break statement */
				RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
				return 1;
			default:
				cant_happen();
			}
		}
		RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
		break;

	case Node_K_do:
		PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);

		do {
			switch (_setjmp(loop_tag)) {
			case 0:	/* normal non-jump */
				DBG_P(("DO", tree->rnode));
				(void) interpret(tree->rnode);
				break;
			case TAG_CONTINUE:	/* continue statement */
				break;
			case TAG_BREAK:	/* break statement */
				RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
				return 1;
			default:
				cant_happen();
			}
			DBG_P(("WHILE", tree->lnode));
		} while (eval_condition(tree->lnode));
		RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
		break;

	case Node_K_for:
		PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);

		DBG_P(("FOR", tree->forloop->init));
		(void) interpret(tree->forloop->init);

		DBG_P(("FOR.WHILE", tree->forloop->cond));
		while (eval_condition(tree->forloop->cond)) {
			switch (_setjmp(loop_tag)) {
			case 0:	/* normal non-jump */
				DBG_P(("FOR.DO", tree->lnode));
				(void) interpret(tree->lnode);
				/* fall through */
			case TAG_CONTINUE:	/* continue statement */
				DBG_P(("FOR.INCR", tree->forloop->incr));
				(void) interpret(tree->forloop->incr);
				break;
			case TAG_BREAK:	/* break statement */
				RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
				return 1;
			default:
				cant_happen();
			}
		}
		RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
		break;

	case Node_K_arrayfor:
#define hakvar forloop->init
#define arrvar forloop->incr
		PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
		DBG_P(("AFOR.VAR", tree->hakvar));
		lhs = get_lhs(tree->hakvar, 1);
		t = tree->arrvar;
		if (tree->arrvar->type == Node_param_list)
			t = stack_ptr[tree->arrvar->param_cnt];
		for (l = assoc_scan(t); l; l = assoc_next(l)) {
			deref = *lhs;
			do_deref();
			*lhs = dupnode(l->retval);
			if (field_num == 0)
				set_record(fields_arr[0]->stptr,
				    fields_arr[0]->stlen);
			DBG_P(("AFOR.NEXTIS", *lhs));
			switch (_setjmp(loop_tag)) {
			case 0:
				DBG_P(("AFOR.DO", tree->lnode));
				(void) interpret(tree->lnode);
			case TAG_CONTINUE:
				break;

			case TAG_BREAK:
				RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
				field_num = -1;
				return 1;
			default:
				cant_happen();
			}
		}
		field_num = -1;
		RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid);
		break;

	case Node_K_break:
		DBG_P(("BREAK", NULL));
		if (loop_tag_valid == 0)
			fatal("unexpected break");
		_longjmp(loop_tag, TAG_BREAK);
		break;

	case Node_K_continue:
		DBG_P(("CONTINUE", NULL));
		if (loop_tag_valid == 0)
			fatal("unexpected continue");
		_longjmp(loop_tag, TAG_CONTINUE);
		break;

	case Node_K_print:
		DBG_P(("PRINT", tree));
		do_print(tree);
		break;

	case Node_K_printf:
		DBG_P(("PRINTF", tree));
		do_printf(tree);
		break;

	case Node_K_next:
		DBG_P(("NEXT", NULL));
		_longjmp(rule_tag, TAG_CONTINUE);
		break;

	case Node_K_exit:
		/*
		 * In A,K,&W, p. 49, it says that an exit statement "...
		 * causes the program to behave as if the end of input had
		 * occurred; no more input is read, and the END actions, if
		 * any are executed." This implies that the rest of the rules
		 * are not done. So we immediately break out of the main loop.
		 */
		DBG_P(("EXIT", NULL));
		exiting = 1;
		if (tree)
			exit_val = (int) force_number(tree_eval(tree->lnode));
		free_result();
		_longjmp(rule_tag, TAG_BREAK);
		break;

	case Node_K_return:
		DBG_P(("RETURN", NULL));
		ret_node = dupnode(tree_eval(tree->lnode));
		ret_node->flags |= TEMP;
		_longjmp(func_tag, TAG_RETURN);
		break;

	default:
		/*
		 * Appears to be an expression statement.  Throw away the
		 * value. 
		 */
		DBG_P(("E", NULL));
		(void) tree_eval(tree);
		free_result();
		break;
	}
	return 1;
}

/* evaluate a subtree, allocating strings on a temporary stack. */

NODE *
r_tree_eval(tree)
NODE *tree;
{
	register NODE *r, *t1, *t2;	/* return value & temporary subtrees */
	int i;
	register NODE **lhs;
	int di;
	AWKNUM x, x2;
	long lx;
	struct re_pattern_buffer *rp;
	extern NODE **fields_arr;

	if (tree->type != Node_var)
		source = tree->source_file;
	sourceline = tree->source_line;
	switch (tree->type) {
	case Node_and:
		DBG_P(("AND", tree));
		return tmp_number((AWKNUM) (eval_condition(tree->lnode)
					    && eval_condition(tree->rnode)));

	case Node_or:
		DBG_P(("OR", tree));
		return tmp_number((AWKNUM) (eval_condition(tree->lnode)
					    || eval_condition(tree->rnode)));

	case Node_not:
		DBG_P(("NOT", tree));
		return tmp_number((AWKNUM) ! eval_condition(tree->lnode));

		/* Builtins */
	case Node_builtin:
		DBG_P(("builtin", tree));
		return ((*tree->proc) (tree->subnode));

	case Node_K_getline:
		DBG_P(("GETLINE", tree));
		return (do_getline(tree));

	case Node_in_array:
		DBG_P(("IN_ARRAY", tree));
		return tmp_number((AWKNUM) in_array(tree->lnode, tree->rnode));

	case Node_K_match:
		DBG_P(("MATCH", tree));
		return do_match(tree);

	case Node_sub:
	case Node_gsub:
		DBG_P(("SUB", tree));
		return do_sub(tree);

	case Node_func_call:
		DBG_P(("func_call", tree));
		return func_call(tree->rnode, tree->lnode);

	case Node_K_delete:
		DBG_P(("DELETE", tree));
		do_delete(tree->lnode, tree->rnode);
		return Nnull_string;

		/* unary operations */

	case Node_var:
	case Node_var_array:
	case Node_param_list:
	case Node_subscript:
	case Node_field_spec:
		DBG_P(("var_type ref", tree));
		lhs = get_lhs(tree, 0);
		field_num = -1;
		deref = 0;
		return *lhs;

	case Node_unary_minus:
		DBG_P(("UMINUS", tree));
		x = -force_number(tree_eval(tree->subnode));
		free_result();
		return tmp_number(x);

	case Node_cond_exp:
		DBG_P(("?:", tree));
		if (eval_condition(tree->lnode)) {
			DBG_P(("True", tree->rnode->lnode));
			return tree_eval(tree->rnode->lnode);
		}
			DBG_P(("False", tree->rnode->rnode));
			return tree_eval(tree->rnode->rnode);

	case Node_match:
	case Node_nomatch:
		DBG_P(("ASSIGN_[no]match", tree));
		t1 = force_string(tree_eval(tree->lnode));
		if (tree->rnode->type == Node_regex) {
			rp = tree->rnode->rereg;
			if (!strict && ((IGNORECASE_node->var_value->numbr != 0)
			    ^ (tree->rnode->re_case != 0))) {
				/* recompile since case sensitivity differs */
				rp = tree->rnode->rereg =
					mk_re_parse(tree->rnode->re_text,
					(IGNORECASE_node->var_value->numbr != 0));
				tree->rnode->re_case = (IGNORECASE_node->var_value->numbr != 0);
			}
		} else {
			rp = make_regexp(force_string(tree_eval(tree->rnode)),
					(IGNORECASE_node->var_value->numbr != 0));
			if (rp == NULL)
				cant_happen();
		}
		i = re_search(rp, t1->stptr, t1->stlen, 0, t1->stlen,
			(struct re_registers *) NULL);
		i = (i == -1) ^ (tree->type == Node_match);
		free_temp(t1);
		return tmp_number((AWKNUM) i);

	case Node_func:
		fatal("function `%s' called with space between name and (,\n%s",
			tree->lnode->param,
			"or used in other expression context");

		/* assignments */
	case Node_assign:
		DBG_P(("ASSIGN", tree));
		r = tree_eval(tree->rnode);
		lhs = get_lhs(tree->lnode, 1);
		*lhs = dupnode(r);
		do_deref();
		if (field_num == 0)
			set_record(fields_arr[0]->stptr, fields_arr[0]->stlen);
		field_num = -1;
		return *lhs;

		/* other assignment types are easier because they are numeric */
	case Node_preincrement:
	case Node_predecrement:
	case Node_postincrement:
	case Node_postdecrement:
	case Node_assign_exp:
	case Node_assign_times:
	case Node_assign_quotient:
	case Node_assign_mod:
	case Node_assign_plus:
	case Node_assign_minus:
		return op_assign(tree);
	}

	/*
	 * Note that if TREE is invalid, gawk will probably bomb in one of
	 * these tree_evals here.  
	 */
	/* evaluate subtrees in order to do binary operation, then keep going */
	t1 = tree_eval(tree->lnode);
	t2 = tree_eval(tree->rnode);

	switch (tree->type) {
	case Node_concat:
		DBG_P(("CONCAT", tree));
		t1 = force_string(t1);
		t2 = force_string(t2);

		r = newnode(Node_val);
		r->flags = (STR|TEMP);
		r->stlen = t1->stlen + t2->stlen;
		r->stref = 1;
		emalloc(r->stptr, char *, r->stlen + 1, "tree_eval");
		bcopy(t1->stptr, r->stptr, t1->stlen);
		bcopy(t2->stptr, r->stptr + t1->stlen, t2->stlen);
		r->stptr[r->stlen] = '\0';
		free_temp(t1);
		free_temp(t2);
		return r;

	case Node_geq:
	case Node_leq:
	case Node_greater:
	case Node_less:
	case Node_notequal:
	case Node_equal:
		di = cmp_nodes(t1, t2);
		free_temp(t1);
		free_temp(t2);
		switch (tree->type) {
		case Node_equal:
			DBG_P(("EQUAL", tree));
			return tmp_number((AWKNUM) (di == 0));
		case Node_notequal:
			DBG_P(("NOT_EQUAL", tree));
			return tmp_number((AWKNUM) (di != 0));
		case Node_less:
			DBG_P(("LESS_THAN", tree));
			return tmp_number((AWKNUM) (di < 0));
		case Node_greater:
			DBG_P(("GREATER_THAN", tree));
			return tmp_number((AWKNUM) (di > 0));
		case Node_leq:
			DBG_P(("LESS_THAN_EQUAL", tree));
			return tmp_number((AWKNUM) (di <= 0));
		case Node_geq:
			DBG_P(("GREATER_THAN_EQUAL", tree));
			return tmp_number((AWKNUM) (di >= 0));
		}
		break;
	}

	(void) force_number(t1);
	(void) force_number(t2);

	switch (tree->type) {
	case Node_exp:
		DBG_P(("EXPONENT", tree));
		x = pow((double) t1->numbr, (double) t2->numbr);
		free_temp(t1);
		free_temp(t2);
		return tmp_number(x);

	case Node_times:
		DBG_P(("MULT", tree));
		x = t1->numbr * t2->numbr;
		free_temp(t1);
		free_temp(t2);
		return tmp_number(x);

	case Node_quotient:
		DBG_P(("DIVIDE", tree));
		x = t2->numbr;
		free_temp(t2);
		if (x == (AWKNUM) 0) {
			free_temp(t1);
			return tmp_number((AWKNUM) 0);
		} else {
			x = t1->numbr / x;
			free_temp(t1);
			return tmp_number(x);
		}

	case Node_mod:
		DBG_P(("MODULUS", tree));
		x = t2->numbr;
		free_temp(t2);
		if (x == (AWKNUM) 0) {
			free_temp(t1);
			return tmp_number((AWKNUM) 0);
		}
		lx = t1->numbr / x;	/* assignment to long truncates */
		x2 = lx * x;
		x = t1->numbr - x2;
		free_temp(t1);
		return tmp_number(x);

	case Node_plus:
		DBG_P(("PLUS", tree));
		x = t1->numbr + t2->numbr;
		free_temp(t1);
		free_temp(t2);
		return tmp_number(x);

	case Node_minus:
		DBG_P(("MINUS", tree));
		x = t1->numbr - t2->numbr;
		free_temp(t1);
		free_temp(t2);
		return tmp_number(x);

	default:
		fatal("illegal type (%d) in tree_eval", tree->type);
	}
	return 0;
}

/*
 * This makes numeric operations slightly more efficient. Just change the
 * value of a numeric node, if possible 
 */
void
assign_number(ptr, value)
NODE **ptr;
AWKNUM value;
{
	extern NODE *deref;
	register NODE *n = *ptr;

#ifdef DEBUG
	if (n->type != Node_val)
		cant_happen();
#endif
	if (n == Nnull_string) {
		*ptr = make_number(value);
		deref = 0;
		return;
	}
	if (n->stref > 1) {
		*ptr = make_number(value);
		return;
	}
	if ((n->flags & STR) && (n->flags & (MALLOC|TEMP)))
		free(n->stptr);
	n->numbr = value;
	n->flags |= NUM;
	n->flags &= ~STR;
	n->stref = 0;
	deref = 0;
}


/* Is TREE true or false?  Returns 0==false, non-zero==true */
static int
eval_condition(tree)
NODE *tree;
{
	register NODE *t1;
	int ret;

	if (tree == NULL)	/* Null trees are the easiest kinds */
		return 1;
	if (tree->type == Node_line_range) {
		/*
		 * Node_line_range is kind of like Node_match, EXCEPT: the
		 * lnode field (more properly, the condpair field) is a node
		 * of a Node_cond_pair; whether we evaluate the lnode of that
		 * node or the rnode depends on the triggered word.  More
		 * precisely:  if we are not yet triggered, we tree_eval the
		 * lnode; if that returns true, we set the triggered word. 
		 * If we are triggered (not ELSE IF, note), we tree_eval the
		 * rnode, clear triggered if it succeeds, and perform our
		 * action (regardless of success or failure).  We want to be
		 * able to begin and end on a single input record, so this
		 * isn't an ELSE IF, as noted above.
		 */
		if (!tree->triggered)
			if (!eval_condition(tree->condpair->lnode))
				return 0;
			else
				tree->triggered = 1;
		/* Else we are triggered */
		if (eval_condition(tree->condpair->rnode))
			tree->triggered = 0;
		return 1;
	}

	/*
	 * Could just be J.random expression. in which case, null and 0 are
	 * false, anything else is true 
	 */

	t1 = tree_eval(tree);
	if (t1->flags & STR)
		ret = t1->stlen != 0;
	else
		ret = t1->numbr != 0.0;
	free_temp(t1);
	return ret;
}

/*
 * strtod() would have been better, except (1) real awk is needlessly
 * restrictive in what strings it will consider to be numbers, and (2) I
 * couldn't find the public domain version anywhere handy. 
 */
static int
is_a_number(str)	/* does the string str have pure-numeric syntax? */
char *str;		/* don't convert it, assume that atof is better */
{
	if (*str == 0)
		return 0;	/* null string is not equal to 0 */

	if (*str == '-')
		str++;
	if (*str == 0)
		return 0;
	/* must be either . or digits (.4 is legal) */
	if (*str != '.' && !isdigit(*str))
		return 0;
	while (isdigit(*str))
		str++;
	if (*str == '.') {
		str++;
		while (isdigit(*str))
			str++;
	}

	/*
	 * curiously, real awk DOESN'T consider "1E1" to be equal to 10! Or
	 * even equal to 1E1 for that matter!  For a laugh, try:
	 * awk 'BEGIN {if ("1E1" == 1E1) print "eq"; else print "neq"; exit}'
	 * Since this behavior is QUITE curious, I include the code for the
	 * adventurous. One might also feel like skipping leading whitespace
	 * (awk doesn't) and allowing a leading + (awk doesn't).
	 */
#ifdef Allow_Exponents
	if (*str == 'e' || *str == 'E') {
		str++;
		if (*str == '+' || *str == '-')
			str++;
		if (!isdigit(*str))
			return 0;
		while (isdigit(*str))
			str++;
	}
#endif
	/*
	 * if we have digested the whole string, we are
	 * successful 
	 */
	return (*str == 0);
}

int
cmp_nodes(t1, t2)
NODE *t1, *t2;
{
	AWKNUM d;
	int ret;
	int len1, len2;

	if (t1 == t2)
		return 0;
	if ((t1->flags & NUM)) {
		if ((t2->flags & NUM))
			d = t1->numbr - t2->numbr;
		else if (is_a_number(t2->stptr))
			d = t1->numbr - force_number(t2);
		else {
			t1 = force_string(t1);
			goto strings;
		}
		if (d == 0.0)	/* from profiling, this is most common */
			return 0;
		if (d > 0.0)
			return 1;
		return -1;
	}
	if ((t2->flags & NUM)) {
		if (is_a_number(t1->stptr))
			d = force_number(t1) - t2->numbr;
		else {
			t2 = force_string(t2);
			goto strings;
		}
		if (d == 0.0)	/* from profiling, this is most common */
			return 0;
		if (d > 0.0)
			return 1;
		return -1;
	}
	if (is_a_number(t1->stptr) && is_a_number(t2->stptr)) {
		/*
		 * following two statements are this way because force_number
		 * is a macro
		 */
		d = force_number(t1);
		d = d - force_number(t2);
		if (d == 0.0)	/* from profiling, this is most common */
			return 0;
		if (d > 0.0)
			return 1;
		return -1;
	}

strings:
	len1 = t1->stlen;
	len2 = t2->stlen;
	if (len1 == 0) {
		if (len2 == 0)
			return 0;
		else
			return -1;
	} else if (len2 == 0)
		return 1;
	ret = memcmp(t1->stptr, t2->stptr, len1 <= len2 ? len1 : len2);
	if (ret == 0 && len1 != len2)
		return len1 < len2 ? -1: 1;
	return ret;
}

#ifdef NOMEMCMP
/*
 * memcmp --- compare strings.
 *
 * We use our own routine since it has to act like strcmp() for return
 * value, and the BSD manual says bcmp() only returns zero/non-zero.
 */

static int
memcmp (s1, s2, l)
register char *s1, *s2;
register int l;
{
	for (; l--; s1++, s2++) {
		if (*s1 != *s2)
			return (*s1 - *s2);
	}
	return (*--s1 - *--s2);
}
#endif

static NODE *
op_assign(tree)
NODE *tree;
{
	AWKNUM rval, lval;
	NODE **lhs;
	AWKNUM t1, t2;
	long ltemp;

	lhs = get_lhs(tree->lnode, 1);
	lval = force_number(*lhs);

	switch(tree->type) {
	case Node_preincrement:
	case Node_predecrement:
		DBG_P(("+-X", tree));
		assign_number(lhs,
		    lval + (tree->type == Node_preincrement ? 1.0 : -1.0));
		do_deref();
		if (field_num == 0)
			set_record(fields_arr[0]->stptr, fields_arr[0]->stlen);
		field_num = -1;
		return *lhs;

	case Node_postincrement:
	case Node_postdecrement:
		DBG_P(("X+-", tree));
		assign_number(lhs,
		    lval + (tree->type == Node_postincrement ? 1.0 : -1.0));
		do_deref();
		if (field_num == 0)
			set_record(fields_arr[0]->stptr, fields_arr[0]->stlen);
		field_num = -1;
		return tmp_number(lval);
	}

	rval = force_number(tree_eval(tree->rnode));
	free_result();
	switch(tree->type) {
	case Node_assign_exp:
		DBG_P(("ASSIGN_exp", tree));
		assign_number(lhs, (AWKNUM) pow((double) lval, (double) rval));
		break;

	case Node_assign_times:
		DBG_P(("ASSIGN_times", tree));
		assign_number(lhs, lval * rval);
		break;

	case Node_assign_quotient:
		DBG_P(("ASSIGN_quotient", tree));
		assign_number(lhs, lval / rval);
		break;

	case Node_assign_mod:
		DBG_P(("ASSIGN_mod", tree));
		ltemp = lval / rval;	/* assignment to long truncates */
		t1 = ltemp * rval;
		t2 = lval - t1;
		assign_number(lhs, t2);
		break;

	case Node_assign_plus:
		DBG_P(("ASSIGN_plus", tree));
		assign_number(lhs, lval + rval);
		break;

	case Node_assign_minus:
		DBG_P(("ASSIGN_minus", tree));
		assign_number(lhs, lval - rval);
		break;
	}
	do_deref();
	if (field_num == 0)
		set_record(fields_arr[0]->stptr, fields_arr[0]->stlen);
	field_num = -1;
	return *lhs;
}

