eval.c File Reference

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

Go to the source code of this file.

Classes
struct	loop_info
struct	fcall
Defines
#define	INCREMENT(n)
#define	PUSH_BINDING(stack, x, val)   (memcpy((char *)(stack), (const char *)(x), sizeof(jmp_buf)), val++)
#define	RESTORE_BINDING(stack, x, val)   (memcpy((char *)(x), (const char *)(stack), sizeof(jmp_buf)), val--)
#define	C(c)   ((char)c)
#define	hakvar   forloop->init
#define	arrvar   forloop->incr
#define	NLOOPS   4
Functions
double pow	P ((double x, double y))
const char *	nodetype2str (NODETYPE type)
const char *	flags2str (int flagval)
const char *	genflags2str (int flagval, const struct flagtab *tab)
int	interpret (register NODE *volatile tree)
NODE *	r_tree_eval (register NODE *tree, int iscond)
static int	eval_condition (register NODE *tree)
int	cmp_nodes (register NODE *t1, register NODE *t2)
static NODE *	op_assign (register NODE *tree)
static void	pop_forloop ()
static void	pop_all_forloops ()
static void	push_forloop (const char *varname, NODE **elems, size_t nelems)
static void	pop_fcall ()
static void	pop_fcall_stack ()
static void	push_args (int count, NODE *argp, NODE **oldstack, const char *func_name, char **varnames)
static NODE *	func_call (NODE *tree)
NODE **	r_get_lhs (register NODE *ptr, Func_ptr *assign, int reference)
static NODE *	match_op (register NODE *tree)
void	set_IGNORECASE ()
void	set_BINMODE ()
void	set_OFS ()
void	set_ORS ()
static int	fmt_ok (NODE *n)
static int	fmt_index (NODE *n)
void	set_OFMT ()
void	set_CONVFMT ()
void	set_LINT ()
void	set_TEXTDOMAIN ()
NODE *	assign_val (NODE **lhs_p, NODE *rhs)
void	update_ERRNO ()
static int	comp_func (const void *p1, const void *p2)
Variables
NODE *	_t
NODE *	ret_node
int	OFSlen
int	ORSlen
int	OFMTidx
int	CONVFMTidx
static jmp_buf	loop_tag
static int	loop_tag_valid = FALSE
static int	func_tag_valid = FALSE
static jmp_buf	func_tag
int	exiting
int	exit_val
static const char *const	nodetypes []
static struct loop_info *	loop_stack
size_t	nloops_active = 0
static struct fcall *	fcall_list
static long	fcall_list_size = 0
static long	curfcall = -1
NODE **	stack_ptr
NODE **	fmt_list = NULL

---

Define Documentation

#define arrvar   forloop->incr

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

Definition at line 82 of file eval.c.

#define hakvar   forloop->init

#define INCREMENT (  n   )

Definition at line 61 of file eval.c.

#define NLOOPS   4

Referenced by push_forloop().

#define PUSH_BINDING (  stack, x, val   )     (memcpy((char *)(stack), (const char *)(x), sizeof(jmp_buf)), val++)

Definition at line 69 of file eval.c. Referenced by func_call(), and interpret().

#define RESTORE_BINDING (  stack, x, val   )     (memcpy((char *)(x), (const char *)(stack), sizeof(jmp_buf)), val--)

Definition at line 70 of file eval.c. Referenced by func_call(), and interpret().

---

Function Documentation

NODE* assign_val (  NODE **  lhs_p, NODE *  rhs )

Definition at line 2196 of file eval.c. References dupnode, and unref(). Referenced by r_tree_eval(), and update_PROCINFO(). { if (rhs != *lhs_p) { /* * Since we know that the nodes are different, * we can do the unref() before the dupnode(). */ unref(*lhs_p); *lhs_p = dupnode(rhs); } return *lhs_p; }

int cmp_nodes (  register NODE *  t1, register NODE *  t2 )

Definition at line 1212 of file eval.c. References force_number, force_string, IGNORECASE, MAYBE_NUM, memcmp(), memset(), and NUMBER. Referenced by fmt_index(), interpret(), merge(), r_tree_eval(), and re_update(). { register int ret; register size_t len1, len2; register int l; int ldiff; if (t1 == t2) return 0; if (t1->flags & MAYBE_NUM) (void) force_number(t1); if (t2->flags & MAYBE_NUM) (void) force_number(t2); if ((t1->flags & NUMBER) && (t2->flags & NUMBER)) { 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 ldiff; 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; #ifdef MBS_SUPPORT if (gawk_mb_cur_max > 1) { mbstate_t mbs; memset(&mbs, 0, sizeof(mbstate_t)); ret = strncasecmpmbs((const char *) cp1, mbs, (const char *) cp2, mbs, l); } else #endif 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); }

static int comp_func (  const void *  p1, const void *  p2 )  [static]

Definition at line 2225 of file eval.c. References memcmp(). Referenced by interpret(). { size_t len1, len2; const char *str1, *str2; const NODE *t1, *t2; int cmp1; t1 = *((const NODE *const *) p1); t2 = *((const NODE *const *) p2); /* t1 = force_string(t1); t2 = force_string(t2); */ len1 = t1->ahname_len; str1 = t1->ahname_str; len2 = t2->ahname_len; str2 = t2->ahname_str; /* Array indexes are strings, compare as such, always! */ cmp1 = memcmp(str1, str2, len1 < len2 ? len1 : len2); /* if prefixes are equal, size matters */ return (cmp1 != 0 ? cmp1 : len1 < len2 ? -1 : (len1 > len2)); }

static int eval_condition (  register NODE *  tree  )  [static]

Definition at line 1160 of file eval.c. References FALSE, exp_node::flags, force_number, free_temp, m_tree_eval, MAYBE_NUM, Node_line_range, NULL, NUMBER, and TRUE. Referenced by eval_condition(), interpret(), pprint(), r_tree_eval(), and tree_eval(). { register NODE *t1; register int ret; if (tree == NULL) /* Null trees are the easiest kinds */ return TRUE; if (tree->type == Node_line_range) { /* * Node_line_range is kind of like Node_match, EXCEPT: the * lnode field (more properly, the condpair field) is a node * of a Node_cond_pair; whether we evaluate the lnode of that * node or the rnode depends on the triggered word. More * precisely: if we are not yet triggered, we tree_eval the * lnode; if that returns true, we set the triggered word. * If we are triggered (not ELSE IF, note), we tree_eval the * rnode, clear triggered if it succeeds, and perform our * action (regardless of success or failure). We want to be * able to begin and end on a single input record, so this * isn't an ELSE IF, as noted above. */ if (! tree->triggered) { if (! eval_condition(tree->condpair->lnode)) return FALSE; else tree->triggered = TRUE; } /* Else we are triggered */ if (eval_condition(tree->condpair->rnode)) tree->triggered = FALSE; return TRUE; } /* * Could just be J.random expression. in which case, null and 0 are * false, anything else is true */ t1 = m_tree_eval(tree, TRUE); if (t1->flags & MAYBE_NUM) (void) force_number(t1); if (t1->flags & NUMBER) ret = (t1->numbr != 0.0); else ret = (t1->stlen != 0); free_temp(t1); return ret; }

const char* flags2str (  int  flagval  )

Definition at line 273 of file eval.c. References ARRAYMAXED, FIELD, FUNC, genflags2str(), INTLSTR, MALLOC, MAYBE_NUM, NULL, NUMBER, NUMCUR, PERM, STRCUR, STRING, and TEMP. Referenced by valinfo(). { static const struct flagtab values[] = { { MALLOC, "MALLOC" }, { TEMP, "TEMP" }, { PERM, "PERM" }, { STRING, "STRING" }, { STRCUR, "STRCUR" }, { NUMCUR, "NUMCUR" }, { NUMBER, "NUMBER" }, { MAYBE_NUM, "MAYBE_NUM" }, { ARRAYMAXED, "ARRAYMAXED" }, { FUNC, "FUNC" }, { FIELD, "FIELD" }, { INTLSTR, "INTLSTR" }, { 0, NULL }, }; return genflags2str(flagval, values); }

static int fmt_index (  NODE *  n  )  [static]

Definition at line 2075 of file eval.c. References _, cmp_nodes(), CONVFMT_node, do_lint, dupnode, emalloc, erealloc, fmt_ok(), force_string, lintwarn, NULL, and OFMT_node. Referenced by set_CONVFMT(), and set_OFMT(). { register int ix = 0; static int fmt_num = 4; static int fmt_hiwater = 0; if (fmt_list == NULL) emalloc(fmt_list, NODE **, fmt_num*sizeof(*fmt_list), "fmt_index"); (void) force_string(n); while (ix < fmt_hiwater) { if (cmp_nodes(fmt_list[ix], n) == 0) return ix; ix++; } /* not found */ n->stptr[n->stlen] = '\0'; if (do_lint && ! fmt_ok(n)) lintwarn(_("bad `%sFMT' specification `%s'"), n == CONVFMT_node->var_value ? "CONV" : n == OFMT_node->var_value ? "O" : "", n->stptr); if (fmt_hiwater >= fmt_num) { fmt_num *= 2; erealloc(fmt_list, NODE **, fmt_num * sizeof(*fmt_list), "fmt_index"); } fmt_list[fmt_hiwater] = dupnode(n); return fmt_hiwater++; }

static int fmt_ok (  NODE *  n  )  [static]

Definition at line 2048 of file eval.c. References force_string, ISDIGIT, NULL, and strchr(). Referenced by fmt_index(). { NODE *tmp = force_string(n); const 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; }

static NODE* func_call (  NODE *  tree  )  [static]

Definition at line 1611 of file eval.c. References _, FALSE, fatal, exp_node::flags, INCREMENT, interpret(), lookup(), name, Nnull_string, Node_func, NULL, PERM, pop_fcall(), push_args(), PUSH_BINDING, RESTORE_BINDING, TEMP, and exp_node::type. Referenced by r_tree_eval(). { register NODE *r; NODE *name, *arg_list; NODE *f; jmp_buf volatile func_tag_stack; jmp_buf volatile loop_tag_stack; int volatile save_loop_tag_valid = FALSE; NODE *save_ret_node; extern NODE *ret_node; /* tree->rnode is a Node_val giving function name */ /* tree->lnode is Node_expression_list of calling args. */ name = tree->rnode; arg_list = tree->lnode; /* retrieve function definition node */ if (tree->funcbody != NULL) f = tree->funcbody; else { f = lookup(name->stptr); if (f == NULL || f->type != Node_func) fatal(_("function `%s' not defined"), name->stptr); tree->funcbody = f; /* save for next call */ } #ifdef FUNC_TRACE fprintf(stderr, _("function %s called\n"), name->stptr); #endif push_args(f->lnode->param_cnt, arg_list, stack_ptr, name->stptr, f->parmlist); /* * Execute function body, saving context, as a return statement * will longjmp back here. * * Have to save and restore the loop_tag stuff so that a return * inside a loop in a function body doesn't scrog any loops going * on in the main program. We save the necessary info in variables * local to this function so that function nesting works OK. * We also only bother to save the loop stuff if we're in a loop * when the function is called. */ if (loop_tag_valid) { int junk = 0; save_loop_tag_valid = (volatile int) loop_tag_valid; PUSH_BINDING(loop_tag_stack, loop_tag, junk); loop_tag_valid = FALSE; } PUSH_BINDING(func_tag_stack, func_tag, func_tag_valid); save_ret_node = ret_node; ret_node = Nnull_string; /* default return value */ INCREMENT(f->exec_count); /* count function calls */ if (setjmp(func_tag) == 0) (void) interpret(f->rnode); r = ret_node; ret_node = (NODE *) save_ret_node; RESTORE_BINDING(func_tag_stack, func_tag, func_tag_valid); pop_fcall(); /* Restore the loop_tag stuff if necessary. */ if (save_loop_tag_valid) { int junk = 0; loop_tag_valid = (int) save_loop_tag_valid; RESTORE_BINDING(loop_tag_stack, loop_tag, junk); } if ((r->flags & PERM) == 0) r->flags |= TEMP; return r; }

const char* genflags2str (  int  flagval, const struct flagtab *  tab )

Definition at line 297 of file eval.c. References _, fatal, i, name, NULL, and flagtab::val. Referenced by flags2str(), iopflags2str(), redflags2str(), and reflags2str(). { 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++) { /* * 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 ((flagval & tab[i].val) != 0) { if (sp != buffer) { *sp++ = '|'; space_left--; } strcpy(sp, tab[i].name); /* note ordering! */ space_left -= strlen(sp); sp += strlen(sp); } } return buffer; }

int interpret (  register NODE *volatile  tree  )

Definition at line 335 of file eval.c. References _, ahname_len, ahname_str, array_size, array_vname(), cant_happen, cmp_nodes(), comp_func(), do_delete(), do_delete_loop(), do_lint, do_nextfile(), do_posix, do_print(), do_print_rec(), do_printf(), do_traditional, dupnode, emalloc, eval_condition(), FALSE, fatal, force_number, force_string, free_temp, get_array, get_lhs, i, in_begin_rule, in_end_rule, INCREMENT, lintwarn, make_string, Node_K_arrayfor, Node_K_break, Node_K_continue, Node_K_default, Node_K_delete, Node_K_delete_loop, Node_K_do, Node_K_exit, Node_K_for, Node_K_if, Node_K_next, Node_K_nextfile, Node_K_print, Node_K_print_rec, Node_K_printf, Node_K_return, Node_K_switch, Node_K_while, Node_regex, Node_rule_list, Node_rule_node, Node_statement_list, Node_var, Node_var_new, NULL, pop_all_forloops(), pop_fcall_stack(), pop_forloop(), PUSH_BINDING, push_forloop(), re_update(), research(), RESTORE_BINDING, source, sourceline, TAG_BREAK, TAG_CONTINUE, TAG_RETURN, tree_eval, TRUE, exp_node::type, unref(), and whiny_users. Referenced by do_input(), func_call(), and main(). { jmp_buf volatile loop_tag_stack; /* shallow binding stack for loop_tag */ static jmp_buf rule_tag; /* tag the rule currently being run, for NEXT * and EXIT statements. It is static because * there are no nested rules */ register NODE *volatile t = NULL; /* temporary */ NODE **volatile lhs; /* lhs == Left Hand Side for assigns, etc */ NODE *volatile stable_tree; int volatile traverse = TRUE; /* True => loop thru tree (Node_rule_list) */ /* avoid false source indications */ source = NULL; sourceline = 0; if (tree == NULL) return 1; sourceline = tree->source_line; source = tree->source_file; switch (tree->type) { case Node_rule_node: traverse = FALSE; /* False => one for-loop iteration only */ /* FALL THROUGH */ case Node_rule_list: for (t = tree; t != NULL; t = t->rnode) { if (traverse) tree = t->lnode; sourceline = tree->source_line; source = tree->source_file; INCREMENT(tree->exec_count); switch (setjmp(rule_tag)) { case 0: /* normal non-jump */ /* test pattern, if any */ if (tree->lnode == NULL || eval_condition(tree->lnode)) { /* using the lnode exec_count is kludgey */ if (tree->lnode != NULL) INCREMENT(tree->lnode->exec_count); (void) interpret(tree->rnode); } break; case TAG_CONTINUE: /* NEXT statement */ pop_all_forloops(); pop_fcall_stack(); return 1; case TAG_BREAK: /* EXIT statement */ pop_all_forloops(); pop_fcall_stack(); return 0; default: cant_happen(); } if (! traverse) /* case Node_rule_node */ break; /* don't loop */ } break; case Node_statement_list: for (t = tree; t != NULL; t = t->rnode) (void) interpret(t->lnode); break; case Node_K_if: INCREMENT(tree->exec_count); if (eval_condition(tree->lnode)) { INCREMENT(tree->rnode->exec_count); (void) interpret(tree->rnode->lnode); } else { (void) interpret(tree->rnode->rnode); } break; case Node_K_switch: { NODE *switch_value; NODE *switch_body; NODE *case_list; NODE *default_list; NODE *case_stmt; int match_found = FALSE; PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); INCREMENT(tree->exec_count); stable_tree = tree; switch_value = tree_eval(stable_tree->lnode); switch_body = stable_tree->rnode; case_list = switch_body->lnode; default_list = switch_body->rnode; for (; case_list != NULL; case_list = case_list->rnode) { case_stmt = case_list->lnode; /* * Once a match is found, all cases will be processed as they fall through, * so continue to execute statements until a break is reached. */ if (! match_found) { if (case_stmt->type == Node_K_default) ; /* do nothing */ else if (case_stmt->lnode->type == Node_regex) { NODE *t1; Regexp *rp; t1 = force_string(switch_value); rp = re_update(case_stmt->lnode); match_found = (research(rp, t1->stptr, 0, t1->stlen, FALSE) >= 0); if (t1 != switch_value) free_temp(t1); } else { match_found = (cmp_nodes(switch_value, case_stmt->lnode) == 0); } } /* If a match was found, execute the statements associated with the case. */ if (match_found) { INCREMENT(case_stmt->exec_count); switch (setjmp(loop_tag)) { case 0: /* Normal non-jump */ (void) interpret(case_stmt->rnode); break; case TAG_CONTINUE: /* continue statement */ free_temp(switch_value); RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); longjmp(loop_tag, TAG_CONTINUE); break; case TAG_BREAK: /* break statement */ free_temp(switch_value); RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); return 1; default: cant_happen(); } } } free_temp(switch_value); /* * If a default section was found, execute the statements associated with it * and execute any trailing case statements if the default falls through. */ if (! match_found && default_list != NULL) { for (case_list = default_list; case_list != NULL; case_list = case_list->rnode) { case_stmt = case_list->lnode; INCREMENT(case_stmt->exec_count); switch (setjmp(loop_tag)) { case 0: /* Normal non-jump */ (void) interpret(case_stmt->rnode); break; case TAG_CONTINUE: /* continue statement */ RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); longjmp(loop_tag, TAG_CONTINUE); break; case TAG_BREAK: /* break statement */ RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); return 1; default: cant_happen(); } } } RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); } break; case Node_K_while: PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); stable_tree = tree; while (eval_condition(stable_tree->lnode)) { INCREMENT(stable_tree->exec_count); switch (setjmp(loop_tag)) { case 0: /* normal non-jump */ (void) interpret(stable_tree->rnode); break; case TAG_CONTINUE: /* continue statement */ break; case TAG_BREAK: /* break statement */ RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); return 1; default: cant_happen(); } } RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); break; case Node_K_do: PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); stable_tree = tree; do { INCREMENT(stable_tree->exec_count); switch (setjmp(loop_tag)) { case 0: /* normal non-jump */ (void) interpret(stable_tree->rnode); break; case TAG_CONTINUE: /* continue statement */ break; case TAG_BREAK: /* break statement */ RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); return 1; default: cant_happen(); } } while (eval_condition(stable_tree->lnode)); RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); break; case Node_K_for: PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); (void) interpret(tree->forloop->init); stable_tree = tree; while (eval_condition(stable_tree->forloop->cond)) { INCREMENT(stable_tree->exec_count); switch (setjmp(loop_tag)) { case 0: /* normal non-jump */ (void) interpret(stable_tree->lnode); /* fall through */ case TAG_CONTINUE: /* continue statement */ (void) interpret(stable_tree->forloop->incr); break; case TAG_BREAK: /* break statement */ RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); return 1; default: cant_happen(); } } RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); break; case Node_K_arrayfor: { Func_ptr after_assign = NULL; NODE **list = NULL; NODE *volatile array; NODE *volatile save_array; volatile size_t i, num_elems; size_t j; volatile int retval = 0; int sort_indices = whiny_users; #define hakvar forloop->init #define arrvar forloop->incr /* get the array */ save_array = tree->arrvar; array = get_array(save_array); /* sanity: do nothing if empty */ if (array->var_array == NULL || array->table_size == 0) break; /* from switch */ /* allocate space for array */ num_elems = array->table_size; emalloc(list, NODE **, num_elems * sizeof(NODE *), "for_loop"); /* populate it */ for (i = j = 0; i < array->array_size; i++) { NODE *t = array->var_array[i]; if (t == NULL) continue; for (; t != NULL; t = t->ahnext) { list[j++] = dupnode(t); assert(list[j-1] == t); } } if (sort_indices) qsort(list, num_elems, sizeof(NODE *), comp_func); /* shazzam! */ /* now we can run the loop */ push_forloop(array->vname, list, num_elems); PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); lhs = get_lhs(tree->hakvar, &after_assign, FALSE); stable_tree = tree; for (i = 0; i < num_elems; i++) { INCREMENT(stable_tree->exec_count); unref(*((NODE **) lhs)); *lhs = make_string(list[i]->ahname_str, list[i]->ahname_len); if (after_assign) (*after_assign)(); switch (setjmp(loop_tag)) { case 0: (void) interpret(stable_tree->lnode); case TAG_CONTINUE: break; case TAG_BREAK: retval = 1; goto done; default: cant_happen(); } } done: RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); pop_forloop(); if (do_lint && num_elems != array->table_size) lintwarn(_("for loop: array `%s' changed size from %ld to %ld during loop execution"), array_vname(save_array), (long) num_elems, (long) array->table_size); if (retval == 1) return 1; break; } #undef hakvar #undef arrvar case Node_K_break: INCREMENT(tree->exec_count); 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_traditional is on, and complain if lint. */ static int warned = FALSE; if (do_lint && ! warned) { lintwarn(_("`break' outside a loop is not portable")); warned = TRUE; } if (! do_traditional || do_posix) fatal(_("`break' outside a loop is not allowed")); longjmp(rule_tag, TAG_CONTINUE); } else longjmp(loop_tag, TAG_BREAK); break; case Node_K_continue: INCREMENT(tree->exec_count); 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_traditional is on, and complain if lint. */ static int warned = FALSE; if (do_lint && ! warned) { lintwarn(_("`continue' outside a loop is not portable")); warned = TRUE; } if (! do_traditional || do_posix) fatal(_("`continue' outside a loop is not allowed")); longjmp(rule_tag, TAG_CONTINUE); } else longjmp(loop_tag, TAG_CONTINUE); break; case Node_K_print: INCREMENT(tree->exec_count); do_print(tree); break; case Node_K_print_rec: INCREMENT(tree->exec_count); do_print_rec(tree); break; case Node_K_printf: INCREMENT(tree->exec_count); do_printf(tree); break; case Node_K_delete: INCREMENT(tree->exec_count); do_delete(tree->lnode, tree->rnode); break; case Node_K_delete_loop: INCREMENT(tree->exec_count); do_delete_loop(tree->lnode, tree->rnode); break; case Node_K_next: INCREMENT(tree->exec_count); if (in_begin_rule) fatal(_("`next' cannot be called from a BEGIN rule")); else if (in_end_rule) fatal(_("`next' cannot be called from an END rule")); /* could add a lint check here for in a loop or function */ longjmp(rule_tag, TAG_CONTINUE); break; case Node_K_nextfile: INCREMENT(tree->exec_count); if (in_begin_rule) fatal(_("`nextfile' cannot be called from a BEGIN rule")); else if (in_end_rule) fatal(_("`nextfile' cannot be called from an END rule")); /* could add a lint check here for in a loop or function */ /* * Have to do this cleanup here, since we don't longjump * back to the main awk rule loop (rule_tag). */ pop_all_forloops(); pop_fcall_stack(); do_nextfile(); break; case Node_K_exit: INCREMENT(tree->exec_count); /* * In A,K,&W, p. 49, it says that an exit statement "... * causes the program to behave as if the end of input had * occurred; no more input is read, and the END actions, if * any are executed." This implies that the rest of the rules * are not done. So we immediately break out of the main loop. */ exiting = TRUE; if (tree->lnode != NULL) { t = tree_eval(tree->lnode); exit_val = (int) force_number(t); free_temp(t); } longjmp(rule_tag, TAG_BREAK); break; case Node_K_return: INCREMENT(tree->exec_count); t = tree_eval(tree->lnode); ret_node = dupnode(t); free_temp(t); longjmp(func_tag, TAG_RETURN); break; default: /* * Appears to be an expression statement. Throw away the * value. */ if (do_lint && (tree->type == Node_var || tree->type ==