/*

 * eval.c - gawk bytecode interpreter

 */

/*

 * Copyright (C) 1986, 1988, 1989, 1991-2017 the Free Software Foundation, Inc.

 *

 * This file is part of GAWK, the GNU implementation of the

 * AWK Programming 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 3 of the License, 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 this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */

#include "awk.h"

extern double pow(double x, double y);

extern double modf(double x, double *yp);

extern double fmod(double x, double y);

NODE **fcall_list = NULL;

long fcall_count = 0;

int currule = 0;

IOBUF *curfile = NULL;		/* current data file */

bool exiting = false;

int (*interpret)(INSTRUCTION *);

#define MAX_EXEC_HOOKS	10

static int num_exec_hook = 0;

static Func_pre_exec pre_execute[MAX_EXEC_HOOKS];

static Func_post_exec post_execute = NULL;

extern void frame_popped();

int OFSlen;

int ORSlen;

int OFMTidx;

int CONVFMTidx;

static NODE *node_Boolean[2];

/* This rather ugly macro is for VMS C */

#ifdef C

#undef C

#endif

#define C(c) ((char)c)

/*

 * This table is used by the regexp routines to do case independent

 * matching. Basically, every ascii character maps to itself, except

 * uppercase letters map to lower case ones. This table has 256

 * entries, for ISO 8859-1. 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.

 *

 * 6/2004:

 * This table is also used for IGNORECASE for == and !=, and index().

 * Although with GLIBC, we could use tolower() everywhere and RE_ICASE

 * for the regex matcher, precomputing this table once gives us a

 * performance improvement.  I also think it's better for portability

 * to non-GLIBC systems.  All the world is not (yet :-) GNU/Linux.

 */

#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',

	/* Latin 1: */

	C('\200'), C('\201'), C('\202'), C('\203'), C('\204'), C('\205'), C('\206'), C('\207'),

	C('\210'), C('\211'), C('\212'), C('\213'), C('\214'), C('\215'), C('\216'), C('\217'),

	C('\220'), C('\221'), C('\222'), C('\223'), C('\224'), C('\225'), C('\226'), C('\227'),

	C('\230'), C('\231'), C('\232'), C('\233'), C('\234'), C('\235'), C('\236'), C('\237'),

	C('\240'), C('\241'), C('\242'), C('\243'), C('\244'), C('\245'), C('\246'), C('\247'),

	C('\250'), C('\251'), C('\252'), C('\253'), C('\254'), C('\255'), C('\256'), C('\257'),

	C('\260'), C('\261'), C('\262'), C('\263'), C('\264'), C('\265'), C('\266'), C('\267'),

	C('\270'), C('\271'), C('\272'), C('\273'), C('\274'), C('\275'), C('\276'), C('\277'),

	C('\340'), C('\341'), C('\342'), C('\343'), C('\344'), C('\345'), C('\346'), C('\347'),

	C('\350'), C('\351'), C('\352'), C('\353'), C('\354'), C('\355'), C('\356'), C('\357'),

	C('\360'), C('\361'), C('\362'), C('\363'), C('\364'), C('\365'), C('\366'), C('\327'),

	C('\370'), C('\371'), C('\372'), C('\373'), C('\374'), C('\375'), C('\376'), C('\337'),

	C('\340'), C('\341'), C('\342'), C('\343'), C('\344'), C('\345'), C('\346'), C('\347'),

	C('\350'), C('\351'), C('\352'), C('\353'), C('\354'), C('\355'), C('\356'), C('\357'),

	C('\360'), C('\361'), C('\362'), C('\363'), C('\364'), C('\365'), C('\366'), C('\367'),

	C('\370'), C('\371'), C('\372'), C('\373'), C('\374'), C('\375'), C('\376'), C('\377'),

};

#elif defined(USE_EBCDIC)

char casetable[] = {

 /*00  NU    SH    SX    EX    PF    HT    LC    DL */

      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,

 /*08              SM    VT    FF    CR    SO    SI */

      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,

 /*10  DE    D1    D2    TM    RS    NL    BS    IL */

      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,

 /*18  CN    EM    CC    C1    FS    GS    RS    US */

      0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,

 /*20  DS    SS    FS          BP    LF    EB    EC */

      0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,

 /*28              SM    C2    EQ    AK    BL       */

      0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,

 /*30              SY          PN    RS    UC    ET */

      0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,

 /*38                    C3    D4    NK          SU */

      0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,

 /*40  SP                                           */

      0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,

 /*48             CENT    .     <     (     +     | */

      0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,

 /*50   &                                           */

      0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,

 /*58               !     $     *     )     ;     ^ */

      0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,

 /*60   -     /                                     */

      0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,

 /*68               |     ,     %     _     >     ? */

      0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,

 /*70                                               */

      0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,

 /*78         `     :     #     @     '     =     " */

      0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,

 /*80         a     b     c     d     e     f     g */

      0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

 /*88   h     i           {                         */

      0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,

 /*90         j     k     l     m     n     o     p */

      0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,

 /*98   q     r           }                         */

      0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,

 /*A0         ~     s     t     u     v     w     x */

      0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,

 /*A8   y     z                       [             */

      0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,

 /*B0                                               */

      0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,

 /*B8                                 ]             */

      0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,

 /*C0   {     A     B     C     D     E     F     G */

      0xC0, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

 /*C8   H     I                                     */

      0x88, 0x89, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,

 /*D0   }     J     K     L     M     N     O     P */

      0xD0, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,

 /*D8   Q     R                                     */

      0x98, 0x99, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,

 /*E0   \           S     T     U     V     W     X */

      0xE0, 0xE1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,

 /*E8   Y     Z                                     */

      0xA8, 0xA9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,

 /*F0   0     1     2     3     4     5     6     7 */

      0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,

 /*F8   8     9                                     */

      0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF

};

#else

#include "You lose. You will need a translation table for your character set."

#endif

#undef C

/* load_casetable --- for a non-ASCII locale, redo the table */

void

load_casetable(void)

{

#if defined(LC_CTYPE)

	int i;

	char *cp;

	static bool loaded = false;

	if (loaded || do_traditional)

		return;

	loaded = true;

	cp = setlocale(LC_CTYPE, NULL);

	/* this is not per standard, but it's pretty safe */

	if (cp == NULL || strcmp(cp, "C") == 0 || strcmp(cp, "POSIX") == 0)

		return;

#ifndef USE_EBCDIC

	/* use of isalpha is ok here (see is_alpha in awkgram.y) */

	for (i = 0200; i <= 0377; i++) {

		if (isalpha(i) && islower(i) && i != toupper(i))

			casetable[i] = toupper(i);

		else

			casetable[i] = i;

	}

#endif

#endif

}

/*

 * This table maps node types to strings for debugging.

 * KEEP IN SYNC WITH awk.h!!!!

 */

static const char *const nodetypes[] = {

	"Node_illegal",

	"Node_val",

	"Node_regex",

	"Node_dynregex",

	"Node_var",

	"Node_var_array",

	"Node_var_new",

	"Node_param_list",

	"Node_func",

	"Node_ext_func",

	"Node_builtin_func",

	"Node_array_ref",

	"Node_array_tree",

	"Node_array_leaf",

	"Node_dump_array",

	"Node_arrayfor",

	"Node_frame",

	"Node_instruction",

	"Node_final --- this should never appear",

	NULL

};

/*

 * This table maps Op codes to strings.

 * KEEP IN SYNC WITH awk.h!!!!

 */

static struct optypetab {

	char *desc;

	char *operator;

} optypes[] = {

	{ "Op_illegal", NULL },

	{ "Op_times", " * " },

	{ "Op_times_i", " * " },

	{ "Op_quotient", " / " },

	{ "Op_quotient_i", " / " },

	{ "Op_mod", " % " },

	{ "Op_mod_i", " % " },

	{ "Op_plus", " + " },

	{ "Op_plus_i", " + " },

	{ "Op_minus", " - " },

	{ "Op_minus_i", " - " },

	{ "Op_exp", " ^ " },

	{ "Op_exp_i", " ^ " },

	{ "Op_concat", " " },

	{ "Op_line_range", NULL },

	{ "Op_cond_pair", ", " },

	{ "Op_subscript", "[]" },

	{ "Op_sub_array", "[]" },

	{ "Op_preincrement", "++" },

	{ "Op_predecrement", "--" },

	{ "Op_postincrement", "++" },

	{ "Op_postdecrement", "--" },

	{ "Op_unary_minus", "-" },

	{ "Op_unary_plus", "+" },

	{ "Op_field_spec", "$" },

	{ "Op_not", "! " },

	{ "Op_assign", " = " },

	{ "Op_store_var", " = " },

	{ "Op_store_sub", " = " },

	{ "Op_store_field", " = " },

	{ "Op_assign_times", " *= " },

	{ "Op_assign_quotient", " /= " },

	{ "Op_assign_mod", " %= " },

	{ "Op_assign_plus", " += " },

	{ "Op_assign_minus", " -= " },

	{ "Op_assign_exp", " ^= " },

	{ "Op_assign_concat", " " },

	{ "Op_and", " && " },

	{ "Op_and_final", NULL },

	{ "Op_or", " || " },

	{ "Op_or_final", NULL },

	{ "Op_equal", " == " },

	{ "Op_notequal", " != " },

	{ "Op_less", " < " },

	{ "Op_greater", " > " },

	{ "Op_leq", " <= " },

	{ "Op_geq", " >= " },

	{ "Op_match", " ~ " },

	{ "Op_match_rec", NULL },

	{ "Op_nomatch", " !~ " },

	{ "Op_rule", NULL },

	{ "Op_K_case", "case" },

	{ "Op_K_default", "default" },

	{ "Op_K_break", "break" },

	{ "Op_K_continue", "continue" },

	{ "Op_K_print", "print" },

	{ "Op_K_print_rec", "print" },

	{ "Op_K_printf", "printf" },

	{ "Op_K_next", "next" },

	{ "Op_K_exit", "exit" },

	{ "Op_K_return", "return" },

	{ "Op_K_delete", "delete" },

	{ "Op_K_delete_loop", NULL },

	{ "Op_K_getline_redir", "getline" },

	{ "Op_K_getline", "getline" },

	{ "Op_K_nextfile", "nextfile" },

	{ "Op_builtin", NULL },

	{ "Op_sub_builtin", NULL },

	{ "Op_ext_builtin", NULL },

	{ "Op_in_array", " in " },

	{ "Op_func_call", NULL },

	{ "Op_indirect_func_call", NULL },

	{ "Op_push", NULL },

	{ "Op_push_arg", NULL },

	{ "Op_push_arg_untyped", NULL },

	{ "Op_push_i", NULL },

	{ "Op_push_re", NULL },

	{ "Op_push_array", NULL },

	{ "Op_push_param", NULL },

	{ "Op_push_lhs", NULL },

	{ "Op_subscript_lhs", "[]" },

	{ "Op_field_spec_lhs", "$" },

	{ "Op_no_op", NULL },

	{ "Op_pop", NULL },

	{ "Op_jmp", NULL },

	{ "Op_jmp_true", NULL },

	{ "Op_jmp_false", NULL },

	{ "Op_get_record", NULL },

	{ "Op_newfile", NULL },

	{ "Op_arrayfor_init", NULL },

	{ "Op_arrayfor_incr", NULL },

	{ "Op_arrayfor_final", NULL },

	{ "Op_var_update", NULL },

	{ "Op_var_assign", NULL },

	{ "Op_field_assign", NULL },

	{ "Op_subscript_assign", NULL },

	{ "Op_after_beginfile", NULL },

	{ "Op_after_endfile", NULL },

	{ "Op_func", NULL },

	{ "Op_comment", NULL },

	{ "Op_exec_count", NULL },

	{ "Op_breakpoint", NULL },

	{ "Op_lint", NULL },

	{ "Op_atexit", NULL },

	{ "Op_stop", NULL },

	{ "Op_token", NULL },

	{ "Op_symbol", NULL },

	{ "Op_list", NULL },

	{ "Op_K_do", "do" },

	{ "Op_K_for", "for" },

	{ "Op_K_arrayfor", "for" },

	{ "Op_K_while", "while" },

	{ "Op_K_switch", "switch" },

	{ "Op_K_if", "if" },

	{ "Op_K_else", "else" },

	{ "Op_K_function", "function" },

	{ "Op_cond_exp", NULL },

	{ "Op_parens", NULL },

	{ "Op_final --- this should never appear", NULL },

	{ NULL, NULL },

};

/* nodetype2str --- convert a node type into a printable value */

const char *

nodetype2str(NODETYPE type)

{

	static char buf[40];

	if (type >= Node_illegal && type <= Node_final)

		return nodetypes[(int) type];

	sprintf(buf, _("unknown nodetype %d"), (int) type);

	return buf;

}

/* opcode2str --- convert a opcode type into a printable value */

const char *

opcode2str(OPCODE op)

{

	if (op >= Op_illegal && op < Op_final)

		return optypes[(int) op].desc;

	fatal(_("unknown opcode %d"), (int) op);

	return NULL;

}

const char *

op2str(OPCODE op)

{

	if (op >= Op_illegal && op < Op_final) {

		if (optypes[(int) op].operator != NULL)

			return optypes[(int) op].operator;

		else

			fatal(_("opcode %s not an operator or keyword"),

					optypes[(int) op].desc);

	} else

		fatal(_("unknown opcode %d"), (int) op);

	return NULL;

}

/* flags2str --- make a flags value readable */

const char *

flags2str(int flagval)

{

	static const struct flagtab values[] = {

		{ MALLOC, "MALLOC" },

		{ STRING, "STRING" },

		{ STRCUR, "STRCUR" },

		{ NUMCUR, "NUMCUR" },

		{ NUMBER, "NUMBER" },

		{ USER_INPUT, "USER_INPUT" },

		{ INTLSTR, "INTLSTR" },

		{ NUMINT, "NUMINT" },

		{ INTIND, "INTIND" },

		{ WSTRCUR, "WSTRCUR" },

		{ MPFN,	"MPFN" },

		{ MPZN,	"MPZN" },

		{ NO_EXT_SET, "NO_EXT_SET" },

		{ NULL_FIELD, "NULL_FIELD" },

		{ ARRAYMAXED, "ARRAYMAXED" },

		{ HALFHAT, "HALFHAT" },

		{ XARRAY, "XARRAY" },

		{ NUMCONSTSTR, "NUMCONSTSTR" },

		{ REGEX, "REGEX" },

		{ 0,	NULL },

	};

	return genflags2str(flagval, values);

}

/* genflags2str --- general routine to convert a flag value to a string */

const char *

genflags2str(int flagval, const struct flagtab *tab)

{

	static char buffer[BUFSIZ];

	char *sp;

	int i, space_left, space_needed;

	sp = buffer;

	space_left = BUFSIZ;

	for (i = 0; tab[i].name != NULL; i++) {

		if ((flagval & tab[i].val) != 0) {

			/*

			 * note the trick, we want 1 or 0 for whether we need

			 * the '|' character.

			 */

			space_needed = (strlen(tab[i].name) + (sp != buffer));

			if (space_left <= space_needed)

				fatal(_("buffer overflow in genflags2str"));

			if (sp != buffer) {

				*sp++ = '|';

				space_left--;

			}

			strcpy(sp, tab[i].name);

			/* note ordering! */

			space_left -= strlen(sp);

			sp += strlen(sp);

		}

	}

	*sp = '\0';

	return buffer;

}

/* posix_compare --- compare strings using strcoll */

static int

posix_compare(NODE *s1, NODE *s2)

{

	int ret = 0;

	char save1, save2;

	size_t l = 0;

	save1 = s1->stptr[s1->stlen];

	s1->stptr[s1->stlen] = '\0';

	save2 = s2->stptr[s2->stlen];

	s2->stptr[s2->stlen] = '\0';

	if (gawk_mb_cur_max == 1) {

		if (strlen(s1->stptr) == s1->stlen && strlen(s2->stptr) == s2->stlen)

			ret = strcoll(s1->stptr, s2->stptr);

		else {

			char b1[2], b2[2];

			char *p1, *p2;

			size_t i;

			if (s1->stlen < s2->stlen)

				l = s1->stlen;

			else

				l = s2->stlen;

			b1[1] = b2[1] = '\0';

			for (i = ret = 0, p1 = s1->stptr, p2 = s2->stptr;

			     ret == 0 && i < l;

			     p1++, p2++) {

				b1[0] = *p1;

				b2[0] = *p2;

				ret = strcoll(b1, b2);

			}

		}

		/*

		 * Either worked through the strings or ret != 0.

		 * In either case, ret will be the right thing to return.

		 */

	}

#if ! defined(__DJGPP__)

	else {

		/* Similar logic, using wide characters */

		(void) force_wstring(s1);

		(void) force_wstring(s2);

		if (wcslen(s1->wstptr) == s1->wstlen && wcslen(s2->wstptr) == s2->wstlen)

			ret = wcscoll(s1->wstptr, s2->wstptr);

		else {

			wchar_t b1[2], b2[2];

			wchar_t *p1, *p2;

			size_t i;

			if (s1->wstlen < s2->wstlen)

				l = s1->wstlen;

			else

				l = s2->wstlen;

			b1[1] = b2[1] = L'\0';

			for (i = ret = 0, p1 = s1->wstptr, p2 = s2->wstptr;

			     ret == 0 && i < l;

			     p1++, p2++) {

				b1[0] = *p1;

				b2[0] = *p2;

				ret = wcscoll(b1, b2);

			}

		}

		/*

		 * Either worked through the strings or ret != 0.

		 * In either case, ret will be the right thing to return.

		 */

	}

#endif

	s1->stptr[s1->stlen] = save1;

	s2->stptr[s2->stlen] = save2;

	return ret;

}

/* cmp_nodes --- compare two nodes, returning negative, 0, positive */

int

cmp_nodes(NODE *t1, NODE *t2, bool use_strcmp)

{

	int ret = 0;

	size_t len1, len2;

	int l, ldiff;

	if (t1 == t2)

		return 0;

	(void) fixtype(t1);

	(void) fixtype(t2);

	if ((t1->flags & NUMBER) != 0 && (t2->flags & NUMBER) != 0)

		return cmp_numbers(t1, t2);

	(void) force_string(t1);

	(void) force_string(t2);

	len1 = t1->stlen;

	len2 = t2->stlen;

	ldiff = len1 - len2;

	if (len1 == 0 || len2 == 0)

		return ldiff;

	if (do_posix && ! use_strcmp)

		return posix_compare(t1, t2);

	l = (ldiff <= 0 ? len1 : len2);

	if (IGNORECASE) {

		const unsigned char *cp1 = (const unsigned char *) t1->stptr;

		const unsigned char *cp2 = (const unsigned char *) t2->stptr;

		char save1 = t1->stptr[t1->stlen];

		char save2 = t2->stptr[t2->stlen];

		if (gawk_mb_cur_max > 1) {

			t1->stptr[t1->stlen] = t2->stptr[t2->stlen] = '\0';

			ret = strncasecmpmbs((const unsigned char *) cp1,

					     (const unsigned char *) cp2, l);

			t1->stptr[t1->stlen] = save1;

			t2->stptr[t2->stlen] = save2;

		} else {

			/* Could use tolower() here; see discussion above. */

			for (ret = 0; l-- > 0 && ret == 0; cp1++, cp2++)

				ret = casetable[*cp1] - casetable[*cp2];

		}

	} else

		ret = memcmp(t1->stptr, t2->stptr, l);

	ret = ret == 0 ? ldiff : ret;

	return ret;

}

/* push_frame --- push a frame NODE onto stack */

static void

push_frame(NODE *f)

{

	static long max_fcall;

	/* NB: frame numbering scheme as in GDB. frame_ptr => frame #0. */

	fcall_count++;

	if (fcall_list == NULL) {

		max_fcall = 10;

		emalloc(fcall_list, NODE **, (max_fcall + 1) * sizeof(NODE *), "push_frame");

	} else if (fcall_count == max_fcall) {

		max_fcall *= 2;

		erealloc(fcall_list, NODE **, (max_fcall + 1) * sizeof(NODE *), "push_frame");

	}

	if (fcall_count > 1)

		memmove(fcall_list + 2, fcall_list + 1, (fcall_count - 1) * sizeof(NODE *));

	fcall_list[1] = f;

}

/* pop_frame --- pop off a frame NODE*/

static void

pop_frame()

{

	if (fcall_count > 1)

		memmove(fcall_list + 1, fcall_list + 2, (fcall_count - 1) * sizeof(NODE *));

	fcall_count--;

	assert(fcall_count >= 0);

	if (do_debug)

		frame_popped();

}

/* dump_fcall_stack --- print a backtrace of the awk function calls */

void

dump_fcall_stack(FILE *fp)

{

	NODE *f, *func;

	long i = 0, j, k = 0;

	if (fcall_count == 0)

		return;

	fprintf(fp, _("\n\t# Function Call Stack:\n\n"));

	/* current frame */

	func = frame_ptr->func_node;

	for (j = 0; j <= frame_ptr->num_tail_calls; j++)

		fprintf(fp, "\t# %3ld. %s\n", k++, func->vname);

	/* outer frames except main */

	for (i = 1; i < fcall_count; i++) {

		f = fcall_list[i];

		func = f->func_node;

		for (j = 0; j <= f->num_tail_calls; j++)

			fprintf(fp, "\t# %3ld. %s\n", k++, func->vname);

	}

	fprintf(fp, "\t# %3ld. -- main --\n", k);

}

/* set_IGNORECASE --- update IGNORECASE as appropriate */

void

set_IGNORECASE()

{

	static bool warned = false;

	if ((do_lint || do_traditional) && ! warned) {

		warned = true;

		lintwarn(_("`IGNORECASE' is a gawk extension"));

	}

	load_casetable();

	if (do_traditional)

		IGNORECASE = false;

   	else

		IGNORECASE = boolval(IGNORECASE_node->var_value);

	set_RS();	/* set_RS() calls set_FS() if need be, for us */

}

/* set_BINMODE --- set translation mode (OS/2, DOS, others) */

void

set_BINMODE()

{

	static bool warned = false;

	char *p;

	NODE *v = fixtype(BINMODE_node->var_value);

	if ((do_lint || do_traditional) && ! warned) {

		warned = true;

		lintwarn(_("`BINMODE' is a gawk extension"));

	}

	if (do_traditional)

		BINMODE = TEXT_TRANSLATE;

	else if ((v->flags & NUMBER) != 0) {

		BINMODE = get_number_si(v);

		/* Make sure the value is rational. */

		if (BINMODE < TEXT_TRANSLATE)

			BINMODE = TEXT_TRANSLATE;

		else if (BINMODE > BINMODE_BOTH)

			BINMODE = BINMODE_BOTH;

	} else if ((v->flags & STRING) != 0) {

		p = v->stptr;

		/*

		 * Allow only one of the following:

		 * "0", "1", "2", "3",

		 * "r", "w", "rw", "wr"

		 * ANYTHING ELSE goes to 3. So there.

		 */

		switch (v->stlen) {

		case 1:

			switch (p[0]) {

			case '0':

			case '1':

			case '2':

			case '3':

				BINMODE = p[0] - '0';

				break;

			case 'r':

				BINMODE = BINMODE_INPUT;

				break;

			case 'w':

				BINMODE = BINMODE_OUTPUT;

				break;

			default:

				BINMODE = BINMODE_BOTH;

				goto bad_value;

				break;

			}

			break;

		case 2:

			switch (p[0]) {

			case 'r':

				BINMODE = BINMODE_BOTH;

				if (p[1] != 'w')

					goto bad_value;

				break;

			case 'w':

				BINMODE = BINMODE_BOTH;

				if (p[1] != 'r')

					goto bad_value;

				break;

			}

			break;

		default:

	bad_value:

			lintwarn(_("BINMODE value `%s' is invalid, treated as 3"), p);

			break;

		}

	} else

		BINMODE = 3;		/* shouldn't happen */

}

/* set_OFS --- update OFS related variables when OFS assigned to */

void

set_OFS()

{

	static bool first = true;

	size_t new_ofs_len;

	if (first)	/* true when called from init_vars() in main() */

		first = false;

	else {

		/* rebuild $0 using OFS that was current when $0 changed */

		if (! field0_valid) {

			get_field(UNLIMITED - 1, NULL);

			rebuild_record();

		}

	}

	/*

	 * Save OFS value for use in building record and in printing.

	 * Can't just have OFS point into the OFS_node since it's

	 * already updated when we come into this routine, and we need

	 * the old value to rebuild the record (see above).

	 */

	OFS_node->var_value = force_string(OFS_node->var_value);

	new_ofs_len = OFS_node->var_value->stlen;

	if (OFS == NULL)

		emalloc(OFS, char *, new_ofs_len + 1, "set_OFS");

	else if (OFSlen < new_ofs_len)

		erealloc(OFS, char *, new_ofs_len + 1, "set_OFS");

	memcpy(OFS, OFS_node->var_value->stptr, OFS_node->var_value->stlen);

	OFSlen = new_ofs_len;

	OFS[OFSlen] = '\0';

}

/* set_ORS --- update ORS related variables when ORS assigned to */

void

set_ORS()

{

	ORS_node->var_value = force_string(ORS_node->var_value);

	ORS = ORS_node->var_value->stptr;

	ORSlen = ORS_node->var_value->stlen;

}

/* fmt_ok --- is the conversion format a valid one? */

NODE **fmt_list = NULL;

static int fmt_ok(NODE *n);

static int fmt_index(NODE *n);

static int

fmt_ok(NODE *n)

{

	NODE *tmp = force_string(n);

	const char *p = tmp->stptr;

#if ! defined(PRINTF_HAS_F_FORMAT) || PRINTF_HAS_F_FORMAT != 1

	static const char float_formats[] = "efgEG";

#else

	static const char float_formats[] = "efgEFG";

#endif

#if defined(HAVE_LOCALE_H)

	static const char flags[] = " +-#'";

#else

	static const char flags[] = " +-#";

#endif

	// We rely on the caller to zero-terminate n->stptr.

	if (*p++ != '%')

		return 0;

	while (*p && strchr(flags, *p) != NULL)	/* flags */

		p++;

	while (*p && isdigit((unsigned char) *p))	/* width - %*.*g is NOT allowed */

		p++;

	if (*p == '\0' || (*p != '.' && ! isdigit((unsigned char) *p)))

		return 0;

	if (*p == '.')

		p++;

	while (*p && isdigit((unsigned char) *p))	/* precision */

		p++;

	if (*p == '\0' || strchr(float_formats, *p) == NULL)

		return 0;

	if (*++p != '\0')