Apple-2gs-SW/hush
1
0
Fork 0
mirror of https://github.com/sheumann/hush.git synced 2024-10-11 10:23:41 +00:00
Code Issues Projects Releases Wiki Activity

awk: move all data to malloc space

Browse Source 
function                                             old     new   delta
evaluate                                            6448    6728    +280
awk_getline                                          676     705     +29
parse_expr                                           726     752     +26
next_token                                           917     943     +26
next_input_file                                      237     252     +15
awk_split                                            498     510     +12
awk_sub                                              632     643     +11
split_f0                                             160     170     +10
getvar_s                                              98     108     +10
...
chain_loop                                           128     121      -7
nvalloc                                              179     171      -8
chain_node                                           107      99      -8
mainseq                                               12       -     -12
endseq                                                12       -     -12
chain_group                                          640     628     -12
beginseq                                              12       -     -12
awk_exit                                             112     100     -12
fsrealloc                                            127     110     -17
static.v                                              20       -     -20
static.rsm                                            24       -     -24
ttt                                                   28       -     -28
parse_program                                        339     311     -28
static.sreg                                           32       -     -32
intvar                                                76       -     -76
static.tspl                                           84       -     -84
rsplitter                                             84       -     -84
fsplitter                                             84       -     -84
------------------------------------------------------------------------------
(add/remove: 0/39 grow/shrink: 16/11 up/down: 439/-685)      Total: -246 bytes
This commit is contained in:
Denis Vlasenko 2007-06-06 17:01:00 +00:00
parent c084d2f205
commit ae5a8aac26
2 changed files with 233 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
coreutils/diff.c
View File

@ -155,8 +155,6 @@ struct globals {
} while (0) } while (0)
static void print_only(const char *path, size_t dirlen, const char *entry) static void print_only(const char *path, size_t dirlen, const char *entry)
{ {
if (dirlen > 1) if (dirlen > 1)
@ -164,7 +162,6 @@ static void print_only(const char *path, size_t dirlen, const char *entry)
printf("Only in %.*s: %s\n", (int) dirlen, path, entry); printf("Only in %.*s: %s\n", (int) dirlen, path, entry);
} }
static void print_status(int val, char *path1, char *path2, char *entry) static void print_status(int val, char *path1, char *path2, char *entry)
{ {
const char * const _entry = entry ? entry : ""; const char * const _entry = entry ? entry : "";

378
editors/awk.c
View File

@ -35,7 +35,7 @@ extern char **environ;
/* Variable */ /* Variable */
typedef struct var_s { typedef struct var_s {
unsigned short type; /* flags */ unsigned type; /* flags */
double number; double number;
char *string; char *string;
union { union {
@ -55,7 +55,7 @@ typedef struct chain_s {
/* Function */ /* Function */
typedef struct func_s { typedef struct func_s {
unsigned short nargs; unsigned nargs;
struct chain_s body; struct chain_s body;
} func; } func;
@ -66,7 +66,7 @@ typedef struct rstream_s {
int adv; int adv;
int size; int size;
int pos; int pos;
unsigned short is_pipe; smallint is_pipe;
} rstream; } rstream;
typedef struct hash_item_s { typedef struct hash_item_s {
@ -394,34 +394,101 @@ enum { NPRIMES = sizeof(PRIMES) / sizeof(PRIMES[0]) };
/* globals */ /* globals */
static var *intvar[NUM_INTERNAL_VARS]; struct globals {
static chain beginseq, mainseq, endseq, *seq; /* former 'struct t' */
static int nextrec, nextfile; uint32_t t_info; /* often used */
static node *break_ptr, *continue_ptr; uint32_t t_tclass;
static rstream *iF; char *t_string;
static xhash *vhash, *ahash, *fdhash, *fnhash; double t_double;
static const char *programname; int t_lineno;
static int lineno; int t_rollback;
static int is_f0_split;
static int nfields; /* the rest */
static var *Fields; smallint icase;
static tsplitter fsplitter, rsplitter; smallint exiting;
static nvblock *cb; smallint nextrec;
static char *pos; smallint nextfile;
static char *buf; smallint is_f0_split;
static int icase; chain beginseq, mainseq, endseq, *seq;
static int exiting; node *break_ptr, *continue_ptr;
rstream *iF;
xhash *vhash, *ahash, *fdhash, *fnhash;
const char *g_progname;
int g_lineno;
int nfields;
int maxfields; /* used in fsrealloc() only */
var *Fields;
nvblock *g_cb;
char *g_pos;
char *g_buf;
/* former statics from various functions */
char *split_f0__fstrings;
rstream next_input_file__rsm;
smallint next_input_file__files_happen;
smallint next_token__concat_inserted;
uint32_t next_token__save_tclass;
uint32_t next_token__save_info;
uint32_t next_token__ltclass;
var *evaluate__fnargs;
unsigned evaluate__seed;
regex_t evaluate__sreg;
var ptest__v;
tsplitter exec_builtin__tspl;
/* biggest members go last */
var *intvar[NUM_INTERNAL_VARS];
tsplitter fsplitter, rsplitter;
};
#define G (*ptr_to_globals)
/* for debug */
/* char Gsize[sizeof(G)]; ~0x240 */
/* Trying to keep most of members accessible with short offsets: */
/* char Gofs_seed[offsetof(struct globals, evaluate__seed)]; ~0xc0 */
#define t_info (G.t_info )
#define t_tclass (G.t_tclass )
#define t_string (G.t_string )
#define t_double (G.t_double )
#define t_lineno (G.t_lineno )
#define t_rollback (G.t_rollback )
#define icase (G.icase )
#define exiting (G.exiting )
#define nextrec (G.nextrec )
#define nextfile (G.nextfile )
#define is_f0_split (G.is_f0_split )
#define beginseq (G.beginseq )
#define mainseq (G.mainseq )
#define endseq (G.endseq )
#define seq (G.seq )
#define break_ptr (G.break_ptr )
#define continue_ptr (G.continue_ptr)
#define iF (G.iF )
#define vhash (G.vhash )
#define ahash (G.ahash )
#define fdhash (G.fdhash )
#define fnhash (G.fnhash )
#define g_progname (G.g_progname )
#define g_lineno (G.g_lineno )
#define nfields (G.nfields )
#define maxfields (G.maxfields )
#define Fields (G.Fields )
#define g_cb (G.g_cb )
#define g_pos (G.g_pos )
#define g_buf (G.g_buf )
#define intvar (G.intvar )
#define fsplitter (G.fsplitter )
#define rsplitter (G.rsplitter )
#define INIT_G() do { \
PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
G.next_token__ltclass = TC_OPTERM; \
G.evaluate__seed = 1; \
} while (0)
static struct {
uint32_t tclass;
uint32_t info;
char *string;
double number;
int lineno;
int rollback;
} ttt;
/* It had even better name: 't'. Whoever knows what is it, please rename! */
/* (actually it looks like unrelated stuff lumped together...) */
/* function prototypes */ /* function prototypes */
static void handle_special(var *); static void handle_special(var *);
@ -455,12 +522,9 @@ static void zero_out_var(var * vp)
static void syntax_error(const char * const message) ATTRIBUTE_NORETURN; static void syntax_error(const char * const message) ATTRIBUTE_NORETURN;
static void syntax_error(const char * const message) static void syntax_error(const char * const message)
{ {
bb_error_msg_and_die("%s:%i: %s", programname, lineno, message); bb_error_msg_and_die("%s:%i: %s", g_progname, g_lineno, message);
} }
#define runtime_error(x) syntax_error(x)
/* ---- hash stuff ---- */ /* ---- hash stuff ---- */
static unsigned hashidx(const char *name) static unsigned hashidx(const char *name)
@ -581,7 +645,7 @@ static void skip_spaces(char **s)
while (1) { while (1) {
if (*p == '\\' && p[1] == '\n') { if (*p == '\\' && p[1] == '\n') {
p++; p++;
ttt.lineno++; t_lineno++;
} else if (*p != ' ' && *p != '\t') { } else if (*p != ' ' && *p != '\t') {
break; break;
} }
@ -714,8 +778,8 @@ static const char *getvar_s(var *v)
{ {
/* if v is numeric and has no cached string, convert it to string */ /* if v is numeric and has no cached string, convert it to string */
if ((v->type & (VF_NUMBER | VF_CACHED)) == VF_NUMBER) { if ((v->type & (VF_NUMBER | VF_CACHED)) == VF_NUMBER) {
fmt_num(buf, MAXVARFMT, getvar_s(intvar[CONVFMT]), v->number, TRUE); fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[CONVFMT]), v->number, TRUE);
v->string = xstrdup(buf); v->string = xstrdup(g_buf);
v->type |= VF_CACHED; v->type |= VF_CACHED;
} }
return (v->string == NULL) ? "" : v->string; return (v->string == NULL) ? "" : v->string;
@ -773,7 +837,6 @@ static int istrue(var *v)
{ {
if (is_numeric(v)) if (is_numeric(v))
return (v->number == 0) ? 0 : 1; return (v->number == 0) ? 0 : 1;
else
return (v->string && *(v->string)) ? 1 : 0; return (v->string && *(v->string)) ? 1 : 0;
} }
@ -784,26 +847,26 @@ static var *nvalloc(int n)
var *v, *r; var *v, *r;
int size; int size;
while (cb) { while (g_cb) {
pb = cb; pb = g_cb;
if ((cb->pos - cb->nv) + n <= cb->size) break; if ((g_cb->pos - g_cb->nv) + n <= g_cb->size) break;
cb = cb->next; g_cb = g_cb->next;
} }
if (! cb) { if (!g_cb) {
size = (n <= MINNVBLOCK) ? MINNVBLOCK : n; size = (n <= MINNVBLOCK) ? MINNVBLOCK : n;
cb = xmalloc(sizeof(nvblock) + size * sizeof(var)); g_cb = xmalloc(sizeof(nvblock) + size * sizeof(var));
cb->size = size; g_cb->size = size;
cb->pos = cb->nv; g_cb->pos = g_cb->nv;
cb->prev = pb; g_cb->prev = pb;
cb->next = NULL; g_cb->next = NULL;
if (pb) pb->next = cb; if (pb) pb->next = g_cb;
} }
v = r = cb->pos; v = r = g_cb->pos;
cb->pos += n; g_cb->pos += n;
while (v < cb->pos) { while (v < g_cb->pos) {
v->type = 0; v->type = 0;
v->string = NULL; v->string = NULL;
v++; v++;
@ -816,10 +879,10 @@ static void nvfree(var *v)
{ {
var *p; var *p;
if (v < cb->nv || v >= cb->pos) if (v < g_cb->nv || v >= g_cb->pos)
runtime_error(EMSG_INTERNAL_ERROR); syntax_error(EMSG_INTERNAL_ERROR);
for (p = v; p < cb->pos; p++) { for (p = v; p < g_cb->pos; p++) {
if ((p->type & (VF_ARRAY | VF_CHILD)) == VF_ARRAY) { if ((p->type & (VF_ARRAY | VF_CHILD)) == VF_ARRAY) {
clear_array(iamarray(p)); clear_array(iamarray(p));
free(p->x.array->items); free(p->x.array->items);
@ -831,9 +894,9 @@ static void nvfree(var *v)
clrvar(p); clrvar(p);
} }
cb->pos = v; g_cb->pos = v;
while (cb->prev && cb->pos == cb->nv) { while (g_cb->prev && g_cb->pos == g_cb->nv) {
cb = cb->prev; g_cb = g_cb->prev;
} }
} }
@ -844,9 +907,11 @@ static void nvfree(var *v)
*/ */
static uint32_t next_token(uint32_t expected) static uint32_t next_token(uint32_t expected)
{ {
static int concat_inserted; #define concat_inserted (G.next_token__concat_inserted)
static uint32_t save_tclass, save_info; #define save_tclass (G.next_token__save_tclass)
static uint32_t ltclass = TC_OPTERM; #define save_info (G.next_token__save_info)
/* Initialized to TC_OPTERM: */
#define ltclass (G.next_token__ltclass)
char *p, *pp, *s; char *p, *pp, *s;
const char *tl; const char *tl;
@ -854,32 +919,32 @@ static uint32_t next_token(uint32_t expected)
const uint32_t *ti; const uint32_t *ti;
int l; int l;
if (ttt.rollback) { if (t_rollback) {
ttt.rollback = FALSE; t_rollback = FALSE;
} else if (concat_inserted) { } else if (concat_inserted) {
concat_inserted = FALSE; concat_inserted = FALSE;
ttt.tclass = save_tclass; t_tclass = save_tclass;
ttt.info = save_info; t_info = save_info;
} else { } else {
p = pos; p = g_pos;
readnext: readnext:
skip_spaces(&p); skip_spaces(&p);
lineno = ttt.lineno; g_lineno = t_lineno;
if (*p == '#') if (*p == '#')
while (*p != '\n' && *p != '\0') while (*p != '\n' && *p != '\0')
p++; p++;
if (*p == '\n') if (*p == '\n')
ttt.lineno++; t_lineno++;
if (*p == '\0') { if (*p == '\0') {
tc = TC_EOF; tc = TC_EOF;
} else if (*p == '\"') { } else if (*p == '\"') {
/* it's a string */ /* it's a string */
ttt.string = s = ++p; t_string = s = ++p;
while (*p != '\"') { while (*p != '\"') {
if (*p == '\0' || *p == '\n') if (*p == '\0' || *p == '\n')
syntax_error(EMSG_UNEXP_EOS); syntax_error(EMSG_UNEXP_EOS);
@ -891,7 +956,7 @@ static uint32_t next_token(uint32_t expected)
} else if ((expected & TC_REGEXP) && *p == '/') { } else if ((expected & TC_REGEXP) && *p == '/') {
/* it's regexp */ /* it's regexp */
ttt.string = s = ++p; t_string = s = ++p;
while (*p != '/') { while (*p != '/') {
if (*p == '\0' || *p == '\n') if (*p == '\0' || *p == '\n')
syntax_error(EMSG_UNEXP_EOS); syntax_error(EMSG_UNEXP_EOS);
@ -911,7 +976,7 @@ static uint32_t next_token(uint32_t expected)
} else if (*p == '.' || isdigit(*p)) { } else if (*p == '.' || isdigit(*p)) {
/* it's a number */ /* it's a number */
ttt.number = strtod(p, &p); t_double = strtod(p, &p);
if (*p == '.') if (*p == '.')
syntax_error(EMSG_UNEXP_TOKEN); syntax_error(EMSG_UNEXP_TOKEN);
tc = TC_NUMBER; tc = TC_NUMBER;
@ -935,7 +1000,7 @@ static uint32_t next_token(uint32_t expected)
&& *tl == *p && strncmp(p, tl, l) == 0 && *tl == *p && strncmp(p, tl, l) == 0
&& !((tc & TC_WORD) && isalnum_(p[l])) && !((tc & TC_WORD) && isalnum_(p[l]))
) { ) {
ttt.info = *ti; t_info = *ti;
p += l; p += l;
break; break;
} }
@ -950,7 +1015,7 @@ static uint32_t next_token(uint32_t expected)
if (!isalnum_(*p)) if (!isalnum_(*p))
syntax_error(EMSG_UNEXP_TOKEN); syntax_error(EMSG_UNEXP_TOKEN);
ttt.string = --p; t_string = --p;
while (isalnum_(*(++p))) { while (isalnum_(*(++p))) {
*(p-1) = *p; *(p-1) = *p;
} }
@ -969,7 +1034,7 @@ static uint32_t next_token(uint32_t expected)
} }
} }
} }
pos = p; g_pos = p;
/* skipping newlines in some cases */ /* skipping newlines in some cases */
if ((ltclass & TC_NOTERM) && (tc & TC_NEWLINE)) if ((ltclass & TC_NOTERM) && (tc & TC_NEWLINE))
@ -979,14 +1044,14 @@ static uint32_t next_token(uint32_t expected)
if ((ltclass & TC_CONCAT1) && (tc & TC_CONCAT2) && (expected & TC_BINOP)) { if ((ltclass & TC_CONCAT1) && (tc & TC_CONCAT2) && (expected & TC_BINOP)) {
concat_inserted = TRUE; concat_inserted = TRUE;
save_tclass = tc; save_tclass = tc;
save_info = ttt.info; save_info = t_info;
tc = TC_BINOP; tc = TC_BINOP;
ttt.info = OC_CONCAT | SS | P(35); t_info = OC_CONCAT | SS | P(35);
} }
ttt.tclass = tc; t_tclass = tc;
} }
ltclass = ttt.tclass; ltclass = t_tclass;
/* Are we ready for this? */ /* Are we ready for this? */
if (!(ltclass & expected)) if (!(ltclass & expected))
@ -994,11 +1059,15 @@ static uint32_t next_token(uint32_t expected)
EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN); EMSG_UNEXP_EOS : EMSG_UNEXP_TOKEN);
return ltclass; return ltclass;
#undef concat_inserted
#undef save_tclass
#undef save_info
#undef ltclass
} }
static void rollback_token(void) static void rollback_token(void)
{ {
ttt.rollback = TRUE; t_rollback = TRUE;
} }
static node *new_node(uint32_t info) static node *new_node(uint32_t info)
@ -1007,7 +1076,7 @@ static node *new_node(uint32_t info)
n = xzalloc(sizeof(node)); n = xzalloc(sizeof(node));
n->info = info; n->info = info;
n->lineno = lineno; n->lineno = g_lineno;
return n; return n;
} }
@ -1043,7 +1112,7 @@ static node *parse_expr(uint32_t iexp)
xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP | iexp; xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP | iexp;
while (!((tc = next_token(xtc)) & iexp)) { while (!((tc = next_token(xtc)) & iexp)) {
if (glptr && (ttt.info == (OC_COMPARE | VV | P(39) | 2))) { if (glptr && (t_info == (OC_COMPARE | VV | P(39) | 2))) {
/* input redirection (<) attached to glptr node */ /* input redirection (<) attached to glptr node */
cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37)); cn = glptr->l.n = new_node(OC_CONCAT | SS | P(37));
cn->a.n = glptr; cn->a.n = glptr;
@ -1054,17 +1123,17 @@ static node *parse_expr(uint32_t iexp)
/* for binary and postfix-unary operators, jump back over /* for binary and postfix-unary operators, jump back over
* previous operators with higher priority */ * previous operators with higher priority */
vn = cn; vn = cn;
while ( ((ttt.info & PRIMASK) > (vn->a.n->info & PRIMASK2)) while ( ((t_info & PRIMASK) > (vn->a.n->info & PRIMASK2))
|| ((ttt.info == vn->info) && ((ttt.info & OPCLSMASK) == OC_COLON)) ) || ((t_info == vn->info) && ((t_info & OPCLSMASK) == OC_COLON)) )
vn = vn->a.n; vn = vn->a.n;
if ((ttt.info & OPCLSMASK) == OC_TERNARY) if ((t_info & OPCLSMASK) == OC_TERNARY)
ttt.info += P(6); t_info += P(6);
cn = vn->a.n->r.n = new_node(ttt.info); cn = vn->a.n->r.n = new_node(t_info);
cn->a.n = vn->a.n; cn->a.n = vn->a.n;
if (tc & TC_BINOP) { if (tc & TC_BINOP) {
cn->l.n = vn; cn->l.n = vn;
xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP; xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
if ((ttt.info & OPCLSMASK) == OC_PGETLINE) { if ((t_info & OPCLSMASK) == OC_PGETLINE) {
/* it's a pipe */ /* it's a pipe */
next_token(TC_GETLINE); next_token(TC_GETLINE);
/* give maximum priority to this pipe */ /* give maximum priority to this pipe */
@ -1081,7 +1150,7 @@ static node *parse_expr(uint32_t iexp)
/* for operands and prefix-unary operators, attach them /* for operands and prefix-unary operators, attach them
* to last node */ * to last node */
vn = cn; vn = cn;
cn = vn->r.n = new_node(ttt.info); cn = vn->r.n = new_node(t_info);
cn->a.n = vn; cn->a.n = vn;
xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP; xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
if (tc & (TC_OPERAND | TC_REGEXP)) { if (tc & (TC_OPERAND | TC_REGEXP)) {
@ -1092,12 +1161,12 @@ static node *parse_expr(uint32_t iexp)
case TC_VARIABLE: case TC_VARIABLE:
case TC_ARRAY: case TC_ARRAY:
cn->info = OC_VAR; cn->info = OC_VAR;
v = hash_search(ahash, ttt.string); v = hash_search(ahash, t_string);
if (v != NULL) { if (v != NULL) {
cn->info = OC_FNARG; cn->info = OC_FNARG;
cn->l.i = v->x.aidx; cn->l.i = v->x.aidx;
} else { } else {
cn->l.v = newvar(ttt.string); cn->l.v = newvar(t_string);
} }
if (tc & TC_ARRAY) { if (tc & TC_ARRAY) {
cn->info |= xS; cn->info |= xS;
@ -1110,18 +1179,18 @@ static node *parse_expr(uint32_t iexp)
cn->info = OC_VAR; cn->info = OC_VAR;
v = cn->l.v = xzalloc(sizeof(var)); v = cn->l.v = xzalloc(sizeof(var));
if (tc & TC_NUMBER) if (tc & TC_NUMBER)
setvar_i(v, ttt.number); setvar_i(v, t_double);
else else
setvar_s(v, ttt.string); setvar_s(v, t_string);
break; break;
case TC_REGEXP: case TC_REGEXP:
mk_re_node(ttt.string, cn, xzalloc(sizeof(regex_t)*2)); mk_re_node(t_string, cn, xzalloc(sizeof(regex_t)*2));
break; break;
case TC_FUNCTION: case TC_FUNCTION:
cn->info = OC_FUNC; cn->info = OC_FUNC;
cn->r.f = newfunc(ttt.string); cn->r.f = newfunc(t_string);
cn->l.n = condition(); cn->l.n = condition();
break; break;
@ -1153,10 +1222,10 @@ static node *chain_node(uint32_t info)
if (!seq->first) if (!seq->first)
seq->first = seq->last = new_node(0); seq->first = seq->last = new_node(0);
if (seq->programname != programname) { if (seq->programname != g_progname) {
seq->programname = programname; seq->programname = g_progname;
n = chain_node(OC_NEWSOURCE); n = chain_node(OC_NEWSOURCE);
n->l.s = xstrdup(programname); n->l.s = xstrdup(g_progname);
} }
n = seq->last; n = seq->last;
@ -1172,7 +1241,7 @@ static void chain_expr(uint32_t info)
n = chain_node(info); n = chain_node(info);
n->l.n = parse_expr(TC_OPTERM | TC_GRPTERM); n->l.n = parse_expr(TC_OPTERM | TC_GRPTERM);
if (ttt.tclass & TC_GRPTERM) if (t_tclass & TC_GRPTERM)
rollback_token(); rollback_token();
} }
@ -1211,7 +1280,7 @@ static void chain_group(void)
if (c & TC_GRPSTART) { if (c & TC_GRPSTART) {
while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) { while (next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
if (ttt.tclass & TC_NEWLINE) continue; if (t_tclass & TC_NEWLINE) continue;
rollback_token(); rollback_token();
chain_group(); chain_group();
} }
@ -1219,7 +1288,7 @@ static void chain_group(void)
rollback_token(); rollback_token();
chain_expr(OC_EXEC | Vx); chain_expr(OC_EXEC | Vx);
} else { /* TC_STATEMNT */ } else { /* TC_STATEMNT */
switch (ttt.info & OPCLSMASK) { switch (t_info & OPCLSMASK) {
case ST_IF: case ST_IF:
n = chain_node(OC_BR | Vx); n = chain_node(OC_BR | Vx);
n->l.n = condition(); n->l.n = condition();
@ -1251,7 +1320,7 @@ static void chain_group(void)
case ST_FOR: case ST_FOR:
next_token(TC_SEQSTART); next_token(TC_SEQSTART);
n2 = parse_expr(TC_SEMICOL | TC_SEQTERM); n2 = parse_expr(TC_SEMICOL | TC_SEQTERM);
if (ttt.tclass & TC_SEQTERM) { /* for-in */ if (t_tclass & TC_SEQTERM) { /* for-in */
if ((n2->info & OPCLSMASK) != OC_IN) if ((n2->info & OPCLSMASK) != OC_IN)
syntax_error(EMSG_UNEXP_TOKEN); syntax_error(EMSG_UNEXP_TOKEN);
n = chain_node(OC_WALKINIT | VV); n = chain_node(OC_WALKINIT | VV);
@ -1274,13 +1343,13 @@ static void chain_group(void)
case OC_PRINT: case OC_PRINT:
case OC_PRINTF: case OC_PRINTF:
n = chain_node(ttt.info); n = chain_node(t_info);
n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM); n->l.n = parse_expr(TC_OPTERM | TC_OUTRDR | TC_GRPTERM);
if (ttt.tclass & TC_OUTRDR) { if (t_tclass & TC_OUTRDR) {
n->info |= ttt.info; n->info |= t_info;
n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM); n->r.n = parse_expr(TC_OPTERM | TC_GRPTERM);
} }
if (ttt.tclass & TC_GRPTERM) if (t_tclass & TC_GRPTERM)
rollback_token(); rollback_token();
break; break;
@ -1296,7 +1365,7 @@ static void chain_group(void)
/* delete, next, nextfile, return, exit */ /* delete, next, nextfile, return, exit */
default: default:
chain_expr(ttt.info); chain_expr(t_info);
} }
} }
} }
@ -1308,8 +1377,8 @@ static void parse_program(char *p)
func *f; func *f;
var *v; var *v;
pos = p; g_pos = p;
ttt.lineno = 1; t_lineno = 1;
while ((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART | while ((tclass = next_token(TC_EOF | TC_OPSEQ | TC_GRPSTART |
TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) { TC_OPTERM | TC_BEGIN | TC_END | TC_FUNCDECL)) != TC_EOF) {
@ -1327,12 +1396,12 @@ static void parse_program(char *p)
} else if (tclass & TC_FUNCDECL) { } else if (tclass & TC_FUNCDECL) {
next_token(TC_FUNCTION); next_token(TC_FUNCTION);
pos++; g_pos++;
f = newfunc(ttt.string); f = newfunc(t_string);
f->body.first = NULL; f->body.first = NULL;
f->nargs = 0; f->nargs = 0;
while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) { while (next_token(TC_VARIABLE | TC_SEQTERM) & TC_VARIABLE) {
v = findvar(ahash, ttt.string); v = findvar(ahash, t_string);
v->x.aidx = (f->nargs)++; v->x.aidx = (f->nargs)++;
if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM) if (next_token(TC_COMMA | TC_SEQTERM) & TC_SEQTERM)
@ -1346,7 +1415,7 @@ static void parse_program(char *p)
rollback_token(); rollback_token();
cn = chain_node(OC_TEST); cn = chain_node(OC_TEST);
cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART); cn->l.n = parse_expr(TC_OPTERM | TC_EOF | TC_GRPSTART);
if (ttt.tclass & TC_GRPSTART) { if (t_tclass & TC_GRPSTART) {
rollback_token(); rollback_token();
chain_group(); chain_group();
} else { } else {
@ -1414,7 +1483,6 @@ static void qrealloc(char **b, int n, int *size)
/* resize field storage space */ /* resize field storage space */
static void fsrealloc(int size) static void fsrealloc(int size)
{ {
static int maxfields; /* = 0;*/
int i; int i;
if (size >= maxfields) { if (size >= maxfields) {
@ -1504,7 +1572,7 @@ static int awk_split(const char *s, node *spl, char **slist)
static void split_f0(void) static void split_f0(void)
{ {
static char *fstrings = NULL; #define fstrings (G.split_f0__fstrings)
int i, n; int i, n;
char *s; char *s;
@ -1527,6 +1595,7 @@ static void split_f0(void)
clrvar(intvar[NF]); clrvar(intvar[NF]);
intvar[NF]->type = VF_NUMBER | VF_SPECIAL; intvar[NF]->type = VF_NUMBER | VF_SPECIAL;
intvar[NF]->number = nfields; intvar[NF]->number = nfields;
#undef fstrings
} }
/* perform additional actions when some internal variables changed */ /* perform additional actions when some internal variables changed */
@ -1636,9 +1705,8 @@ static int hashwalk_next(var *v)
/* evaluate node, return 1 when result is true, 0 otherwise */ /* evaluate node, return 1 when result is true, 0 otherwise */
static int ptest(node *pattern) static int ptest(node *pattern)
{ {
static var v; /* static: to save stack space? */ /* ptest__v is "static": to save stack space? */
return istrue(evaluate(pattern, &G.ptest__v));
return istrue(evaluate(pattern, &v));
} }
/* read next record from stream rsm into a variable v */ /* read next record from stream rsm into a variable v */
@ -1750,7 +1818,7 @@ static int fmt_num(char *b, int size, const char *format, double n, int int_as_i
} else if (strchr("eEfgG", c)) { } else if (strchr("eEfgG", c)) {
r = snprintf(b, size, format, n); r = snprintf(b, size, format, n);
} else { } else {
runtime_error(EMSG_INV_FMT); syntax_error(EMSG_INV_FMT);
} }
} }
return r; return r;
@ -1888,6 +1956,8 @@ static int awk_sub(node *rn, const char *repl, int nm, var *src, var *dest, int
static var *exec_builtin(node *op, var *res) static var *exec_builtin(node *op, var *res)
{ {
#define tspl (G.exec_builtin__tspl)
int (*to_xxx)(int); int (*to_xxx)(int);
var *tv; var *tv;
node *an[4]; node *an[4];
@ -1895,7 +1965,6 @@ static var *exec_builtin(node *op, var *res)
const char *as[4]; const char *as[4];
regmatch_t pmatch[2]; regmatch_t pmatch[2];
regex_t sreg, *re; regex_t sreg, *re;
static tsplitter tspl;
node *spl; node *spl;
uint32_t isr, info; uint32_t isr, info;
int nargs; int nargs;
@ -1917,7 +1986,7 @@ static var *exec_builtin(node *op, var *res)
nargs = i; nargs = i;
if (nargs < (info >> 30)) if (nargs < (info >> 30))
runtime_error(EMSG_TOO_FEW_ARGS); syntax_error(EMSG_TOO_FEW_ARGS);
switch (info & OPNMASK) { switch (info & OPNMASK) {
@ -1925,7 +1994,7 @@ static var *exec_builtin(node *op, var *res)
#if ENABLE_FEATURE_AWK_MATH #if ENABLE_FEATURE_AWK_MATH
setvar_i(res, atan2(getvar_i(av[i]), getvar_i(av[1]))); setvar_i(res, atan2(getvar_i(av[i]), getvar_i(av[1])));
#else #else
runtime_error(EMSG_NO_MATH); syntax_error(EMSG_NO_MATH);
#endif #endif
break; break;
@ -2027,11 +2096,11 @@ static var *exec_builtin(node *op, var *res)
else else
time(&tt); time(&tt);
//s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"; //s = (nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y";
i = strftime(buf, MAXVARFMT, i = strftime(g_buf, MAXVARFMT,
((nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"), ((nargs > 0) ? as[0] : "%a %b %d %H:%M:%S %Z %Y"),
localtime(&tt)); localtime(&tt));
buf[i] = '\0'; g_buf[i] = '\0';
setvar_s(res, buf); setvar_s(res, g_buf);
break; break;
case B_ma: case B_ma:
@ -2065,6 +2134,7 @@ static var *exec_builtin(node *op, var *res)
nvfree(tv); nvfree(tv);
return res; return res;
#undef tspl
} }
/* /*
@ -2076,9 +2146,10 @@ static var *exec_builtin(node *op, var *res)
static var *evaluate(node *op, var *res) static var *evaluate(node *op, var *res)
{ {
/* This procedure is recursive so we should count every byte */ /* This procedure is recursive so we should count every byte */
static var *fnargs = NULL; #define fnargs (G.evaluate__fnargs)
static unsigned seed = 1; /* seed is initialized to 1 */
static regex_t sreg; #define seed (G.evaluate__seed)
#define sreg (G.evaluate__sreg)
node *op1; node *op1;
var *v1; var *v1;
@ -2089,7 +2160,7 @@ static var *evaluate(node *op, var *res)
int i; int i;
} L, R; } L, R;
uint32_t opinfo; uint32_t opinfo;
short opn; int opn;
union { union {
char *s; char *s;
rstream *rsm; rstream *rsm;
@ -2106,8 +2177,8 @@ static var *evaluate(node *op, var *res)
while (op) { while (op) {
opinfo = op->info; opinfo = op->info;
opn = (short)(opinfo & OPNMASK); opn = (opinfo & OPNMASK);
lineno = op->lineno; g_lineno = op->lineno;
/* execute inevitable things */ /* execute inevitable things */
op1 = op->l.n; op1 = op->l.n;
@ -2183,9 +2254,9 @@ static var *evaluate(node *op, var *res)
while (op1) { while (op1) {
L.v = evaluate(nextarg(&op1), v1); L.v = evaluate(nextarg(&op1), v1);
if (L.v->type & VF_NUMBER) { if (L.v->type & VF_NUMBER) {
fmt_num(buf, MAXVARFMT, getvar_s(intvar[OFMT]), fmt_num(g_buf, MAXVARFMT, getvar_s(intvar[OFMT]),
getvar_i(L.v), TRUE); getvar_i(L.v), TRUE);
fputs(buf, X.F); fputs(g_buf, X.F);
} else { } else {
fputs(getvar_s(L.v), X.F); fputs(getvar_s(L.v), X.F);
} }
@ -2210,7 +2281,7 @@ static var *evaluate(node *op, var *res)
} else if (X.info == OC_FNARG) { } else if (X.info == OC_FNARG) {
R.v = &fnargs[op1->l.i]; R.v = &fnargs[op1->l.i];
} else { } else {
runtime_error(EMSG_NOT_ARRAY); syntax_error(EMSG_NOT_ARRAY);
} }
if (op1->r.n) { if (op1->r.n) {
@ -2223,7 +2294,7 @@ static var *evaluate(node *op, var *res)
break; break;
case XC( OC_NEWSOURCE ): case XC( OC_NEWSOURCE ):
programname = op->l.s; g_progname = op->l.s;
break; break;
case XC( OC_RETURN ): case XC( OC_RETURN ):
@ -2285,13 +2356,13 @@ static var *evaluate(node *op, var *res)
case XC( OC_TERNARY ): case XC( OC_TERNARY ):
if ((op->r.n->info & OPCLSMASK) != OC_COLON) if ((op->r.n->info & OPCLSMASK) != OC_COLON)
runtime_error(EMSG_POSSIBLE_ERROR); syntax_error(EMSG_POSSIBLE_ERROR);
res = evaluate(istrue(L.v) ? op->r.n->l.n : op->r.n->r.n, res); res = evaluate(istrue(L.v) ? op->r.n->l.n : op->r.n->r.n, res);
break; break;
case XC( OC_FUNC ): case XC( OC_FUNC ):
if (!op->r.f->body.first) if (!op->r.f->body.first)
runtime_error(EMSG_UNDEF_FUNC); syntax_error(EMSG_UNDEF_FUNC);
X.v = R.v = nvalloc(op->r.f->nargs+1); X.v = R.v = nvalloc(op->r.f->nargs+1);
while (op1) { while (op1) {
@ -2306,9 +2377,9 @@ static var *evaluate(node *op, var *res)
R.v = fnargs; R.v = fnargs;
fnargs = X.v; fnargs = X.v;
L.s = programname; L.s = g_progname;
res = evaluate(op->r.f->body.first, res); res = evaluate(op->r.f->body.first, res);
programname = L.s; g_progname = L.s;
nvfree(fnargs); nvfree(fnargs);
fnargs = R.v; fnargs = R.v;
@ -2387,7 +2458,7 @@ static var *evaluate(node *op, var *res)
case F_lg: case F_lg:
case F_si: case F_si:
case F_sq: case F_sq:
runtime_error(EMSG_NO_MATH); syntax_error(EMSG_NO_MATH);
break; break;
#endif #endif
case F_sr: case F_sr:
@ -2525,18 +2596,18 @@ static var *evaluate(node *op, var *res)
L.d *= R.d; L.d *= R.d;
break; break;
case '/': case '/':
if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO); if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO);
L.d /= R.d; L.d /= R.d;
break; break;
case '&': case '&':
#if ENABLE_FEATURE_AWK_MATH #if ENABLE_FEATURE_AWK_MATH
L.d = pow(L.d, R.d); L.d = pow(L.d, R.d);
#else #else
runtime_error(EMSG_NO_MATH); syntax_error(EMSG_NO_MATH);
#endif #endif
break; break;
case '%': case '%':
if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO); if (R.d == 0) syntax_error(EMSG_DIV_BY_ZERO);
L.d -= (int)(L.d / R.d) * R.d; L.d -= (int)(L.d / R.d) * R.d;
break; break;
} }
@ -2566,7 +2637,7 @@ static var *evaluate(node *op, var *res)
break; break;
default: default:
runtime_error(EMSG_POSSIBLE_ERROR); syntax_error(EMSG_POSSIBLE_ERROR);
} }
if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS) if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS)
op = op->a.n; op = op->a.n;
@ -2577,6 +2648,9 @@ static var *evaluate(node *op, var *res)
} }
nvfree(v1); nvfree(v1);
return res; return res;
#undef fnargs
#undef seed
#undef sreg
} }
@ -2635,8 +2709,8 @@ static int is_assignment(const char *expr)
/* switch to next input file */ /* switch to next input file */
static rstream *next_input_file(void) static rstream *next_input_file(void)
{ {
static rstream rsm; #define rsm (G.next_input_file__rsm)
static int files_happen = FALSE; #define files_happen (G.next_input_file__files_happen)
FILE *F = NULL; FILE *F = NULL;
const char *fname, *ind; const char *fname, *ind;
@ -2663,6 +2737,8 @@ static rstream *next_input_file(void)
setvar_s(intvar[FILENAME], fname); setvar_s(intvar[FILENAME], fname);
rsm.F = F; rsm.F = F;
return &rsm; return &rsm;
#undef rsm
#undef files_happen
} }
int awk_main(int argc, char **argv); int awk_main(int argc, char **argv);
@ -2678,6 +2754,8 @@ int awk_main(int argc, char **argv)
char *vnames = (char *)vNames; /* cheat */ char *vnames = (char *)vNames; /* cheat */
char *vvalues = (char *)vValues; char *vvalues = (char *)vValues;
INIT_G();
/* Undo busybox.c, or else strtod may eat ','! This breaks parsing: /* Undo busybox.c, or else strtod may eat ','! This breaks parsing:
* $1,$2 == '$1,' '$2', NOT '$1' ',' '$2' */ * $1,$2 == '$1,' '$2', NOT '$1' ',' '$2' */
if (ENABLE_LOCALE_SUPPORT) if (ENABLE_LOCALE_SUPPORT)
@ -2686,7 +2764,7 @@ int awk_main(int argc, char **argv)
zero_out_var(&tv); zero_out_var(&tv);
/* allocate global buffer */ /* allocate global buffer */
buf = xmalloc(MAXVARFMT + 1); g_buf = xmalloc(MAXVARFMT + 1);
vhash = hash_init(); vhash = hash_init();
ahash = hash_init(); ahash = hash_init();
@ -2725,7 +2803,7 @@ int awk_main(int argc, char **argv)
free(s); free(s);
} }
opt_complementary = "v::"; opt_complementary = "v::";
opt = getopt32(argc, argv, "F:v:f:W:", &opt_F, &opt_v, &programname, &opt_W); opt = getopt32(argc, argv, "F:v:f:W:", &opt_F, &opt_v, &g_progname, &opt_W);
argv += optind; argv += optind;
argc -= optind; argc -= optind;
if (opt & 0x1) if (opt & 0x1)
@ -2736,7 +2814,7 @@ int awk_main(int argc, char **argv)
} }
if (opt & 0x4) { // -f if (opt & 0x4) { // -f
char *s = s; /* die, gcc, die */ char *s = s; /* die, gcc, die */
FILE *from_file = afopen(programname, "r"); FILE *from_file = afopen(g_progname, "r");
/* one byte is reserved for some trick in next_token */ /* one byte is reserved for some trick in next_token */
if (fseek(from_file, 0, SEEK_END) == 0) { if (fseek(from_file, 0, SEEK_END) == 0) {
flen = ftell(from_file); flen = ftell(from_file);
@ -2756,7 +2834,7 @@ int awk_main(int argc, char **argv)
} else { // no -f: take program from 1st parameter } else { // no -f: take program from 1st parameter
if (!argc) if (!argc)
bb_show_usage(); bb_show_usage();
programname = "cmd. line"; g_progname = "cmd. line";
parse_program(*argv++); parse_program(*argv++);
argc--; argc--;
} }
@ -2793,7 +2871,7 @@ int awk_main(int argc, char **argv)
} }
if (i < 0) if (i < 0)
runtime_error(strerror(errno)); syntax_error(strerror(errno));
iF = next_input_file(); iF = next_input_file();
} }