*
* 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 <unistd.h>
#include <errno.h>
#include <string.h>
+#include <strings.h>
#include <time.h>
#include <math.h>
#include <ctype.h>
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) */
/* Tree node */
typedef struct node_s {
- unsigned long info;
+ uint32_t info;
unsigned short lineno;
union {
struct node_s *n;
"\3END" "\0"
;
-static unsigned long tokeninfo[] = {
+static const uint32_t tokeninfo[] = {
0,
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 exiting = 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;
/* function prototypes */
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)
{
- bb_error_msg("%s:%i: %s", programname, lineno, message);
- 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)
+static unsigned int hashidx(const char *name)
{
register unsigned int idx=0;
{
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;
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;
if (++hash->nel / hash->csize > 10)
hash_rebuild(hash);
- l = bb_strlen(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;
while (*phi) {
hi = *phi;
if (strcmp(hi->name, name) == 0) {
- hash->glen -= (bb_strlen(name) + 1);
+ hash->glen -= (strlen(name) + 1);
hash->nel--;
*phi = hi->next;
free(hi);
register char *p = *s;
while(*p == ' ' || *p == '\t' ||
- (*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
+ (*p == '\\' && *(p+1) == '\n' && (++p, ++t.lineno))) {
p++;
}
*s = p;
}
/* 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) ? bb_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;
}
/* set array element to user string */
-static void setari_u(var *a, int idx, char *s)
+static void setari_u(var *a, int idx, const char *s)
{
register var *v;
static char sidx[12];
return v->number;
}
-static var *copyvar(var *dest, var *src)
+static var *copyvar(var *dest, const var *src)
{
if (dest != src) {
clrvar(dest);
/* 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) {
}
*(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)
+static node *new_node(uint32_t info)
{
register node *n;
- n = (node *)xcalloc(sizeof(node), 1);
+ n = (node *)xzalloc(sizeof(node));
n->info = info;
n->lineno = lineno;
return n;
/* 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;
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:
}
/* add node to chain. Return ptr to alloc'd node */
-static node *chain_node(unsigned long info)
+static node *chain_node(uint32_t info)
{
register node *n;
return n;
}
-static void chain_expr(unsigned long info)
+static void chain_expr(uint32_t info)
{
node *n;
/* parse group and attach it to chain */
static void chain_group(void)
{
- unsigned long c;
+ uint32_t c;
node *n, *n2, *n3;
do {
static void parse_program(char *p)
{
- unsigned long tclass;
+ uint32_t tclass;
node *cn;
func *f;
var *v;
regfree(re);
regfree(ire);
}
- if (bb_strlen(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;
regmatch_t pmatch[2];
/* in worst case, each char would be a separate field */
- *slist = s1 = bb_xstrndup(s, bb_strlen(s) * 2 + 3);
+ *slist = s1 = bb_xstrndup(s, strlen(s) * 2 + 3);
c[0] = c[1] = (char)spl->info;
c[2] = c[3] = '\0';
/* recalculate $0 */
sep = getvar_s(V[OFS]);
- sl = bb_strlen(sep);
+ sl = strlen(sep);
b = NULL;
len = 0;
for (i=0; i<n; i++) {
s = getvar_s(&Fields[i]);
- l = bb_strlen(s);
+ l = strlen(s);
if (b) {
memcpy(b+len, sep, sl);
len += sl;
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];
}
} 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++;
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);
} else if (c == 's') {
s1 = getvar_s(arg);
- qrealloc(&b, incr+i+bb_strlen(s1), &bsize);
+ qrealloc(&b, incr+i+strlen(s1), &bsize);
i += sprintf(b+i, s, s1);
} else {
i = di = 0;
sp = getvar_s(src);
- rl = bb_strlen(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;
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 = bb_strlen(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;
case B_ix:
n = 0;
- ll = bb_strlen(as[1]);
- l = bb_strlen(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]);
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)
case F_le:
if (! op1)
L.s = getvar_s(V[F0]);
- R.d = bb_strlen(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:
/* concatenation (" ") and index joining (",") */
case XC( OC_CONCAT ):
case XC( OC_COMMA ):
- opn = bb_strlen(L.s) + bb_strlen(R.s) + 2;
+ 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 + bb_strlen(L.s));
+ X.s = (char *)xrealloc(X.s, opn + strlen(L.s));
strcat(X.s, L.s);
}
strcat(X.s, R.s);
/* 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;
return &rsm;
}
-extern int awk_main(int argc, char **argv)
+int awk_main(int argc, char **argv)
{
char *s, *s1;
- int i, j, c;
+ int i, j, c, flen;
var *v;
static var tv;
char **envp;
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);
+ 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);