| /* | |
| * eval.c - gawk parse tree interpreter | |
| */ | |
| /* | |
| * Copyright (C) 1986, 1988, 1989 the Free Software Foundation, Inc. | |
| * | |
| * This file is part of GAWK, the GNU implementation of the | |
| * AWK Progamming 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 1, 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 GAWK; see the file COPYING. If not, write to | |
| * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
| */ | |
| #include "gawk.h" | |
| extern void do_print(); | |
| extern void do_printf(); | |
| extern NODE *do_match(); | |
| extern NODE *do_sub(); | |
| extern NODE *do_getline(); | |
| extern NODE *concat_exp(); | |
| extern int in_array(); | |
| extern void do_delete(); | |
| extern double pow(); | |
| static int eval_condition(); | |
| static NODE *op_assign(); | |
| static NODE *func_call(); | |
| static NODE *match_op(); | |
| NODE *_t; /* used as a temporary in macros */ | |
| #ifdef MSDOS | |
| double _msc51bug; /* to get around a bug in MSC 5.1 */ | |
| #endif | |
| NODE *ret_node; | |
| /* More of that debugging stuff */ | |
| #ifdef DEBUG | |
| #define DBG_P(X) print_debug X | |
| #else | |
| #define DBG_P(X) | |
| #endif | |
| /* Macros and variables to save and restore function and loop bindings */ | |
| /* | |
| * 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--) | |
| 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 func_tag; | |
| 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 | |
| * is compiled on doesn't use 7-bit ascii, casetable[] should not be | |
| * defined to the linker, so gawk should not load. | |
| * | |
| * Do NOT make this array static, it is used in several spots, not | |
| * just in this file. | |
| */ | |
| #if 'a' == 97 /* it's ascii */ | |
| char casetable[] = { | |
| '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', | |
| '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', | |
| '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', | |
| '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', | |
| /* ' ' '!' '"' '#' '$' '%' '&' ''' */ | |
| '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', | |
| /* '(' ')' '*' '+' ',' '-' '.' '/' */ | |
| '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', | |
| /* '0' '1' '2' '3' '4' '5' '6' '7' */ | |
| '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', | |
| /* '8' '9' ':' ';' '<' '=' '>' '?' */ | |
| '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', | |
| /* '@' 'A' 'B' 'C' 'D' 'E' 'F' 'G' */ | |
| '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', | |
| /* 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' */ | |
| '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', | |
| /* 'P' 'Q' 'R' 'S' 'T' 'U' 'V' 'W' */ | |
| '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', | |
| /* 'X' 'Y' 'Z' '[' '\' ']' '^' '_' */ | |
| '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', | |
| /* '`' 'a' 'b' 'c' 'd' 'e' 'f' 'g' */ | |
| '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', | |
| /* 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' */ | |
| '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', | |
| /* 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' */ | |
| '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', | |
| /* 'x' 'y' 'z' '{' '|' '}' '~' */ | |
| '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', | |
| '\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', | |
| '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307', | |
| '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317', | |
| '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327', | |
| '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\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 | |
| #include "You lose. You will need a translation table for your character set." | |
| #endif | |
| /* | |
| * Tree is a bunch of rules to run. Returns zero if it hit an exit() | |
| * statement | |
| */ | |
| int | |
| interpret(tree) | |
| NODE *tree; | |
| { | |
| volatile jmp_buf 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 *t = NULL;/* temporary */ | |
| volatile NODE **lhs; /* lhs == Left Hand Side for assigns, etc */ | |
| volatile struct search *l; /* For array_for */ | |
| volatile NODE *stable_tree; | |
| if (tree == NULL) | |
| return 1; | |
| sourceline = tree->source_line; | |
| source = tree->source_file; | |
| switch (tree->type) { | |
| case Node_rule_list: | |
| for (t = tree; t != NULL; t = t->rnode) { | |
| tree = t->lnode; | |
| /* FALL THROUGH */ | |
| case Node_rule_node: | |
| sourceline = tree->source_line; | |
| source = tree->source_file; | |
| switch (setjmp(rule_tag)) { | |
| case 0: /* normal non-jump */ | |
| /* test pattern, if any */ | |
| if (tree->lnode == NULL | |
| || eval_condition(tree->lnode)) { | |
| DBG_P(("Found a rule", tree->rnode)); | |
| if (tree->rnode == NULL) { | |
| /* | |
| * special case: pattern with | |
| * no action is equivalent to | |
| * an action of {print} | |
| */ | |
| NODE printnode; | |
| printnode.type = Node_K_print; | |
| printnode.lnode = NULL; | |
| printnode.rnode = NULL; | |
| do_print(&printnode); | |
| } else if (tree->rnode->type == Node_illegal) { | |
| /* | |
| * An empty statement | |
| * (``{ }'') is different | |
| * from a missing statement. | |
| * A missing statement is | |
| * equal to ``{ print }'' as | |
| * above, but an empty | |
| * statement is as in C, do | |
| * nothing. | |
| */ | |
| } else | |
| (void) interpret(tree->rnode); | |
| } | |
| break; | |
| case TAG_CONTINUE: /* NEXT statement */ | |
| return 1; | |
| case TAG_BREAK: | |
| return 0; | |
| default: | |
| cant_happen(); | |
| } | |
| if (t == NULL) | |
| break; | |
| } | |
| break; | |
| case Node_statement_list: | |
| for (t = tree; t != NULL; t = t->rnode) { | |
| DBG_P(("Statements", t->lnode)); | |
| (void) interpret(t->lnode); | |
| } | |
| break; | |
| case Node_K_if: | |
| DBG_P(("IF", tree->lnode)); | |
| if (eval_condition(tree->lnode)) { | |
| DBG_P(("True", tree->rnode->lnode)); | |
| (void) interpret(tree->rnode->lnode); | |
| } else { | |
| DBG_P(("False", tree->rnode->rnode)); | |
| (void) interpret(tree->rnode->rnode); | |
| } | |
| break; | |
| case Node_K_while: | |
| PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); | |
| DBG_P(("WHILE", tree->lnode)); | |
| stable_tree = tree; | |
| while (eval_condition(stable_tree->lnode)) { | |
| switch (setjmp(loop_tag)) { | |
| case 0: /* normal non-jump */ | |
| DBG_P(("DO", stable_tree->rnode)); | |
| (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 { | |
| switch (setjmp(loop_tag)) { | |
| case 0: /* normal non-jump */ | |
| DBG_P(("DO", stable_tree->rnode)); | |
| (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(); | |
| } | |
| DBG_P(("WHILE", stable_tree->lnode)); | |
| } 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); | |
| DBG_P(("FOR", tree->forloop->init)); | |
| (void) interpret(tree->forloop->init); | |
| DBG_P(("FOR.WHILE", tree->forloop->cond)); | |
| stable_tree = tree; | |
| while (eval_condition(stable_tree->forloop->cond)) { | |
| switch (setjmp(loop_tag)) { | |
| case 0: /* normal non-jump */ | |
| DBG_P(("FOR.DO", stable_tree->lnode)); | |
| (void) interpret(stable_tree->lnode); | |
| /* fall through */ | |
| case TAG_CONTINUE: /* continue statement */ | |
| DBG_P(("FOR.INCR", stable_tree->forloop->incr)); | |
| (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: | |
| #define hakvar forloop->init | |
| #define arrvar forloop->incr | |
| PUSH_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); | |
| DBG_P(("AFOR.VAR", tree->hakvar)); | |
| lhs = (volatile NODE **) get_lhs(tree->hakvar, 1); | |
| t = tree->arrvar; | |
| if (t->type == Node_param_list) | |
| t = stack_ptr[t->param_cnt]; | |
| stable_tree = tree; | |
| for (l = assoc_scan(t); l; l = assoc_next((struct search *)l)) { | |
| deref = *((NODE **) lhs); | |
| do_deref(); | |
| *lhs = dupnode(l->retval); | |
| if (field_num == 0) | |
| set_record(fields_arr[0]->stptr, | |
| fields_arr[0]->stlen); | |
| DBG_P(("AFOR.NEXTIS", *lhs)); | |
| switch (setjmp(loop_tag)) { | |
| case 0: | |
| DBG_P(("AFOR.DO", stable_tree->lnode)); | |
| (void) interpret(stable_tree->lnode); | |
| case TAG_CONTINUE: | |
| break; | |
| case TAG_BREAK: | |
| RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); | |
| field_num = -1; | |
| return 1; | |
| default: | |
| cant_happen(); | |
| } | |
| } | |
| field_num = -1; | |
| RESTORE_BINDING(loop_tag_stack, loop_tag, loop_tag_valid); | |
| break; | |
| case Node_K_break: | |
| DBG_P(("BREAK", NULL)); | |
| if (loop_tag_valid == 0) | |
| fatal("unexpected break"); | |
| longjmp(loop_tag, TAG_BREAK); | |
| break; | |
| case Node_K_continue: | |
| DBG_P(("CONTINUE", NULL)); | |
| if (loop_tag_valid == 0) | |
| fatal("unexpected continue"); | |
| longjmp(loop_tag, TAG_CONTINUE); | |
| break; | |
| case Node_K_print: | |
| DBG_P(("PRINT", tree)); | |
| do_print(tree); | |
| break; | |
| case Node_K_printf: | |
| DBG_P(("PRINTF", tree)); | |
| do_printf(tree); | |
| break; | |
| case Node_K_next: | |
| DBG_P(("NEXT", NULL)); | |
| longjmp(rule_tag, TAG_CONTINUE); | |
| break; | |
| case Node_K_exit: | |
| /* | |
| * 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. | |
| */ | |
| DBG_P(("EXIT", NULL)); | |
| exiting = 1; | |
| if (tree) { | |
| t = tree_eval(tree->lnode); | |
| exit_val = (int) force_number(t); | |
| } | |
| free_temp(t); | |
| longjmp(rule_tag, TAG_BREAK); | |
| break; | |
| case Node_K_return: | |
| DBG_P(("RETURN", NULL)); | |
| 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. | |
| */ | |
| DBG_P(("E", NULL)); | |
| t = tree_eval(tree); | |
| free_temp(t); | |
| break; | |
| } | |
| return 1; | |
| } | |
| /* evaluate a subtree, allocating strings on a temporary stack. */ | |
| NODE * | |
| r_tree_eval(tree) | |
| NODE *tree; | |
| { | |
| register NODE *r, *t1, *t2; /* return value & temporary subtrees */ | |
| int i; | |
| register NODE **lhs; | |
| int di; | |
| AWKNUM x, x2; | |
| long lx; | |
| extern NODE **fields_arr; | |
| source = tree->source_file; | |
| sourceline = tree->source_line; | |
| switch (tree->type) { | |
| case Node_and: | |
| DBG_P(("AND", tree)); | |
| return tmp_number((AWKNUM) (eval_condition(tree->lnode) | |
| && eval_condition(tree->rnode))); | |
| case Node_or: | |
| DBG_P(("OR", tree)); | |
| return tmp_number((AWKNUM) (eval_condition(tree->lnode) | |
| || eval_condition(tree->rnode))); | |
| case Node_not: | |
| DBG_P(("NOT", tree)); | |
| return tmp_number((AWKNUM) ! eval_condition(tree->lnode)); | |
| /* Builtins */ | |
| case Node_builtin: | |
| DBG_P(("builtin", tree)); | |
| return ((*tree->proc) (tree->subnode)); | |
| case Node_K_getline: | |
| DBG_P(("GETLINE", tree)); | |
| return (do_getline(tree)); | |
| case Node_in_array: | |
| DBG_P(("IN_ARRAY", tree)); | |
| return tmp_number((AWKNUM) in_array(tree->lnode, tree->rnode)); | |
| case Node_func_call: | |
| DBG_P(("func_call", tree)); | |
| return func_call(tree->rnode, tree->lnode); | |
| case Node_K_delete: | |
| DBG_P(("DELETE", tree)); | |
| do_delete(tree->lnode, tree->rnode); | |
| return Nnull_string; | |
| /* unary operations */ | |
| case Node_var: | |
| case Node_var_array: | |
| case Node_param_list: | |
| case Node_subscript: | |
| case Node_field_spec: | |
| DBG_P(("var_type ref", tree)); | |
| lhs = get_lhs(tree, 0); | |
| field_num = -1; | |
| deref = 0; | |
| return *lhs; | |
| case Node_unary_minus: | |
| DBG_P(("UMINUS", tree)); | |
| t1 = tree_eval(tree->subnode); | |
| x = -force_number(t1); | |
| free_temp(t1); | |
| return tmp_number(x); | |
| case Node_cond_exp: | |
| DBG_P(("?:", tree)); | |
| if (eval_condition(tree->lnode)) { | |
| DBG_P(("True", tree->rnode->lnode)); | |
| return tree_eval(tree->rnode->lnode); | |
| } | |
| DBG_P(("False", tree->rnode->rnode)); | |
| return tree_eval(tree->rnode->rnode); | |
| case Node_match: | |
| case Node_nomatch: | |
| case Node_regex: | |
| DBG_P(("[no]match_op", tree)); | |
| return match_op(tree); | |
| case Node_func: | |
| fatal("function `%s' called with space between name and (,\n%s", | |
| tree->lnode->param, | |
| "or used in other expression context"); | |
| /* assignments */ | |
| case Node_assign: | |
| DBG_P(("ASSIGN", tree)); | |
| r = tree_eval(tree->rnode); | |
| lhs = get_lhs(tree->lnode, 1); | |
| *lhs = dupnode(r); | |
| free_temp(r); | |
| do_deref(); | |
| if (field_num == 0) | |
| set_record(fields_arr[0]->stptr, fields_arr[0]->stlen); | |
| field_num = -1; | |
| return *lhs; | |
| /* other assignment types are easier because they are numeric */ | |
| case Node_preincrement: | |
| case Node_predecrement: | |
| case Node_postincrement: | |
| case Node_postdecrement: | |
| case Node_assign_exp: | |
| case Node_assign_times: | |
| case Node_assign_quotient: | |
| case Node_assign_mod: | |
| case Node_assign_plus: | |
| case Node_assign_minus: | |
| return op_assign(tree); | |
| default: | |
| break; /* handled below */ | |
| } | |
| /* evaluate subtrees in order to do binary operation, then keep going */ | |
| t1 = tree_eval(tree->lnode); | |
| t2 = tree_eval(tree->rnode); | |
| switch (tree->type) { | |
| case Node_concat: | |
| DBG_P(("CONCAT", tree)); | |
| t1 = force_string(t1); | |
| t2 = force_string(t2); | |
| r = newnode(Node_val); | |
| r->flags |= (STR|TEMP); | |
| r->stlen = t1->stlen + t2->stlen; | |
| r->stref = 1; | |
| emalloc(r->stptr, char *, r->stlen + 1, "tree_eval"); | |
| memcpy(r->stptr, t1->stptr, t1->stlen); | |
| memcpy(r->stptr + t1->stlen, t2->stptr, t2->stlen + 1); | |
| free_temp(t1); | |
| free_temp(t2); | |
| return r; | |
| case Node_geq: | |
| case Node_leq: | |
| case Node_greater: | |
| case Node_less: | |
| case Node_notequal: | |
| case Node_equal: | |
| di = cmp_nodes(t1, t2); | |
| free_temp(t1); | |
| free_temp(t2); | |
| switch (tree->type) { | |
| case Node_equal: | |
| DBG_P(("EQUAL", tree)); | |
| return tmp_number((AWKNUM) (di == 0)); | |
| case Node_notequal: | |
| DBG_P(("NOT_EQUAL", tree)); | |
| return tmp_number((AWKNUM) (di != 0)); | |
| case Node_less: | |
| DBG_P(("LESS_THAN", tree)); | |
| return tmp_number((AWKNUM) (di < 0)); | |
| case Node_greater: | |
| DBG_P(("GREATER_THAN", tree)); | |
| return tmp_number((AWKNUM) (di > 0)); | |
| case Node_leq: | |
| DBG_P(("LESS_THAN_EQUAL", tree)); | |
| return tmp_number((AWKNUM) (di <= 0)); | |
| case Node_geq: | |
| DBG_P(("GREATER_THAN_EQUAL", tree)); | |
| return tmp_number((AWKNUM) (di >= 0)); | |
| default: | |
| cant_happen(); | |
| } | |
| break; | |
| default: | |
| break; /* handled below */ | |
| } | |
| (void) force_number(t1); | |
| (void) force_number(t2); | |
| switch (tree->type) { | |
| case Node_exp: | |
| DBG_P(("EXPONENT", tree)); | |
| if ((lx = t2->numbr) == t2->numbr) { /* integer exponent */ | |
| if (lx == 0) | |
| x = 1; | |
| else if (lx == 1) | |
| x = t1->numbr; | |
| else { | |
| /* doing it this way should be more precise */ | |
| for (x = x2 = t1->numbr; --lx; ) | |
| x *= x2; | |
| } | |
| } else | |
| x = pow((double) t1->numbr, (double) t2->numbr); | |
| free_temp(t1); | |
| free_temp(t2); | |
| return tmp_number(x); | |
| case Node_times: | |
| DBG_P(("MULT", tree)); | |
| x = t1->numbr * t2->numbr; | |
| free_temp(t1); | |
| free_temp(t2); | |
| return tmp_number(x); | |
| case Node_quotient: | |
| DBG_P(("DIVIDE", tree)); | |
| x = t2->numbr; | |
| free_temp(t2); | |
| if (x == (AWKNUM) 0) | |
| fatal("division by zero attempted"); | |
| /* NOTREACHED */ | |
| else { | |
| x = t1->numbr / x; | |
| free_temp(t1); | |
| return tmp_number(x); | |
| } | |
| case Node_mod: | |
| DBG_P(("MODULUS", tree)); | |
| x = t2->numbr; | |
| free_temp(t2); | |
| if (x == (AWKNUM) 0) | |
| fatal("division by zero attempted in mod"); | |
| /* NOTREACHED */ | |
| lx = t1->numbr / x; /* assignment to long truncates */ | |
| x2 = lx * x; | |
| x = t1->numbr - x2; | |
| free_temp(t1); | |
| return tmp_number(x); | |
| case Node_plus: | |
| DBG_P(("PLUS", tree)); | |
| x = t1->numbr + t2->numbr; | |
| free_temp(t1); | |
| free_temp(t2); | |
| return tmp_number(x); | |
| case Node_minus: | |
| DBG_P(("MINUS", tree)); | |
| x = t1->numbr - t2->numbr; | |
| free_temp(t1); | |
| free_temp(t2); | |
| return tmp_number(x); | |
| default: | |
| fatal("illegal type (%d) in tree_eval", tree->type); | |
| } | |
| return 0; | |
| } | |
| /* | |
| * This makes numeric operations slightly more efficient. Just change the | |
| * value of a numeric node, if possible | |
| */ | |
| void | |
| assign_number(ptr, value) | |
| NODE **ptr; | |
| AWKNUM value; | |
| { | |
| extern NODE *deref; | |
| register NODE *n = *ptr; | |
| #ifdef DEBUG | |
| if (n->type != Node_val) | |
| cant_happen(); | |
| #endif | |
| if (n == Nnull_string) { | |
| *ptr = make_number(value); | |
| deref = 0; | |
| return; | |
| } | |
| if (n->stref > 1) { | |
| *ptr = make_number(value); | |
| return; | |
| } | |
| if ((n->flags & STR) && (n->flags & (MALLOC|TEMP))) | |
| free(n->stptr); | |
| n->numbr = value; | |
| n->flags |= (NUM|NUMERIC); | |
| n->flags &= ~STR; | |
| n->stref = 0; | |
| deref = 0; | |
| } | |
| /* Is TREE true or false? Returns 0==false, non-zero==true */ | |
| static int | |
| eval_condition(tree) | |
| NODE *tree; | |
| { | |
| register NODE *t1; | |
| int ret; | |
| if (tree == NULL) /* Null trees are the easiest kinds */ | |
| return 1; | |
| 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 0; | |
| else | |
| tree->triggered = 1; | |
| /* Else we are triggered */ | |
| if (eval_condition(tree->condpair->rnode)) | |
| tree->triggered = 0; | |
| return 1; | |
| } | |
| /* | |
| * Could just be J.random expression. in which case, null and 0 are | |
| * false, anything else is true | |
| */ | |
| t1 = tree_eval(tree); | |
| if (t1->flags & NUMERIC) | |
| ret = t1->numbr != 0.0; | |
| else | |
| ret = t1->stlen != 0; | |
| free_temp(t1); | |
| return ret; | |
| } | |
| int | |
| cmp_nodes(t1, t2) | |
| NODE *t1, *t2; | |
| { | |
| AWKNUM d; | |
| AWKNUM d1; | |
| AWKNUM d2; | |
| int ret; | |
| int len1, len2; | |
| if (t1 == t2) | |
| return 0; | |
| d1 = force_number(t1); | |
| d2 = force_number(t2); | |
| if ((t1->flags & NUMERIC) && (t2->flags & NUMERIC)) { | |
| d = d1 - d2; | |
| if (d == 0.0) /* from profiling, this is most common */ | |
| return 0; | |
| if (d > 0.0) | |
| return 1; | |
| return -1; | |
| } | |
| t1 = force_string(t1); | |
| t2 = force_string(t2); | |
| len1 = t1->stlen; | |
| len2 = t2->stlen; | |
| if (len1 == 0) { | |
| if (len2 == 0) | |
| return 0; | |
| else | |
| return -1; | |
| } else if (len2 == 0) | |
| return 1; | |
| ret = memcmp(t1->stptr, t2->stptr, len1 <= len2 ? len1 : len2); | |
| if (ret == 0 && len1 != len2) | |
| return len1 < len2 ? -1: 1; | |
| return ret; | |
| } | |
| static NODE * | |
| op_assign(tree) | |
| NODE *tree; | |
| { | |
| AWKNUM rval, lval; | |
| NODE **lhs; | |
| AWKNUM t1, t2; | |
| long ltemp; | |
| NODE *tmp; | |
| lhs = get_lhs(tree->lnode, 1); | |
| lval = force_number(*lhs); | |
| switch(tree->type) { | |
| case Node_preincrement: | |
| case Node_predecrement: | |
| DBG_P(("+-X", tree)); | |
| assign_number(lhs, | |
| lval + (tree->type == Node_preincrement ? 1.0 : -1.0)); | |
| do_deref(); | |
| if (field_num == 0) | |
| set_record(fields_arr[0]->stptr, fields_arr[0]->stlen); | |
| field_num = -1; | |
| return *lhs; | |
| case Node_postincrement: | |
| case Node_postdecrement: | |
| DBG_P(("X+-", tree)); | |
| assign_number(lhs, | |
| lval + (tree->type == Node_postincrement ? 1.0 : -1.0)); | |
| do_deref(); | |
| if (field_num == 0) | |
| set_record(fields_arr[0]->stptr, fields_arr[0]->stlen); | |
| field_num = -1; | |
| return tmp_number(lval); | |
| default: | |
| break; /* handled below */ | |
| } | |
| tmp = tree_eval(tree->rnode); | |
| rval = force_number(tmp); | |
| free_temp(tmp); | |
| switch(tree->type) { | |
| case Node_assign_exp: | |
| DBG_P(("ASSIGN_exp", tree)); | |
| if ((ltemp = rval) == rval) { /* integer exponent */ | |
| if (ltemp == 0) | |
| assign_number(lhs, (AWKNUM) 1); | |
| else if (ltemp == 1) | |
| assign_number(lhs, lval); | |
| else { | |
| /* doing it this way should be more precise */ | |
| for (t1 = t2 = lval; --ltemp; ) | |
| t1 *= t2; | |
| assign_number(lhs, t1); | |
| } | |
| } else | |
| assign_number(lhs, (AWKNUM) pow((double) lval, (double) rval)); | |
| break; | |
| case Node_assign_times: | |
| DBG_P(("ASSIGN_times", tree)); | |
| assign_number(lhs, lval * rval); | |
| break; | |
| case Node_assign_quotient: | |
| DBG_P(("ASSIGN_quotient", tree)); | |
| if (rval == (AWKNUM) 0) | |
| fatal("division by zero attempted in /="); | |
| assign_number(lhs, lval / rval); | |
| break; | |
| case Node_assign_mod: | |
| DBG_P(("ASSIGN_mod", tree)); | |
| if (rval == (AWKNUM) 0) | |
| fatal("division by zero attempted in %="); | |
| ltemp = lval / rval; /* assignment to long truncates */ | |
| t1 = ltemp * rval; | |
| t2 = lval - t1; | |
| assign_number(lhs, t2); | |
| break; | |
| case Node_assign_plus: | |
| DBG_P(("ASSIGN_plus", tree)); | |
| assign_number(lhs, lval + rval); | |
| break; | |
| case Node_assign_minus: | |
| DBG_P(("ASSIGN_minus", tree)); | |
| assign_number(lhs, lval - rval); | |
| break; | |
| default: | |
| cant_happen(); | |
| } | |
| do_deref(); | |
| if (field_num == 0) | |
| set_record(fields_arr[0]->stptr, fields_arr[0]->stlen); | |
| field_num = -1; | |
| return *lhs; | |
| } | |
| NODE **stack_ptr; | |
| static NODE * | |
| func_call(name, arg_list) | |
| NODE *name; /* name is a Node_val giving function name */ | |
| NODE *arg_list; /* Node_expression_list of calling args. */ | |
| { | |
| register NODE *arg, *argp, *r; | |
| NODE *n, *f; | |
| volatile jmp_buf func_tag_stack; | |
| volatile jmp_buf loop_tag_stack; | |
| volatile int save_loop_tag_valid = 0; | |
| volatile NODE **save_stack, *save_ret_node; | |
| NODE **local_stack, **sp; | |
| int count; | |
| extern NODE *ret_node; | |
| /* | |
| * retrieve function definition node | |
| */ | |
| f = lookup(variables, name->stptr); | |
| if (!f || 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; | |
| 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) { | |
| arg = argp->lnode; | |
| r = newnode(Node_var); | |
| /* | |
| * 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) | |
| *r = *arg; | |
| else { | |
| n = tree_eval(arg); | |
| r->lnode = dupnode(n); | |
| r->rnode = (NODE *) NULL; | |
| free_temp(n); | |
| } | |
| *sp++ = r; | |
| count--; | |
| } | |
| if (argp != NULL) /* left over calling args. */ | |
| warning( | |
| "function `%s' called with more arguments than declared", | |
| name->stptr); | |
| /* | |
| * add remaining params. on stack with null value | |
| */ | |
| while (count-- > 0) { | |
| r = newnode(Node_var); | |
| r->lnode = Nnull_string; | |
| r->rnode = (NODE *) NULL; | |
| *sp++ = r; | |
| } | |
| /* | |
| * 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 = 0; | |
| } | |
| save_stack = (volatile NODE **) stack_ptr; | |
| stack_ptr = local_stack; | |
| PUSH_BINDING(func_tag_stack, func_tag, func_tag_valid); | |
| save_ret_node = (volatile NODE *) ret_node; | |
| ret_node = Nnull_string; /* default return value */ | |
| 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); | |
| stack_ptr = (NODE **) save_stack; | |
| /* | |
| * here, we pop each parameter and check whether | |
| * it was an array. If so, and if the arg. passed in was | |
| * a simple variable, then the value should be copied back. | |
| * This achieves "call-by-reference" for arrays. | |
| */ | |
| sp = local_stack; | |
| count = f->lnode->param_cnt; | |
| for (argp = arg_list; count > 0 && argp != NULL; argp = argp->rnode) { | |
| arg = argp->lnode; | |
| n = *sp++; | |
| if (arg->type == Node_var && n->type == Node_var_array) { | |
| arg->var_array = n->var_array; | |
| arg->type = Node_var_array; | |
| } | |
| deref = n->lnode; | |
| do_deref(); | |
| freenode(n); | |
| count--; | |
| } | |
| while (count-- > 0) { | |
| n = *sp++; | |
| deref = n->lnode; | |
| do_deref(); | |
| freenode(n); | |
| } | |
| free((char *) local_stack); | |
| /* 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)) | |
| r->flags |= TEMP; | |
| return r; | |
| } | |
| /* | |
| * 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 | |
| */ | |
| NODE ** | |
| get_lhs(ptr, assign) | |
| NODE *ptr; | |
| int assign; /* this is being called for the LHS of an assign. */ | |
| { | |
| register NODE **aptr; | |
| NODE *n; | |
| #ifdef DEBUG | |
| if (ptr == NULL) | |
| cant_happen(); | |
| #endif | |
| deref = NULL; | |
| field_num = -1; | |
| switch (ptr->type) { | |
| case Node_var: | |
| case Node_var_array: | |
| if (ptr == NF_node && (int) NF_node->var_value->numbr == -1) | |
| (void) get_field(HUGE-1, assign); /* parse record */ | |
| deref = ptr->var_value; | |
| #ifdef DEBUG | |
| if (deref->type != Node_val) | |
| cant_happen(); | |
| if (deref->flags == 0) | |
| cant_happen(); | |
| #endif | |
| return &(ptr->var_value); | |
| case Node_param_list: | |
| n = stack_ptr[ptr->param_cnt]; | |
| deref = n->var_value; | |
| #ifdef DEBUG | |
| if (deref->type != Node_val) | |
| cant_happen(); | |
| if (deref->flags == 0) | |
| cant_happen(); | |
| #endif | |
| return &(n->var_value); | |
| case Node_field_spec: | |
| n = tree_eval(ptr->lnode); | |
| field_num = (int) force_number(n); | |
| free_temp(n); | |
| if (field_num < 0) | |
| fatal("attempt to access field %d", field_num); | |
| aptr = get_field(field_num, assign); | |
| deref = *aptr; | |
| return aptr; | |
| case Node_subscript: | |
| n = ptr->lnode; | |
| if (n->type == Node_param_list) | |
| n = stack_ptr[n->param_cnt]; | |
| aptr = assoc_lookup(n, concat_exp(ptr->rnode)); | |
| deref = *aptr; | |
| #ifdef DEBUG | |
| if (deref->type != Node_val) | |
| cant_happen(); | |
| if (deref->flags == 0) | |
| cant_happen(); | |
| #endif | |
| return aptr; | |
| case Node_func: | |
| fatal ("`%s' is a function, assignment is not allowed", | |
| ptr->lnode->param); | |
| default: | |
| cant_happen(); | |
| } | |
| return 0; | |
| } | |
| static NODE * | |
| match_op(tree) | |
| NODE *tree; | |
| { | |
| NODE *t1; | |
| struct re_pattern_buffer *rp; | |
| int i; | |
| int match = 1; | |
| if (tree->type == Node_nomatch) | |
| match = 0; | |
| if (tree->type == Node_regex) | |
| t1 = WHOLELINE; | |
| else { | |
| if (tree->lnode) | |
| t1 = force_string(tree_eval(tree->lnode)); | |
| else | |
| t1 = WHOLELINE; | |
| tree = tree->rnode; | |
| } | |
| if (tree->type == Node_regex) { | |
| rp = tree->rereg; | |
| if (!strict && ((IGNORECASE_node->var_value->numbr != 0) | |
| ^ (tree->re_case != 0))) { | |
| /* recompile since case sensitivity differs */ | |
| rp = tree->rereg = | |
| mk_re_parse(tree->re_text, | |
| (IGNORECASE_node->var_value->numbr != 0)); | |
| tree->re_case = | |
| (IGNORECASE_node->var_value->numbr != 0); | |
| } | |
| } else { | |
| rp = make_regexp(force_string(tree_eval(tree)), | |
| (IGNORECASE_node->var_value->numbr != 0)); | |
| if (rp == NULL) | |
| cant_happen(); | |
| } | |
| i = re_search(rp, t1->stptr, t1->stlen, 0, t1->stlen, | |
| (struct re_registers *) NULL); | |
| i = (i == -1) ^ (match == 1); | |
| free_temp(t1); | |
| if (tree->type != Node_regex) { | |
| free(rp->buffer); | |
| free(rp->fastmap); | |
| free((char *) rp); | |
| } | |
| return tmp_number((AWKNUM) i); | |
| } |