MultiSource/Benchmarks/MallocBench/gawk/node.c

/*
 * node.c -- routines for node management
 */

/* 
 * Copyright (C) 1986, 1988, 1989 the Free Software Foundation, Inc.
 * 
 * This file is part of GAWK, the GNU implementation of the
 * AWK Progamming 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 1, 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 GAWK; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "gawk.h"

extern double strtod();

/*
 * We can't dereference a variable until after we've given it its new value.
 * This variable points to the value we have to free up 
 */
NODE *deref;

AWKNUM
r_force_number(n)
NODE *n;
{
	char *ptr;

#ifdef DEBUG
	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
	if (n->stlen == 0)
		n->numbr = 0.0;
	else if (n->stlen == 1) {
		if (isdigit(n->stptr[0])) {
			n->numbr = n->stptr[0] - '0';
			n->flags |= NUMERIC;
		} else
			n->numbr = 0.0;
	} else {
		errno = 0;
		n->numbr = (AWKNUM) strtod(n->stptr, &ptr);
		/* the following >= should be ==, but for SunOS 3.5 strtod() */
		if (errno == 0 && ptr >= n->stptr + n->stlen)
			n->flags |= NUMERIC;
	}
	n->flags |= NUM;
	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 char *values[] = {
	"0",
	"1",
	"2",
	"3",
	"4",
	"5",
	"6",
	"7",
	"8",
	"9",
};
#define	NVAL	(sizeof(values)/sizeof(values[0]))

NODE *
r_force_string(s)
NODE *s;
{
	char buf[128];
	char *fmt;
	long num;
	char *sp = buf;

#ifdef DEBUG
	if (s == NULL)
		cant_happen();
	if (s->type != Node_val)
		cant_happen();
	if (s->flags & STR)
		return s;
	if (!(s->flags & NUM))
		cant_happen();
	if (s->stref != 0)
		cant_happen();
#endif
	s->flags |= STR;
	/* should check validity of user supplied OFMT */
	fmt = OFMT_node->var_value->stptr;
	if ((num = s->numbr) == s->numbr) {
		/* integral value */
		if (num < NVAL && num >= 0) {
			sp = values[num];
			s->stlen = 1;
		} else {
			(void) sprintf(sp, "%ld", num);
			s->stlen = strlen(sp);
		}
	} else {
		(void) sprintf(sp, fmt, s->numbr);
		s->stlen = strlen(sp);
	}
	s->stref = 1;
	emalloc(s->stptr, char *, s->stlen + 1, "force_string");
	memcpy(s->stptr, sp, s->stlen+1);
	return s;
}

/*
 * Duplicate a node.  (For strings, "duplicate" means crank up the
 * reference count.)
 */
NODE *
dupnode(n)
NODE *n;
{
	register NODE *r;

	if (n->flags & TEMP) {
		n->flags &= ~TEMP;
		n->flags |= MALLOC;
		return n;
	}
	if ((n->flags & (MALLOC|STR)) == (MALLOC|STR)) {
		if (n->stref < 255)
			n->stref++;
		return n;
	}
	r = newnode(Node_illegal);
	*r = *n;
	r->flags &= ~(PERM|TEMP);
	r->flags |= MALLOC;
	if (n->type == Node_val && (n->flags & STR)) {
		r->stref = 1;
		emalloc(r->stptr, char *, r->stlen + 1, "dupnode");
		memcpy(r->stptr, n->stptr, r->stlen+1);
	}
	return r;
}

/* this allocates a node with defined numbr */
NODE *
make_number(x)
AWKNUM x;
{
	register NODE *r;

	r = newnode(Node_val);
	r->numbr = x;
	r->flags |= (NUM|NUMERIC);
	r->stref = 0;
	return r;
}

/*
 * This creates temporary nodes.  They go away quite quickly, so don't use
 * them for anything important 
 */
NODE *
tmp_number(x)
AWKNUM x;
{
	NODE *r;

	r = make_number(x);
	r->flags |= TEMP;
	return r;
}

/*
 * Make a string node.
 */

NODE *
make_str_node(s, len, scan)
char *s;
int len;
int scan;
{
	register NODE *r;
	char *pf;
	register char *pt;
	register int c;
	register char *end;

	r = newnode(Node_val);
	emalloc(r->stptr, char *, len + 1, s);
	memcpy(r->stptr, s, len);
	r->stptr[len] = '\0';
	end = &(r->stptr[len]);
	       
	if (scan) {	/* scan for escape sequences */
		for (pf = pt = r->stptr; pf < end;) {
			c = *pf++;
			if (c == '\\') {
				c = parse_escape(&pf);
				if (c < 0)
					cant_happen();
				*pt++ = c;
			} else
				*pt++ = c;
		}
		len = pt - 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->flags |= (STR|MALLOC);

	return r;
}

/* Read the warning under tmp_number */
NODE *
tmp_string(s, len)
char *s;
int len;
{
	register NODE *r;

	r = make_string(s, len);
	r->flags |= TEMP;
	return r;
}


#define NODECHUNK	100

static NODE *nextfree = NULL;

NODE *
newnode(ty)
NODETYPE ty;
{
	NODE *it;
	NODE *np;

#if defined(MPROF) || defined(NOMEMOPT)
	emalloc(it, NODE *, sizeof(NODE), "newnode");
#else
	if (nextfree == NULL) {
		/* get more nodes and initialize list */
		emalloc(nextfree, NODE *, NODECHUNK * sizeof(NODE), "newnode");
		for (np = nextfree; np < &nextfree[NODECHUNK - 1]; np++)
			np->nextp = np + 1;
		np->nextp = NULL;
	}
	/* get head of freelist */
	it = nextfree;
	nextfree = nextfree->nextp;
#endif
	it->type = ty;
	it->flags = MALLOC;
#ifdef MEMDEBUG
	fprintf(stderr, "node: new: %0x\n", it);
#endif
	return it;
}

void
freenode(it)
NODE *it;
{
#ifdef DEBUG
	NODE *nf;
#endif
#ifdef MEMDEBUG
	fprintf(stderr, "node: free: %0x\n", it);
#endif
#if defined(MPROF) || defined(NOMEMOPT) 
	free((char *) it);
#elif defined(IGNOREFREE)	
#else
#ifdef DEBUG
	for (nf = nextfree; nf; nf = nf->nextp)
		if (nf == it)
			fatal("attempt to free free node");
#endif
	/* add it to head of freelist */
	it->nextp = nextfree;
	nextfree = it;
#endif
}

#ifdef DEBUG
pf()
{
	NODE *nf = nextfree;
	while (nf != NULL) {
		fprintf(stderr, "%0x ", nf);
		nf = nf->nextp;
	}
}
#endif

void
do_deref()
{
	if (deref == NULL)
		return;
	if (deref->flags & PERM) {
		deref = 0;
		return;
	}
	if ((deref->flags & MALLOC) || (deref->flags & TEMP)) {
		deref->flags &= ~TEMP;
		if (deref->flags & STR) {
			if (deref->stref > 1 && deref->stref != 255) {
				deref->stref--;
				deref = 0;
				return;
			}
			free(deref->stptr);
		}
		freenode(deref);
	}
	deref = 0;
}