mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-23 11:18:54 +00:00
70029cff55
took about 15 files off the vendor branch for what turned out to be good reason a Gawk update takes an order of magnitude more effort than it should...
572 lines
11 KiB
C
572 lines
11 KiB
C
/*
|
|
* node.c -- routines for node management
|
|
*/
|
|
|
|
/*
|
|
* 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
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include "awk.h"
|
|
|
|
/* r_force_number --- force a value to be numeric */
|
|
|
|
AWKNUM
|
|
r_force_number(register NODE *n)
|
|
{
|
|
register char *cp;
|
|
register char *cpend;
|
|
char save;
|
|
char *ptr;
|
|
unsigned int newflags;
|
|
extern double strtod();
|
|
|
|
#ifdef GAWKDEBUG
|
|
if (n == NULL)
|
|
cant_happen();
|
|
if (n->type != Node_val)
|
|
cant_happen();
|
|
if(n->flags == 0)
|
|
cant_happen();
|
|
if (n->flags & NUM)
|
|
return n->numbr;
|
|
#endif
|
|
|
|
/* all the conditionals are an attempt to avoid the expensive strtod */
|
|
|
|
n->numbr = 0.0;
|
|
n->flags |= NUM;
|
|
n->flags &= ~UNINITIALIZED;
|
|
|
|
if (n->stlen == 0) {
|
|
if (0 && do_lint)
|
|
lintwarn(_("can't convert string to float"));
|
|
return 0.0;
|
|
}
|
|
|
|
cp = n->stptr;
|
|
if (ISALPHA(*cp)) {
|
|
if (0 && do_lint)
|
|
lintwarn(_("can't convert string to float"));
|
|
return 0.0;
|
|
}
|
|
|
|
cpend = cp + n->stlen;
|
|
while (cp < cpend && ISSPACE(*cp))
|
|
cp++;
|
|
if (cp == cpend || ISALPHA(*cp)) {
|
|
if (0 && do_lint)
|
|
lintwarn(_("can't convert string to float"));
|
|
return 0.0;
|
|
}
|
|
|
|
if (n->flags & MAYBE_NUM) {
|
|
newflags = NUMBER;
|
|
n->flags &= ~MAYBE_NUM;
|
|
} else
|
|
newflags = 0;
|
|
if (cpend - cp == 1) {
|
|
if (ISDIGIT(*cp)) {
|
|
n->numbr = (AWKNUM)(*cp - '0');
|
|
n->flags |= newflags;
|
|
} else if (0 && do_lint)
|
|
lintwarn(_("can't convert string to float"));
|
|
return n->numbr;
|
|
}
|
|
|
|
if (do_non_decimal_data) {
|
|
errno = 0;
|
|
if (! do_traditional && isnondecimal(cp)) {
|
|
n->numbr = nondec2awknum(cp, cpend - cp);
|
|
goto finish;
|
|
}
|
|
}
|
|
|
|
errno = 0;
|
|
save = *cpend;
|
|
*cpend = '\0';
|
|
n->numbr = (AWKNUM) strtod((const char *) cp, &ptr);
|
|
|
|
/* POSIX says trailing space is OK for NUMBER */
|
|
while (ISSPACE(*ptr))
|
|
ptr++;
|
|
*cpend = save;
|
|
finish:
|
|
/* the >= should be ==, but for SunOS 3.5 strtod() */
|
|
if (errno == 0 && ptr >= cpend) {
|
|
n->flags |= newflags;
|
|
} else {
|
|
if (0 && do_lint && ptr < cpend)
|
|
lintwarn(_("can't convert string to float"));
|
|
errno = 0;
|
|
}
|
|
|
|
return n->numbr;
|
|
}
|
|
|
|
/*
|
|
* the following lookup table is used as an optimization in force_string
|
|
* (more complicated) variations on this theme didn't seem to pay off, but
|
|
* systematic testing might be in order at some point
|
|
*/
|
|
static const char *values[] = {
|
|
"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9",
|
|
};
|
|
#define NVAL (sizeof(values)/sizeof(values[0]))
|
|
|
|
/* format_val --- format a numeric value based on format */
|
|
|
|
NODE *
|
|
format_val(char *format, int index, register NODE *s)
|
|
{
|
|
char buf[BUFSIZ];
|
|
register char *sp = buf;
|
|
double val;
|
|
char *orig, *trans, save;
|
|
|
|
if (! do_traditional && (s->flags & INTLSTR) != 0) {
|
|
save = s->stptr[s->stlen];
|
|
s->stptr[s->stlen] = '\0';
|
|
|
|
orig = s->stptr;
|
|
trans = dgettext(TEXTDOMAIN, orig);
|
|
|
|
s->stptr[s->stlen] = save;
|
|
return tmp_string(trans, strlen(trans));
|
|
}
|
|
|
|
/* not an integral value, or out of range */
|
|
if ((val = double_to_int(s->numbr)) != s->numbr
|
|
|| val < LONG_MIN || val > LONG_MAX) {
|
|
/*
|
|
* Once upon a time, if GFMT_WORKAROUND wasn't defined,
|
|
* we just blindly did this:
|
|
* sprintf(sp, format, s->numbr);
|
|
* s->stlen = strlen(sp);
|
|
* s->stfmt = (char) index;
|
|
* but that's no good if, e.g., OFMT is %s. So we punt,
|
|
* and just always format the value ourselves.
|
|
*/
|
|
|
|
NODE *dummy, *r;
|
|
unsigned short oflags;
|
|
extern NODE **fmt_list; /* declared in eval.c */
|
|
|
|
/* create dummy node for a sole use of format_tree */
|
|
getnode(dummy);
|
|
dummy->type = Node_expression_list;
|
|
dummy->lnode = s;
|
|
dummy->rnode = NULL;
|
|
oflags = s->flags;
|
|
s->flags |= PERM; /* prevent from freeing by format_tree() */
|
|
r = format_tree(format, fmt_list[index]->stlen, dummy, 2);
|
|
s->flags = oflags;
|
|
s->stfmt = (char) index;
|
|
s->stlen = r->stlen;
|
|
s->stptr = r->stptr;
|
|
freenode(r); /* Do not free_temp(r)! We want */
|
|
freenode(dummy); /* to keep s->stptr == r->stpr. */
|
|
|
|
goto no_malloc;
|
|
} else {
|
|
/* integral value */
|
|
/* force conversion to long only once */
|
|
register long num = (long) val;
|
|
if (num < NVAL && num >= 0) {
|
|
sp = (char *) values[num];
|
|
s->stlen = 1;
|
|
} else {
|
|
(void) sprintf(sp, "%ld", num);
|
|
s->stlen = strlen(sp);
|
|
}
|
|
s->stfmt = -1;
|
|
}
|
|
emalloc(s->stptr, char *, s->stlen + 2, "format_val");
|
|
memcpy(s->stptr, sp, s->stlen+1);
|
|
no_malloc:
|
|
s->stref = 1;
|
|
s->flags |= STR;
|
|
s->flags &= ~UNINITIALIZED;
|
|
return s;
|
|
}
|
|
|
|
/* r_force_string --- force a value to be a string */
|
|
|
|
NODE *
|
|
r_force_string(register NODE *s)
|
|
{
|
|
NODE *ret;
|
|
#ifdef GAWKDEBUG
|
|
if (s == NULL)
|
|
cant_happen();
|
|
if (s->type != Node_val)
|
|
cant_happen();
|
|
if (s->stref <= 0)
|
|
cant_happen();
|
|
if ((s->flags & STR) != 0
|
|
&& (s->stfmt == -1 || s->stfmt == CONVFMTidx))
|
|
return s;
|
|
#endif
|
|
|
|
ret = format_val(CONVFMT, CONVFMTidx, s);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* dupnode:
|
|
* Duplicate a node. (For strings, "duplicate" means crank up the
|
|
* reference count.)
|
|
*/
|
|
|
|
NODE *
|
|
dupnode(NODE *n)
|
|
{
|
|
register NODE *r;
|
|
|
|
if ((n->flags & TEMP) != 0) {
|
|
n->flags &= ~TEMP;
|
|
n->flags |= MALLOC;
|
|
return n;
|
|
}
|
|
if ((n->flags & PERM) != 0)
|
|
return n;
|
|
if ((n->flags & (MALLOC|STR)) == (MALLOC|STR)) {
|
|
if (n->stref < LONG_MAX)
|
|
n->stref++;
|
|
return n;
|
|
}
|
|
getnode(r);
|
|
*r = *n;
|
|
r->flags &= ~(PERM|TEMP|FIELD);
|
|
r->flags |= MALLOC;
|
|
if (n->type == Node_val && (n->flags & STR) != 0) {
|
|
r->stref = 1;
|
|
emalloc(r->stptr, char *, r->stlen + 2, "dupnode");
|
|
memcpy(r->stptr, n->stptr, r->stlen);
|
|
r->stptr[r->stlen] = '\0';
|
|
}
|
|
return r;
|
|
}
|
|
|
|
/* copy_node --- force a brand new copy of a node to be allocated */
|
|
|
|
NODE *
|
|
copynode(NODE *old)
|
|
{
|
|
NODE *new;
|
|
int saveflags;
|
|
|
|
assert(old != NULL);
|
|
saveflags = old->flags;
|
|
old->flags &= ~(MALLOC|PERM);
|
|
new = dupnode(old);
|
|
old->flags = saveflags;
|
|
return new;
|
|
}
|
|
|
|
/* mk_number --- allocate a node with defined number */
|
|
|
|
NODE *
|
|
mk_number(AWKNUM x, unsigned int flags)
|
|
{
|
|
register NODE *r;
|
|
|
|
getnode(r);
|
|
r->type = Node_val;
|
|
r->numbr = x;
|
|
r->flags = flags | SCALAR;
|
|
#ifdef GAWKDEBUG
|
|
r->stref = 1;
|
|
r->stptr = NULL;
|
|
r->stlen = 0;
|
|
#endif
|
|
return r;
|
|
}
|
|
|
|
/* make_str_node --- make a string node */
|
|
|
|
NODE *
|
|
make_str_node(char *s, size_t len, int flags)
|
|
{
|
|
register NODE *r;
|
|
|
|
getnode(r);
|
|
r->type = Node_val;
|
|
r->flags = (STRING|STR|MALLOC|SCALAR);
|
|
if (flags & ALREADY_MALLOCED)
|
|
r->stptr = s;
|
|
else {
|
|
emalloc(r->stptr, char *, len + 2, s);
|
|
memcpy(r->stptr, s, len);
|
|
}
|
|
r->stptr[len] = '\0';
|
|
|
|
if ((flags & SCAN) != 0) { /* scan for escape sequences */
|
|
char *pf;
|
|
register char *ptm;
|
|
register int c;
|
|
register char *end;
|
|
|
|
end = &(r->stptr[len]);
|
|
for (pf = ptm = r->stptr; pf < end;) {
|
|
c = *pf++;
|
|
if (c == '\\') {
|
|
c = parse_escape(&pf);
|
|
if (c < 0) {
|
|
if (do_lint)
|
|
lintwarn(_("backslash at end of string"));
|
|
c = '\\';
|
|
}
|
|
*ptm++ = c;
|
|
} else
|
|
*ptm++ = c;
|
|
}
|
|
len = ptm - r->stptr;
|
|
erealloc(r->stptr, char *, len + 1, "make_str_node");
|
|
r->stptr[len] = '\0';
|
|
r->flags |= PERM;
|
|
}
|
|
r->stlen = len;
|
|
r->stref = 1;
|
|
r->stfmt = -1;
|
|
|
|
return r;
|
|
}
|
|
|
|
/* tmp_string --- allocate a temporary string */
|
|
|
|
NODE *
|
|
tmp_string(char *s, size_t len)
|
|
{
|
|
register NODE *r;
|
|
|
|
r = make_string(s, len);
|
|
r->flags |= TEMP;
|
|
return r;
|
|
}
|
|
|
|
/* more_nodes --- allocate more nodes */
|
|
|
|
#define NODECHUNK 100
|
|
|
|
NODE *nextfree = NULL;
|
|
|
|
NODE *
|
|
more_nodes()
|
|
{
|
|
register NODE *np;
|
|
|
|
/* get more nodes and initialize list */
|
|
emalloc(nextfree, NODE *, NODECHUNK * sizeof(NODE), "more_nodes");
|
|
for (np = nextfree; np <= &nextfree[NODECHUNK - 1]; np++) {
|
|
np->flags = 0;
|
|
np->flags |= UNINITIALIZED;
|
|
#ifndef NO_PROFILING
|
|
np->exec_count = 0;
|
|
#endif
|
|
np->nextp = np + 1;
|
|
}
|
|
--np;
|
|
np->nextp = NULL;
|
|
np = nextfree;
|
|
nextfree = nextfree->nextp;
|
|
return np;
|
|
}
|
|
|
|
#ifdef MEMDEBUG
|
|
#undef freenode
|
|
/* freenode --- release a node back to the pool */
|
|
|
|
void
|
|
freenode(NODE *it)
|
|
{
|
|
it->flags &= ~SCALAR;
|
|
it->flags |= UNINITIALIZED;
|
|
#ifdef MPROF
|
|
it->stref = 0;
|
|
free((char *) it);
|
|
#else /* not MPROF */
|
|
#ifndef NO_PROFILING
|
|
it->exec_count = 0;
|
|
#endif
|
|
/* add it to head of freelist */
|
|
it->nextp = nextfree;
|
|
nextfree = it;
|
|
#endif /* not MPROF */
|
|
}
|
|
#endif /* GAWKDEBUG */
|
|
|
|
/* unref --- remove reference to a particular node */
|
|
|
|
void
|
|
unref(register NODE *tmp)
|
|
{
|
|
if (tmp == NULL)
|
|
return;
|
|
if ((tmp->flags & PERM) != 0)
|
|
return;
|
|
tmp->flags &= ~TEMP;
|
|
if ((tmp->flags & MALLOC) != 0) {
|
|
if ((tmp->flags & STR) != 0) {
|
|
if (tmp->stref > 1) {
|
|
if (tmp->stref != LONG_MAX)
|
|
tmp->stref--;
|
|
return;
|
|
}
|
|
free(tmp->stptr);
|
|
}
|
|
freenode(tmp);
|
|
return;
|
|
}
|
|
if ((tmp->flags & FIELD) != 0) {
|
|
freenode(tmp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* parse_escape:
|
|
*
|
|
* Parse a C escape sequence. STRING_PTR points to a variable containing a
|
|
* pointer to the string to parse. That pointer is updated past the
|
|
* characters we use. The value of the escape sequence is returned.
|
|
*
|
|
* A negative value means the sequence \ newline was seen, which is supposed to
|
|
* be equivalent to nothing at all.
|
|
*
|
|
* If \ is followed by a null character, we return a negative value and leave
|
|
* the string pointer pointing at the null character.
|
|
*
|
|
* If \ is followed by 000, we return 0 and leave the string pointer after the
|
|
* zeros. A value of 0 does not mean end of string.
|
|
*
|
|
* Posix doesn't allow \x.
|
|
*/
|
|
|
|
int
|
|
parse_escape(char **string_ptr)
|
|
{
|
|
register int c = *(*string_ptr)++;
|
|
register int i;
|
|
register int count;
|
|
|
|
switch (c) {
|
|
case 'a':
|
|
return BELL;
|
|
case 'b':
|
|
return '\b';
|
|
case 'f':
|
|
return '\f';
|
|
case 'n':
|
|
return '\n';
|
|
case 'r':
|
|
return '\r';
|
|
case 't':
|
|
return '\t';
|
|
case 'v':
|
|
return '\v';
|
|
case '\n':
|
|
return -2;
|
|
case 0:
|
|
(*string_ptr)--;
|
|
return -1;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
i = c - '0';
|
|
count = 0;
|
|
while (++count < 3) {
|
|
if ((c = *(*string_ptr)++) >= '0' && c <= '7') {
|
|
i *= 8;
|
|
i += c - '0';
|
|
} else {
|
|
(*string_ptr)--;
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
case 'x':
|
|
if (do_lint) {
|
|
static int didwarn = FALSE;
|
|
|
|
if (! didwarn) {
|
|
didwarn = TRUE;
|
|
lintwarn(_("POSIX does not allow `\\x' escapes"));
|
|
}
|
|
}
|
|
if (do_posix)
|
|
return ('x');
|
|
if (! ISXDIGIT((*string_ptr)[0])) {
|
|
warning(_("no hex digits in `\\x' escape sequence"));
|
|
return ('x');
|
|
}
|
|
i = 0;
|
|
for (;;) {
|
|
/* do outside test to avoid multiple side effects */
|
|
c = *(*string_ptr)++;
|
|
if (ISXDIGIT(c)) {
|
|
i *= 16;
|
|
if (ISDIGIT(c))
|
|
i += c - '0';
|
|
else if (ISUPPER(c))
|
|
i += c - 'A' + 10;
|
|
else
|
|
i += c - 'a' + 10;
|
|
} else {
|
|
(*string_ptr)--;
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
case '\\':
|
|
case '"':
|
|
return c;
|
|
default:
|
|
{
|
|
static short warned[256];
|
|
unsigned char uc = (unsigned char) c;
|
|
|
|
/* N.B.: use unsigned char here to avoid Latin-1 problems */
|
|
|
|
if (! warned[uc]) {
|
|
warned[uc] = TRUE;
|
|
|
|
warning(_("escape sequence `\\%c' treated as plain `%c'"), uc, uc);
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
}
|