*
* Copyright (C) 2002 by Dmitry Zakharov <dmit@crp.bank.gov.ua>
*
- * This program 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.
- *
- * This program 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
- *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
-#include <time.h>
-#include <math.h>
-#include <ctype.h>
-#include <getopt.h>
-#include <regex.h>
-
#include "busybox.h"
+#include "xregex.h"
+#include <math.h>
#define MAXVARFMT 240
double number;
char *string;
union {
- int aidx; /* func arg index (on compilation stage) */
+ int aidx; /* func arg idx (for compilation stage) */
struct xhash_s *array; /* array ptr */
struct var_s *parent; /* for func args, ptr to actual parameter */
char **walker; /* list of array elements (for..in) */
typedef struct rstream_s {
FILE *F;
char *buffer;
+ int adv;
int size;
int pos;
unsigned short is_pipe;
/* Tree node */
typedef struct node_s {
- unsigned long info;
+ uint32_t info;
unsigned short lineno;
union {
struct node_s *n;
/* builtins */
enum {
B_a2=0, B_ix, B_ma, B_sp, B_ss, B_ti, B_lo, B_up,
- B_ge, B_gs, B_su
+ B_ge, B_gs, B_su,
+ B_an, B_co, B_ls, B_or, B_rs, B_xo,
};
/* tokens and their corresponding info values */
"\5while" NTC
"\4else" NTC
+ "\3and" "\5compl" "\6lshift" "\2or"
+ "\6rshift" "\3xor"
"\5close" "\6system" "\6fflush" "\5atan2" /* BUILTIN */
"\3cos" "\3exp" "\3int" "\3log"
"\4rand" "\3sin" "\4sqrt" "\5srand"
"\3END" "\0"
;
-static unsigned long tokeninfo[] = {
+static const uint32_t tokeninfo[] = {
0,
0,
ST_WHILE,
0,
+ OC_B|B_an|P(0x83), OC_B|B_co|P(0x41), OC_B|B_ls|P(0x83), OC_B|B_or|P(0x83),
+ OC_B|B_rs|P(0x83), OC_B|B_xo|P(0x83),
OC_FBLTIN|Sx|F_cl, OC_FBLTIN|Sx|F_sy, OC_FBLTIN|Sx|F_ff, OC_B|B_a2|P(0x83),
OC_FBLTIN|Nx|F_co, OC_FBLTIN|Nx|F_ex, OC_FBLTIN|Nx|F_in, OC_FBLTIN|Nx|F_lg,
OC_FBLTIN|F_rn, OC_FBLTIN|Nx|F_si, OC_FBLTIN|Nx|F_sq, OC_FBLTIN|Nx|F_sr,
};
/* internal variable names and their initial values */
-/* asterisk marks SPECIAL vars; $ is just no-named Field0 */
+/* asterisk marks SPECIAL vars; $ is just no-named Field0 */
enum {
CONVFMT=0, OFMT, FS, OFS,
ORS, RS, RT, FILENAME,
static char * vNames =
"CONVFMT\0" "OFMT\0" "FS\0*" "OFS\0"
- "ORS\0" "RS\0*" "RT\0" "FILENAME\0"
+ "ORS\0" "RS\0*" "RT\0" "FILENAME\0"
"SUBSEP\0" "ARGIND\0" "ARGC\0" "ARGV\0"
"ERRNO\0" "FNR\0"
"NR\0" "NF\0*" "IGNORECASE\0*"
/* hash size may grow to these values */
#define FIRST_PRIME 61;
static const unsigned int PRIMES[] = { 251, 1021, 4093, 16381, 65521 };
-static const unsigned int NPRIMES = sizeof(PRIMES) / sizeof(unsigned int);
+enum { NPRIMES = sizeof(PRIMES) / sizeof(unsigned int) };
/* globals */
static char *programname;
static short lineno;
static int is_f0_split;
-static int nfields = 0;
-static var *Fields = NULL;
+static int nfields;
+static var *Fields;
static tsplitter fsplitter, rsplitter;
-static nvblock *cb = NULL;
+static nvblock *cb;
static char *pos;
static char *buf;
-static int icase = FALSE;
+static int icase;
+static int exiting;
static struct {
- unsigned long tclass;
- unsigned long info;
+ uint32_t tclass;
+ uint32_t info;
char *string;
double number;
short lineno;
} t;
/* function prototypes */
-extern void xregcomp(regex_t *preg, const char *regex, int cflags);
static void handle_special(var *);
-static node *parse_expr(unsigned long);
+static node *parse_expr(uint32_t);
static void chain_group(void);
static var *evaluate(node *, var *);
static rstream *next_input_file(void);
-static int fmt_num(char *, int, char *, double, int);
-static int awk_exit(int);
+static int fmt_num(char *, int, const char *, double, int);
+static int awk_exit(int) ATTRIBUTE_NORETURN;
/* ---- error handling ---- */
static const char EMSG_NO_MATH[] = "Math support is not compiled in";
#endif
+static void syntax_error(const char * const message) ATTRIBUTE_NORETURN;
static void syntax_error(const char * const message)
{
- error_msg("%s:%i: %s", programname, lineno, message);
- awk_exit(1);
+ bb_error_msg_and_die("%s:%i: %s", programname, lineno, message);
}
#define runtime_error(x) syntax_error(x)
/* ---- hash stuff ---- */
-static unsigned int hashidx(char *name) {
-
- register unsigned int idx=0;
+static unsigned int hashidx(const char *name)
+{
+ unsigned int idx=0;
while (*name) idx = *name++ + (idx << 6) - idx;
return idx;
}
/* create new hash */
-static xhash *hash_init(void) {
-
+static xhash *hash_init(void)
+{
xhash *newhash;
-
- newhash = (xhash *)xcalloc(1, sizeof(xhash));
+
+ newhash = (xhash *)xzalloc(sizeof(xhash));
newhash->csize = FIRST_PRIME;
- newhash->items = (hash_item **)xcalloc(newhash->csize, sizeof(hash_item *));
+ newhash->items = (hash_item **)xzalloc(newhash->csize * sizeof(hash_item *));
return newhash;
}
/* find item in hash, return ptr to data, NULL if not found */
-static void *hash_search(xhash *hash, char *name) {
-
+static void *hash_search(xhash *hash, const char *name)
+{
hash_item *hi;
hi = hash->items [ hashidx(name) % hash->csize ];
}
/* grow hash if it becomes too big */
-static void hash_rebuild(xhash *hash) {
-
+static void hash_rebuild(xhash *hash)
+{
unsigned int newsize, i, idx;
hash_item **newitems, *hi, *thi;
return;
newsize = PRIMES[hash->nprime++];
- newitems = (hash_item **)xcalloc(newsize, sizeof(hash_item *));
+ newitems = (hash_item **)xzalloc(newsize * sizeof(hash_item *));
for (i=0; i<hash->csize; i++) {
hi = hash->items[i];
}
/* find item in hash, add it if necessary. Return ptr to data */
-static void *hash_find(xhash *hash, char *name) {
-
+static void *hash_find(xhash *hash, const char *name)
+{
hash_item *hi;
unsigned int idx;
int l;
if (++hash->nel / hash->csize > 10)
hash_rebuild(hash);
- l = xstrlen(name) + 1;
- hi = xcalloc(sizeof(hash_item) + l, 1);
+ l = strlen(name) + 1;
+ hi = xzalloc(sizeof(hash_item) + l);
memcpy(hi->name, name, l);
idx = hashidx(name) % hash->csize;
#define newfile(name) (rstream *) hash_find ( fdhash , (name) )
#define newfunc(name) (func *) hash_find ( fnhash , (name) )
-static void hash_remove(xhash *hash, char *name) {
-
+static void hash_remove(xhash *hash, const char *name)
+{
hash_item *hi, **phi;
phi = &(hash->items[ hashidx(name) % hash->csize ]);
while (*phi) {
hi = *phi;
if (strcmp(hi->name, name) == 0) {
- hash->glen -= (xstrlen(name) + 1);
+ hash->glen -= (strlen(name) + 1);
hash->nel--;
*phi = hi->next;
free(hi);
/* ------ some useful functions ------ */
-static void skip_spaces(char **s) {
-
- register char *p = *s;
+static void skip_spaces(char **s)
+{
+ char *p = *s;
while(*p == ' ' || *p == '\t' ||
- (*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
- p++;
+ (*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
+ p++;
}
*s = p;
}
-static char *nextword(char **s) {
-
- register char *p = *s;
+static char *nextword(char **s)
+{
+ char *p = *s;
while (*(*s)++) ;
return p;
}
-static char nextchar(char **s) {
-
- register char c, *pps;
+static char nextchar(char **s)
+{
+ char c, *pps;
c = *((*s)++);
pps = *s;
- if (c == '\\') c = process_escape_sequence((const char**)s);
+ if (c == '\\') c = bb_process_escape_sequence((const char**)s);
if (c == '\\' && *s == pps) c = *((*s)++);
return c;
}
-static inline int isalnum_(int c) {
-
+static int ATTRIBUTE_ALWAYS_INLINE isalnum_(int c)
+{
return (isalnum(c) || c == '_');
}
-static FILE *afopen(const char *path, const char *mode) {
-
+static FILE *afopen(const char *path, const char *mode)
+{
return (*path == '-' && *(path+1) == '\0') ? stdin : xfopen(path, mode);
}
/* -------- working with variables (set/get/copy/etc) -------- */
-static xhash *iamarray(var *v) {
-
+static xhash *iamarray(var *v)
+{
var *a = v;
while (a->type & VF_CHILD)
return a->x.array;
}
-static void clear_array(xhash *array) {
-
+static void clear_array(xhash *array)
+{
unsigned int i;
hash_item *hi, *thi;
}
/* clear a variable */
-static var *clrvar(var *v) {
-
+static var *clrvar(var *v)
+{
if (!(v->type & VF_FSTR))
free(v->string);
}
/* assign string value to variable */
-static var *setvar_p(var *v, char *value) {
-
+static var *setvar_p(var *v, char *value)
+{
clrvar(v);
v->string = value;
handle_special(v);
}
/* same as setvar_p but make a copy of string */
-static var *setvar_s(var *v, char *value) {
-
+static var *setvar_s(var *v, const char *value)
+{
return setvar_p(v, (value && *value) ? xstrdup(value) : NULL);
}
/* same as setvar_s but set USER flag */
-static var *setvar_u(var *v, char *value) {
-
+static var *setvar_u(var *v, const char *value)
+{
setvar_s(v, value);
v->type |= VF_USER;
return v;
}
/* set array element to user string */
-static void setari_u(var *a, int idx, char *s) {
-
- register var *v;
+static void setari_u(var *a, int idx, const char *s)
+{
+ var *v;
static char sidx[12];
sprintf(sidx, "%d", idx);
}
/* assign numeric value to variable */
-static var *setvar_i(var *v, double value) {
-
+static var *setvar_i(var *v, double value)
+{
clrvar(v);
v->type |= VF_NUMBER;
v->number = value;
return v;
}
-static char *getvar_s(var *v) {
-
+static char *getvar_s(var *v)
+{
/* if v is numeric and has no cached string, convert it to string */
if ((v->type & (VF_NUMBER | VF_CACHED)) == VF_NUMBER) {
fmt_num(buf, MAXVARFMT, getvar_s(V[CONVFMT]), v->number, TRUE);
return (v->string == NULL) ? "" : v->string;
}
-static double getvar_i(var *v) {
-
+static double getvar_i(var *v)
+{
char *s;
if ((v->type & (VF_NUMBER | VF_CACHED)) == 0) {
return v->number;
}
-static var *copyvar(var *dest, var *src) {
-
+static var *copyvar(var *dest, const var *src)
+{
if (dest != src) {
clrvar(dest);
dest->type |= (src->type & ~VF_DONTTOUCH);
return dest;
}
-static var *incvar(var *v) {
-
+static var *incvar(var *v)
+{
return setvar_i(v, getvar_i(v)+1.);
}
/* return true if v is number or numeric string */
-static int is_numeric(var *v) {
-
+static int is_numeric(var *v)
+{
getvar_i(v);
return ((v->type ^ VF_DIRTY) & (VF_NUMBER | VF_USER | VF_DIRTY));
}
/* return 1 when value of v corresponds to true, 0 otherwise */
-static int istrue(var *v) {
-
+static int istrue(var *v)
+{
if (is_numeric(v))
return (v->number == 0) ? 0 : 1;
else
return (v->string && *(v->string)) ? 1 : 0;
}
-/* temporary varables allocator. Last allocated should be first freed */
-static var *nvalloc(int n) {
-
+/* temporary variables allocator. Last allocated should be first freed */
+static var *nvalloc(int n)
+{
nvblock *pb = NULL;
var *v, *r;
int size;
return r;
}
-static void nvfree(var *v) {
-
+static void nvfree(var *v)
+{
var *p;
if (v < cb->nv || v >= cb->pos)
/* Parse next token pointed by global pos, place results into global t.
* If token isn't expected, give away. Return token class
*/
-static unsigned long next_token(unsigned long expected) {
-
+static uint32_t next_token(uint32_t expected)
+{
char *p, *pp, *s;
char *tl;
- unsigned long tc, *ti;
+ uint32_t tc;
+ const uint32_t *ti;
int l;
- static int concat_inserted = FALSE;
- static unsigned long save_tclass, save_info;
- static unsigned long ltclass = TC_OPTERM;
+ static int concat_inserted;
+ static uint32_t save_tclass, save_info;
+ static uint32_t ltclass = TC_OPTERM;
if (t.rollback) {
syntax_error(EMSG_UNEXP_EOS);
if ((*s++ = *p++) == '\\') {
pp = p;
- *(s-1) = process_escape_sequence((const char **)&p);
+ *(s-1) = bb_process_escape_sequence((const char **)&p);
if (*pp == '\\') *s++ = '\\';
if (p == pp) *s++ = *p++;
}
}
*(p-1) = '\0';
tc = TC_VARIABLE;
+ /* also consume whitespace between functionname and bracket */
+ if (! (expected & TC_VARIABLE)) skip_spaces(&p);
if (*p == '(') {
tc = TC_FUNCTION;
} else {
- skip_spaces(&p);
if (*p == '[') {
p++;
tc = TC_ARRAY;
static void rollback_token(void) { t.rollback = TRUE; }
-static node *new_node(unsigned long info) {
-
- register node *n;
+static node *new_node(uint32_t info)
+{
+ node *n;
- n = (node *)xcalloc(sizeof(node), 1);
+ n = (node *)xzalloc(sizeof(node));
n->info = info;
n->lineno = lineno;
return n;
}
-static node *mk_re_node(char *s, node *n, regex_t *re) {
-
+static node *mk_re_node(char *s, node *n, regex_t *re)
+{
n->info = OC_REGEXP;
n->l.re = re;
n->r.ire = re + 1;
return n;
}
-static node *condition(void) {
-
+static node *condition(void)
+{
next_token(TC_SEQSTART);
return parse_expr(TC_SEQTERM);
}
/* parse expression terminated by given argument, return ptr
* to built subtree. Terminator is eaten by parse_expr */
-static node *parse_expr(unsigned long iexp) {
-
+static node *parse_expr(uint32_t iexp)
+{
node sn;
node *cn = &sn;
node *vn, *glptr;
- unsigned long tc, xtc;
+ uint32_t tc, xtc;
var *v;
sn.info = PRIMASK;
if (glptr && (t.info == (OC_COMPARE|VV|P(39)|2))) {
/* input redirection (<) attached to glptr node */
cn = glptr->l.n = new_node(OC_CONCAT|SS|P(37));
+ cn->a.n = glptr;
xtc = TC_OPERAND | TC_UOPPRE;
glptr = NULL;
/* for binary and postfix-unary operators, jump back over
* previous operators with higher priority */
vn = cn;
- while ( ((t.info & PRIMASK) > (vn->a.n->info & PRIMASK2)) ||
+ while ( ((t.info & PRIMASK) > (vn->a.n->info & PRIMASK2)) ||
((t.info == vn->info) && ((t.info & OPCLSMASK) == OC_COLON)) )
vn = vn->a.n;
if ((t.info & OPCLSMASK) == OC_TERNARY)
/* for operands and prefix-unary operators, attach them
* to last node */
vn = cn;
- cn = vn->r.n = new_node(t.info);
+ cn = vn->r.n = new_node(t.info);
cn->a.n = vn;
xtc = TC_OPERAND | TC_UOPPRE | TC_REGEXP;
if (tc & (TC_OPERAND | TC_REGEXP)) {
- xtc = TC_UOPPRE | TC_BINOP | TC_OPERAND | iexp;
- /* one should be very careful with switch on tclass -
+ xtc = TC_UOPPRE | TC_UOPPOST | TC_BINOP | TC_OPERAND | iexp;
+ /* one should be very careful with switch on tclass -
* only simple tclasses should be used! */
switch (tc) {
case TC_VARIABLE:
case TC_ARRAY:
cn->info = OC_VAR;
- if ((v = hash_search(ahash, t.string)) != NULL) {
+ if ((v = hash_search(ahash, t.string)) != NULL) {
cn->info = OC_FNARG;
cn->l.i = v->x.aidx;
} else {
- cn->l.v = newvar(t.string);
+ cn->l.v = newvar(t.string);
}
if (tc & TC_ARRAY) {
cn->info |= xS;
cn->r.n = parse_expr(TC_ARRTERM);
}
- xtc = TC_UOPPOST | TC_UOPPRE | TC_BINOP | TC_OPERAND | iexp;
break;
-
+
case TC_NUMBER:
case TC_STRING:
cn->info = OC_VAR;
- v = cn->l.v = xcalloc(sizeof(var), 1);
+ v = cn->l.v = xzalloc(sizeof(var));
if (tc & TC_NUMBER)
setvar_i(v, t.number);
else
case TC_REGEXP:
mk_re_node(t.string, cn,
- (regex_t *)xcalloc(sizeof(regex_t),2));
+ (regex_t *)xzalloc(sizeof(regex_t)*2));
break;
case TC_FUNCTION:
- cn->info = OC_FUNC;
+ cn->info = OC_FUNC;
cn->r.f = newfunc(t.string);
cn->l.n = condition();
break;
}
/* add node to chain. Return ptr to alloc'd node */
-static node *chain_node(unsigned long info) {
-
- register node *n;
+static node *chain_node(uint32_t info)
+{
+ node *n;
if (! seq->first)
seq->first = seq->last = new_node(0);
return n;
}
-static void chain_expr(unsigned long info) {
-
+static void chain_expr(uint32_t info)
+{
node *n;
n = chain_node(info);
rollback_token();
}
-static node *chain_loop(node *nn) {
-
+static node *chain_loop(node *nn)
+{
node *n, *n2, *save_brk, *save_cont;
save_brk = break_ptr;
}
/* parse group and attach it to chain */
-static void chain_group(void) {
-
- unsigned long c;
+static void chain_group(void)
+{
+ uint32_t c;
node *n, *n2, *n3;
do {
if (c & TC_GRPSTART) {
while(next_token(TC_GRPSEQ | TC_GRPTERM) != TC_GRPTERM) {
+ if (t.tclass & TC_NEWLINE) continue;
rollback_token();
chain_group();
}
}
}
-static void parse_program(char *p) {
-
- unsigned long tclass;
+static void parse_program(char *p)
+{
+ uint32_t tclass;
node *cn;
func *f;
var *v;
/* -------- program execution part -------- */
-static node *mk_splitter(char *s, tsplitter *spl) {
-
- register regex_t *re, *ire;
+static node *mk_splitter(char *s, tsplitter *spl)
+{
+ regex_t *re, *ire;
node *n;
re = &spl->re[0];
ire = &spl->re[1];
n = &spl->n;
- if ((n->info && OPCLSMASK) == OC_REGEXP) {
+ if ((n->info & OPCLSMASK) == OC_REGEXP) {
regfree(re);
regfree(ire);
}
- if (xstrlen(s) > 1) {
+ if (strlen(s) > 1) {
mk_re_node(s, n, re);
} else {
- n->info = (unsigned long) *s;
+ n->info = (uint32_t) *s;
}
return n;
}
/* use node as a regular expression. Supplied with node ptr and regex_t
- * storage space. Return ptr to regex (if result points to preg, it shuold
+ * storage space. Return ptr to regex (if result points to preg, it should
* be later regfree'd manually
*/
-static regex_t *as_regex(node *op, regex_t *preg) {
-
+static regex_t *as_regex(node *op, regex_t *preg)
+{
var *v;
char *s;
}
/* gradually increasing buffer */
-static void qrealloc(char **b, int n, int *size) {
-
+static void qrealloc(char **b, int n, int *size)
+{
if (! *b || n >= *size)
*b = xrealloc(*b, *size = n + (n>>1) + 80);
}
/* resize field storage space */
-static void fsrealloc(int size) {
-
+static void fsrealloc(int size)
+{
static int maxfields = 0;
int i;
nfields = size;
}
-static int awk_split(char *s, node *spl, char **slist) {
-
+static int awk_split(char *s, node *spl, char **slist)
+{
int l, n=0;
char c[4];
char *s1;
regmatch_t pmatch[2];
/* in worst case, each char would be a separate field */
- *slist = s1 = xstrndup(s, xstrlen(s) * 2 + 3);
+ *slist = s1 = xstrndup(s, strlen(s) * 2 + 3);
c[0] = c[1] = (char)spl->info;
c[2] = c[3] = '\0';
}
} else { /* space split */
while (*s) {
- while (isspace(*s)) s++;
+ s = skip_whitespace(s);
if (! *s) break;
n++;
while (*s && !isspace(*s))
return n;
}
-static void split_f0(void) {
-
+static void split_f0(void)
+{
static char *fstrings = NULL;
int i, n;
char *s;
}
/* perform additional actions when some internal variables changed */
-static void handle_special(var *v) {
-
+static void handle_special(var *v)
+{
int n;
char *b, *sep, *s;
int sl, l, len, i, bsize;
/* recalculate $0 */
sep = getvar_s(V[OFS]);
- sl = xstrlen(sep);
+ sl = strlen(sep);
b = NULL;
len = 0;
for (i=0; i<n; i++) {
s = getvar_s(&Fields[i]);
- l = xstrlen(s);
+ l = strlen(s);
if (b) {
memcpy(b+len, sep, sl);
len += sl;
memcpy(b+len, s, l);
len += l;
}
- b[len] = '\0';
+ if (b) b[len] = '\0';
setvar_p(V[F0], b);
is_f0_split = TRUE;
}
/* step through func/builtin/etc arguments */
-static node *nextarg(node **pn) {
-
+static node *nextarg(node **pn)
+{
node *n;
n = *pn;
return n;
}
-static void hashwalk_init(var *v, xhash *array) {
-
+static void hashwalk_init(var *v, xhash *array)
+{
char **w;
hash_item *hi;
int i;
free(v->x.walker);
v->type |= VF_WALK;
- w = v->x.walker = (char **)xcalloc(2 + 2*sizeof(char *) + array->glen, 1);
+ w = v->x.walker = (char **)xzalloc(2 + 2*sizeof(char *) + array->glen);
*w = *(w+1) = (char *)(w + 2);
for (i=0; i<array->csize; i++) {
hi = array->items[i];
}
}
-static int hashwalk_next(var *v) {
-
+static int hashwalk_next(var *v)
+{
char **w;
w = v->x.walker;
}
/* evaluate node, return 1 when result is true, 0 otherwise */
-static int ptest(node *pattern) {
+static int ptest(node *pattern)
+{
static var v;
-
return istrue(evaluate(pattern, &v));
}
/* read next record from stream rsm into a variable v */
-static int awk_getline(rstream *rsm, var *v) {
-
+static int awk_getline(rstream *rsm, var *v)
+{
char *b;
regmatch_t pmatch[2];
- int p, pp=0, size;
+ int a, p, pp=0, size;
int fd, so, eo, r, rp;
- char c, *s;
+ char c, *m, *s;
/* we're using our own buffer since we need access to accumulating
* characters
*/
fd = fileno(rsm->F);
- b = rsm->buffer;
+ m = rsm->buffer;
+ a = rsm->adv;
p = rsm->pos;
size = rsm->size;
c = (char) rsplitter.n.info;
rp = 0;
+
+ if (! m) qrealloc(&m, 256, &size);
do {
- qrealloc(&b, p+128, &size);
+ b = m + a;
so = eo = p;
r = 1;
if (p > 0) {
}
} else if (c != '\0') {
s = strchr(b+pp, c);
+ if (! s) s = memchr(b+pp, '\0', p - pp);
if (s) {
so = eo = s-b;
eo++;
}
}
+ if (a > 0) {
+ memmove(m, (const void *)(m+a), p+1);
+ b = m;
+ a = 0;
+ }
+
+ qrealloc(&m, a+p+128, &size);
+ b = m + a;
pp = p;
p += safe_read(fd, b+p, size-p-1);
if (p < pp) {
b[eo] = c;
}
- p -= eo;
- if (p) memmove(b, (const void *)(b+eo), p+1);
-
- rsm->buffer = b;
- rsm->pos = p;
+ rsm->buffer = m;
+ rsm->adv = a + eo;
+ rsm->pos = p - eo;
rsm->size = size;
return r;
}
-static int fmt_num(char *b, int size, char *format, double n, int int_as_int) {
-
+static int fmt_num(char *b, int size, const char *format, double n, int int_as_int)
+{
int r=0;
- char c, *s=format;
+ char c;
+ const char *s=format;
if (int_as_int && n == (int)n) {
r = snprintf(b, size, "%d", (int)n);
/* formatted output into an allocated buffer, return ptr to buffer */
-static char *awk_printf(node *n) {
-
+static char *awk_printf(node *n)
+{
char *b = NULL;
char *fmt, *s, *s1, *f;
int i, j, incr, bsize;
s = f;
while (*f && (*f != '%' || *(++f) == '%'))
f++;
- while (*f && !isalpha(*f))
+ while (*f && !isalpha(*f))
f++;
incr = (f - s) + MAXVARFMT;
is_numeric(arg) ? (char)getvar_i(arg) : *getvar_s(arg));
} else if (c == 's') {
- s1 = getvar_s(arg);
- qrealloc(&b, incr+i+xstrlen(s1), &bsize);
+ s1 = getvar_s(arg);
+ qrealloc(&b, incr+i+strlen(s1), &bsize);
i += sprintf(b+i, s, s1);
} else {
* all matches. If src or dst is NULL, use $0. If ex=TRUE, enable
* subexpression matching (\1-\9)
*/
-static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex) {
-
+static int awk_sub(node *rn, char *repl, int nm, var *src, var *dest, int ex)
+{
char *ds = NULL;
char *sp, *s;
int c, i, j, di, rl, so, eo, nbs, n, dssize;
i = di = 0;
sp = getvar_s(src);
- rl = xstrlen(repl);
+ rl = strlen(repl);
while (regexec(re, sp, 10, pmatch, sp==getvar_s(src) ? 0:REG_NOTBOL) == 0) {
so = pmatch[0].rm_so;
eo = pmatch[0].rm_eo;
return i;
}
-static var *exec_builtin(node *op, var *res) {
-
+static var *exec_builtin(node *op, var *res)
+{
int (*to_xxx)(int);
var *tv;
node *an[4];
regex_t sreg, *re;
static tsplitter tspl;
node *spl;
- unsigned long isr, info;
+ uint32_t isr, info;
int nargs;
time_t tt;
char *s, *s1;
break;
case B_ss:
- l = xstrlen(as[0]);
+ l = strlen(as[0]);
i = getvar_i(av[1]) - 1;
if (i>l) i=l; if (i<0) i=0;
n = (nargs > 2) ? getvar_i(av[2]) : l-i;
s[n] = '\0';
setvar_p(res, s);
break;
+
+ case B_an:
+ setvar_i(res, (long)getvar_i(av[0]) & (long)getvar_i(av[1]));
+ break;
+
+ case B_co:
+ setvar_i(res, ~(long)getvar_i(av[0]));
+ break;
+
+ case B_ls:
+ setvar_i(res, (long)getvar_i(av[0]) << (long)getvar_i(av[1]));
+ break;
+
+ case B_or:
+ setvar_i(res, (long)getvar_i(av[0]) | (long)getvar_i(av[1]));
+ break;
+
+ case B_rs:
+ setvar_i(res, (long)((unsigned long)getvar_i(av[0]) >> (unsigned long)getvar_i(av[1])));
+ break;
+
+ case B_xo:
+ setvar_i(res, (long)getvar_i(av[0]) ^ (long)getvar_i(av[1]));
+ break;
case B_lo:
to_xxx = tolower;
case B_ix:
n = 0;
- ll = xstrlen(as[1]);
- l = xstrlen(as[0]) - ll;
+ ll = strlen(as[1]);
+ l = strlen(as[0]) - ll;
if (ll > 0 && l >= 0) {
if (! icase) {
s = strstr(as[0], as[1]);
*/
#define XC(n) ((n) >> 8)
-static var *evaluate(node *op, var *res) {
-
- /* This procedure is recursive so we should count every byte */
+static var *evaluate(node *op, var *res)
+{
+ /* This procedure is recursive so we should count every byte */
static var *fnargs = NULL;
static unsigned int seed = 1;
static regex_t sreg;
double d;
int i;
} L, R;
- unsigned long opinfo;
+ uint32_t opinfo;
short opn;
union {
char *s;
FILE *F;
var *v;
regex_t *re;
- unsigned long info;
+ uint32_t info;
} X;
if (! op)
opn = (short)(opinfo & OPNMASK);
lineno = op->lineno;
- /* execute inevitable things */
+ /* execute inevitable things */
op1 = op->l.n;
if (opinfo & OF_RES1) X.v = L.v = evaluate(op1, v1);
if (opinfo & OF_RES2) R.v = evaluate(op->r.n, v1+1);
/* just evaluate an expression, also used as unconditional jump */
case XC( OC_EXEC ):
- break;
+ break;
/* branch, used in if-else and various loops */
case XC( OC_BR ):
- op = istrue(L.v) ? op->a.n : op->r.n;
+ op = istrue(L.v) ? op->a.n : op->r.n;
break;
/* initialize for-in loop */
case XC( OC_WALKINIT ):
- hashwalk_init(L.v, iamarray(R.v));
+ hashwalk_init(L.v, iamarray(R.v));
break;
/* get next array item */
case XC( OC_PRINT ):
case XC( OC_PRINTF ):
X.F = stdout;
- if (op->r.n) {
+ if (op->r.n) {
X.rsm = newfile(R.s);
if (! X.rsm->F) {
if (opn == '|') {
if((X.rsm->F = popen(R.s, "w")) == NULL)
- perror_msg_and_die("popen");
+ bb_perror_msg_and_die("popen");
X.rsm->is_pipe = 1;
} else {
X.rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
}
if ((opinfo & OPCLSMASK) == OC_PRINT) {
- if (! op1) {
+ if (! op1) {
fputs(getvar_s(V[F0]), X.F);
} else {
while (op1) {
L.v = evaluate(nextarg(&op1), v1);
if (L.v->type & VF_NUMBER) {
fmt_num(buf, MAXVARFMT, getvar_s(V[OFMT]),
- getvar_i(L.v), TRUE);
+ getvar_i(L.v), TRUE);
fputs(buf, X.F);
} else {
fputs(getvar_s(L.v), X.F);
break;
case XC( OC_DELETE ):
- X.info = op1->info & OPCLSMASK;
- if (X.info == OC_VAR) {
+ X.info = op1->info & OPCLSMASK;
+ if (X.info == OC_VAR) {
R.v = op1->l.v;
} else if (X.info == OC_FNARG) {
R.v = &fnargs[op1->l.i];
runtime_error(EMSG_NOT_ARRAY);
}
- if (op1->r.n) {
+ if (op1->r.n) {
clrvar(L.v);
L.s = getvar_s(evaluate(op1->r.n, v1));
hash_remove(iamarray(R.v), L.s);
break;
case XC( OC_NEWSOURCE ):
- programname = op->l.s;
+ programname = op->l.s;
break;
case XC( OC_RETURN ):
break;
case XC( OC_NEXTFILE ):
- nextfile = TRUE;
+ nextfile = TRUE;
case XC( OC_NEXT ):
- nextrec = TRUE;
+ nextrec = TRUE;
case XC( OC_DONE ):
clrvar(res);
break;
case XC( OC_EXIT ):
- awk_exit(L.d);
+ awk_exit(L.d);
/* -- recursive node type -- */
case XC( OC_VAR ):
- L.v = op->l.v;
+ L.v = op->l.v;
if (L.v == V[NF])
split_f0();
goto v_cont;
case XC( OC_FNARG ):
- L.v = &fnargs[op->l.i];
+ L.v = &fnargs[op->l.i];
v_cont:
- res = (op->r.n) ? findvar(iamarray(L.v), R.s) : L.v;
+ res = (op->r.n) ? findvar(iamarray(L.v), R.s) : L.v;
break;
case XC( OC_IN ):
break;
case XC( OC_REGEXP ):
- op1 = op;
+ op1 = op;
L.s = getvar_s(V[F0]);
goto re_cont;
case XC( OC_MATCH ):
- op1 = op->r.n;
+ op1 = op->r.n;
re_cont:
X.re = as_regex(op1, &sreg);
R.i = regexec(X.re, L.s, 0, NULL, 0);
break;
case XC( OC_MOVE ):
- /* if source is a temporary string, jusk relink it to dest */
+ /* if source is a temporary string, jusk relink it to dest */
if (R.v == v1+1 && R.v->string) {
res = setvar_p(L.v, R.v->string);
R.v->string = NULL;
} else {
- res = copyvar(L.v, R.v);
+ res = copyvar(L.v, R.v);
}
break;
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);
res = evaluate(istrue(L.v) ? op->r.n->l.n : op->r.n->r.n, res);
break;
case XC( OC_FUNC ):
- if (! op->r.f->body.first)
+ if (! op->r.f->body.first)
runtime_error(EMSG_UNDEF_FUNC);
X.v = R.v = nvalloc(op->r.f->nargs+1);
case XC( OC_GETLINE ):
case XC( OC_PGETLINE ):
- if (op1) {
+ if (op1) {
X.rsm = newfile(L.s);
if (! X.rsm->F) {
if ((opinfo & OPCLSMASK) == OC_PGETLINE) {
setvar_i(res, L.i);
break;
- /* simple builtins */
+ /* simple builtins */
case XC( OC_FBLTIN ):
- switch (opn) {
+ switch (opn) {
case F_in:
- R.d = (int)L.d;
+ R.d = (int)L.d;
break;
case F_rn:
- R.d = (double)rand() / (double)RAND_MAX;
+ R.d = (double)rand() / (double)RAND_MAX;
break;
#ifdef CONFIG_FEATURE_AWK_MATH
case F_co:
- R.d = cos(L.d);
+ R.d = cos(L.d);
break;
case F_ex:
- R.d = exp(L.d);
+ R.d = exp(L.d);
break;
case F_lg:
- R.d = log(L.d);
+ R.d = log(L.d);
break;
case F_si:
- R.d = sin(L.d);
+ R.d = sin(L.d);
break;
case F_sq:
- R.d = sqrt(L.d);
+ R.d = sqrt(L.d);
break;
#else
case F_co:
break;
case F_le:
- if (! op1)
+ if (! op1)
L.s = getvar_s(V[F0]);
- R.d = xstrlen(L.s);
+ R.d = strlen(L.s);
break;
case F_sy:
fflush(NULL);
- R.d = (L.s && *L.s) ? system(L.s) : 0;
+ R.d = (L.s && *L.s) ? (system(L.s) >> 8) : 0;
break;
case F_ff:
break;
case XC( OC_SPRINTF ):
- setvar_p(res, awk_printf(op1));
+ setvar_p(res, awk_printf(op1));
break;
case XC( OC_UNARY ):
- X.v = R.v;
- L.d = R.d = getvar_i(R.v);
- switch (opn) {
+ X.v = R.v;
+ L.d = R.d = getvar_i(R.v);
+ switch (opn) {
case 'P':
- L.d = ++R.d;
+ L.d = ++R.d;
goto r_op_change;
case 'p':
- R.d++;
+ R.d++;
goto r_op_change;
case 'M':
- L.d = --R.d;
+ L.d = --R.d;
goto r_op_change;
case 'm':
- R.d--;
+ R.d--;
goto r_op_change;
case '!':
- L.d = istrue(X.v) ? 0 : 1;
+ L.d = istrue(X.v) ? 0 : 1;
break;
case '-':
- L.d = -R.d;
+ L.d = -R.d;
break;
r_op_change:
setvar_i(X.v, R.d);
break;
case XC( OC_FIELD ):
- R.i = (int)getvar_i(R.v);
- if (R.i == 0) {
+ R.i = (int)getvar_i(R.v);
+ if (R.i == 0) {
res = V[F0];
} else {
split_f0();
/* concatenation (" ") and index joining (",") */
case XC( OC_CONCAT ):
case XC( OC_COMMA ):
- opn = xstrlen(L.s) + xstrlen(R.s) + 2;
- X.s = (char *)xmalloc(opn);
+ opn = strlen(L.s) + strlen(R.s) + 2;
+ X.s = (char *)xmalloc(opn);
strcpy(X.s, L.s);
if ((opinfo & OPCLSMASK) == OC_COMMA) {
L.s = getvar_s(V[SUBSEP]);
- X.s = (char *)xrealloc(X.s, opn + xstrlen(L.s));
+ X.s = (char *)xrealloc(X.s, opn + strlen(L.s));
strcat(X.s, L.s);
}
strcat(X.s, R.s);
case XC( OC_BINARY ):
case XC( OC_REPLACE ):
- R.d = getvar_i(R.v);
+ R.d = getvar_i(R.v);
switch (opn) {
case '+':
- L.d += R.d;
+ L.d += R.d;
break;
case '-':
- L.d -= R.d;
+ L.d -= R.d;
break;
case '*':
- L.d *= R.d;
+ L.d *= R.d;
break;
case '/':
- if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
- L.d /= R.d;
+ if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
+ L.d /= R.d;
break;
case '&':
#ifdef CONFIG_FEATURE_AWK_MATH
- L.d = pow(L.d, R.d);
+ L.d = pow(L.d, R.d);
#else
runtime_error(EMSG_NO_MATH);
#endif
break;
case '%':
- if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
- L.d -= (int)(L.d / R.d) * R.d;
+ if (R.d == 0) runtime_error(EMSG_DIV_BY_ZERO);
+ L.d -= (int)(L.d / R.d) * R.d;
break;
}
res = setvar_i(((opinfo&OPCLSMASK) == OC_BINARY) ? res : X.v, L.d);
}
switch (opn & 0xfe) {
case 0:
- R.i = (L.d > 0);
+ R.i = (L.d > 0);
break;
case 2:
- R.i = (L.d >= 0);
+ R.i = (L.d >= 0);
break;
case 4:
- R.i = (L.d == 0);
+ R.i = (L.d == 0);
break;
}
setvar_i(res, (opn & 0x1 ? R.i : !R.i) ? 1 : 0);
break;
default:
- runtime_error(EMSG_POSSIBLE_ERROR);
+ runtime_error(EMSG_POSSIBLE_ERROR);
}
if ((opinfo & OPCLSMASK) <= SHIFT_TIL_THIS)
op = op->a.n;
/* -------- main & co. -------- */
-static int awk_exit(int r) {
-
+static int awk_exit(int r)
+{
unsigned int i;
hash_item *hi;
+ static var tv;
+
+ if (! exiting) {
+ exiting = TRUE;
+ nextrec = FALSE;
+ evaluate(endseq.first, &tv);
+ }
/* waiting for children */
for (i=0; i<fdhash->csize; i++) {
/* if expr looks like "var=value", perform assignment and return 1,
* otherwise return 0 */
-static int is_assignment(char *expr) {
-
+static int is_assignment(const char *expr)
+{
char *exprc, *s, *s0, *s1;
exprc = xstrdup(expr);
}
/* switch to next input file */
-static rstream *next_input_file(void) {
-
+static rstream *next_input_file(void)
+{
static rstream rsm;
FILE *F = NULL;
char *fname, *ind;
if (rsm.F) fclose(rsm.F);
rsm.F = NULL;
- rsm.pos = 0;
+ rsm.pos = rsm.adv = 0;
do {
if (getvar_i(V[ARGIND])+1 >= getvar_i(V[ARGC])) {
return &rsm;
}
-extern int awk_main(int argc, char **argv) {
-
+int awk_main(int argc, char **argv)
+{
+ unsigned opt;
+ char *opt_F, *opt_v, *opt_W;
char *s, *s1;
- int i, j, c;
+ int i, j, c, flen;
var *v;
static var tv;
char **envp;
for (envp=environ; *envp; envp++) {
s = xstrdup(*envp);
s1 = strchr(s, '=');
+ if (!s1) {
+ goto keep_going;
+ }
*(s1++) = '\0';
setvar_u(findvar(iamarray(V[ENVIRON]), s), s1);
+keep_going:
free(s);
}
- while((c = getopt(argc, argv, "F:v:f:W:")) != EOF) {
- switch (c) {
- case 'F':
- setvar_s(V[FS], optarg);
- break;
- case 'v':
- if (! is_assignment(optarg))
- show_usage();
- break;
- case 'f':
- from_file = TRUE;
- F = afopen(programname = optarg, "r");
- s = NULL;
- /* one byte is reserved for some trick in next_token */
- for (i=j=1; j>0; i+=j) {
- s = (char *)xrealloc(s, i+4096);
- j = fread(s+i, 1, 4094, F);
- }
- s[i] = '\0';
- fclose(F);
- parse_program(s+1);
- free(s);
- break;
- case 'W':
- error_msg("Warning: unrecognized option '-W %s' ignored\n", optarg);
- break;
-
- default:
- show_usage();
+ opt = getopt32(argc, argv, "F:v:f:W:", &opt_F, &opt_v, &programname, &opt_W);
+ if (opt & 0x1) setvar_s(V[FS], opt_F); // -F
+ if (opt & 0x2) if (!is_assignment(opt_v)) bb_show_usage(); // -v
+ if (opt & 0x4) { // -f
+ from_file = TRUE;
+ F = afopen(programname, "r");
+ s = NULL;
+ /* one byte is reserved for some trick in next_token */
+ if (fseek(F, 0, SEEK_END) == 0) {
+ flen = ftell(F);
+ s = (char *)xmalloc(flen+4);
+ fseek(F, 0, SEEK_SET);
+ i = 1 + fread(s+1, 1, flen, F);
+ } else {
+ for (i=j=1; j>0; i+=j) {
+ s = (char *)xrealloc(s, i+4096);
+ j = fread(s+i, 1, 4094, F);
+ }
}
+ s[i] = '\0';
+ fclose(F);
+ parse_program(s+1);
+ free(s);
}
+ if (opt & 0x8) // -W
+ bb_error_msg("warning: unrecognized option '-W %s' ignored", opt_W);
if (!from_file) {
if (argc == optind)
- show_usage();
- programname="cmd. line";
+ bb_show_usage();
+ programname = "cmd. line";
parse_program(argv[optind++]);
}
}
- evaluate(endseq.first, &tv);
awk_exit(EXIT_SUCCESS);
return 0;
}
-
projects / oweals / busybox.git / blobdiff