/*

 * field.c - routines for dealing with fields and record parsing

 */

/*

 * Copyright (C) 1986, 1988, 1989, 1991-2018 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"

/*

 * In case that the system doesn't have isblank().

 * Don't bother with autoconf ifdef junk, just force it.

 * See dfa.c and regex_internal.h and regcomp.c. Bleah.

 */

static int

is_blank(int c)

{

	return c == ' ' || c == '\t';

}

typedef void (* Setfunc)(long, char *, long, NODE *);

/* is the API currently overriding the default parsing mechanism? */

static bool api_parser_override = false;

typedef long (*parse_field_func_t)(long, char **, int, NODE *,

			     Regexp *, Setfunc, NODE *, NODE *, bool);

static parse_field_func_t parse_field;

/*

 * N.B. The normal_parse_field function pointer contains the parse_field value

 * that should be used except when API field parsing is overriding the default

 * field parsing mechanism.

 */

static parse_field_func_t normal_parse_field;

static long re_parse_field(long, char **, int, NODE *,

			     Regexp *, Setfunc, NODE *, NODE *, bool);

static long def_parse_field(long, char **, int, NODE *,

			      Regexp *, Setfunc, NODE *, NODE *, bool);

static long null_parse_field(long, char **, int, NODE *,

			     Regexp *, Setfunc, NODE *, NODE *, bool);

static long sc_parse_field(long, char **, int, NODE *,

			     Regexp *, Setfunc, NODE *, NODE *, bool);

static long fw_parse_field(long, char **, int, NODE *,

			     Regexp *, Setfunc, NODE *, NODE *, bool);

static const awk_fieldwidth_info_t *api_fw = NULL;

static long fpat_parse_field(long, char **, int, NODE *,

			     Regexp *, Setfunc, NODE *, NODE *, bool);

static void set_element(long num, char * str, long len, NODE *arr);

static void grow_fields_arr(long num);

static void set_field(long num, char *str, long len, NODE *dummy);

static void purge_record(void);

static char *parse_extent;	/* marks where to restart parse of record */

static long parse_high_water = 0; /* field number that we have parsed so far */

static long nf_high_water = 0;	/* size of fields_arr */

static bool resave_fs;

static NODE *save_FS;		/* save current value of FS when line is read,

				 * to be used in deferred parsing

				 */

static awk_fieldwidth_info_t *FIELDWIDTHS = NULL;

NODE **fields_arr;		/* array of pointers to the field nodes */

bool field0_valid;		/* $(>0) has not been changed yet */

int default_FS;			/* true when FS == " " */

Regexp *FS_re_yes_case = NULL;

Regexp *FS_re_no_case = NULL;

Regexp *FS_regexp = NULL;

Regexp *FPAT_re_yes_case = NULL;

Regexp *FPAT_re_no_case = NULL;

Regexp *FPAT_regexp = NULL;

NODE *Null_field = NULL;

/* init_fields --- set up the fields array to start with */

void

init_fields()

{

	emalloc(fields_arr, NODE **, sizeof(NODE *), "init_fields");

	getnode(fields_arr[0]);

	*fields_arr[0] = *Nnull_string;

	fields_arr[0]->flags |= NULL_FIELD;

	parse_extent = fields_arr[0]->stptr;

	save_FS = dupnode(FS_node->var_value);

	getnode(Null_field);

	*Null_field = *Nnull_string;

	Null_field->valref = 1;

	Null_field->flags = (STRCUR|STRING|NULL_FIELD); /* do not set MALLOC */

	field0_valid = true;

}

/* grow_fields --- acquire new fields as needed */

static void

grow_fields_arr(long num)

{

	int t;

	NODE *n;

	erealloc(fields_arr, NODE **, (num + 1) * sizeof(NODE *), "grow_fields_arr");

	for (t = nf_high_water + 1; t <= num; t++) {

		getnode(n);

		*n = *Null_field;

		fields_arr[t] = n;

	}

	nf_high_water = num;

}

/* set_field --- set the value of a particular field */

/*ARGSUSED*/

static void

set_field(long num,

	char *str,

	long len,

	NODE *dummy ATTRIBUTE_UNUSED)	/* just to make interface same as set_element */

{

	NODE *n;

	if (num > nf_high_water)

		grow_fields_arr(num);

	n = fields_arr[num];

	n->stptr = str;

	n->stlen = len;

	n->flags = (STRCUR|STRING|USER_INPUT);	/* do not set MALLOC */

}

/* rebuild_record --- Someone assigned a value to $(something).

			Fix up $0 to be right */

void

rebuild_record()

{

	/*

	 * use explicit unsigned longs for lengths, in case

	 * a size_t isn't big enough.

	 */

	unsigned long tlen;

	NODE *tmp;

	char *ops;

	char *cops;

	long i;

	assert(NF != -1);

	tlen = 0;

	for (i = NF; i > 0; i--) {

		tmp = fields_arr[i];

		tmp = force_string(tmp);

		tlen += tmp->stlen;

	}

	tlen += (NF - 1) * OFSlen;

	if ((long) tlen < 0)

		tlen = 0;

	emalloc(ops, char *, tlen + 1, "rebuild_record");

	cops = ops;

	ops[0] = '\0';

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

		free_wstr(fields_arr[i]);

		tmp = fields_arr[i];

		/* copy field */

		if (tmp->stlen == 1)

			*cops++ = tmp->stptr[0];

		else if (tmp->stlen != 0) {

			memcpy(cops, tmp->stptr, tmp->stlen);

			cops += tmp->stlen;

		}

		/* copy OFS */

		if (i != NF) {

			if (OFSlen == 1)

				*cops++ = *OFS;

			else if (OFSlen != 0) {

				memcpy(cops, OFS, OFSlen);

				cops += OFSlen;

			}

		}

	}

	tmp = make_str_node(ops, tlen, ALREADY_MALLOCED);

	/*

	 * Since we are about to unref fields_arr[0], we want to find

	 * any fields that still point into it, and have them point

	 * into the new field zero.  This has to be done intelligently,

	 * so that unrefing a field doesn't try to unref into the old $0.

	 */

	for (cops = ops, i = 1; i <= NF; i++) {

		NODE *r = fields_arr[i];

		/*

		 * There is no reason to copy malloc'ed fields to point into

		 * the new $0 buffer, although that's how previous versions did

		 * it. It seems faster to leave the malloc'ed fields in place.

		 */

		if (r->stlen > 0 && (r->flags & MALLOC) == 0) {

			NODE *n;

			getnode(n);

			*n = *r;

			if (r->valref > 1) {

				/*

				 * This can and does happen.  It seems clear that

				 * we can't leave r's stptr pointing into the

				 * old $0 buffer that we are about to unref.

				 */

				emalloc(r->stptr, char *, r->stlen + 1, "rebuild_record");

				memcpy(r->stptr, cops, r->stlen);

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

				r->flags |= MALLOC;

				n->valref = 1;	// reset in the new field to start it off correctly!

			}

			n->stptr = cops;

			unref(r);

			fields_arr[i] = n;

			assert((n->flags & WSTRCUR) == 0);

		}

		cops += fields_arr[i]->stlen + OFSlen;

	}

	assert((fields_arr[0]->flags & MALLOC) == 0

		? fields_arr[0]->valref == 1

		: true);

	unref(fields_arr[0]);

	fields_arr[0] = tmp;

	field0_valid = true;

}

/*

 * set_record:

 * setup $0, but defer parsing rest of line until reference is made to $(>0)

 * or to NF.  At that point, parse only as much as necessary.

 *

 * Manage a private buffer for the contents of $0.  Doing so keeps us safe

 * if `getline var' decides to rearrange the contents of the IOBUF that

 * $0 might have been pointing into.  The cost is the copying of the buffer;

 * but better correct than fast.

 */

void

set_record(const char *buf, int cnt, const awk_fieldwidth_info_t *fw)

{

	NODE *n;

	static char *databuf;

	static unsigned long databuf_size;

#define INITIAL_SIZE	512

#define MAX_SIZE	((unsigned long) ~0)	/* maximally portable ... */

	purge_record();

	/* buffer management: */

	if (databuf_size == 0) {	/* first time */

		ezalloc(databuf, char *, INITIAL_SIZE, "set_record");

		databuf_size = INITIAL_SIZE;

	}

	/*

	 * Make sure there's enough room. Since we sometimes need

	 * to place a sentinel at the end, we make sure

	 * databuf_size is > cnt after allocation.

	 */

	if (cnt >= databuf_size) {

		do {

			if (databuf_size > MAX_SIZE/2)

				fatal(_("input record too large"));

			databuf_size *= 2;

		} while (cnt >= databuf_size);

		erealloc(databuf, char *, databuf_size, "set_record");

		memset(databuf, '\0', databuf_size);

	}

	/* copy the data */

	memcpy(databuf, buf, cnt);

	/*

	 * Add terminating '\0' so that C library routines

	 * will know when to stop.

	 */

	databuf[cnt] = '\0';

	/* manage field 0: */

	assert((fields_arr[0]->flags & MALLOC) == 0

		? fields_arr[0]->valref == 1

		: true);

	unref(fields_arr[0]);

	getnode(n);

	n->stptr = databuf;

	n->stlen = cnt;

	n->valref = 1;

	n->type = Node_val;

	n->stfmt = STFMT_UNUSED;

#ifdef HAVE_MPFR

	n->strndmode = MPFR_round_mode;

#endif

	n->flags = (STRING|STRCUR|USER_INPUT);	/* do not set MALLOC */

	fields_arr[0] = n;

	if (fw != api_fw) {

		if ((api_fw = fw) != NULL) {

			if (! api_parser_override) {

				api_parser_override = true;

				parse_field = fw_parse_field;

				update_PROCINFO_str("FS", "API");

			}

		} else if (api_parser_override) {

			api_parser_override = false;

			parse_field = normal_parse_field;

			update_PROCINFO_str("FS", current_field_sep_str());

		}

	}

#undef INITIAL_SIZE

#undef MAX_SIZE

}

/* reset_record --- start over again with current $0 */

void

reset_record()

{

	fields_arr[0] = force_string(fields_arr[0]);

	purge_record();

}

static void

purge_record()

{

	int i;

	NF = -1;

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

		NODE *n;

		NODE *r = fields_arr[i];

		if ((r->flags & MALLOC) == 0 && r->valref > 1) {

			/* This can and does happen. We must copy the string! */

			const char *save = r->stptr;

			emalloc(r->stptr, char *, r->stlen + 1, "purge_record");

			memcpy(r->stptr, save, r->stlen);

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

			r->flags |= MALLOC;

		}

		unref(r);

		getnode(n);

		*n = *Null_field;

		fields_arr[i] = n;

	}

	parse_high_water = 0;

	/*

	 * $0 = $0 should resplit using the current value of FS.

	 */

	if (resave_fs) {

		resave_fs = false;

		unref(save_FS);

		save_FS = dupnode(FS_node->var_value);

	}

	field0_valid = true;

}

/* set_NF --- handle what happens to $0 and fields when NF is changed */

void

set_NF()

{

	int i;

	long nf;

	NODE *n;

	assert(NF != -1);

	(void) force_number(NF_node->var_value);

	nf = get_number_si(NF_node->var_value);

	if (nf < 0)

		fatal(_("NF set to negative value"));

	NF = nf;

	if (NF > nf_high_water)

		grow_fields_arr(NF);

	if (parse_high_water < NF) {

		for (i = parse_high_water + 1; i >= 0 && i <= NF; i++) {

			unref(fields_arr[i]);

			getnode(n);

			*n = *Null_field;

			fields_arr[i] = n;

		}

		parse_high_water = NF;

	} else if (parse_high_water > 0) {

		for (i = NF + 1; i >= 0 && i <= parse_high_water; i++) {

			unref(fields_arr[i]);

			getnode(n);

			*n = *Null_field;

			fields_arr[i] = n;

		}

		parse_high_water = NF;

	}

	field0_valid = false;

}

/*

 * re_parse_field --- parse fields using a regexp.

 *

 * This is called both from get_field() and from do_split()

 * via (*parse_field)().  This variation is for when FS is a regular

 * expression -- either user-defined or because RS=="" and FS==" "

 */

static long

re_parse_field(long up_to,	/* parse only up to this field number */

	char **buf,	/* on input: string to parse; on output: point to start next */

	int len,

	NODE *fs ATTRIBUTE_UNUSED,

	Regexp *rp,

	Setfunc set,	/* routine to set the value of the parsed field */

	NODE *n,

	NODE *sep_arr,  /* array of field separators (maybe NULL) */

	bool in_middle)

{

	char *scan = *buf;

	long nf = parse_high_water;

	char *field;

	char *end = scan + len;

	int regex_flags = RE_NEED_START;

	char *sep;

	size_t mbclen = 0;

	mbstate_t mbs;

	memset(&mbs, 0, sizeof(mbstate_t));

	if (in_middle)

		regex_flags |= RE_NO_BOL;

	if (up_to == UNLIMITED)

		nf = 0;

	if (len == 0)

		return nf;

	if (RS_is_null && default_FS) {

		sep = scan;

		while (scan < end && (*scan == ' ' || *scan == '\t' || *scan == '\n'))

			scan++;

		if (sep_arr != NULL && sep < scan)

			set_element(nf, sep, (long)(scan - sep), sep_arr);

	}

	if (rp == NULL) /* use FS */

		rp = FS_regexp;

	field = scan;

	while (scan < end

	       && research(rp, scan, 0, (end - scan), regex_flags) != -1

	       && nf < up_to) {

		regex_flags |= RE_NO_BOL;

		if (REEND(rp, scan) == RESTART(rp, scan)) {   /* null match */

			if (gawk_mb_cur_max > 1)	{

				mbclen = mbrlen(scan, end-scan, &mbs);

				if ((mbclen == 1) || (mbclen == (size_t) -1)

					|| (mbclen == (size_t) -2) || (mbclen == 0)) {

					/* We treat it as a singlebyte character.  */

					mbclen = 1;

				}

				scan += mbclen;

			} else

				scan++;

			if (scan == end) {

				(*set)(++nf, field, (long)(scan - field), n);

				up_to = nf;

				break;

			}

			continue;

		}

		(*set)(++nf, field,

		       (long)(scan + RESTART(rp, scan) - field), n);

		if (sep_arr != NULL)

	    		set_element(nf, scan + RESTART(rp, scan),

           			(long) (REEND(rp, scan) - RESTART(rp, scan)), sep_arr);

		scan += REEND(rp, scan);

		field = scan;

		if (scan == end)	/* FS at end of record */

			(*set)(++nf, field, 0L, n);

	}

	if (nf != up_to && scan < end) {

		(*set)(++nf, scan, (long)(end - scan), n);

		scan = end;

	}

	*buf = scan;

	return nf;

}

/*

 * def_parse_field --- default field parsing.

 *

 * This is called both from get_field() and from do_split()

 * via (*parse_field)().  This variation is for when FS is a single space

 * character.

 */

static long

def_parse_field(long up_to,	/* parse only up to this field number */

	char **buf,	/* on input: string to parse; on output: point to start next */

	int len,

	NODE *fs,

	Regexp *rp ATTRIBUTE_UNUSED,

	Setfunc set,	/* routine to set the value of the parsed field */

	NODE *n,

	NODE *sep_arr,  /* array of field separators (maybe NULL) */

	bool in_middle ATTRIBUTE_UNUSED)

{

	char *scan = *buf;

	long nf = parse_high_water;

	char *field;

	char *end = scan + len;

	char sav;

	char *sep;

	if (up_to == UNLIMITED)

		nf = 0;

	if (len == 0)

		return nf;

	/*

	 * Nasty special case. If FS set to "", return whole record

	 * as first field. This is not worth a separate function.

	 */

	if (fs->stlen == 0) {

		(*set)(++nf, *buf, len, n);

		*buf += len;

		return nf;

	}

	/* before doing anything save the char at *end */

	sav = *end;

	/* because it will be destroyed now: */

	*end = ' ';	/* sentinel character */

	sep = scan;

	for (; nf < up_to; scan++) {

		/*

		 * special case:  fs is single space, strip leading whitespace

		 */

		while (scan < end && (*scan == ' ' || *scan == '\t' || *scan == '\n'))

			scan++;

		if (sep_arr != NULL && scan > sep)

			set_element(nf, sep, (long) (scan - sep), sep_arr);

		if (scan >= end)

			break;

		field = scan;

		while (*scan != ' ' && *scan != '\t' && *scan != '\n')

			scan++;

		(*set)(++nf, field, (long)(scan - field), n);

		if (scan == end)

			break;

		sep = scan;

	}

	/* everything done, restore original char at *end */

	*end = sav;

	*buf = scan;

	return nf;

}

/*

 * null_parse_field --- each character is a separate field

 *

 * This is called both from get_field() and from do_split()

 * via (*parse_field)().  This variation is for when FS is the null string.

 */

static long

null_parse_field(long up_to,	/* parse only up to this field number */

	char **buf,	/* on input: string to parse; on output: point to start next */

	int len,

	NODE *fs ATTRIBUTE_UNUSED,

	Regexp *rp ATTRIBUTE_UNUSED,

	Setfunc set,	/* routine to set the value of the parsed field */

	NODE *n,

	NODE *sep_arr,  /* array of field separators (maybe NULL) */

	bool in_middle ATTRIBUTE_UNUSED)

{

	char *scan = *buf;

	long nf = parse_high_water;

	char *end = scan + len;

	if (up_to == UNLIMITED)

		nf = 0;

	if (len == 0)

		return nf;

	if (gawk_mb_cur_max > 1) {

		mbstate_t mbs;

		memset(&mbs, 0, sizeof(mbstate_t));

		for (; nf < up_to && scan < end;) {

			size_t mbclen = mbrlen(scan, end-scan, &mbs);

			if ((mbclen == 1) || (mbclen == (size_t) -1)

				|| (mbclen == (size_t) -2) || (mbclen == 0)) {

				/* We treat it as a singlebyte character.  */

				mbclen = 1;

			}

			if (sep_arr != NULL && nf > 0)

				set_element(nf, scan, 0L, sep_arr);

			(*set)(++nf, scan, mbclen, n);

			scan += mbclen;

		}

	} else {

		for (; nf < up_to && scan < end; scan++) {

			if (sep_arr != NULL && nf > 0)

				set_element(nf, scan, 0L, sep_arr);

			(*set)(++nf, scan, 1L, n);

		}

	}

	*buf = scan;

	return nf;

}

/*

 * sc_parse_field --- single character field separator

 *

 * This is called both from get_field() and from do_split()

 * via (*parse_field)().  This variation is for when FS is a single character

 * other than space.

 */

static long

sc_parse_field(long up_to,	/* parse only up to this field number */

	char **buf,	/* on input: string to parse; on output: point to start next */

	int len,

	NODE *fs,

	Regexp *rp ATTRIBUTE_UNUSED,

	Setfunc set,	/* routine to set the value of the parsed field */

	NODE *n,

	NODE *sep_arr,  /* array of field separators (maybe NULL) */

	bool in_middle ATTRIBUTE_UNUSED)

{

	char *scan = *buf;

	char fschar;

	long nf = parse_high_water;

	char *field;

	char *end = scan + len;

	char sav;

	size_t mbclen = 0;

	mbstate_t mbs;

	memset(&mbs, 0, sizeof(mbstate_t));

	if (up_to == UNLIMITED)

		nf = 0;

	if (len == 0)

		return nf;

	if (RS_is_null && fs->stlen == 0)

		fschar = '\n';

	else

		fschar = fs->stptr[0];

	/* before doing anything save the char at *end */

	sav = *end;

	/* because it will be destroyed now: */

	*end = fschar;	/* sentinel character */

	for (; nf < up_to;) {

		field = scan;

		if (gawk_mb_cur_max > 1) {

			while (*scan != fschar) {

				mbclen = mbrlen(scan, end-scan, &mbs);

				if ((mbclen == 1) || (mbclen == (size_t) -1)

					|| (mbclen == (size_t) -2) || (mbclen == 0)) {

					/* We treat it as a singlebyte character.  */

					mbclen = 1;

				}

				scan += mbclen;

			}

		} else {

			while (*scan != fschar)

				scan++;

		}

		(*set)(++nf, field, (long)(scan - field), n);

		if (scan == end)

			break;

		if (sep_arr != NULL)

			set_element(nf, scan, 1L, sep_arr);

		scan++;

		if (scan == end) {	/* FS at end of record */

			(*set)(++nf, field, 0L, n);

			break;

		}

	}

	/* everything done, restore original char at *end */

	*end = sav;

	*buf = scan;

	return nf;

}

/*

 * calc_mbslen --- calculate the length in bytes of a multi-byte string

 * containing len characters.

 */

static size_t

calc_mbslen(char *scan, char *end, size_t len, mbstate_t *mbs)

{

	size_t mbclen;

	char *mbscan = scan;

	while (len-- > 0 && mbscan < end) {

		mbclen = mbrlen(mbscan, end - mbscan, mbs);

		if (!(mbclen > 0 && mbclen <= (size_t)(end - mbscan)))

			/*

			 * We treat it as a singlebyte character. This should

			 * catch error codes 0, (size_t) -1, and (size_t) -2.

			 */

			mbclen = 1;

		mbscan += mbclen;

	}

	return mbscan - scan;

}

/*

 * fw_parse_field --- field parsing using FIELDWIDTHS spec

 *

 * This is called from get_field() via (*parse_field)().

 * This variation is for fields are fixed widths.

 */

static long

fw_parse_field(long up_to,	/* parse only up to this field number */

	char **buf,	/* on input: string to parse; on output: point to start next */

	int len,

	NODE *fs ATTRIBUTE_UNUSED,

	Regexp *rp ATTRIBUTE_UNUSED,

	Setfunc set,	/* routine to set the value of the parsed field */

	NODE *n,

	NODE *dummy ATTRIBUTE_UNUSED, /* sep_arr not needed here: hence dummy */

	bool in_middle ATTRIBUTE_UNUSED)

{

	char *scan = *buf;

	long nf = parse_high_water;

	char *end = scan + len;

	const awk_fieldwidth_info_t *fw;

	mbstate_t mbs;

	size_t skiplen;

	size_t flen;

	fw = (api_parser_override ? api_fw : FIELDWIDTHS);

	if (up_to == UNLIMITED)

		nf = 0;

	if (len == 0)

		return nf;

	if (gawk_mb_cur_max > 1 && fw->use_chars) {

		/*

		 * Reset the shift state. Arguably, the shift state should

		 * be part of the file state and carried forward at all times,

		 * but nobody has complained so far, so this may not matter

		 * in practice.

		 */

		memset(&mbs, 0, sizeof(mbstate_t));

		while (nf < up_to && scan < end) {

			if (nf >= fw->nf) {

				*buf = end;

				return nf;

			}

			scan += calc_mbslen(scan, end, fw->fields[nf].skip, &mbs);

			flen = calc_mbslen(scan, end, fw->fields[nf].len, &mbs);

			(*set)(++nf, scan, (long) flen, n);

			scan += flen;

		}

	} else {

		while (nf < up_to && scan < end) {

			if (nf >= fw->nf) {

				*buf = end;

				return nf;

			}

			skiplen = fw->fields[nf].skip;

			if (skiplen > end - scan)

				skiplen = end - scan;

			scan += skiplen;

			flen = fw->fields[nf].len;

			if (flen > end - scan)

				flen = end - scan;

			(*set)(++nf, scan, (long) flen, n);

			scan += flen;

		}

	}

	*buf = scan;

	return nf;

}

/* invalidate_field0 --- $0 needs reconstruction */

void

invalidate_field0()

{

	field0_valid = false;

}

/* get_field --- return a particular $n */

/* assign is not NULL if this field is on the LHS of an assign */

NODE **

get_field(long requested, Func_ptr *assign)

{

	bool in_middle = false;

	/*

	 * if requesting whole line but some other field has been altered,

	 * then the whole line must be rebuilt

	 */

	if (requested == 0) {

		if (! field0_valid) {

			/* first, parse remainder of input record */

			if (NF == -1) {

				NF = (*parse_field)(UNLIMITED - 1, &parse_extent,

		    			fields_arr[0]->stlen -

					(parse_extent - fields_arr[0]->stptr),

		    			save_FS, FS_regexp, set_field,

					(NODE *) NULL,

					(NODE *) NULL,

					in_middle);

				parse_high_water = NF;

			}

			rebuild_record();

		}

		if (assign != NULL)

			*assign = reset_record;

		return &fields_arr[0];

	}

	/* assert(requested > 0); */

#if 0

	if (assign != NULL)

		field0_valid = false;		/* $0 needs reconstruction */

#else

	/*

	 * Keep things uniform. Also, mere intention of assigning something

	 * to $n should not make $0 invalid. Makes sense to invalidate $0

	 * after the actual assignment is performed. Not a real issue in

	 * the interpreter otherwise, but causes problem in the

	 * debugger when watching or printing fields.

	 */

	if (assign != NULL)

		*assign = invalidate_field0;	/* $0 needs reconstruction */

#endif

	if (requested <= parse_high_water)	/* already parsed this field */

		return &fields_arr[requested];

	if (NF == -1) {	/* have not yet parsed to end of record */

		/*

		 * parse up to requested fields, calling set_field() for each,

		 * saving in parse_extent the point where the parse left off

		 */

		if (parse_high_water == 0)	/* starting at the beginning */