aboutsummaryrefslogtreecommitdiffstats
path: root/eval.c
diff options
context:
space:
mode:
Diffstat (limited to 'eval.c')
-rw-r--r--eval.c369
1 files changed, 243 insertions, 126 deletions
diff --git a/eval.c b/eval.c
index 5006ccf7..36e4d678 100644
--- a/eval.c
+++ b/eval.c
@@ -6,7 +6,7 @@
* Copyright (C) 1986, 1988, 1989, 1991-1995 the Free Software Foundation, Inc.
*
* This file is part of GAWK, the GNU implementation of the
- * AWK Progamming Language.
+ * 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
@@ -19,8 +19,8 @@
* 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, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
#include "awk.h"
@@ -34,7 +34,9 @@ static NODE *op_assign P((NODE *tree));
static NODE *func_call P((NODE *name, NODE *arg_list));
static NODE *match_op P((NODE *tree));
+#if __GNUC__ < 2
NODE *_t; /* used as a temporary in macros */
+#endif
#ifdef MSDOS
double _msc51bug; /* to get around a bug in MSC 5.1 */
#endif
@@ -49,12 +51,12 @@ int CONVFMTidx;
* the val variable allows return/continue/break-out-of-context to be
* caught and diagnosed
*/
-#define PUSH_BINDING(stack, x, val) (memcpy ((char *)(stack), (char *)(x), sizeof (jmp_buf)), val++)
-#define RESTORE_BINDING(stack, x, val) (memcpy ((char *)(x), (char *)(stack), sizeof (jmp_buf)), val--)
+#define PUSH_BINDING(stack, x, val) (memcpy((char *)(stack), (char *)(x), sizeof(jmp_buf)), val++)
+#define RESTORE_BINDING(stack, x, val) (memcpy((char *)(x), (char *)(stack), sizeof(jmp_buf)), val--)
-static jmp_buf loop_tag; /* always the current binding */
-static int loop_tag_valid = 0; /* nonzero when loop_tag valid */
-static int func_tag_valid = 0;
+static jmp_buf loop_tag; /* always the current binding */
+static int loop_tag_valid = FALSE; /* nonzero when loop_tag valid */
+static int func_tag_valid = FALSE;
static jmp_buf func_tag;
extern int exiting, exit_val;
@@ -62,7 +64,7 @@ extern int exiting, exit_val;
* 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
+ * 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.
*
@@ -99,6 +101,24 @@ char casetable[] = {
'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
/* 'x' 'y' 'z' '{' '|' '}' '~' */
'\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
+#ifndef USE_PURE_ASCII
+ '\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',
+ '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
+ '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
+ '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\327',
+ '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\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
'\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
'\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
'\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
@@ -115,12 +135,14 @@ char casetable[] = {
'\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
'\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
'\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
+#endif
};
#else
#include "You lose. You will need a translation table for your character set."
#endif
/*
+ * interpret:
* Tree is a bunch of rules to run. Returns zero if it hit an exit()
* statement
*/
@@ -135,7 +157,7 @@ register NODE *volatile tree;
register NODE *volatile t = NULL; /* temporary */
NODE **volatile lhs; /* lhs == Left Hand Side for assigns, etc */
NODE *volatile stable_tree;
- int volatile traverse = 1; /* True => loop thru tree (Node_rule_list) */
+ int volatile traverse = TRUE; /* True => loop thru tree (Node_rule_list) */
/* avoid false source indications */
source = NULL;
@@ -147,7 +169,7 @@ register NODE *volatile tree;
source = tree->source_file;
switch (tree->type) {
case Node_rule_node:
- traverse = 0; /* False => one for-loop iteration only */
+ traverse = FALSE; /* False => one for-loop iteration only */
/* FALL THROUGH */
case Node_rule_list:
for (t = tree; t != NULL; t = t->rnode) {
@@ -169,8 +191,8 @@ register NODE *volatile tree;
default:
cant_happen();
}
- if (!traverse) /* case Node_rule_node */
- break; /* don't loop */
+ if (! traverse) /* case Node_rule_node */
+ break; /* don't loop */
}
break;
@@ -180,11 +202,10 @@ register NODE *volatile tree;
break;
case Node_K_if:
- if (eval_condition(tree->lnode)) {
+ if (eval_condition(tree->lnode))
(void) interpret(tree->rnode->lnode);
- } else {
+ else
(void) interpret(tree->rnode->rnode);
- }
break;
case Node_K_while:
@@ -263,6 +284,8 @@ register NODE *volatile tree;
if (t->type == Node_param_list)
t = stack_ptr[t->param_cnt];
stable_tree = tree;
+ if ((t->flags & SCALAR) != 0)
+ fatal("attempt to use scalar as array");
for (assoc_scan(t, (struct search *)&l);
l.retval;
assoc_next((struct search *)&l)) {
@@ -288,40 +311,40 @@ register NODE *volatile tree;
}
case Node_K_break:
- if (loop_tag_valid == 0) {
+ if (! loop_tag_valid) {
/*
* Old AT&T nawk treats break outside of loops like
* next. New ones catch it at parse time. Allow it if
- * do_unix is on, and complain if lint.
+ * do_traditional is on, and complain if lint.
*/
- static int warned = 0;
+ static int warned = FALSE;
if (do_lint && ! warned) {
- warning("use of `break' outside of loop is not portable");
- warned = 1;
+ warning("use of `break' outside a loop is not portable");
+ warned = TRUE;
}
- if (! do_unix)
- fatal("use of `break' outside of loop is not allowed");
+ if (! do_traditional || do_posix)
+ fatal("use of `break' outside a loop is not allowed");
longjmp(rule_tag, TAG_CONTINUE);
} else
longjmp(loop_tag, TAG_BREAK);
break;
case Node_K_continue:
- if (loop_tag_valid == 0) {
+ if (! loop_tag_valid) {
/*
* Old AT&T nawk treats continue outside of loops like
* next. New ones catch it at parse time. Allow it if
- * do_unix is on, and complain if lint.
+ * do_traditional is on, and complain if lint.
*/
- static int warned = 0;
+ static int warned = FALSE;
if (do_lint && ! warned) {
- warning("use of `continue' outside of loop is not portable");
- warned = 1;
+ warning("use of `continue' outside a loop is not portable");
+ warned = TRUE;
}
- if (! do_unix)
- fatal("use of `continue' outside of loop is not allowed");
+ if (! do_traditional || do_posix)
+ fatal("use of `continue' outside a loop is not allowed");
longjmp(rule_tag, TAG_CONTINUE);
} else
longjmp(loop_tag, TAG_CONTINUE);
@@ -336,7 +359,7 @@ register NODE *volatile tree;
break;
case Node_K_delete:
- if (tree->rnode != NULL)
+ if (tree->rnode != NULL) /* delete array */
do_delete(tree->lnode, tree->rnode);
else
assoc_clear(tree->lnode);
@@ -358,8 +381,8 @@ register NODE *volatile tree;
* any are executed." This implies that the rest of the rules
* are not done. So we immediately break out of the main loop.
*/
- exiting = 1;
- if (tree->lnode) {
+ exiting = TRUE;
+ if (tree->lnode != NULL) {
t = tree_eval(tree->lnode);
exit_val = (int) force_number(t);
free_temp(t);
@@ -388,11 +411,12 @@ register NODE *volatile tree;
return 1;
}
-/* evaluate a subtree */
+/* r_tree_eval --- evaluate a subtree */
NODE *
-r_tree_eval(tree)
+r_tree_eval(tree, iscond)
register NODE *tree;
+int iscond;
{
register NODE *r, *t1, *t2; /* return value & temporary subtrees */
register NODE **lhs;
@@ -402,24 +426,30 @@ register NODE *tree;
#ifdef _CRAY
long lx2;
#endif
+ char namebuf[100];
#ifdef DEBUG
if (tree == NULL)
return Nnull_string;
- if (tree->type == Node_val) {
- if ((char)tree->stref <= 0) cant_happen();
+ else if (tree->type == Node_val) {
+ if (tree->stref <= 0)
+ cant_happen();
return tree;
- }
- if (tree->type == Node_var) {
- if ((char)tree->var_value->stref <= 0) cant_happen();
+ } else if (tree->type == Node_var) {
+ if (tree->var_value->stref <= 0)
+ cant_happen();
return tree->var_value;
}
#endif
if (tree->type == Node_param_list) {
+ int paramnum = tree->param_cnt + 1;
+
tree = stack_ptr[tree->param_cnt];
if (tree == NULL)
return Nnull_string;
+ sprintf(namebuf, "parameter #%d", paramnum);
+ tree->vname = namebuf;
}
switch (tree->type) {
@@ -439,7 +469,7 @@ register NODE *tree;
/* Builtins */
case Node_builtin:
- return ((*tree->proc) (tree->subnode));
+ return (*tree->proc)(tree->subnode);
case Node_K_getline:
return (do_getline(tree));
@@ -464,11 +494,12 @@ register NODE *tree;
case Node_ORS:
case Node_OFMT:
case Node_CONVFMT:
- lhs = get_lhs(tree, (Func_ptr *)0);
+ lhs = get_lhs(tree, (Func_ptr *) NULL);
return *lhs;
case Node_var_array:
- fatal("attempt to use array `%s' in a scalar context", tree->vname);
+ fatal("attempt to use array `%s' in a scalar context",
+ tree->vname);
case Node_unary_minus:
t1 = tree_eval(tree->subnode);
@@ -496,6 +527,8 @@ register NODE *tree;
{
Func_ptr after_assign = NULL;
+ if (iscond && do_lint)
+ warning("assignment used in conditional context");
r = tree_eval(tree->rnode);
lhs = get_lhs(tree->lnode, &after_assign);
if (r != *lhs) {
@@ -506,6 +539,7 @@ register NODE *tree;
unref(save);
}
free_temp(r);
+ tree->lnode->flags |= SCALAR;
if (after_assign)
(*after_assign)();
return *lhs;
@@ -662,9 +696,7 @@ register NODE *tree;
if (x2 == 0)
fatal("division by zero attempted");
#ifdef _CRAY
- /*
- * special case for integer division, put in for Cray
- */
+ /* special case for integer division, put in for Cray */
lx2 = x2;
if (lx2 == 0)
return tmp_number(x1 / x2);
@@ -678,12 +710,12 @@ register NODE *tree;
case Node_mod:
if (x2 == 0)
fatal("division by zero attempted in mod");
-#ifndef FMOD_MISSING
- return tmp_number(fmod (x1, x2));
-#else
+#ifdef HAVE_FMOD
+ return tmp_number(fmod(x1, x2));
+#else /* ! HAVE_FMOD */
(void) modf(x1 / x2, &x);
return tmp_number(x1 - x * x2);
-#endif
+#endif /* ! HAVE_FMOD */
case Node_plus:
return tmp_number(x1 + x2);
@@ -692,7 +724,8 @@ register NODE *tree;
return tmp_number(x1 - x2);
case Node_var_array:
- fatal("attempt to use array `%s' in a scalar context", tree->vname);
+ fatal("attempt to use array `%s' in a scalar context",
+ tree->vname);
default:
fatal("illegal type (%d) in tree_eval", tree->type);
@@ -700,7 +733,8 @@ register NODE *tree;
return 0;
}
-/* Is TREE true or false? Returns 0==false, non-zero==true */
+/* eval_condition --- is TREE true or false? Returns 0==false, non-zero==true */
+
static int
eval_condition(tree)
register NODE *tree;
@@ -709,7 +743,7 @@ register NODE *tree;
register int ret;
if (tree == NULL) /* Null trees are the easiest kinds */
- return 1;
+ return TRUE;
if (tree->type == Node_line_range) {
/*
* Node_line_range is kind of like Node_match, EXCEPT: the
@@ -724,15 +758,15 @@ register NODE *tree;
* 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;
+ if (! tree->triggered)
+ if (! eval_condition(tree->condpair->lnode))
+ return FALSE;
else
- tree->triggered = 1;
+ tree->triggered = TRUE;
/* Else we are triggered */
if (eval_condition(tree->condpair->rnode))
- tree->triggered = 0;
- return 1;
+ tree->triggered = FALSE;
+ return TRUE;
}
/*
@@ -740,26 +774,27 @@ register NODE *tree;
* false, anything else is true
*/
- t1 = tree_eval(tree);
+ t1 = m_tree_eval(tree, TRUE);
if (t1->flags & MAYBE_NUM)
(void) force_number(t1);
if (t1->flags & NUMBER)
- ret = t1->numbr != 0.0;
+ ret = (t1->numbr != 0.0);
else
- ret = t1->stlen != 0;
+ ret = (t1->stlen != 0);
free_temp(t1);
return ret;
}
-/*
- * compare two nodes, returning negative, 0, positive
- */
+/* cmp_nodes --- compare two nodes, returning negative, 0, positive */
+
int
cmp_nodes(t1, t2)
register NODE *t1, *t2;
{
register int ret;
register size_t len1, len2;
+ register int l;
+ int ldiff;
if (t1 == t2)
return 0;
@@ -768,20 +803,35 @@ register NODE *t1, *t2;
if (t2->flags & MAYBE_NUM)
(void) force_number(t2);
if ((t1->flags & NUMBER) && (t2->flags & NUMBER)) {
- if (t1->numbr == t2->numbr) return 0;
- else if (t1->numbr - t2->numbr < 0) return -1;
- else return 1;
+ if (t1->numbr == t2->numbr)
+ return 0;
+ /* don't subtract, in case one or both are infinite */
+ else if (t1->numbr < t2->numbr)
+ return -1;
+ else
+ return 1;
}
(void) force_string(t1);
(void) force_string(t2);
len1 = t1->stlen;
len2 = t2->stlen;
+ ldiff = len1 - len2;
if (len1 == 0 || len2 == 0)
- return len1 - len2;
- ret = memcmp(t1->stptr, t2->stptr, len1 <= len2 ? len1 : len2);
- return ret == 0 ? len1-len2 : ret;
+ return ldiff;
+ l = (ldiff <= 0 ? len1 : len2);
+ if (IGNORECASE) {
+ register unsigned char *cp1 = (unsigned char *) t1->stptr;
+ register unsigned char *cp2 = (unsigned char *) t2->stptr;
+
+ for (ret = 0; l-- > 0 && ret == 0; cp1++, cp2++)
+ ret = casetable[*cp1] - casetable[*cp2];
+ } else
+ ret = memcmp(t1->stptr, t2->stptr, l);
+ return (ret == 0 ? ldiff : ret);
}
+/* op_assign --- do +=, -=, etc. */
+
static NODE *
op_assign(tree)
register NODE *tree;
@@ -806,6 +856,7 @@ register NODE *tree;
unref(*lhs);
*lhs = make_number(lval +
(tree->type == Node_preincrement ? 1.0 : -1.0));
+ tree->lnode->flags |= SCALAR;
if (after_assign)
(*after_assign)();
return *lhs;
@@ -815,6 +866,7 @@ register NODE *tree;
unref(*lhs);
*lhs = make_number(lval +
(tree->type == Node_postincrement ? 1.0 : -1.0));
+ tree->lnode->flags |= SCALAR;
if (after_assign)
(*after_assign)();
return tmp_number(lval);
@@ -859,9 +911,7 @@ register NODE *tree;
if (rval == (AWKNUM) 0)
fatal("division by zero attempted in /=");
#ifdef _CRAY
- /*
- * special case for integer division, put in for Cray
- */
+ /* special case for integer division, put in for Cray */
ltemp = rval;
if (ltemp == 0) {
*lhs = make_number(lval / rval);
@@ -871,20 +921,20 @@ register NODE *tree;
if (ltemp * lval == rval)
*lhs = make_number((AWKNUM) ltemp);
else
-#endif
+#endif /* _CRAY */
*lhs = make_number(lval / rval);
break;
case Node_assign_mod:
if (rval == (AWKNUM) 0)
fatal("division by zero attempted in %=");
-#ifndef FMOD_MISSING
+#ifdef HAVE_FMOD
*lhs = make_number(fmod(lval, rval));
-#else
+#else /* ! HAVE_FMOD */
(void) modf(lval / rval, &t1);
t2 = lval - rval * t1;
*lhs = make_number(t2);
-#endif
+#endif /* ! HAVE_FMOD */
break;
case Node_assign_plus:
@@ -897,11 +947,14 @@ register NODE *tree;
default:
cant_happen();
}
+ tree->lnode->flags |= SCALAR;
if (after_assign)
(*after_assign)();
return *lhs;
}
+/* func_call --- call a function, call by reference for arrays */
+
NODE **stack_ptr;
static NODE *
@@ -913,36 +966,31 @@ NODE *arg_list; /* Node_expression_list of calling args. */
NODE *n, *f;
jmp_buf volatile func_tag_stack;
jmp_buf volatile loop_tag_stack;
- int volatile save_loop_tag_valid = 0;
+ int volatile save_loop_tag_valid = FALSE;
NODE **volatile save_stack, *save_ret_node;
NODE **volatile local_stack = NULL, **sp;
int count;
extern NODE *ret_node;
- /*
- * retrieve function definition node
- */
+ /* retrieve function definition node */
f = lookup(name->stptr);
- if (!f || f->type != Node_func)
+ if (f == NULL || f->type != Node_func)
fatal("function `%s' not defined", name->stptr);
#ifdef FUNC_TRACE
fprintf(stderr, "function %s called\n", name->stptr);
#endif
count = f->lnode->param_cnt;
- if (count)
+ if (count > 0)
emalloc(local_stack, NODE **, count*sizeof(NODE *), "func_call");
sp = local_stack;
- /*
- * for each calling arg. add NODE * on stack
- */
- for (argp = arg_list; count && argp != NULL; argp = argp->rnode) {
+ /* for each calling arg. add NODE * on stack */
+ for (argp = arg_list; count > 0 && argp != NULL; argp = argp->rnode) {
arg = argp->lnode;
getnode(r);
r->type = Node_var;
- /*
- * call by reference for arrays; see below also
- */
+
+ /* call by reference for arrays; see below also */
if (arg->type == Node_param_list)
arg = stack_ptr[arg->param_cnt];
if (arg->type == Node_var_array)
@@ -951,6 +999,8 @@ NODE *arg_list; /* Node_expression_list of calling args. */
n = tree_eval(arg);
r->lnode = dupnode(n);
r->rnode = (NODE *) NULL;
+ if ((n->flags & SCALAR) != 0)
+ r->flags |= SCALAR;
free_temp(n);
}
*sp++ = r;
@@ -960,13 +1010,13 @@ NODE *arg_list; /* Node_expression_list of calling args. */
warning(
"function `%s' called with more arguments than declared",
name->stptr);
- /*
- * add remaining params. on stack with null value
- */
+
+ /* add remaining params. on stack with null value */
while (count-- > 0) {
getnode(r);
r->type = Node_var;
r->lnode = Nnull_string;
+ r->flags &= ~SCALAR;
r->rnode = (NODE *) NULL;
*sp++ = r;
}
@@ -987,7 +1037,7 @@ NODE *arg_list; /* Node_expression_list of calling args. */
save_loop_tag_valid = (volatile int) loop_tag_valid;
PUSH_BINDING(loop_tag_stack, loop_tag, junk);
- loop_tag_valid = 0;
+ loop_tag_valid = FALSE;
}
save_stack = stack_ptr;
stack_ptr = local_stack;
@@ -1032,7 +1082,7 @@ NODE *arg_list; /* Node_expression_list of calling args. */
}
while (count-- > 0) {
n = *sp++;
- /* if n is an (local) array, all the elements should be freed */
+ /* if n is a local array, all the elements should be freed */
if (n->type == Node_var_array)
assoc_clear(n);
unref(n->lnode);
@@ -1049,12 +1099,13 @@ NODE *arg_list; /* Node_expression_list of calling args. */
RESTORE_BINDING(loop_tag_stack, loop_tag, junk);
}
- if (!(r->flags & PERM))
+ if ((r->flags & PERM) == 0)
r->flags |= TEMP;
return r;
}
/*
+ * r_get_lhs:
* This returns a POINTER to a node pointer. get_lhs(ptr) is the current
* value of the var, or where to store the var's new value
*/
@@ -1072,30 +1123,32 @@ Func_ptr *assign;
switch (ptr->type) {
case Node_var_array:
- fatal("attempt to use array `%s' in a scalar context", ptr->vname);
+ fatal("attempt to use array `%s' in a scalar context",
+ ptr->vname);
+
case Node_var:
aptr = &(ptr->var_value);
#ifdef DEBUG
- if ((char)ptr->var_value->stref <= 0)
+ if (ptr->var_value->stref <= 0)
cant_happen();
#endif
break;
case Node_FIELDWIDTHS:
aptr = &(FIELDWIDTHS_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_FIELDWIDTHS;
break;
case Node_RS:
aptr = &(RS_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_RS;
break;
case Node_FS:
aptr = &(FS_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_FS;
break;
@@ -1103,7 +1156,7 @@ Func_ptr *assign;
unref(FNR_node->var_value);
FNR_node->var_value = make_number((AWKNUM) FNR);
aptr = &(FNR_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_FNR;
break;
@@ -1111,7 +1164,7 @@ Func_ptr *assign;
unref(NR_node->var_value);
NR_node->var_value = make_number((AWKNUM) NR);
aptr = &(NR_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_NR;
break;
@@ -1121,39 +1174,37 @@ Func_ptr *assign;
unref(NF_node->var_value);
NF_node->var_value = make_number((AWKNUM) NF);
aptr = &(NF_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_NF;
break;
case Node_IGNORECASE:
- unref(IGNORECASE_node->var_value);
- IGNORECASE_node->var_value = make_number((AWKNUM) IGNORECASE);
aptr = &(IGNORECASE_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_IGNORECASE;
break;
case Node_OFMT:
aptr = &(OFMT_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_OFMT;
break;
case Node_CONVFMT:
aptr = &(CONVFMT_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_CONVFMT;
break;
case Node_ORS:
aptr = &(ORS_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_ORS;
break;
case Node_OFS:
aptr = &(OFS_node->var_value);
- if (assign)
+ if (assign != NULL)
*assign = set_OFS;
break;
@@ -1172,7 +1223,7 @@ Func_ptr *assign;
fatal("attempt to access field %d", field_num);
if (field_num == 0 && field0_valid) { /* short circuit */
aptr = &fields_arr[0];
- if (assign)
+ if (assign != NULL)
*assign = reset_record;
break;
}
@@ -1181,13 +1232,18 @@ Func_ptr *assign;
}
case Node_subscript:
n = ptr->lnode;
- if (n->type == Node_param_list)
+ if (n->type == Node_param_list) {
+ int i = n->param_cnt + 1;
+
n = stack_ptr[n->param_cnt];
+ if ((n->flags & SCALAR) != 0)
+ fatal("attempt to use scalar parameter %d as an array", i);
+ }
aptr = assoc_lookup(n, concat_exp(ptr->rnode));
break;
case Node_func:
- fatal ("`%s' is a function, assignment is not allowed",
+ fatal("`%s' is a function, assignment is not allowed",
ptr->lnode->param);
default:
cant_happen();
@@ -1195,6 +1251,8 @@ Func_ptr *assign;
return aptr;
}
+/* match_op --- do ~ and !~ */
+
static NODE *
match_op(tree)
register NODE *tree;
@@ -1202,10 +1260,11 @@ register NODE *tree;
register NODE *t1;
register Regexp *rp;
int i;
- int match = 1;
+ int match = TRUE;
+ int kludge_need_start = FALSE; /* XXX --- see below */
if (tree->type == Node_nomatch)
- match = 0;
+ match = FALSE;
if (tree->type == Node_regex)
t1 = *get_field(0, (Func_ptr *) 0);
else {
@@ -1213,25 +1272,51 @@ register NODE *tree;
tree = tree->rnode;
}
rp = re_update(tree);
- i = research(rp, t1->stptr, 0, t1->stlen, 0);
- i = (i == -1) ^ (match == 1);
+ /*
+ * XXX
+ *
+ * Any place where research() is called with a last parameter of
+ * FALSE, we need to use the avoid_dfa test. This is the only place
+ * at the moment.
+ *
+ * A new or improved dfa that distinguishes beginning/end of
+ * string from beginning/end of line will allow us to get rid of
+ * this temporary hack.
+ *
+ * The avoid_dfa() function is in re.c; it is not very smart.
+ */
+ if (avoid_dfa(tree, t1->stptr, t1->stlen))
+ kludge_need_start = TRUE;
+ i = research(rp, t1->stptr, 0, t1->stlen, kludge_need_start);
+ i = (i == -1) ^ (match == TRUE);
free_temp(t1);
return tmp_number((AWKNUM) i);
}
+/* set_IGNORECASE --- update IGNORECASE as appropriate */
+
void
set_IGNORECASE()
{
- static int warned = 0;
+ static int warned = FALSE;
- if ((do_lint || do_unix) && ! warned) {
- warned = 1;
+ if ((do_lint || do_traditional) && ! warned) {
+ warned = TRUE;
warning("IGNORECASE not supported in compatibility mode");
}
- IGNORECASE = (force_number(IGNORECASE_node->var_value) != 0.0);
+ if (do_traditional)
+ IGNORECASE = FALSE;
+ else if (IGNORECASE_node->var_value->flags & STRING)
+ IGNORECASE = (force_string(IGNORECASE_node->var_value)->stlen > 0);
+ else if (IGNORECASE_node->var_value->flags & NUMBER)
+ IGNORECASE = (force_number(IGNORECASE_node->var_value) != 0.0);
+ else
+ IGNORECASE = FALSE; /* shouldn't happen */
set_FS_if_not_FIELDWIDTHS();
}
+/* set_OFS --- update OFS related variables when OFS assigned to */
+
void
set_OFS()
{
@@ -1240,6 +1325,8 @@ set_OFS()
OFS[OFSlen] = '\0';
}
+/* set_ORS --- update ORS related variables when ORS assigned to */
+
void
set_ORS()
{
@@ -1248,6 +1335,8 @@ set_ORS()
ORS[ORSlen] = '\0';
}
+/* fmt_ok --- is the conversion format a valid one? */
+
NODE **fmt_list = NULL;
static int fmt_ok P((NODE *n));
static int fmt_index P((NODE *n));
@@ -1256,10 +1345,30 @@ static int
fmt_ok(n)
NODE *n;
{
- /* to be done later */
+ NODE *tmp = force_string(n);
+ char *p = tmp->stptr;
+
+ if (*p++ != '%')
+ return 0;
+ while (*p && strchr(" +-#", *p) != NULL) /* flags */
+ p++;
+ while (*p && isdigit(*p)) /* width - %*.*g is NOT allowed */
+ p++;
+ if (*p == '\0' || (*p != '.' && ! isdigit(*p)))
+ return 0;
+ if (*p == '.')
+ p++;
+ while (*p && isdigit(*p)) /* precision */
+ p++;
+ if (*p == '\0' || strchr("efgEG", *p) == NULL)
+ return 0;
+ if (*++p != '\0')
+ return 0;
return 1;
}
+/* fmt_index --- track values of OFMT and CONVFMT to keep semantics correct */
+
static int
fmt_index(n)
NODE *n;
@@ -1278,8 +1387,12 @@ NODE *n;
}
/* not found */
n->stptr[n->stlen] = '\0';
- if (!fmt_ok(n))
- warning("bad FMT specification");
+ if (do_lint && ! fmt_ok(n))
+ warning("bad %sFMT specification",
+ n == CONVFMT_node->var_value ? "CONV"
+ : n == OFMT_node->var_value ? "O"
+ : "");
+
if (fmt_hiwater >= fmt_num) {
fmt_num *= 2;
emalloc(fmt_list, NODE **, fmt_num, "fmt_index");
@@ -1288,6 +1401,8 @@ NODE *n;
return fmt_hiwater++;
}
+/* set_OFMT --- track OFMT correctly */
+
void
set_OFMT()
{
@@ -1295,6 +1410,8 @@ set_OFMT()
OFMT = fmt_list[OFMTidx]->stptr;
}
+/* set_CONVFMT --- track CONVFMT correctly */
+
void
set_CONVFMT()
{
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-04 06:22:33 +0000