1
0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-23 11:18:54 +00:00
freebsd/contrib/awk/awkgram.y
David E. O'Brien 622bfc32f3 I'd put down $10 says the author did a last minute tweak to awkgram.y (which
had an error in it), and applied it by hand to awkgram.c (getting it right)
rather than really generating an new awkgram.c properly using Bison/YACC...
Fix his mistake here.
2001-11-02 23:41:29 +00:00

2876 lines
65 KiB
Plaintext

/*
* awk.y --- yacc/bison parser
*/
/*
* Copyright (C) 1986, 1988, 1989, 1991-2001 the Free Software Foundation, Inc.
*
* This file is part of GAWK, the GNU implementation of the
* AWK Programming Language.
*
* GAWK is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* GAWK is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
%{
#ifdef GAWKDEBUG
#define YYDEBUG 12
#endif
#include "awk.h"
#define CAN_FREE TRUE
#define DONT_FREE FALSE
#if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
static void yyerror(const char *m, ...) ;
#else
static void yyerror(); /* va_alist */
#endif
static char *get_src_buf P((void));
static int yylex P((void));
static NODE *node_common P((NODETYPE op));
static NODE *snode P((NODE *subn, NODETYPE op, int sindex));
static NODE *mkrangenode P((NODE *cpair));
static NODE *make_for_loop P((NODE *init, NODE *cond, NODE *incr));
static NODE *append_right P((NODE *list, NODE *new));
static void func_install P((NODE *params, NODE *def));
static void pop_var P((NODE *np, int freeit));
static void pop_params P((NODE *params));
static NODE *make_param P((char *name));
static NODE *mk_rexp P((NODE *exp));
static int dup_parms P((NODE *func));
static void param_sanity P((NODE *arglist));
static void parms_shadow P((const char *fname, NODE *func));
static int isnoeffect P((NODETYPE t));
static int isassignable P((NODE *n));
static void dumpintlstr P((char *str, size_t len));
static void count_args P((NODE *n));
enum defref { FUNC_DEFINE, FUNC_USE };
static void func_use P((char *name, enum defref how));
static void check_funcs P((void));
static int want_assign; /* lexical scanning kludge */
static int want_regexp; /* lexical scanning kludge */
static int can_return; /* lexical scanning kludge */
static int io_allowed = TRUE; /* lexical scanning kludge */
static int parsing_end_rule = FALSE; /* for warnings */
static char *lexptr; /* pointer to next char during parsing */
static char *lexend;
static char *lexptr_begin; /* keep track of where we were for error msgs */
static char *lexeme; /* beginning of lexeme for debugging */
static char *thisline = NULL;
#define YYDEBUG_LEXER_TEXT (lexeme)
static int param_counter;
static char *tokstart = NULL;
static char *tok = NULL;
static char *tokend;
static long func_count; /* total number of functions */
#define HASHSIZE 1021 /* this constant only used here */
NODE *variables[HASHSIZE];
static int var_count; /* total number of global variables */
extern char *source;
extern int sourceline;
extern struct src *srcfiles;
extern int numfiles;
extern int errcount;
extern NODE *begin_block;
extern NODE *end_block;
%}
%union {
long lval;
AWKNUM fval;
NODE *nodeval;
NODETYPE nodetypeval;
char *sval;
NODE *(*ptrval)();
}
%type <nodeval> function_prologue function_body
%type <nodeval> rexp exp start program rule simp_exp
%type <nodeval> non_post_simp_exp
%type <nodeval> pattern
%type <nodeval> action variable param_list
%type <nodeval> rexpression_list opt_rexpression_list
%type <nodeval> expression_list opt_expression_list
%type <nodeval> statements statement if_statement opt_param_list
%type <nodeval> opt_exp opt_variable regexp
%type <nodeval> input_redir output_redir
%type <nodetypeval> print
%type <sval> func_name
%type <lval> lex_builtin
%token <sval> FUNC_CALL NAME REGEXP
%token <lval> ERROR
%token <nodeval> YNUMBER YSTRING
%token <nodetypeval> RELOP APPEND_OP
%token <nodetypeval> ASSIGNOP MATCHOP NEWLINE CONCAT_OP
%token <nodetypeval> LEX_BEGIN LEX_END LEX_IF LEX_ELSE LEX_RETURN LEX_DELETE
%token <nodetypeval> LEX_WHILE LEX_DO LEX_FOR LEX_BREAK LEX_CONTINUE
%token <nodetypeval> LEX_PRINT LEX_PRINTF LEX_NEXT LEX_EXIT LEX_FUNCTION
%token <nodetypeval> LEX_GETLINE LEX_NEXTFILE
%token <nodetypeval> LEX_IN
%token <lval> LEX_AND LEX_OR INCREMENT DECREMENT
%token <lval> LEX_BUILTIN LEX_LENGTH
/* these are just yylval numbers */
/* Lowest to highest */
%right ASSIGNOP
%right '?' ':'
%left LEX_OR
%left LEX_AND
%left LEX_GETLINE
%nonassoc LEX_IN
%left FUNC_CALL LEX_BUILTIN LEX_LENGTH
%nonassoc ','
%nonassoc MATCHOP
%nonassoc RELOP '<' '>' '|' APPEND_OP TWOWAYIO
%left CONCAT_OP
%left YSTRING YNUMBER
%left '+' '-'
%left '*' '/' '%'
%right '!' UNARY
%right '^'
%left INCREMENT DECREMENT
%left '$'
%left '(' ')'
%%
start
: opt_nls program opt_nls
{
expression_value = $2;
check_funcs();
}
;
program
: rule
{
if ($1 != NULL)
$$ = $1;
else
$$ = NULL;
yyerrok;
}
| program rule
/* add the rule to the tail of list */
{
if ($2 == NULL)
$$ = $1;
else if ($1 == NULL)
$$ = $2;
else {
if ($1->type != Node_rule_list)
$1 = node($1, Node_rule_list,
(NODE*) NULL);
$$ = append_right($1,
node($2, Node_rule_list, (NODE *) NULL));
}
yyerrok;
}
| error { $$ = NULL; }
| program error { $$ = NULL; }
| /* empty */ { $$ = NULL; }
;
rule
: LEX_BEGIN { io_allowed = FALSE; }
action
{
if (begin_block != NULL) {
if (begin_block->type != Node_rule_list)
begin_block = node(begin_block, Node_rule_list,
(NODE *) NULL);
(void) append_right(begin_block, node(
node((NODE *) NULL, Node_rule_node, $3),
Node_rule_list, (NODE *) NULL) );
} else
begin_block = node((NODE *) NULL, Node_rule_node, $3);
$$ = NULL;
io_allowed = TRUE;
yyerrok;
}
| LEX_END { io_allowed = FALSE; parsing_end_rule = TRUE; }
action
{
if (end_block != NULL) {
if (end_block->type != Node_rule_list)
end_block = node(end_block, Node_rule_list,
(NODE *) NULL);
(void) append_right (end_block, node(
node((NODE *) NULL, Node_rule_node, $3),
Node_rule_list, (NODE *) NULL));
} else
end_block = node((NODE *) NULL, Node_rule_node, $3);
$$ = NULL;
io_allowed = TRUE;
parsing_end_rule = FALSE;
yyerrok;
}
| LEX_BEGIN statement_term
{
warning(_("BEGIN blocks must have an action part"));
errcount++;
yyerrok;
}
| LEX_END statement_term
{
warning(_("END blocks must have an action part"));
errcount++;
yyerrok;
}
| pattern action
{ $$ = node($1, Node_rule_node, $2); yyerrok; }
| action
{ $$ = node((NODE *) NULL, Node_rule_node, $1); yyerrok; }
| pattern statement_term
{
$$ = node($1,
Node_rule_node,
node(node(node(make_number(0.0),
Node_field_spec,
(NODE *) NULL),
Node_expression_list,
(NODE *) NULL),
Node_K_print,
(NODE *) NULL));
yyerrok;
}
| function_prologue function_body
{
func_install($1, $2);
$$ = NULL;
yyerrok;
}
;
func_name
: NAME
{ $$ = $1; }
| FUNC_CALL
{ $$ = $1; }
| lex_builtin
{
yyerror(_("`%s' is a built-in function, it cannot be redefined"),
tokstart);
errcount++;
/* yyerrok; */
}
;
lex_builtin
: LEX_BUILTIN
| LEX_LENGTH
;
function_prologue
: LEX_FUNCTION
{
param_counter = 0;
}
func_name '(' opt_param_list r_paren opt_nls
{
NODE *t;
t = make_param($3);
t->flags |= FUNC;
$$ = append_right(t, $5);
can_return = TRUE;
/* check for duplicate parameter names */
if (dup_parms($$))
errcount++;
}
;
function_body
: l_brace statements r_brace opt_semi opt_nls
{
$$ = $2;
can_return = FALSE;
}
| l_brace r_brace opt_semi opt_nls
{
$$ = node((NODE *) NULL, Node_K_return, (NODE *) NULL);
can_return = FALSE;
}
;
pattern
: exp
{ $$ = $1; }
| exp ',' exp
{ $$ = mkrangenode(node($1, Node_cond_pair, $3)); }
;
regexp
/*
* In this rule, want_regexp tells yylex that the next thing
* is a regexp so it should read up to the closing slash.
*/
: '/'
{ ++want_regexp; }
REGEXP '/'
{
NODE *n;
size_t len;
getnode(n);
n->type = Node_regex;
len = strlen($3);
n->re_exp = make_string($3, len);
n->re_reg = make_regexp($3, len, FALSE, TRUE);
n->re_text = NULL;
n->re_flags = CONST;
n->re_cnt = 1;
$$ = n;
}
;
action
: l_brace statements r_brace opt_semi opt_nls
{ $$ = $2; }
| l_brace r_brace opt_semi opt_nls
{ $$ = NULL; }
;
statements
: statement
{
$$ = $1;
if (do_lint && isnoeffect($$->type))
lintwarn(_("statement may have no effect"));
}
| statements statement
{
if ($1 == NULL || $1->type != Node_statement_list)
$1 = node($1, Node_statement_list, (NODE *) NULL);
$$ = append_right($1,
node($2, Node_statement_list, (NODE *) NULL));
yyerrok;
}
| error
{ $$ = NULL; }
| statements error
{ $$ = NULL; }
;
statement_term
: nls
| semi opt_nls
;
statement
: semi opt_nls
{ $$ = NULL; }
| l_brace r_brace
{ $$ = NULL; }
| l_brace statements r_brace
{ $$ = $2; }
| if_statement
{ $$ = $1; }
| LEX_WHILE '(' exp r_paren opt_nls statement
{ $$ = node($3, Node_K_while, $6); }
| LEX_DO opt_nls statement LEX_WHILE '(' exp r_paren opt_nls
{ $$ = node($6, Node_K_do, $3); }
| LEX_FOR '(' NAME LEX_IN NAME r_paren opt_nls statement
{
/*
* Efficiency hack. Recognize the special case of
*
* for (iggy in foo)
* delete foo[iggy]
*
* and treat it as if it were
*
* delete foo
*
* Check that the body is a `delete a[i]' statement,
* and that both the loop var and array names match.
*/
if ($8 != NULL && $8->type == Node_K_delete
&& $8->rnode != NULL
&& ($8->rnode->type == Node_var || $8->rnode->type == Node_param_list)
&& strcmp($3, $8->rnode->var_value->vname) == 0
&& strcmp($5, $8->lnode->vname) == 0) {
$8->type = Node_K_delete_loop;
$$ = $8;
} else {
$$ = node($8, Node_K_arrayfor,
make_for_loop(variable($3, CAN_FREE, Node_var),
(NODE *) NULL, variable($5, CAN_FREE, Node_var_array)));
}
}
| LEX_FOR '(' opt_exp semi opt_nls exp semi opt_nls opt_exp r_paren opt_nls statement
{
$$ = node($12, Node_K_for, (NODE *) make_for_loop($3, $6, $9));
}
| LEX_FOR '(' opt_exp semi opt_nls semi opt_nls opt_exp r_paren opt_nls statement
{
$$ = node($11, Node_K_for,
(NODE *) make_for_loop($3, (NODE *) NULL, $8));
}
| LEX_BREAK statement_term
/* for break, maybe we'll have to remember where to break to */
{ $$ = node((NODE *) NULL, Node_K_break, (NODE *) NULL); }
| LEX_CONTINUE statement_term
/* similarly */
{ $$ = node((NODE *) NULL, Node_K_continue, (NODE *) NULL); }
| print '(' expression_list r_paren output_redir statement_term
{
$$ = node($3, $1, $5);
if ($$->type == Node_K_printf)
count_args($$);
}
| print opt_rexpression_list output_redir statement_term
{
if ($1 == Node_K_print && $2 == NULL) {
static int warned = FALSE;
$2 = node(node(make_number(0.0),
Node_field_spec,
(NODE *) NULL),
Node_expression_list,
(NODE *) NULL);
if (do_lint && ! io_allowed && ! warned) {
warned = TRUE;
lintwarn(
_("plain `print' in BEGIN or END rule should probably be `print \"\"'"));
}
}
$$ = node($2, $1, $3);
if ($$->type == Node_K_printf)
count_args($$);
}
| LEX_NEXT statement_term
{ NODETYPE type;
if (! io_allowed)
yyerror(_("`next' used in BEGIN or END action"));
type = Node_K_next;
$$ = node((NODE *) NULL, type, (NODE *) NULL);
}
| LEX_NEXTFILE statement_term
{
if (do_lint)
lintwarn(_("`nextfile' is a gawk extension"));
if (do_traditional) {
/*
* can't use yyerror, since may have overshot
* the source line
*/
errcount++;
error(_("`nextfile' is a gawk extension"));
}
if (! io_allowed) {
/* same thing */
errcount++;
error(_("`nextfile' used in BEGIN or END action"));
}
$$ = node((NODE *) NULL, Node_K_nextfile, (NODE *) NULL);
}
| LEX_EXIT opt_exp statement_term
{ $$ = node($2, Node_K_exit, (NODE *) NULL); }
| LEX_RETURN
{
if (! can_return)
yyerror(_("`return' used outside function context"));
}
opt_exp statement_term
{ $$ = node($3, Node_K_return, (NODE *) NULL); }
| LEX_DELETE NAME '[' expression_list ']' statement_term
{ $$ = node(variable($2, CAN_FREE, Node_var_array), Node_K_delete, $4); }
| LEX_DELETE NAME statement_term
{
if (do_lint)
lintwarn(_("`delete array' is a gawk extension"));
if (do_traditional) {
/*
* can't use yyerror, since may have overshot
* the source line
*/
errcount++;
error(_("`delete array' is a gawk extension"));
}
$$ = node(variable($2, CAN_FREE, Node_var_array), Node_K_delete, (NODE *) NULL);
}
| exp statement_term
{ $$ = $1; }
;
print
: LEX_PRINT
{ $$ = $1; }
| LEX_PRINTF
{ $$ = $1; }
;
if_statement
: LEX_IF '(' exp r_paren opt_nls statement
{
$$ = node($3, Node_K_if,
node($6, Node_if_branches, (NODE *) NULL));
}
| LEX_IF '(' exp r_paren opt_nls statement
LEX_ELSE opt_nls statement
{ $$ = node($3, Node_K_if,
node($6, Node_if_branches, $9)); }
;
nls
: NEWLINE
{ want_assign = FALSE; }
| nls NEWLINE
;
opt_nls
: /* empty */
| nls
;
input_redir
: /* empty */
{ $$ = NULL; }
| '<' simp_exp
{ $$ = node($2, Node_redirect_input, (NODE *) NULL); }
;
output_redir
: /* empty */
{ $$ = NULL; }
| '>' exp
{ $$ = node($2, Node_redirect_output, (NODE *) NULL); }
| APPEND_OP exp
{ $$ = node($2, Node_redirect_append, (NODE *) NULL); }
| '|' exp
{ $$ = node($2, Node_redirect_pipe, (NODE *) NULL); }
| TWOWAYIO exp
{
if ($2->type == Node_K_getline
&& $2->rnode->type == Node_redirect_twoway)
yyerror(_("multistage two-way pipelines don't work"));
$$ = node($2, Node_redirect_twoway, (NODE *) NULL);
}
;
opt_param_list
: /* empty */
{ $$ = NULL; }
| param_list
{ $$ = $1; }
;
param_list
: NAME
{ $$ = make_param($1); }
| param_list comma NAME
{ $$ = append_right($1, make_param($3)); yyerrok; }
| error
{ $$ = NULL; }
| param_list error
{ $$ = NULL; }
| param_list comma error
{ $$ = NULL; }
;
/* optional expression, as in for loop */
opt_exp
: /* empty */
{ $$ = NULL; }
| exp
{ $$ = $1; }
;
opt_rexpression_list
: /* empty */
{ $$ = NULL; }
| rexpression_list
{ $$ = $1; }
;
rexpression_list
: rexp
{ $$ = node($1, Node_expression_list, (NODE *) NULL); }
| rexpression_list comma rexp
{
$$ = append_right($1,
node($3, Node_expression_list, (NODE *) NULL));
yyerrok;
}
| error
{ $$ = NULL; }
| rexpression_list error
{ $$ = NULL; }
| rexpression_list error rexp
{ $$ = NULL; }
| rexpression_list comma error
{ $$ = NULL; }
;
opt_expression_list
: /* empty */
{ $$ = NULL; }
| expression_list
{ $$ = $1; }
;
expression_list
: exp
{ $$ = node($1, Node_expression_list, (NODE *) NULL); }
| expression_list comma exp
{
$$ = append_right($1,
node($3, Node_expression_list, (NODE *) NULL));
yyerrok;
}
| error
{ $$ = NULL; }
| expression_list error
{ $$ = NULL; }
| expression_list error exp
{ $$ = NULL; }
| expression_list comma error
{ $$ = NULL; }
;
/* Expressions, not including the comma operator. */
exp : variable ASSIGNOP
{ want_assign = FALSE; }
exp
{
if (do_lint && $4->type == Node_regex)
lintwarn(_("regular expression on right of assignment"));
$$ = node($1, $2, $4);
}
| '(' expression_list r_paren LEX_IN NAME
{ $$ = node(variable($5, CAN_FREE, Node_var_array), Node_in_array, $2); }
| exp '|' LEX_GETLINE opt_variable
{
$$ = node($4, Node_K_getline,
node($1, Node_redirect_pipein, (NODE *) NULL));
}
| exp TWOWAYIO LEX_GETLINE opt_variable
{
$$ = node($4, Node_K_getline,
node($1, Node_redirect_twoway, (NODE *) NULL));
}
| LEX_GETLINE opt_variable input_redir
{
if (do_lint && ! io_allowed && parsing_end_rule && $3 == NULL)
lintwarn(_("non-redirected `getline' undefined inside END action"));
$$ = node($2, Node_K_getline, $3);
}
| exp LEX_AND exp
{ $$ = node($1, Node_and, $3); }
| exp LEX_OR exp
{ $$ = node($1, Node_or, $3); }
| exp MATCHOP exp
{
if ($1->type == Node_regex)
warning(_("regular expression on left of `~' or `!~' operator"));
$$ = node($1, $2, mk_rexp($3));
}
| regexp
{
$$ = $1;
if (do_lint && tokstart[0] == '*') {
/* possible C comment */
int n = strlen(tokstart) - 1;
if (tokstart[n] == '*')
lintwarn(_("regexp constant `/%s/' looks like a C comment, but is not"), tokstart);
}
}
| '!' regexp %prec UNARY
{
$$ = node(node(make_number(0.0),
Node_field_spec,
(NODE *) NULL),
Node_nomatch,
$2);
}
| exp LEX_IN NAME
{ $$ = node(variable($3, CAN_FREE, Node_var_array), Node_in_array, $1); }
| exp RELOP exp
{
if (do_lint && $3->type == Node_regex)
lintwarn(_("regular expression on right of comparison"));
$$ = node($1, $2, $3);
}
| exp '<' exp
{ $$ = node($1, Node_less, $3); }
| exp '>' exp
{ $$ = node($1, Node_greater, $3); }
| exp '?' exp ':' exp
{ $$ = node($1, Node_cond_exp, node($3, Node_if_branches, $5));}
| simp_exp
{ $$ = $1; }
| exp simp_exp %prec CONCAT_OP
{ $$ = node($1, Node_concat, $2); }
;
rexp
: variable ASSIGNOP
{ want_assign = FALSE; }
rexp
{ $$ = node($1, $2, $4); }
| rexp LEX_AND rexp
{ $$ = node($1, Node_and, $3); }
| rexp LEX_OR rexp
{ $$ = node($1, Node_or, $3); }
| LEX_GETLINE opt_variable input_redir
{
if (do_lint && ! io_allowed && $3 == NULL)
lintwarn(_("non-redirected `getline' undefined inside BEGIN or END action"));
$$ = node($2, Node_K_getline, $3);
}
| regexp
{ $$ = $1; }
| '!' regexp %prec UNARY
{ $$ = node((NODE *) NULL, Node_nomatch, $2); }
| rexp MATCHOP rexp
{ $$ = node($1, $2, mk_rexp($3)); }
| rexp LEX_IN NAME
{ $$ = node(variable($3, CAN_FREE, Node_var_array), Node_in_array, $1); }
| rexp RELOP rexp
{ $$ = node($1, $2, $3); }
| rexp '?' rexp ':' rexp
{ $$ = node($1, Node_cond_exp, node($3, Node_if_branches, $5));}
| simp_exp
{ $$ = $1; }
| rexp simp_exp %prec CONCAT_OP
{ $$ = node($1, Node_concat, $2); }
;
simp_exp
: non_post_simp_exp
/* Binary operators in order of decreasing precedence. */
| simp_exp '^' simp_exp
{ $$ = node($1, Node_exp, $3); }
| simp_exp '*' simp_exp
{ $$ = node($1, Node_times, $3); }
| simp_exp '/' simp_exp
{ $$ = node($1, Node_quotient, $3); }
| simp_exp '%' simp_exp
{ $$ = node($1, Node_mod, $3); }
| simp_exp '+' simp_exp
{ $$ = node($1, Node_plus, $3); }
| simp_exp '-' simp_exp
{ $$ = node($1, Node_minus, $3); }
| variable INCREMENT
{ $$ = node($1, Node_postincrement, (NODE *) NULL); }
| variable DECREMENT
{ $$ = node($1, Node_postdecrement, (NODE *) NULL); }
;
non_post_simp_exp
: '!' simp_exp %prec UNARY
{ $$ = node($2, Node_not, (NODE *) NULL); }
| '(' exp r_paren
{ $$ = $2; }
| LEX_BUILTIN
'(' opt_expression_list r_paren
{ $$ = snode($3, Node_builtin, (int) $1); }
| LEX_LENGTH '(' opt_expression_list r_paren
{ $$ = snode($3, Node_builtin, (int) $1); }
| LEX_LENGTH
{
if (do_lint)
lintwarn(_("call of `length' without parentheses is not portable"));
$$ = snode((NODE *) NULL, Node_builtin, (int) $1);
if (do_posix)
warning(_("call of `length' without parentheses is deprecated by POSIX"));
}
| FUNC_CALL '(' opt_expression_list r_paren
{
$$ = node($3, Node_func_call, make_string($1, strlen($1)));
func_use($1, FUNC_USE);
param_sanity($3);
free($1);
}
| variable
| INCREMENT variable
{ $$ = node($2, Node_preincrement, (NODE *) NULL); }
| DECREMENT variable
{ $$ = node($2, Node_predecrement, (NODE *) NULL); }
| YNUMBER
{ $$ = $1; }
| YSTRING
{ $$ = $1; }
| '-' simp_exp %prec UNARY
{
if ($2->type == Node_val) {
$2->numbr = -(force_number($2));
$$ = $2;
} else
$$ = node($2, Node_unary_minus, (NODE *) NULL);
}
| '+' simp_exp %prec UNARY
{
/*
* was: $$ = $2
* POSIX semantics: force a conversion to numeric type
*/
$$ = node (make_number(0.0), Node_plus, $2);
}
;
opt_variable
: /* empty */
{ $$ = NULL; }
| variable
{ $$ = $1; }
;
variable
: NAME
{ $$ = variable($1, CAN_FREE, Node_var); }
| NAME '[' expression_list ']'
{
if ($3 == NULL) {
fatal(_("invalid subscript expression"));
} else if ($3->rnode == NULL) {
$$ = node(variable($1, CAN_FREE, Node_var_array), Node_subscript, $3->lnode);
freenode($3);
} else
$$ = node(variable($1, CAN_FREE, Node_var_array), Node_subscript, $3);
}
| '$' non_post_simp_exp
{ $$ = node($2, Node_field_spec, (NODE *) NULL); }
;
l_brace
: '{' opt_nls
;
r_brace
: '}' opt_nls { yyerrok; }
;
r_paren
: ')' { yyerrok; }
;
opt_semi
: /* empty */
| semi
;
semi
: ';' { yyerrok; want_assign = FALSE; }
;
comma : ',' opt_nls { yyerrok; }
;
%%
struct token {
const char *operator; /* text to match */
NODETYPE value; /* node type */
int class; /* lexical class */
unsigned flags; /* # of args. allowed and compatability */
# define ARGS 0xFF /* 0, 1, 2, 3 args allowed (any combination */
# define A(n) (1<<(n))
# define VERSION_MASK 0xFF00 /* old awk is zero */
# define NOT_OLD 0x0100 /* feature not in old awk */
# define NOT_POSIX 0x0200 /* feature not in POSIX */
# define GAWKX 0x0400 /* gawk extension */
# define RESX 0x0800 /* Bell Labs Research extension */
NODE *(*ptr)(); /* function that implements this keyword */
};
/* Tokentab is sorted ascii ascending order, so it can be binary searched. */
/* Function pointers come from declarations in awk.h. */
static struct token tokentab[] = {
{"BEGIN", Node_illegal, LEX_BEGIN, 0, 0},
{"END", Node_illegal, LEX_END, 0, 0},
#ifdef ARRAYDEBUG
{"adump", Node_builtin, LEX_BUILTIN, GAWKX|A(1), do_adump},
#endif
{"and", Node_builtin, LEX_BUILTIN, GAWKX|A(2), do_and},
{"asort", Node_builtin, LEX_BUILTIN, GAWKX|A(1)|A(2), do_asort},
{"atan2", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2), do_atan2},
{"bindtextdomain", Node_builtin, LEX_BUILTIN, GAWKX|A(1)|A(2), do_bindtextdomain},
{"break", Node_K_break, LEX_BREAK, 0, 0},
{"close", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1)|A(2), do_close},
{"compl", Node_builtin, LEX_BUILTIN, GAWKX|A(1), do_compl},
{"continue", Node_K_continue, LEX_CONTINUE, 0, 0},
{"cos", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_cos},
{"dcgettext", Node_builtin, LEX_BUILTIN, GAWKX|A(1)|A(2)|A(3), do_dcgettext},
{"delete", Node_K_delete, LEX_DELETE, NOT_OLD, 0},
{"do", Node_K_do, LEX_DO, NOT_OLD, 0},
{"else", Node_illegal, LEX_ELSE, 0, 0},
{"exit", Node_K_exit, LEX_EXIT, 0, 0},
{"exp", Node_builtin, LEX_BUILTIN, A(1), do_exp},
{"extension", Node_builtin, LEX_BUILTIN, GAWKX|A(2), do_ext},
{"fflush", Node_builtin, LEX_BUILTIN, RESX|A(0)|A(1), do_fflush},
{"for", Node_K_for, LEX_FOR, 0, 0},
{"func", Node_K_function, LEX_FUNCTION, NOT_POSIX|NOT_OLD, 0},
{"function", Node_K_function, LEX_FUNCTION, NOT_OLD, 0},
{"gensub", Node_builtin, LEX_BUILTIN, GAWKX|A(3)|A(4), do_gensub},
{"getline", Node_K_getline, LEX_GETLINE, NOT_OLD, 0},
{"gsub", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2)|A(3), do_gsub},
{"if", Node_K_if, LEX_IF, 0, 0},
{"in", Node_illegal, LEX_IN, 0, 0},
{"index", Node_builtin, LEX_BUILTIN, A(2), do_index},
{"int", Node_builtin, LEX_BUILTIN, A(1), do_int},
{"length", Node_builtin, LEX_LENGTH, A(0)|A(1), do_length},
{"log", Node_builtin, LEX_BUILTIN, A(1), do_log},
{"lshift", Node_builtin, LEX_BUILTIN, GAWKX|A(2), do_lshift},
{"match", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2)|A(3), do_match},
{"mktime", Node_builtin, LEX_BUILTIN, GAWKX|A(1), do_mktime},
{"next", Node_K_next, LEX_NEXT, 0, 0},
{"nextfile", Node_K_nextfile, LEX_NEXTFILE, GAWKX, 0},
{"or", Node_builtin, LEX_BUILTIN, GAWKX|A(2), do_or},
{"print", Node_K_print, LEX_PRINT, 0, 0},
{"printf", Node_K_printf, LEX_PRINTF, 0, 0},
{"rand", Node_builtin, LEX_BUILTIN, NOT_OLD|A(0), do_rand},
{"return", Node_K_return, LEX_RETURN, NOT_OLD, 0},
{"rshift", Node_builtin, LEX_BUILTIN, GAWKX|A(2), do_rshift},
{"sin", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_sin},
{"split", Node_builtin, LEX_BUILTIN, A(2)|A(3), do_split},
{"sprintf", Node_builtin, LEX_BUILTIN, 0, do_sprintf},
{"sqrt", Node_builtin, LEX_BUILTIN, A(1), do_sqrt},
{"srand", Node_builtin, LEX_BUILTIN, NOT_OLD|A(0)|A(1), do_srand},
#if defined(GAWKDEBUG) || defined(ARRAYDEBUG) /* || ... */
{"stopme", Node_builtin, LEX_BUILTIN, GAWKX|A(0), stopme},
#endif
{"strftime", Node_builtin, LEX_BUILTIN, GAWKX|A(0)|A(1)|A(2), do_strftime},
{"strtonum", Node_builtin, LEX_BUILTIN, GAWKX|A(1), do_strtonum},
{"sub", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2)|A(3), do_sub},
{"substr", Node_builtin, LEX_BUILTIN, A(2)|A(3), do_substr},
{"system", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_system},
{"systime", Node_builtin, LEX_BUILTIN, GAWKX|A(0), do_systime},
{"tolower", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_tolower},
{"toupper", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_toupper},
{"while", Node_K_while, LEX_WHILE, 0, 0},
{"xor", Node_builtin, LEX_BUILTIN, GAWKX|A(2), do_xor},
};
/* getfname --- return name of a builtin function (for pretty printing) */
const char *
getfname(register NODE *(*fptr)())
{
register int i, j;
j = sizeof(tokentab) / sizeof(tokentab[0]);
/* linear search, no other way to do it */
for (i = 0; i < j; i++)
if (tokentab[i].ptr == fptr)
return tokentab[i].operator;
fatal(_("fptr %x not in tokentab\n"), fptr);
return NULL; /* to stop warnings */
}
/* yyerror --- print a syntax error message, show where */
/*
* Function identifier purposely indented to avoid mangling
* by ansi2knr. Sigh.
*/
static void
#if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
yyerror(const char *m, ...)
#else
/* VARARGS0 */
yyerror(va_alist)
va_dcl
#endif
{
va_list args;
const char *mesg = NULL;
register char *bp, *cp;
char *scan;
char buf[120];
static char end_of_file_line[] = "(END OF FILE)";
errcount++;
/* Find the current line in the input file */
if (lexptr && lexeme) {
if (thisline == NULL) {
cp = lexeme;
if (*cp == '\n') {
cp--;
mesg = _("unexpected newline");
}
for (; cp != lexptr_begin && *cp != '\n'; --cp)
continue;
if (*cp == '\n')
cp++;
thisline = cp;
}
/* NL isn't guaranteed */
bp = lexeme;
while (bp < lexend && *bp && *bp != '\n')
bp++;
} else {
thisline = end_of_file_line;
bp = thisline + strlen(thisline);
}
msg("%.*s", (int) (bp - thisline), thisline);
bp = buf;
cp = buf + sizeof(buf) - 24; /* 24 more than longest msg. input */
if (lexptr != NULL) {
scan = thisline;
while (bp < cp && scan < lexeme)
if (*scan++ == '\t')
*bp++ = '\t';
else
*bp++ = ' ';
*bp++ = '^';
*bp++ = ' ';
}
#if defined(HAVE_STDARG_H) && defined(__STDC__) && __STDC__
va_start(args, m);
if (mesg == NULL)
mesg = m;
#else
va_start(args);
if (mesg == NULL)
mesg = va_arg(args, char *);
#endif
strcpy(bp, mesg);
err("", buf, args);
va_end(args);
}
/* get_src_buf --- read the next buffer of source program */
static char *
get_src_buf()
{
static int samefile = FALSE;
static int nextfile = 0;
static char *buf = NULL;
static int fd;
int n;
register char *scan;
static int len = 0;
static int did_newline = FALSE;
int newfile;
struct stat sbuf;
# define SLOP 128 /* enough space to hold most source lines */
again:
newfile = FALSE;
if (nextfile > numfiles)
return NULL;
if (srcfiles[nextfile].stype == CMDLINE) {
if (len == 0) {
len = strlen(srcfiles[nextfile].val);
if (len == 0) {
/*
* Yet Another Special case:
* gawk '' /path/name
* Sigh.
*/
static int warned = FALSE;
if (do_lint && ! warned) {
warned = TRUE;
lintwarn(_("empty program text on command line"));
}
++nextfile;
goto again;
}
sourceline = 1;
lexptr = lexptr_begin = srcfiles[nextfile].val;
lexend = lexptr + len;
} else if (! did_newline && *(lexptr-1) != '\n') {
/*
* The following goop is to ensure that the source
* ends with a newline and that the entire current
* line is available for error messages.
*/
int offset;
did_newline = TRUE;
offset = lexptr - lexeme;
for (scan = lexeme; scan > lexptr_begin; scan--)
if (*scan == '\n') {
scan++;
break;
}
len = lexptr - scan;
emalloc(buf, char *, len+1, "get_src_buf");
memcpy(buf, scan, len);
thisline = buf;
lexptr = buf + len;
*lexptr = '\n';
lexeme = lexptr - offset;
lexptr_begin = buf;
lexend = lexptr + 1;
} else {
len = 0;
lexeme = lexptr = lexptr_begin = NULL;
}
if (lexptr == NULL && ++nextfile <= numfiles)
goto again;
return lexptr;
}
if (! samefile) {
source = srcfiles[nextfile].val;
if (source == NULL) {
if (buf != NULL) {
free(buf);
buf = NULL;
}
len = 0;
return lexeme = lexptr = lexptr_begin = NULL;
}
fd = pathopen(source);
if (fd <= INVALID_HANDLE) {
char *in;
/* suppress file name and line no. in error mesg */
in = source;
source = NULL;
fatal(_("can't open source file `%s' for reading (%s)"),
in, strerror(errno));
}
len = optimal_bufsize(fd, & sbuf);
newfile = TRUE;
if (buf != NULL)
free(buf);
emalloc(buf, char *, len + SLOP, "get_src_buf");
lexptr_begin = buf + SLOP;
samefile = TRUE;
sourceline = 1;
} else {
/*
* Here, we retain the current source line (up to length SLOP)
* in the beginning of the buffer that was overallocated above
*/
int offset;
int linelen;
offset = lexptr - lexeme;
for (scan = lexeme; scan > lexptr_begin; scan--)
if (*scan == '\n') {
scan++;
break;
}
linelen = lexptr - scan;
if (linelen > SLOP)
linelen = SLOP;
thisline = buf + SLOP - linelen;
memcpy(thisline, scan, linelen);
lexeme = buf + SLOP - offset;
lexptr_begin = thisline;
}
n = read(fd, buf + SLOP, len);
if (n == -1)
fatal(_("can't read sourcefile `%s' (%s)"),
source, strerror(errno));
if (n == 0) {
if (newfile) {
static int warned = FALSE;
if (do_lint && ! warned) {
warned = TRUE;
lintwarn(_("source file `%s' is empty"), source);
}
}
if (fd != fileno(stdin)) /* safety */
close(fd);
samefile = FALSE;
nextfile++;
if (lexeme)
*lexeme = '\0';
len = 0;
goto again;
}
lexptr = buf + SLOP;
lexend = lexptr + n;
return buf;
}
/* tokadd --- add a character to the token buffer */
#define tokadd(x) (*tok++ = (x), tok == tokend ? tokexpand() : tok)
/* tokexpand --- grow the token buffer */
char *
tokexpand()
{
static int toksize = 60;
int tokoffset;
tokoffset = tok - tokstart;
toksize *= 2;
if (tokstart != NULL)
erealloc(tokstart, char *, toksize, "tokexpand");
else
emalloc(tokstart, char *, toksize, "tokexpand");
tokend = tokstart + toksize;
tok = tokstart + tokoffset;
return tok;
}
/* nextc --- get the next input character */
#if GAWKDEBUG
int
nextc()
{
int c;
if (lexptr && lexptr < lexend)
c = (int) (unsigned char) *lexptr++;
else if (get_src_buf())
c = (int) (unsigned char) *lexptr++;
else
c = EOF;
return c;
}
#else
#define nextc() ((lexptr && lexptr < lexend) ? \
((int) (unsigned char) *lexptr++) : \
(get_src_buf() ? ((int) (unsigned char) *lexptr++) : EOF) \
)
#endif
/* pushback --- push a character back on the input */
#define pushback() (lexptr && lexptr > lexptr_begin ? lexptr-- : lexptr)
/* allow_newline --- allow newline after &&, ||, ? and : */
static void
allow_newline()
{
int c;
for (;;) {
c = nextc();
if (c == EOF)
break;
if (c == '#') {
while ((c = nextc()) != '\n' && c != EOF)
continue;
if (c == EOF)
break;
}
if (c == '\n')
sourceline++;
if (! ISSPACE(c)) {
pushback();
break;
}
}
}
/* yylex --- Read the input and turn it into tokens. */
static int
yylex()
{
register int c;
int seen_e = FALSE; /* These are for numbers */
int seen_point = FALSE;
int esc_seen; /* for literal strings */
int low, mid, high;
static int did_newline = FALSE;
char *tokkey;
static int lasttok = 0, eof_warned = FALSE;
int inhex = FALSE;
int intlstr = FALSE;
if (nextc() == EOF) {
if (lasttok != NEWLINE) {
lasttok = NEWLINE;
if (do_lint && ! eof_warned) {
lintwarn(_("source file does not end in newline"));
eof_warned = TRUE;
}
return NEWLINE; /* fake it */
}
return 0;
}
pushback();
#ifdef OS2
/*
* added for OS/2's extproc feature of cmd.exe
* (like #! in BSD sh)
*/
if (strncasecmp(lexptr, "extproc ", 8) == 0) {
while (*lexptr && *lexptr != '\n')
lexptr++;
}
#endif
lexeme = lexptr;
thisline = NULL;
if (want_regexp) {
int in_brack = 0; /* count brackets, [[:alnum:]] allowed */
/*
* Counting brackets is non-trivial. [[] is ok,
* and so is [\]], with a point being that /[/]/ as a regexp
* constant has to work.
*
* Do not count [ or ] if either one is preceded by a \.
* A `[' should be counted if
* a) it is the first one so far (in_brack == 0)
* b) it is the `[' in `[:'
* A ']' should be counted if not preceded by a \, since
* it is either closing `:]' or just a plain list.
* According to POSIX, []] is how you put a ] into a set.
* Try to handle that too.
*
* The code for \ handles \[ and \].
*/
want_regexp = FALSE;
tok = tokstart;
for (;;) {
c = nextc();
switch (c) {
case '[':
/* one day check for `.' and `=' too */
if (nextc() == ':' || in_brack == 0)
in_brack++;
pushback();
break;
case ']':
if (tokstart[0] == '['
&& (tok == tokstart + 1
|| (tok == tokstart + 2
&& tokstart[1] == '^')))
/* do nothing */;
else
in_brack--;
break;
case '\\':
if ((c = nextc()) == EOF) {
yyerror(_("unterminated regexp ends with `\\' at end of file"));
return lasttok = REGEXP; /* kludge */
} else if (c == '\n') {
sourceline++;
continue;
} else {
tokadd('\\');
tokadd(c);
continue;
}
break;
case '/': /* end of the regexp */
if (in_brack > 0)
break;
pushback();
tokadd('\0');
yylval.sval = tokstart;
return lasttok = REGEXP;
case '\n':
pushback();
yyerror(_("unterminated regexp"));
return lasttok = REGEXP; /* kludge */
case EOF:
yyerror(_("unterminated regexp at end of file"));
return lasttok = REGEXP; /* kludge */
}
tokadd(c);
}
}
retry:
while ((c = nextc()) == ' ' || c == '\t')
continue;
lexeme = lexptr ? lexptr - 1 : lexptr;
thisline = NULL;
tok = tokstart;
yylval.nodetypeval = Node_illegal;
switch (c) {
case EOF:
if (lasttok != NEWLINE) {
lasttok = NEWLINE;
if (do_lint && ! eof_warned) {
lintwarn(_("source file does not end in newline"));
eof_warned = TRUE;
}
return NEWLINE; /* fake it */
}
return 0;
case '\n':
sourceline++;
return lasttok = NEWLINE;
case '#': /* it's a comment */
while ((c = nextc()) != '\n') {
if (c == EOF) {
if (lasttok != NEWLINE) {
lasttok = NEWLINE;
if (do_lint && ! eof_warned) {
lintwarn(
_("source file does not end in newline"));
eof_warned = TRUE;
}
return NEWLINE; /* fake it */
}
return 0;
}
}
sourceline++;
return lasttok = NEWLINE;
case '\\':
#ifdef RELAXED_CONTINUATION
/*
* This code puports to allow comments and/or whitespace
* after the `\' at the end of a line used for continuation.
* Use it at your own risk. We think it's a bad idea, which
* is why it's not on by default.
*/
if (! do_traditional) {
/* strip trailing white-space and/or comment */
while ((c = nextc()) == ' ' || c == '\t')
continue;
if (c == '#') {
if (do_lint)
lintwarn(
_("use of `\\ #...' line continuation is not portable"));
while ((c = nextc()) != '\n')
if (c == EOF)
break;
}
pushback();
}
#endif /* RELAXED_CONTINUATION */
if (nextc() == '\n') {
sourceline++;
goto retry;
} else {
yyerror(_("backslash not last character on line"));
exit(1);
}
break;
case '$':
want_assign = TRUE;
return lasttok = '$';
case ':':
case '?':
if (! do_posix)
allow_newline();
return lasttok = c;
case ')':
case '(':
case ';':
case '{':
case ',':
want_assign = FALSE;
/* fall through */
case '[':
case ']':
return lasttok = c;
case '*':
if ((c = nextc()) == '=') {
yylval.nodetypeval = Node_assign_times;
return lasttok = ASSIGNOP;
} else if (do_posix) {
pushback();
return lasttok = '*';
} else if (c == '*') {
/* make ** and **= aliases for ^ and ^= */
static int did_warn_op = FALSE, did_warn_assgn = FALSE;
if (nextc() == '=') {
if (! did_warn_assgn) {
did_warn_assgn = TRUE;
if (do_lint)
lintwarn(_("POSIX does not allow operator `**='"));
if (do_lint_old)
warning(_("old awk does not support operator `**='"));
}
yylval.nodetypeval = Node_assign_exp;
return ASSIGNOP;
} else {
pushback();
if (! did_warn_op) {
did_warn_op = TRUE;
if (do_lint)
lintwarn(_("POSIX does not allow operator `**'"));
if (do_lint_old)
warning(_("old awk does not support operator `**'"));
}
return lasttok = '^';
}
}
pushback();
return lasttok = '*';
case '/':
if (want_assign) {
if (nextc() == '=') {
yylval.nodetypeval = Node_assign_quotient;
return lasttok = ASSIGNOP;
}
pushback();
}
return lasttok = '/';
case '%':
if (nextc() == '=') {
yylval.nodetypeval = Node_assign_mod;
return lasttok = ASSIGNOP;
}
pushback();
return lasttok = '%';
case '^':
{
static int did_warn_op = FALSE, did_warn_assgn = FALSE;
if (nextc() == '=') {
if (do_lint_old && ! did_warn_assgn) {
did_warn_assgn = TRUE;
warning(_("operator `^=' is not supported in old awk"));
}
yylval.nodetypeval = Node_assign_exp;
return lasttok = ASSIGNOP;
}
pushback();
if (do_lint_old && ! did_warn_op) {
did_warn_op = TRUE;
warning(_("operator `^' is not supported in old awk"));
}
return lasttok = '^';
}
case '+':
if ((c = nextc()) == '=') {
yylval.nodetypeval = Node_assign_plus;
return lasttok = ASSIGNOP;
}
if (c == '+')
return lasttok = INCREMENT;
pushback();
return lasttok = '+';
case '!':
if ((c = nextc()) == '=') {
yylval.nodetypeval = Node_notequal;
return lasttok = RELOP;
}
if (c == '~') {
yylval.nodetypeval = Node_nomatch;
want_assign = FALSE;
return lasttok = MATCHOP;
}
pushback();
return lasttok = '!';
case '<':
if (nextc() == '=') {
yylval.nodetypeval = Node_leq;
return lasttok = RELOP;
}
yylval.nodetypeval = Node_less;
pushback();
return lasttok = '<';
case '=':
if (nextc() == '=') {
yylval.nodetypeval = Node_equal;
return lasttok = RELOP;
}
yylval.nodetypeval = Node_assign;
pushback();
return lasttok = ASSIGNOP;
case '>':
if ((c = nextc()) == '=') {
yylval.nodetypeval = Node_geq;
return lasttok = RELOP;
} else if (c == '>') {
yylval.nodetypeval = Node_redirect_append;
return lasttok = APPEND_OP;
}
yylval.nodetypeval = Node_greater;
pushback();
return lasttok = '>';
case '~':
yylval.nodetypeval = Node_match;
want_assign = FALSE;
return lasttok = MATCHOP;
case '}':
/*
* Added did newline stuff. Easier than
* hacking the grammar.
*/
if (did_newline) {
did_newline = FALSE;
return lasttok = c;
}
did_newline++;
--lexptr; /* pick up } next time */
return lasttok = NEWLINE;
case '"':
string:
esc_seen = FALSE;
while ((c = nextc()) != '"') {
if (c == '\n') {
pushback();
yyerror(_("unterminated string"));
exit(1);
}
if (c == '\\') {
c = nextc();
if (c == '\n') {
sourceline++;
continue;
}
esc_seen = TRUE;
tokadd('\\');
}
if (c == EOF) {
pushback();
yyerror(_("unterminated string"));
exit(1);
}
tokadd(c);
}
yylval.nodeval = make_str_node(tokstart,
tok - tokstart, esc_seen ? SCAN : 0);
yylval.nodeval->flags |= PERM;
if (intlstr) {
yylval.nodeval->flags |= INTLSTR;
intlstr = FALSE;
if (do_intl)
dumpintlstr(yylval.nodeval->stptr,
yylval.nodeval->stlen);
}
return lasttok = YSTRING;
case '-':
if ((c = nextc()) == '=') {
yylval.nodetypeval = Node_assign_minus;
return lasttok = ASSIGNOP;
}
if (c == '-')
return lasttok = DECREMENT;
pushback();
return lasttok = '-';
case '.':
c = nextc();
pushback();
if (! ISDIGIT(c))
return lasttok = '.';
else
c = '.';
/* FALL THROUGH */
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* It's a number */
for (;;) {
int gotnumber = FALSE;
tokadd(c);
switch (c) {
case 'x':
case 'X':
if (do_traditional)
goto done;
if (tok == tokstart + 2)
inhex = TRUE;
break;
case '.':
if (seen_point) {
gotnumber = TRUE;
break;
}
seen_point = TRUE;
break;
case 'e':
case 'E':
if (inhex)
break;
if (seen_e) {
gotnumber = TRUE;
break;
}
seen_e = TRUE;
if ((c = nextc()) == '-' || c == '+')
tokadd(c);
else
pushback();
break;
case 'a':
case 'A':
case 'b':
case 'B':
case 'c':
case 'C':
case 'D':
case 'd':
case 'f':
case 'F':
if (do_traditional || ! inhex)
goto done;
/* fall through */
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
break;
default:
done:
gotnumber = TRUE;
}
if (gotnumber)
break;
c = nextc();
}
if (c != EOF)
pushback();
else if (do_lint && ! eof_warned) {
lintwarn(_("source file does not end in newline"));
eof_warned = TRUE;
}
tokadd('\0');
if (! do_traditional && isnondecimal(tokstart))
yylval.nodeval = make_number(nondec2awknum(tokstart, strlen(tokstart)));
else
yylval.nodeval = make_number(atof(tokstart));
yylval.nodeval->flags |= PERM;
return lasttok = YNUMBER;
case '&':
if ((c = nextc()) == '&') {
yylval.nodetypeval = Node_and;
allow_newline();
want_assign = FALSE;
return lasttok = LEX_AND;
}
pushback();
return lasttok = '&';
case '|':
if ((c = nextc()) == '|') {
yylval.nodetypeval = Node_or;
allow_newline();
want_assign = FALSE;
return lasttok = LEX_OR;
} else if (! do_traditional && c == '&') {
yylval.nodetypeval = Node_redirect_twoway;
want_assign = FALSE;
return lasttok = TWOWAYIO;
}
pushback();
return lasttok = '|';
}
if (c != '_' && ! ISALPHA(c)) {
yyerror(_("invalid char '%c' in expression"), c);
exit(1);
}
if (! do_traditional && c == '_') {
if ((c = nextc()) == '"') {
intlstr = TRUE;
goto string;
}
pushback();
c = '_';
}
/* it's some type of name-type-thing. Find its length. */
tok = tokstart;
while (is_identchar(c)) {
tokadd(c);
c = nextc();
}
tokadd('\0');
emalloc(tokkey, char *, tok - tokstart, "yylex");
memcpy(tokkey, tokstart, tok - tokstart);
if (c != EOF)
pushback();
else if (do_lint && ! eof_warned) {
lintwarn(_("source file does not end in newline"));
eof_warned = TRUE;
}
/* See if it is a special token. */
low = 0;
high = (sizeof(tokentab) / sizeof(tokentab[0])) - 1;
while (low <= high) {
int i;
mid = (low + high) / 2;
c = *tokstart - tokentab[mid].operator[0];
i = c ? c : strcmp(tokstart, tokentab[mid].operator);
if (i < 0) /* token < mid */
high = mid - 1;
else if (i > 0) /* token > mid */
low = mid + 1;
else {
if (do_lint) {
if (tokentab[mid].flags & GAWKX)
lintwarn(_("`%s' is a gawk extension"),
tokentab[mid].operator);
if (tokentab[mid].flags & RESX)
lintwarn(_("`%s' is a Bell Labs extension"),
tokentab[mid].operator);
if (tokentab[mid].flags & NOT_POSIX)
lintwarn(_("POSIX does not allow `%s'"),
tokentab[mid].operator);
}
if (do_lint_old && (tokentab[mid].flags & NOT_OLD))
warning(_("`%s' is not supported in old awk"),
tokentab[mid].operator);
if ((do_traditional && (tokentab[mid].flags & GAWKX))
|| (do_posix && (tokentab[mid].flags & NOT_POSIX)))
break;
if (tokentab[mid].class == LEX_BUILTIN
|| tokentab[mid].class == LEX_LENGTH
)
yylval.lval = mid;
else
yylval.nodetypeval = tokentab[mid].value;
free(tokkey);
return lasttok = tokentab[mid].class;
}
}
yylval.sval = tokkey;
if (*lexptr == '(')
return lasttok = FUNC_CALL;
else {
static short goto_warned = FALSE;
want_assign = TRUE;
#define SMART_ALECK 1
if (SMART_ALECK && do_lint
&& ! goto_warned && strcasecmp(tokkey, "goto") == 0) {
goto_warned = TRUE;
lintwarn(_("`goto' considered harmful!\n"));
}
return lasttok = NAME;
}
}
/* node_common --- common code for allocating a new node */
static NODE *
node_common(NODETYPE op)
{
register NODE *r;
getnode(r);
r->type = op;
r->flags = MALLOC;
if (r->type == Node_var)
r->flags |= UNINITIALIZED;
/* if lookahead is NL, lineno is 1 too high */
if (lexeme && *lexeme == '\n')
r->source_line = sourceline - 1;
else
r->source_line = sourceline;
r->source_file = source;
return r;
}
/* node --- allocates a node with defined lnode and rnode. */
NODE *
node(NODE *left, NODETYPE op, NODE *right)
{
register NODE *r;
r = node_common(op);
r->lnode = left;
r->rnode = right;
return r;
}
/* snode --- allocate a node with defined subnode and proc for builtin
functions. Checks for arg. count and supplies defaults where
possible. */
static NODE *
snode(NODE *subn, NODETYPE op, int idx)
{
register NODE *r;
register NODE *n;
int nexp = 0;
int args_allowed;
r = node_common(op);
/* traverse expression list to see how many args. given */
for (n = subn; n != NULL; n = n->rnode) {
nexp++;
if (nexp > 3)
break;
}
/* check against how many args. are allowed for this builtin */
args_allowed = tokentab[idx].flags & ARGS;
if (args_allowed && (args_allowed & A(nexp)) == 0)
fatal(_("%d is invalid as number of arguments for %s"),
nexp, tokentab[idx].operator);
r->proc = tokentab[idx].ptr;
/* special case processing for a few builtins */
if (nexp == 0 && r->proc == do_length) {
subn = node(node(make_number(0.0), Node_field_spec, (NODE *) NULL),
Node_expression_list,
(NODE *) NULL);
} else if (r->proc == do_match) {
static short warned = FALSE;
if (subn->rnode->lnode->type != Node_regex)
subn->rnode->lnode = mk_rexp(subn->rnode->lnode);
if (subn->rnode->rnode != NULL) { /* 3rd argument there */
if (do_lint && ! warned) {
warned = TRUE;
lintwarn(_("match: third argument is a gawk extension"));
}
if (do_traditional)
fatal(_("match: third argument is a gawk extension"));
}
} else if (r->proc == do_sub || r->proc == do_gsub) {
if (subn->lnode->type != Node_regex)
subn->lnode = mk_rexp(subn->lnode);
if (nexp == 2)
append_right(subn, node(node(make_number(0.0),
Node_field_spec,
(NODE *) NULL),
Node_expression_list,
(NODE *) NULL));
else if (subn->rnode->rnode->lnode->type == Node_val) {
if (do_lint) {
char *f;
f = (r->proc == do_sub) ? "sub" : "gsub";
lintwarn(_("%s: string literal as last arg of substitute has no effect"), f);
}
} else if (! isassignable(subn->rnode->rnode->lnode)) {
if (r->proc == do_sub)
yyerror(_("sub third parameter is not a changeable object"));
else
yyerror(_("gsub third parameter is not a changeable object"));
}
} else if (r->proc == do_gensub) {
if (subn->lnode->type != Node_regex)
subn->lnode = mk_rexp(subn->lnode);
if (nexp == 3)
append_right(subn, node(node(make_number(0.0),
Node_field_spec,
(NODE *) NULL),
Node_expression_list,
(NODE *) NULL));
} else if (r->proc == do_split) {
if (nexp == 2)
append_right(subn,
node(FS_node, Node_expression_list, (NODE *) NULL));
n = subn->rnode->rnode->lnode;
if (n->type != Node_regex)
subn->rnode->rnode->lnode = mk_rexp(n);
if (nexp == 2)
subn->rnode->rnode->lnode->re_flags |= FS_DFLT;
} else if (r->proc == do_close) {
static short warned = FALSE;
if ( nexp == 2) {
if (do_lint && nexp == 2 && ! warned) {
warned = TRUE;
lintwarn(_("close: second argument is a gawk extension"));
}
if (do_traditional)
fatal(_("close: second argument is a gawk extension"));
}
} else if (do_intl /* --gen-po */
&& r->proc == do_dcgettext /* dcgettext(...) */
&& subn->lnode->type == Node_val /* 1st arg is constant */
&& (subn->lnode->flags & STR) != 0) { /* it's a string constant */
/* ala xgettext, dcgettext("some string" ...) dumps the string */
NODE *str = subn->lnode;
if ((str->flags & INTLSTR) != 0)
warning(_("use of dcgettext(_\"...\") is incorrect: remove leading underscore"));
/* don't dump it, the lexer already did */
else
dumpintlstr(str->stptr, str->stlen);
}
r->subnode = subn;
if (r->proc == do_sprintf) {
count_args(r);
r->lnode->printf_count = r->printf_count; /* hack */
}
return r;
}
/*
* mkrangenode:
* This allocates a Node_line_range node with defined condpair and
* zeroes the trigger word to avoid the temptation of assuming that calling
* 'node( foo, Node_line_range, 0)' will properly initialize 'triggered'.
* Otherwise like node().
*/
static NODE *
mkrangenode(NODE *cpair)
{
register NODE *r;
getnode(r);
r->type = Node_line_range;
r->condpair = cpair;
r->triggered = FALSE;
return r;
}
/* make_for_loop --- build a for loop */
static NODE *
make_for_loop(NODE *init, NODE *cond, NODE *incr)
{
register FOR_LOOP_HEADER *r;
NODE *n;
emalloc(r, FOR_LOOP_HEADER *, sizeof(FOR_LOOP_HEADER), "make_for_loop");
getnode(n);
n->type = Node_illegal;
r->init = init;
r->cond = cond;
r->incr = incr;
n->sub.nodep.r.hd = r;
return n;
}
/* dup_parms --- return TRUE if there are duplicate parameters */
static int
dup_parms(NODE *func)
{
register NODE *np;
char *fname, **names;
int count, i, j, dups;
NODE *params;
if (func == NULL) /* error earlier */
return TRUE;
fname = func->param;
count = func->param_cnt;
params = func->rnode;
if (count == 0) /* no args, no problem */
return FALSE;
if (params == NULL) /* error earlier */
return TRUE;
emalloc(names, char **, count * sizeof(char *), "dup_parms");
i = 0;
for (np = params; np != NULL; np = np->rnode) {
if (np->param == NULL) { /* error earlier, give up, go home */
free(names);
return TRUE;
}
names[i++] = np->param;
}
dups = 0;
for (i = 1; i < count; i++) {
for (j = 0; j < i; j++) {
if (strcmp(names[i], names[j]) == 0) {
dups++;
error(
_("function `%s': parameter #%d, `%s', duplicates parameter #%d"),
fname, i+1, names[j], j+1);
}
}
}
free(names);
return (dups > 0 ? TRUE : FALSE);
}
/* parms_shadow --- check if parameters shadow globals */
static void
parms_shadow(const char *fname, NODE *func)
{
int count, i;
if (fname == NULL || func == NULL) /* error earlier */
return;
count = func->lnode->param_cnt;
if (count == 0) /* no args, no problem */
return;
/*
* Use warning() and not lintwarn() so that can warn
* about all shadowed parameters.
*/
for (i = 0; i < count; i++) {
if (lookup(func->parmlist[i]) != NULL) {
warning(
_("function `%s': parameter `%s' shadows global variable"),
fname, func->parmlist[i]);
}
}
}
/*
* install:
* Install a name in the symbol table, even if it is already there.
* Caller must check against redefinition if that is desired.
*/
NODE *
install(char *name, NODE *value)
{
register NODE *hp;
register size_t len;
register int bucket;
var_count++;
len = strlen(name);
bucket = hash(name, len, (unsigned long) HASHSIZE);
getnode(hp);
hp->type = Node_hashnode;
hp->hnext = variables[bucket];
variables[bucket] = hp;
hp->hlength = len;
hp->hvalue = value;
hp->hname = name;
hp->hvalue->vname = name;
return hp->hvalue;
}
/* lookup --- find the most recent hash node for name installed by install */
NODE *
lookup(const char *name)
{
register NODE *bucket;
register size_t len;
len = strlen(name);
for (bucket = variables[hash(name, len, (unsigned long) HASHSIZE)];
bucket != NULL; bucket = bucket->hnext)
if (bucket->hlength == len && STREQN(bucket->hname, name, len))
return bucket->hvalue;
return NULL;
}
/* var_comp --- compare two variable names */
static int
var_comp(const void *v1, const void *v2)
{
NODE **npp1, **npp2;
NODE *n1, *n2;
int minlen;
npp1 = (NODE **) v1;
npp2 = (NODE **) v2;
n1 = *npp1;
n2 = *npp2;
if (n1->hlength > n2->hlength)
minlen = n1->hlength;
else
minlen = n2->hlength;
return strncmp(n1->hname, n2->hname, minlen);
}
/* valinfo --- dump var info */
static void
valinfo(NODE *n, FILE *fp)
{
if (n->flags & STRING) {
fprintf(fp, "string (");
pp_string_fp(fp, n->stptr, n->stlen, '"', FALSE);
fprintf(fp, ")\n");
} else if (n->flags & NUMBER)
fprintf(fp, "number (%.17g)\n", n->numbr);
else if (n->flags & STR) {
fprintf(fp, "string value (");
pp_string_fp(fp, n->stptr, n->stlen, '"', FALSE);
fprintf(fp, ")\n");
} else if (n->flags & NUM)
fprintf(fp, "number value (%.17g)\n", n->numbr);
else
fprintf(fp, "?? flags %s\n", flags2str(n->flags));
}
/* dump_vars --- dump the symbol table */
void
dump_vars(const char *fname)
{
int i, j;
NODE **table;
NODE *p;
FILE *fp;
emalloc(table, NODE **, var_count * sizeof(NODE *), "dump_vars");
if (fname == NULL)
fp = stderr;
else if ((fp = fopen(fname, "w")) == NULL) {
warning(_("could not open `%s' for writing (%s)"), fname, strerror(errno));
warning(_("sending profile to standard error"));
fp = stderr;
}
for (i = j = 0; i < HASHSIZE; i++)
for (p = variables[i]; p != NULL; p = p->hnext)
table[j++] = p;
assert(j == var_count);
/* Shazzam! */
qsort(table, j, sizeof(NODE *), var_comp);
for (i = 0; i < j; i++) {
p = table[i];
if (p->hvalue->type == Node_func)
continue;
fprintf(fp, "%.*s: ", (int) p->hlength, p->hname);
if (p->hvalue->type == Node_var_array)
fprintf(fp, "array, %ld elements\n", p->hvalue->table_size);
else if (p->hvalue->type == Node_var)
valinfo(p->hvalue->var_value, fp);
else {
NODE **lhs = get_lhs(p->hvalue, NULL, FALSE);
valinfo(*lhs, fp);
}
}
if (fp != stderr && fclose(fp) != 0)
warning(_("%s: close failed (%s)"), fname, strerror(errno));
free(table);
}
/* release_all_vars --- free all variable memory */
void
release_all_vars()
{
int i;
NODE *p, *next;
for (i = 0; i < HASHSIZE; i++)
for (p = variables[i]; p != NULL; p = next) {
next = p->hnext;
if (p->hvalue->type == Node_func)
continue;
else if (p->hvalue->type == Node_var_array)
assoc_clear(p->hvalue);
else if (p->hvalue->type == Node_var)
unref(p->hvalue->var_value);
else {
NODE **lhs = get_lhs(p->hvalue, NULL, FALSE);
unref((*lhs)->var_value);
}
unref(p);
}
}
/* finfo --- for use in comparison and sorting of function names */
struct finfo {
char *name;
size_t nlen;
NODE *func;
};
/* fcompare --- comparison function for qsort */
static int
fcompare(const void *p1, const void *p2)
{
struct finfo *f1, *f2;
int minlen;
f1 = (struct finfo *) p1;
f2 = (struct finfo *) p2;
if (f1->nlen > f2->nlen)
minlen = f2->nlen;
else
minlen = f1->nlen;
return strncmp(f1->name, f2->name, minlen);
}
/* dump_funcs --- print all functions */
void
dump_funcs()
{
int i, j;
NODE *p;
static struct finfo *tab = NULL;
if (func_count == 0)
return;
if (tab == NULL)
emalloc(tab, struct finfo *, func_count * sizeof(struct finfo), "dump_funcs");
for (i = j = 0; i < HASHSIZE; i++) {
for (p = variables[i]; p != NULL; p = p->hnext) {
if (p->hvalue->type == Node_func) {
tab[j].name = p->hname;
tab[j].nlen = p->hlength;
tab[j].func = p->hvalue;
j++;
}
}
}
assert(j == func_count);
/* Shazzam! */
qsort(tab, func_count, sizeof(struct finfo), fcompare);
for (i = 0; i < j; i++)
pp_func(tab[i].name, tab[i].nlen, tab[i].func);
free(tab);
}
/* shadow_funcs --- check all functions for parameters that shadow globals */
void
shadow_funcs()
{
int i, j;
NODE *p;
struct finfo *tab;
static int calls = 0;
if (func_count == 0)
return;
if (calls++ != 0)
fatal(_("shadow_funcs() called twice!"));
emalloc(tab, struct finfo *, func_count * sizeof(struct finfo), "shadow_funcs");
for (i = j = 0; i < HASHSIZE; i++) {
for (p = variables[i]; p != NULL; p = p->hnext) {
if (p->hvalue->type == Node_func) {
tab[j].name = p->hname;
tab[j].nlen = p->hlength;
tab[j].func = p->hvalue;
j++;
}
}
}
assert(j == func_count);
/* Shazzam! */
qsort(tab, func_count, sizeof(struct finfo), fcompare);
for (i = 0; i < j; i++)
parms_shadow(tab[i].name, tab[i].func);
free(tab);
}
/*
* append_right:
* Add new to the rightmost branch of LIST. This uses n^2 time, so we make
* a simple attempt at optimizing it.
*/
static NODE *
append_right(NODE *list, NODE *new)
{
register NODE *oldlist;
static NODE *savefront = NULL, *savetail = NULL;
if (list == NULL || new == NULL)
return list;
oldlist = list;
if (savefront == oldlist) {
savetail = savetail->rnode = new;
return oldlist;
} else
savefront = oldlist;
while (list->rnode != NULL)
list = list->rnode;
savetail = list->rnode = new;
return oldlist;
}
/*
* func_install:
* check if name is already installed; if so, it had better have Null value,
* in which case def is added as the value. Otherwise, install name with def
* as value.
*
* Extra work, build up and save a list of the parameter names in a table
* and hang it off params->parmlist. This is used to set the `vname' field
* of each function parameter during a function call. See eval.c.
*/
static void
func_install(NODE *params, NODE *def)
{
NODE *r, *n, *thisfunc;
char **pnames, *names, *sp;
size_t pcount = 0, space = 0;
int i;
/* check for function foo(foo) { ... }. bleah. */
for (n = params->rnode; n != NULL; n = n->rnode) {
if (strcmp(n->param, params->param) == 0)
fatal(_("function `%s': can't use function name as parameter name"),
params->param);
}
thisfunc = NULL; /* turn off warnings */
/* symbol table managment */
pop_var(params, FALSE);
r = lookup(params->param);
if (r != NULL) {
fatal(_("function name `%s' previously defined"), params->param);
} else {
thisfunc = node(params, Node_func, def);
(void) install(params->param, thisfunc);
}
/* figure out amount of space to allocate */
for (n = params->rnode; n != NULL; n = n->rnode) {
pcount++;
space += strlen(n->param) + 1;
}
/* allocate it and fill it in */
if (pcount != 0) {
emalloc(names, char *, space, "func_install");
emalloc(pnames, char **, pcount * sizeof(char *), "func_install");
sp = names;
for (i = 0, n = params->rnode; i < pcount; i++, n = n->rnode) {
pnames[i] = sp;
strcpy(sp, n->param);
sp += strlen(n->param) + 1;
}
thisfunc->parmlist = pnames;
} else {
thisfunc->parmlist = NULL;
}
/* remove params from symbol table */
pop_params(params->rnode);
/* update lint table info */
func_use(params->param, FUNC_DEFINE);
func_count++; /* used by profiling / pretty printer */
}
/* pop_var --- remove a variable from the symbol table */
static void
pop_var(NODE *np, int freeit)
{
register NODE *bucket, **save;
register size_t len;
char *name;
name = np->param;
len = strlen(name);
save = &(variables[hash(name, len, (unsigned long) HASHSIZE)]);
for (bucket = *save; bucket != NULL; bucket = bucket->hnext) {
if (len == bucket->hlength && STREQN(bucket->hname, name, len)) {
var_count--;
*save = bucket->hnext;
freenode(bucket);
if (freeit)
free(np->param);
return;
}
save = &(bucket->hnext);
}
}
/* pop_params --- remove list of function parameters from symbol table */
/*
* pop parameters out of the symbol table. do this in reverse order to
* avoid reading freed memory if there were duplicated parameters.
*/
static void
pop_params(NODE *params)
{
if (params == NULL)
return;
pop_params(params->rnode);
pop_var(params, TRUE);
}
/* make_param --- make NAME into a function parameter */
static NODE *
make_param(char *name)
{
NODE *r;
getnode(r);
r->type = Node_param_list;
r->rnode = NULL;
r->param = name;
r->param_cnt = param_counter++;
return (install(name, r));
}
static struct fdesc {
char *name;
short used;
short defined;
struct fdesc *next;
} *ftable[HASHSIZE];
/* func_use --- track uses and definitions of functions */
static void
func_use(char *name, enum defref how)
{
struct fdesc *fp;
int len;
int ind;
len = strlen(name);
ind = hash(name, len, HASHSIZE);
for (fp = ftable[ind]; fp != NULL; fp = fp->next) {
if (strcmp(fp->name, name) == 0) {
if (how == FUNC_DEFINE)
fp->defined++;
else
fp->used++;
return;
}
}
/* not in the table, fall through to allocate a new one */
emalloc(fp, struct fdesc *, sizeof(struct fdesc), "func_use");
memset(fp, '\0', sizeof(struct fdesc));
emalloc(fp->name, char *, len + 1, "func_use");
strcpy(fp->name, name);
if (how == FUNC_DEFINE)
fp->defined++;
else
fp->used++;
fp->next = ftable[ind];
ftable[ind] = fp;
}
/* check_funcs --- verify functions that are called but not defined */
static void
check_funcs()
{
struct fdesc *fp, *next;
int i;
for (i = 0; i < HASHSIZE; i++) {
for (fp = ftable[i]; fp != NULL; fp = fp->next) {
#ifdef REALLYMEAN
/* making this the default breaks old code. sigh. */
if (fp->defined == 0) {
error(
_("function `%s' called but never defined"), fp->name);
errcount++;
}
#else
if (do_lint && fp->defined == 0)
lintwarn(
_("function `%s' called but never defined"), fp->name);
#endif
if (do_lint && fp->used == 0) {
lintwarn(_("function `%s' defined but never called"),
fp->name);
}
}
}
/* now let's free all the memory */
for (i = 0; i < HASHSIZE; i++) {
for (fp = ftable[i]; fp != NULL; fp = next) {
next = fp->next;
free(fp->name);
free(fp);
}
}
}
/* param_sanity --- look for parameters that are regexp constants */
static void
param_sanity(NODE *arglist)
{
NODE *argp, *arg;
int i;
for (i = 1, argp = arglist; argp != NULL; argp = argp->rnode, i++) {
arg = argp->lnode;
if (arg->type == Node_regex)
warning(_("regexp constant for parameter #%d yields boolean value"), i);
}
}
/* variable --- make sure NAME is in the symbol table */
NODE *
variable(char *name, int can_free, NODETYPE type)
{
register NODE *r;
static int env_loaded = FALSE;
static int procinfo_loaded = FALSE;
if (! env_loaded && STREQ(name, "ENVIRON")) {
load_environ();
env_loaded = TRUE;
}
if (! do_traditional && ! procinfo_loaded && STREQ(name, "PROCINFO")) {
load_procinfo();
procinfo_loaded = TRUE;
}
if ((r = lookup(name)) == NULL)
r = install(name, node(Nnull_string, type, (NODE *) NULL));
else if (can_free)
free(name);
return r;
}
/* mk_rexp --- make a regular expression constant */
static NODE *
mk_rexp(NODE *exp)
{
NODE *n;
if (exp->type == Node_regex)
return exp;
getnode(n);
n->type = Node_regex;
n->re_exp = exp;
n->re_text = NULL;
n->re_reg = NULL;
n->re_flags = 0;
n->re_cnt = 1;
return n;
}
/* isnoeffect --- when used as a statement, has no side effects */
/*
* To be completely general, we should recursively walk the parse
* tree, to make sure that all the subexpressions also have no effect.
* Instead, we just weaken the actual warning that's printed, up above
* in the grammar.
*/
static int
isnoeffect(NODETYPE type)
{
switch (type) {
case Node_times:
case Node_quotient:
case Node_mod:
case Node_plus:
case Node_minus:
case Node_subscript:
case Node_concat:
case Node_exp:
case Node_unary_minus:
case Node_field_spec:
case Node_and:
case Node_or:
case Node_equal:
case Node_notequal:
case Node_less:
case Node_greater:
case Node_leq:
case Node_geq:
case Node_match:
case Node_nomatch:
case Node_not:
case Node_val:
case Node_in_array:
case Node_NF:
case Node_NR:
case Node_FNR:
case Node_FS:
case Node_RS:
case Node_FIELDWIDTHS:
case Node_IGNORECASE:
case Node_OFS:
case Node_ORS:
case Node_OFMT:
case Node_CONVFMT:
case Node_BINMODE:
case Node_LINT:
return TRUE;
default:
break; /* keeps gcc -Wall happy */
}
return FALSE;
}
/* isassignable --- can this node be assigned to? */
static int
isassignable(register NODE *n)
{
switch (n->type) {
case Node_var:
case Node_FIELDWIDTHS:
case Node_RS:
case Node_FS:
case Node_FNR:
case Node_NR:
case Node_NF:
case Node_IGNORECASE:
case Node_OFMT:
case Node_CONVFMT:
case Node_ORS:
case Node_OFS:
case Node_LINT:
case Node_BINMODE:
case Node_field_spec:
case Node_subscript:
return TRUE;
case Node_param_list:
return ((n->flags & FUNC) == 0); /* ok if not func name */
default:
break; /* keeps gcc -Wall happy */
}
return FALSE;
}
/* stopme --- for debugging */
NODE *
stopme(NODE *tree)
{
return tmp_number((AWKNUM) 0.0);
}
/* dumpintlstr --- write out an initial .po file entry for the string */
static void
dumpintlstr(char *str, size_t len)
{
char *cp;
/* See the GNU gettext distribution for details on the file format */
if (source != NULL) {
/* ala the gettext sources, remove leading `./'s */
for (cp = source; cp[0] == '.' && cp[1] == '/'; cp += 2)
continue;
printf("#: %s:%d\n", cp, sourceline);
}
printf("msgid ");
fflush(stdout);
pp_string_fp(stdout, str, len, '"', TRUE);
putchar('\n');
printf("msgstr \"\"\n\n");
}
/* count_args --- count the number of printf arguments */
static void
count_args(NODE *tree)
{
size_t count = 0;
NODE *save_tree;
assert(tree->type == Node_K_printf
|| (tree->type == Node_builtin && tree->proc == do_sprintf));
save_tree = tree;
tree = tree->lnode; /* printf format string */
for (count = 0; tree != NULL; tree = tree->rnode)
count++;
save_tree->printf_count = count;
}