field.c File Reference

#include "awk.h"

Go to the source code of this file.

Defines
#define	using_FIELDWIDTHS()   (parse_field == fw_parse_field)
#define	INITIAL_SIZE   512
#define	MAX_SIZE   ((unsigned long) ~0)
Typedefs
typedef void Setfunc	P ((long, char *, long, NODE *))
Functions
void	init_fields ()
static void	grow_fields_arr (long num)
static void	set_field (long num, char *str, long len, NODE *dummy ATTRIBUTE_UNUSED)
static void	rebuild_record ()
void	set_record (const char *buf, int cnt)
void	reset_record ()
void	set_NF ()
static long	re_parse_field (long up_to, char **buf, int len, NODE *fs ATTRIBUTE_UNUSED, Regexp *rp, Setfunc set, NODE *n)
static long	def_parse_field (long up_to, char **buf, int len, NODE *fs, Regexp *rp ATTRIBUTE_UNUSED, Setfunc set, NODE *n)
static long	posix_def_parse_field (long up_to, char **buf, int len, NODE *fs, Regexp *rp ATTRIBUTE_UNUSED, Setfunc set, NODE *n)
static long	null_parse_field (long up_to, char **buf, int len, NODE *fs ATTRIBUTE_UNUSED, Regexp *rp ATTRIBUTE_UNUSED, Setfunc set, NODE *n)
static long	sc_parse_field (long up_to, char **buf, int len, NODE *fs, Regexp *rp ATTRIBUTE_UNUSED, Setfunc set, NODE *n)
static long	fw_parse_field (long up_to, char **buf, int len, NODE *fs ATTRIBUTE_UNUSED, Regexp *rp ATTRIBUTE_UNUSED, Setfunc set, NODE *n)
NODE **	get_field (register long requested, Func_ptr *assign)
static void	set_element (long num, char *s, long len, NODE *n)
NODE *	do_split (NODE *tree)
void	set_FIELDWIDTHS ()
void	set_FS ()
static void	update_PROCINFO (char *subscript, char *str)
Variables
static char *	parse_extent
static long	parse_high_water = 0
static long	nf_high_water = 0
static int	resave_fs
static NODE *	save_FS
static int *	FIELDWIDTHS = NULL
NODE **	fields_arr
int	field0_valid
int	default_FS
Regexp *	FS_re_yes_case = NULL
Regexp *	FS_re_no_case = NULL
Regexp *	FS_regexp = NULL
NODE *	Null_field = NULL

---

Define Documentation

#define INITIAL_SIZE   512

Referenced by set_record().

#define MAX_SIZE   ((unsigned long) ~0)

Referenced by set_record().

#define using_FIELDWIDTHS (   )     (parse_field == fw_parse_field)

Definition at line 69 of file field.c. Referenced by do_split(), set_FS(), and using_fieldwidths().

---

Typedef Documentation

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

Definition at line 28 of file field.c.

---

Function Documentation

static long def_parse_field (  long  up_to, char **  buf, int  len, NODE *  fs, Regexp *rp  ATTRIBUTE_UNUSED, Setfunc  set, NODE *  n )  [static]

Definition at line 421 of file field.c. References HUGE, and parse_high_water. Referenced by do_split(), and set_FS(). : 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) { register char *scan = *buf; register long nf = parse_high_water; register char *field; register char *end = scan + len; char sav; if (up_to == HUGE) 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 */ for (; nf < up_to; scan++) { /* * special case: fs is single space, strip leading whitespace */ while (scan < end && (*scan == ' ' || *scan == '\t' || *scan == '\n')) scan++; if (scan >= end) break; field = scan; while (*scan != ' ' && *scan != '\t' && *scan != '\n') scan++; (*set)(++nf, field, (long)(scan - field), n); if (scan == end) break; } /* everything done, restore original char at *end */ *end = sav; *buf = scan; return nf; }

NODE* do_split (  NODE *  tree  )

Definition at line 796 of file field.c. References _, assoc_clear(), AWKNUM, CONST, def_parse_field(), do_lint, do_posix, dupnode, FALSE, fatal, force_string, free_temp, FS_DFLT, FS_node, FS_regexp, get_param, HUGE, lintwarn, Node_var_array, NULL, null_parse_field(), P, posix_def_parse_field(), re_parse_field(), re_update(), RS_is_null, sc_parse_field(), set_element(), tmp_number, tree_eval, TRUE, exp_node::type, unref(), and using_FIELDWIDTHS. Referenced by snode(). { NODE *src, *arr, *sep, *fs, *src2, *fs2, *tmp; char *s; long (*parseit) P((long, char **, int, NODE *, Regexp *, Setfunc, NODE *)); Regexp *rp = NULL; src = force_string(tree_eval(tree->lnode)); arr = get_param(tree->rnode->lnode); if (arr->type != Node_var_array) fatal(_("split: second argument is not an array")); sep = tree->rnode->rnode->lnode; if (src->stlen == 0) { /* * Skip the work if first arg is the null string. */ free_temp(src); /* * Evaluate sep if it may have side effects. */ if ((sep->re_flags & (FS_DFLT|CONST)) == 0) free_temp(tree_eval(sep->re_exp)); /* * And now we can safely turn off the array. */ assoc_clear(arr); return tmp_number((AWKNUM) 0); } if ((sep->re_flags & FS_DFLT) != 0 && ! using_FIELDWIDTHS() && ! RS_is_null) { parseit = parse_field; fs = force_string(FS_node->var_value); rp = FS_regexp; } else { fs = force_string(tree_eval(sep->re_exp)); if (fs->stlen == 0) { static short warned = FALSE; parseit = null_parse_field; if (do_lint && ! warned) { warned = TRUE; lintwarn(_("split: null string for third arg is a gawk extension")); } } else if (fs->stlen == 1 && (sep->re_flags & CONST) == 0) { if (fs->stptr[0] == ' ') { if (do_posix) parseit = posix_def_parse_field; else parseit = def_parse_field; } else parseit = sc_parse_field; } else { parseit = re_parse_field; rp = re_update(sep); } } /* * do dupnode(), to avoid problems like * x = split(a["LINE"], a, a["FS"]) * since we assoc_clear the array. gack. * this also gives us complete call by value semantics. */ src2 = dupnode(src); free_temp(src); fs2 = dupnode(fs); free_temp(fs); assoc_clear(arr); s = src2->stptr; tmp = tmp_number((AWKNUM) (*parseit)(HUGE, &s, (int) src2->stlen, fs2, rp, set_element, arr)); unref(src2); unref(fs2); return tmp; }

static long fw_parse_field (  long  up_to, char **  buf, int  len, NODE *fs  ATTRIBUTE_UNUSED, Regexp *rp  ATTRIBUTE_UNUSED, Setfunc  set, NODE *  n )  [static]

Definition at line 677 of file field.c. References FIELDWIDTHS, HUGE, and parse_high_water. Referenced by set_FIELDWIDTHS(). : 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) { register char *scan = *buf; register long nf = parse_high_water; register char *end = scan + len; if (up_to == HUGE) nf = 0; if (len == 0) return nf; for (; nf < up_to && (len = FIELDWIDTHS[nf+1]) != -1; ) { if (len > end - scan) len = end - scan; (*set)(++nf, scan, (long) len, n); scan += len; } if (len == -1) *buf = end; else *buf = scan; return nf; }

NODE** get_field (  register long  requested, Func_ptr *  assign )

Definition at line 711 of file field.c. References FALSE, field0_valid, fields_arr, FS_regexp, grow_fields_arr(), HUGE, NF, nf_high_water, NULL, Null_field, parse_extent, parse_high_water, rebuild_record(), reset_record(), save_FS, set_field(), stlen, and stptr. Referenced by do_print_rec(), match_op(), r_get_lhs(), set_FIELDWIDTHS(), and set_FS(). { /* * 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)(HUGE-1, &parse_extent, fields_arr[0]->stlen - (parse_extent - fields_arr[0]->stptr), save_FS, FS_regexp, set_field, (NODE *) NULL); parse_high_water = NF; } rebuild_record(); } if (assign != NULL) *assign = reset_record; return &fields_arr[0]; } /* assert(requested > 0); */ if (assign != NULL) field0_valid = FALSE; /* $0 needs reconstruction */ 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 */ parse_extent = fields_arr[0]->stptr; parse_high_water = (*parse_field)(requested, &parse_extent, fields_arr[0]->stlen - (parse_extent - fields_arr[0]->stptr), save_FS, FS_regexp, set_field, (NODE *) NULL); /* * if we reached the end of the record, set NF to the number of * fields so far. Note that requested might actually refer to * a field that is beyond the end of the record, but we won't * set NF to that value at this point, since this is only a * reference to the field and NF only gets set if the field * is assigned to -- this case is handled below */ if (parse_extent == fields_arr[0]->stptr + fields_arr[0]->stlen) NF = parse_high_water; if (requested == HUGE-1) /* HUGE-1 means set NF */ requested = parse_high_water; } if (parse_high_water < requested) { /* requested beyond end of record */ if (assign != NULL) { /* expand record */ if (requested > nf_high_water) grow_fields_arr(requested); NF = requested; parse_high_water = requested; } else return &Null_field; } return &fields_arr[requested]; }

static void grow_fields_arr (  long  num  )  [static]

Definition at line 90 of file field.c. References erealloc, fields_arr, getnode, n, nf_high_water, and Null_field. Referenced by get_field(), set_field(), and set_NF(). { register int t; register 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; }

void init_fields (   )

Definition at line 74 of file field.c. References dupnode, emalloc, FIELD, exp_node::flags, FS_node, getnode, MAYBE_NUM, Nnull_string, Null_field, NUMBER, NUMCUR, PERM, and TRUE. Referenced by main(). { emalloc(fields_arr, NODE **, sizeof(NODE *), "init_fields"); fields_arr[0] = Nnull_string; parse_extent = fields_arr[0]->stptr; save_FS = dupnode(FS_node->var_value); getnode(Null_field); *Null_field = *Nnull_string; Null_field->flags |= FIELD; Null_field->flags &= ~(NUMCUR|NUMBER|MAYBE_NUM|PERM); field0_valid = TRUE; }

static long null_parse_field (  long  up_to, char **  buf, int  len, NODE *fs  ATTRIBUTE_UNUSED, Regexp *rp  ATTRIBUTE_UNUSED, Setfunc  set, NODE *  n )  [static]

Definition at line 552 of file field.c. References HUGE, memset(), and parse_high_water. Referenced by do_split(), and set_FS(). : 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) { register char *scan = *buf; register long nf = parse_high_water; register char *end = scan + len; if (up_to == HUGE) nf = 0; if (len == 0) return nf; #ifdef MBS_SUPPORT 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; } (*set)(++nf, scan, mbclen, n); scan += mbclen; } } else #endif for (; nf < up_to && scan < end; scan++) (*set)(++nf, scan, 1L, n); *buf = scan; return nf; }

static long posix_def_parse_field (  long  up_to, char **  buf, int  len, NODE *  fs, Regexp *rp  ATTRIBUTE_UNUSED, Setfunc  set, NODE *  n )  [static]

Definition at line 488 of file field.c. References HUGE, and parse_high_water. Referenced by do_split(), and set_FS(). : 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) { register char *scan = *buf; register long nf = parse_high_water; register char *field; register char *end = scan + len; char sav; if (up_to == HUGE) 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 */ for (; nf < up_to; scan++) { /* * special case: fs is single space, strip leading whitespace */ while (scan < end && (*scan == ' ' || *scan == '\t')) scan++; if (scan >= end) break; field = scan; while (*scan != ' ' && *scan != '\t') scan++; (*set)(++nf, field, (long)(scan - field), n); if (scan == end) break; } /* everything done, restore original char at *end */ *end = sav; *buf = scan; return nf; }

static long re_parse_field (  long  up_to, char **  buf, int  len, NODE *fs  ATTRIBUTE_UNUSED, Regexp *  rp, Setfunc  set, NODE *  n )  [static]

Definition at line 346 of file field.c. References default_FS, HUGE, memset(), parse_high_water, REEND, research(), RESTART, RS_is_null, and TRUE. Referenced by do_split(), and set_FS(). : 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) { register char *scan = *buf; register long nf = parse_high_water; register char *field; register char *end = scan + len; #ifdef MBS_SUPPORT size_t mbclen = 0; mbstate_t mbs; if (gawk_mb_cur_max > 1) memset(&mbs, 0, sizeof(mbstate_t)); #endif if (up_to == HUGE) nf = 0; if (len == 0) return nf; if (RS_is_null && default_FS) while (scan < end && (*scan == ' ' || *scan == '\t' || *scan == '\n')) scan++; field = scan; while (scan < end && research(rp, scan, 0, (end - scan), TRUE) != -1 && nf < up_to) { if (REEND(rp, scan) == RESTART(rp, scan)) { /* null match */ #ifdef MBS_SUPPORT 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 #endif 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); 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); }

static void rebuild_record (   )  [static]

Definition at line 127 of file field.c. References ALREADY_MALLOCED, emalloc, FIELD, field0_valid, fields_arr, exp_node::flags, force_string, getnode, i, make_str_node(), MALLOC, memcpy, n, NF, Null_field, NUMBER, NUMCUR, OFS_node, PERM, stlen, STRING, TEMP, TRUE, and unref(). Referenced by get_field(). { /* * use explicit unsigned longs for lengths, in case * a size_t isn't big enough. */ register unsigned long tlen; register unsigned long ofslen; register NODE *tmp; NODE *ofs; char *ops; register char *cops; long i; assert(NF != -1); tlen = 0; ofs = force_string(OFS_node->var_value); ofslen = ofs->stlen; 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 + 2, "rebuild_record"); cops = ops; ops[0] = '\0'; for (i = 1; i <= NF; 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->stptr[0]; else if (ofslen != 0) { memcpy(cops, ofs->stptr, 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++) { if (fields_arr[i]->stlen > 0) { NODE *n; getnode(n); if ((fields_arr[i]->flags & FIELD) == 0) { *n = *Null_field; n->stlen = fields_arr[i]->stlen; if ((fields_arr[i]->flags & (NUMCUR|NUMBER)) != 0) { n->flags |= (fields_arr[i]->flags & (NUMCUR|NUMBER)); n->numbr = fields_arr[i]->numbr; } } else { *n = *(fields_arr[i]); n->flags &= ~(MALLOC|TEMP|PERM|STRING); } n->stptr = cops; unref(fields_arr[i]); fields_arr[i] = n; } cops += fields_arr[i]->stlen + ofslen; } unref(fields_arr[0]); fields_arr[0] = tmp; field0_valid = TRUE; }

void reset_record (   )

Definition at line 274 of file field.c. References dupnode, FALSE, field0_valid, fields_arr, force_string, FS_node, getnode, i, n, NF, Null_field, parse_high_water, resave_fs, save_FS, TRUE, and unref(). Referenced by get_field(), r_get_lhs(), and set_record(). { register int i; NODE *n; (void) force_string(fields_arr[0]); NF = -1; for (i = 1; i <= parse_high_water; i++) { unref(fields_arr[i]); 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; }

static long sc_parse_field (  long  up_to, char **  buf, int  len, NODE *  fs, Regexp *rp  ATTRIBUTE_UNUSED, Setfunc  set, NODE *  n )  [static]

Definition at line 600 of file field.c. References HUGE, memset(), parse_high_water, and RS_is_null. Referenced by do_split(), and set_FS(). : 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) { register char *scan = *buf; register char fschar; register long nf = parse_high_water; register char *field; register char *end = scan + len; char sav; #ifdef MBS_SUPPORT size_t mbclen = 0; mbstate_t mbs; if (gawk_mb_cur_max > 1) memset(&mbs, 0, sizeof(mbstate_t)); #endif if (up_to == HUGE) 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; #ifdef MBS_SUPPORT 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 #endif while (*scan != fschar) scan++; (*set)(++nf, field, (long)(scan - field), n); if (scan == end) break; 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; }

static void set_element (  long  num, char *  s, long  len, NODE *  n )  [static]

Definition at line 784 of file field.c. References assoc_lookup(), AWKNUM, FALSE, exp_node::flags, make_string, MAYBE_NUM, and tmp_number. Referenced by do_split(). { register NODE *it; it = make_string(s, len); it->flags |= MAYBE_NUM; *assoc_lookup(n, tmp_number((AWKNUM) (num)), FALSE) = it; }

static void set_field (  long  num, char *  str, long  len, NODE *dummy  ATTRIBUTE_UNUSED )  [static]

Definition at line 108 of file field.c. References FIELD, fields_arr, exp_node::flags, grow_fields_arr(), MAYBE_NUM, n, nf_high_water, STRCUR, and STRING. Referenced by get_field(). { register 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|MAYBE_NUM|FIELD); }

void set_FIELDWIDTHS (   )

Definition at line 883 of file field.c. References _, do_lint, do_traditional, emalloc, erealloc, FALSE, fatal, fields_arr, FIELDWIDTHS, FIELDWIDTHS_node, force_string, fw_parse_field(), get_field(), HUGE, i, lintwarn, NULL, TRUE, and update_PROCINFO(). Referenced by r_get_lhs(). { register char *scan; char *end; register int i; static int fw_alloc = 4; static int warned = FALSE; extern double strtod(); if (do_lint && ! warned) { warned = TRUE; lintwarn(_("`FIELDWIDTHS' is a gawk extension")); } if (do_traditional) /* quick and dirty, does the trick */ return; /* * If changing the way fields are split, obey least-suprise * semantics, and force $0 to be split totally. */ if (fields_arr != NULL) (void) get_field(HUGE - 1, 0); parse_field = fw_parse_field; scan = force_string(FIELDWIDTHS_node->var_value)->stptr; end = scan + 1; if (FIELDWIDTHS == NULL) emalloc(FIELDWIDTHS, int *, fw_alloc * sizeof(int), "set_FIELDWIDTHS"); FIELDWIDTHS[0] = 0; for (i = 1; ; i++) { if (i >= fw_alloc) { fw_alloc *= 2; erealloc(FIELDWIDTHS, int *, fw_alloc * sizeof(int), "set_FIELDWIDTHS"); } FIELDWIDTHS[i] = (int) strtod(scan, &end); if (end == scan) break; if (FIELDWIDTHS[i] <= 0) fatal(_("field %d in FIELDWIDTHS, must be > 0"), i); scan = end; } FIELDWIDTHS[i] = -1; update_PROCINFO("FS", "FIELDWIDTHS"); }

void set_FS (   )

Definition at line 932 of file field.c. References _, def_parse_field(), default_FS, do_lint, do_posix, do_traditional, dupnode, FALSE, fields_arr, force_string, FS_node, FS_re_no_case, FS_re_yes_case, FS_regexp, get_field(), HUGE, IGNORECASE, lintwarn, make_regexp(), NULL, null_parse_field(), posix_def_parse_field(), re_parse_field(), refree(), resave_fs, RS_is_null, RS_node, sc_parse_field(), STREQN, TRUE, unref(), update_PROCINFO(), and using_FIELDWIDTHS. Referenced by cmdline_fs(), r_get_lhs(), and set_RS(). { char buf[10]; NODE *fs; static NODE *save_fs = NULL; static NODE *save_rs = NULL; int remake_re = TRUE; /* * If changing the way fields are split, obey least-suprise * semantics, and force $0 to be split totally. */ if (fields_arr != NULL) (void) get_field(HUGE - 1, 0); /* It's possible that only IGNORECASE changed, or FS = FS */ /* * This comparison can't use cmp_nodes(), which pays attention * to IGNORECASE, and that's not what we want. */ if (save_fs && FS_node->var_value->stlen == save_fs->stlen && STREQN(FS_node->var_value->stptr, save_fs->stptr, save_fs->stlen) && save_rs && RS_node->var_value->stlen == save_rs->stlen && STREQN(RS_node->var_value->stptr, save_rs->stptr, save_rs->stlen)) { if (FS_regexp != NULL) FS_regexp = (IGNORECASE ? FS_re_no_case : FS_re_yes_case); /* FS = FS */ if (! using_FIELDWIDTHS()) return; else { remake_re = FALSE; goto choose_fs_function; } } unref(save_fs); save_fs = dupnode(FS_node->var_value); unref(save_rs); save_rs = dupnode(RS_node->var_value); resave_fs = TRUE; if (