1193 lines
28 KiB
C
1193 lines
28 KiB
C
/* $NetBSD: array.c,v 1.1.1.2 2003/10/06 15:41:38 wiz Exp $ */
|
|
|
|
/*
|
|
* array.c - routines for associative arrays.
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 1986, 1988, 1989, 1991-2003 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
|
|
*/
|
|
|
|
/*
|
|
* Tree walks (``for (iggy in foo)'') and array deletions use expensive
|
|
* linear searching. So what we do is start out with small arrays and
|
|
* grow them as needed, so that our arrays are hopefully small enough,
|
|
* most of the time, that they're pretty full and we're not looking at
|
|
* wasted space.
|
|
*
|
|
* The decision is made to grow the array if the average chain length is
|
|
* ``too big''. This is defined as the total number of entries in the table
|
|
* divided by the size of the array being greater than some constant.
|
|
*
|
|
* 11/2002: We make the constant a variable, so that it can be tweaked
|
|
* via environment variable.
|
|
*/
|
|
|
|
static int AVG_CHAIN_MAX = 2; /* 11/2002: Modern machines are bigger, cut this down from 10. */
|
|
|
|
#include "awk.h"
|
|
|
|
static NODE *assoc_find P((NODE *symbol, NODE *subs, int hash1));
|
|
static void grow_table P((NODE *symbol));
|
|
|
|
static unsigned long gst_hash_string P((const char *str, size_t len, unsigned long hsize));
|
|
static unsigned long scramble P((unsigned long x));
|
|
static unsigned long awk_hash P((const char *s, size_t len, unsigned long hsize));
|
|
|
|
unsigned long (*hash)P((const char *s, size_t len, unsigned long hsize)) = awk_hash;
|
|
|
|
/* array_init --- possibly temporary function for experimentation purposes */
|
|
|
|
void
|
|
array_init()
|
|
{
|
|
const char *val;
|
|
int newval;
|
|
|
|
if ((val = getenv("AVG_CHAIN_MAX")) != NULL && ISDIGIT(*val)) {
|
|
for (newval = 0; *val && ISDIGIT(*val); val++)
|
|
newval = (newval * 10) + *val - '0';
|
|
|
|
AVG_CHAIN_MAX = newval;
|
|
}
|
|
|
|
if ((val = getenv("AWK_HASH")) != NULL && strcmp(val, "gst") == 0)
|
|
hash = gst_hash_string;
|
|
}
|
|
|
|
/*
|
|
* get_actual --- proceed to the actual Node_var_array,
|
|
* change Node_var_new to an array.
|
|
* If canfatal and type isn't good, die fatally,
|
|
* otherwise return the final actual value.
|
|
*/
|
|
|
|
NODE *
|
|
get_actual(NODE *symbol, int canfatal)
|
|
{
|
|
int isparam = (symbol->type == Node_param_list
|
|
&& (symbol->flags & FUNC) == 0);
|
|
NODE *save_symbol = symbol;
|
|
|
|
if (isparam) {
|
|
save_symbol = symbol = stack_ptr[symbol->param_cnt];
|
|
if (symbol->type == Node_array_ref)
|
|
symbol = symbol->orig_array;
|
|
}
|
|
|
|
switch (symbol->type) {
|
|
case Node_var_new:
|
|
symbol->type = Node_var_array;
|
|
symbol->var_array = NULL;
|
|
/* fall through */
|
|
case Node_var_array:
|
|
break;
|
|
|
|
case Node_array_ref:
|
|
case Node_param_list:
|
|
if (canfatal)
|
|
cant_happen();
|
|
/* else
|
|
fall through */
|
|
|
|
default:
|
|
/* notably Node_var but catches also e.g. FS[1] = "x" */
|
|
if (canfatal)
|
|
fatal(isparam ?
|
|
_("attempt to use scalar parameter `%s' as an array") :
|
|
_("attempt to use scalar `%s' as array"),
|
|
save_symbol->vname);
|
|
else
|
|
break;
|
|
}
|
|
|
|
return symbol;
|
|
}
|
|
|
|
/*
|
|
* array_vname --- print the name of the array
|
|
*
|
|
* Returns a pointer to a statically maintained dynamically allocated string.
|
|
* It's appropriate for printing the name once; if the caller wants
|
|
* to save it, they have to make a copy.
|
|
*
|
|
* Setting MAX_LEN to a positive value (eg. 140) would limit the length
|
|
* of the output to _roughly_ that length.
|
|
*
|
|
* If MAX_LEN == 0, which is the default, the whole stack is printed.
|
|
*/
|
|
#define MAX_LEN 0
|
|
|
|
char *
|
|
array_vname(register const NODE *symbol)
|
|
{
|
|
if (symbol->type == Node_param_list)
|
|
symbol = stack_ptr[symbol->param_cnt];
|
|
|
|
if (symbol->type != Node_array_ref || symbol->orig_array->type != Node_var_array)
|
|
return symbol->vname;
|
|
else {
|
|
static char *message = NULL;
|
|
static size_t msglen = 0;
|
|
char *s;
|
|
size_t len;
|
|
int n;
|
|
const NODE *save_symbol = symbol;
|
|
const char *from = _("from %s");
|
|
|
|
#if (MAX_LEN <= 0) || !defined(HAVE_SNPRINTF)
|
|
/* This is the default branch. */
|
|
|
|
/* First, we have to compute the length of the string: */
|
|
len = strlen(symbol->vname) + 2; /* "%s (" */
|
|
n = 0;
|
|
do {
|
|
symbol = symbol->prev_array;
|
|
len += strlen(symbol->vname);
|
|
n++;
|
|
} while (symbol->type == Node_array_ref);
|
|
/*
|
|
* Each node contributes by strlen(from) minus the length
|
|
* of "%s" in the translation (which is at least 2)
|
|
* plus 2 for ", " or ")\0"; this adds up to strlen(from).
|
|
*/
|
|
len += n * strlen(from);
|
|
|
|
/* (Re)allocate memory: */
|
|
if (message == NULL) {
|
|
emalloc(message, char *, len, "array_vname");
|
|
msglen = len;
|
|
} else if (len > msglen) {
|
|
erealloc(message, char *, len, "array_vname");
|
|
msglen = len;
|
|
} /* else
|
|
current buffer can hold new name */
|
|
|
|
/* We're ready to print: */
|
|
symbol = save_symbol;
|
|
s = message;
|
|
/*
|
|
* Ancient systems have sprintf() returning char *, not int.
|
|
* Thus, `s += sprintf(s, from, name);' is a no-no.
|
|
*/
|
|
sprintf(s, "%s (", symbol->vname);
|
|
s += strlen(s);
|
|
for (;;) {
|
|
symbol = symbol->prev_array;
|
|
sprintf(s, from, symbol->vname);
|
|
s += strlen(s);
|
|
if (symbol->type != Node_array_ref)
|
|
break;
|
|
sprintf(s, ", ");
|
|
s += strlen(s);
|
|
}
|
|
sprintf(s, ")");
|
|
|
|
#else /* MAX_LEN > 0 */
|
|
|
|
/*
|
|
* The following check fails only on
|
|
* abnormally_long_variable_name.
|
|
*/
|
|
#define PRINT_CHECK \
|
|
if (n <= 0 || n >= len) \
|
|
return save_symbol->vname; \
|
|
s += n; len -= n
|
|
#define PRINT(str) \
|
|
n = snprintf(s, len, str); \
|
|
PRINT_CHECK
|
|
#define PRINT_vname(str) \
|
|
n = snprintf(s, len, str, symbol->vname); \
|
|
PRINT_CHECK
|
|
|
|
if (message == NULL)
|
|
emalloc(message, char *, MAX_LEN, "array_vname");
|
|
|
|
s = message;
|
|
len = MAX_LEN;
|
|
|
|
/* First, print the vname of the node. */
|
|
PRINT_vname("%s (");
|
|
|
|
for (;;) {
|
|
symbol = symbol->prev_array;
|
|
/*
|
|
* When we don't have enough space and this is not
|
|
* the last node, shorten the list.
|
|
*/
|
|
if (len < 40 && symbol->type == Node_array_ref) {
|
|
PRINT("..., ");
|
|
symbol = symbol->orig_array;
|
|
}
|
|
PRINT_vname(from);
|
|
if (symbol->type != Node_array_ref)
|
|
break;
|
|
PRINT(", ");
|
|
}
|
|
PRINT(")");
|
|
|
|
#undef PRINT_CHECK
|
|
#undef PRINT
|
|
#undef PRINT_vname
|
|
#endif /* MAX_LEN <= 0 */
|
|
|
|
return message;
|
|
}
|
|
}
|
|
#undef MAX_LEN
|
|
|
|
/* concat_exp --- concatenate expression list into a single string */
|
|
|
|
NODE *
|
|
concat_exp(register NODE *tree)
|
|
{
|
|
register NODE *r;
|
|
char *str;
|
|
char *s;
|
|
size_t len;
|
|
int offset;
|
|
size_t subseplen;
|
|
const char *subsep;
|
|
|
|
if (tree->type != Node_expression_list)
|
|
return force_string(tree_eval(tree));
|
|
r = force_string(tree_eval(tree->lnode));
|
|
if (tree->rnode == NULL)
|
|
return r;
|
|
subseplen = SUBSEP_node->var_value->stlen;
|
|
subsep = SUBSEP_node->var_value->stptr;
|
|
len = r->stlen + subseplen + 2;
|
|
emalloc(str, char *, len, "concat_exp");
|
|
memcpy(str, r->stptr, r->stlen+1);
|
|
s = str + r->stlen;
|
|
free_temp(r);
|
|
for (tree = tree->rnode; tree != NULL; tree = tree->rnode) {
|
|
if (subseplen == 1)
|
|
*s++ = *subsep;
|
|
else {
|
|
memcpy(s, subsep, subseplen+1);
|
|
s += subseplen;
|
|
}
|
|
r = force_string(tree_eval(tree->lnode));
|
|
len += r->stlen + subseplen;
|
|
offset = s - str;
|
|
erealloc(str, char *, len, "concat_exp");
|
|
s = str + offset;
|
|
memcpy(s, r->stptr, r->stlen+1);
|
|
s += r->stlen;
|
|
free_temp(r);
|
|
}
|
|
r = make_str_node(str, s - str, ALREADY_MALLOCED);
|
|
r->flags |= TEMP;
|
|
return r;
|
|
}
|
|
|
|
/* assoc_clear --- flush all the values in symbol[] before doing a split() */
|
|
|
|
void
|
|
assoc_clear(NODE *symbol)
|
|
{
|
|
int i;
|
|
NODE *bucket, *next;
|
|
|
|
if (symbol->var_array == NULL)
|
|
return;
|
|
for (i = 0; i < symbol->array_size; i++) {
|
|
for (bucket = symbol->var_array[i]; bucket != NULL; bucket = next) {
|
|
next = bucket->ahnext;
|
|
unref(bucket->ahvalue);
|
|
unref(bucket); /* unref() will free the ahname_str */
|
|
}
|
|
symbol->var_array[i] = NULL;
|
|
}
|
|
free(symbol->var_array);
|
|
symbol->var_array = NULL;
|
|
symbol->array_size = symbol->table_size = 0;
|
|
symbol->flags &= ~ARRAYMAXED;
|
|
}
|
|
|
|
/* hash --- calculate the hash function of the string in subs */
|
|
|
|
static unsigned long
|
|
awk_hash(register const char *s, register size_t len, unsigned long hsize)
|
|
{
|
|
register unsigned long h = 0;
|
|
|
|
/*
|
|
* This is INCREDIBLY ugly, but fast. We break the string up into
|
|
* 8 byte units. On the first time through the loop we get the
|
|
* "leftover bytes" (strlen % 8). On every other iteration, we
|
|
* perform 8 HASHC's so we handle all 8 bytes. Essentially, this
|
|
* saves us 7 cmp & branch instructions. If this routine is
|
|
* heavily used enough, it's worth the ugly coding.
|
|
*
|
|
* OZ's original sdbm hash, copied from Margo Seltzers db package.
|
|
*/
|
|
|
|
/*
|
|
* Even more speed:
|
|
* #define HASHC h = *s++ + 65599 * h
|
|
* Because 65599 = pow(2, 6) + pow(2, 16) - 1 we multiply by shifts
|
|
*/
|
|
#define HASHC htmp = (h << 6); \
|
|
h = *s++ + htmp + (htmp << 10) - h
|
|
|
|
unsigned long htmp;
|
|
|
|
h = 0;
|
|
|
|
#if defined(VAXC)
|
|
/*
|
|
* This was an implementation of "Duff's Device", but it has been
|
|
* redone, separating the switch for extra iterations from the
|
|
* loop. This is necessary because the DEC VAX-C compiler is
|
|
* STOOPID.
|
|
*/
|
|
switch (len & (8 - 1)) {
|
|
case 7: HASHC;
|
|
case 6: HASHC;
|
|
case 5: HASHC;
|
|
case 4: HASHC;
|
|
case 3: HASHC;
|
|
case 2: HASHC;
|
|
case 1: HASHC;
|
|
default: break;
|
|
}
|
|
|
|
if (len > (8 - 1)) {
|
|
register size_t loop = len >> 3;
|
|
do {
|
|
HASHC;
|
|
HASHC;
|
|
HASHC;
|
|
HASHC;
|
|
HASHC;
|
|
HASHC;
|
|
HASHC;
|
|
HASHC;
|
|
} while (--loop);
|
|
}
|
|
#else /* ! VAXC */
|
|
/* "Duff's Device" for those who can handle it */
|
|
if (len > 0) {
|
|
register size_t loop = (len + 8 - 1) >> 3;
|
|
|
|
switch (len & (8 - 1)) {
|
|
case 0:
|
|
do { /* All fall throughs */
|
|
HASHC;
|
|
case 7: HASHC;
|
|
case 6: HASHC;
|
|
case 5: HASHC;
|
|
case 4: HASHC;
|
|
case 3: HASHC;
|
|
case 2: HASHC;
|
|
case 1: HASHC;
|
|
} while (--loop);
|
|
}
|
|
}
|
|
#endif /* ! VAXC */
|
|
|
|
if (h >= hsize)
|
|
h %= hsize;
|
|
return h;
|
|
}
|
|
|
|
/* assoc_find --- locate symbol[subs] */
|
|
|
|
static NODE * /* NULL if not found */
|
|
assoc_find(NODE *symbol, register NODE *subs, int hash1)
|
|
{
|
|
register NODE *bucket;
|
|
const char *s1_str;
|
|
size_t s1_len;
|
|
NODE *s2;
|
|
|
|
for (bucket = symbol->var_array[hash1]; bucket != NULL;
|
|
bucket = bucket->ahnext) {
|
|
/*
|
|
* This used to use cmp_nodes() here. That's wrong.
|
|
* Array indexes are strings; compare as such, always!
|
|
*/
|
|
s1_str = bucket->ahname_str;
|
|
s1_len = bucket->ahname_len;
|
|
s2 = subs;
|
|
|
|
if (s1_len == s2->stlen) {
|
|
if (s1_len == 0 /* "" is a valid index */
|
|
|| STREQN(s1_str, s2->stptr, s1_len))
|
|
return bucket;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* in_array --- test whether the array element symbol[subs] exists or not,
|
|
* return pointer to value if it does.
|
|
*/
|
|
|
|
NODE *
|
|
in_array(NODE *symbol, NODE *subs)
|
|
{
|
|
register int hash1;
|
|
NODE *ret;
|
|
|
|
symbol = get_array(symbol);
|
|
|
|
/*
|
|
* Evaluate subscript first, it could have side effects.
|
|
*/
|
|
subs = concat_exp(subs); /* concat_exp returns a string node */
|
|
if (symbol->var_array == NULL) {
|
|
free_temp(subs);
|
|
return NULL;
|
|
}
|
|
hash1 = hash(subs->stptr, subs->stlen, (unsigned long) symbol->array_size);
|
|
ret = assoc_find(symbol, subs, hash1);
|
|
free_temp(subs);
|
|
if (ret)
|
|
return ret->ahvalue;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* assoc_lookup:
|
|
* Find SYMBOL[SUBS] in the assoc array. Install it with value "" if it
|
|
* isn't there. Returns a pointer ala get_lhs to where its value is stored.
|
|
*
|
|
* SYMBOL is the address of the node (or other pointer) being dereferenced.
|
|
* SUBS is a number or string used as the subscript.
|
|
*/
|
|
|
|
NODE **
|
|
assoc_lookup(NODE *symbol, NODE *subs, int reference)
|
|
{
|
|
register int hash1;
|
|
register NODE *bucket;
|
|
|
|
assert(symbol->type == Node_var_array);
|
|
|
|
(void) force_string(subs);
|
|
|
|
if (symbol->var_array == NULL) {
|
|
symbol->array_size = symbol->table_size = 0; /* sanity */
|
|
symbol->flags &= ~ARRAYMAXED;
|
|
grow_table(symbol);
|
|
hash1 = hash(subs->stptr, subs->stlen,
|
|
(unsigned long) symbol->array_size);
|
|
} else {
|
|
hash1 = hash(subs->stptr, subs->stlen,
|
|
(unsigned long) symbol->array_size);
|
|
bucket = assoc_find(symbol, subs, hash1);
|
|
if (bucket != NULL) {
|
|
free_temp(subs);
|
|
return &(bucket->ahvalue);
|
|
}
|
|
}
|
|
|
|
if (do_lint && reference) {
|
|
subs->stptr[subs->stlen] = '\0';
|
|
lintwarn(_("reference to uninitialized element `%s[\"%s\"]'"),
|
|
array_vname(symbol), subs->stptr);
|
|
}
|
|
|
|
/* It's not there, install it. */
|
|
if (do_lint && subs->stlen == 0)
|
|
lintwarn(_("subscript of array `%s' is null string"),
|
|
array_vname(symbol));
|
|
|
|
/* first see if we would need to grow the array, before installing */
|
|
symbol->table_size++;
|
|
if ((symbol->flags & ARRAYMAXED) == 0
|
|
&& (symbol->table_size / symbol->array_size) > AVG_CHAIN_MAX) {
|
|
grow_table(symbol);
|
|
/* have to recompute hash value for new size */
|
|
hash1 = hash(subs->stptr, subs->stlen,
|
|
(unsigned long) symbol->array_size);
|
|
}
|
|
|
|
getnode(bucket);
|
|
bucket->type = Node_ahash;
|
|
|
|
/*
|
|
* Freeze this string value --- it must never
|
|
* change, no matter what happens to the value
|
|
* that created it or to CONVFMT, etc.
|
|
*
|
|
* One day: Use an atom table to track array indices,
|
|
* and avoid the extra memory overhead.
|
|
*/
|
|
bucket->flags |= MALLOC;
|
|
bucket->ahname_ref = 1;
|
|
emalloc(bucket->ahname_str, char *, subs->stlen + 2, "assoc_lookup");
|
|
bucket->ahname_len = subs->stlen;
|
|
|
|
memcpy(bucket->ahname_str, subs->stptr, subs->stlen);
|
|
bucket->ahname_str[bucket->ahname_len] = '\0';
|
|
|
|
free_temp(subs);
|
|
|
|
bucket->ahvalue = Nnull_string;
|
|
bucket->ahnext = symbol->var_array[hash1];
|
|
symbol->var_array[hash1] = bucket;
|
|
return &(bucket->ahvalue);
|
|
}
|
|
|
|
/* do_delete --- perform `delete array[s]' */
|
|
|
|
/*
|
|
* `symbol' is array
|
|
* `tree' is subscript
|
|
*/
|
|
|
|
void
|
|
do_delete(NODE *sym, NODE *tree)
|
|
{
|
|
register int hash1;
|
|
register NODE *bucket, *last;
|
|
NODE *subs;
|
|
register NODE *symbol = get_array(sym);
|
|
|
|
if (tree == NULL) { /* delete array */
|
|
assoc_clear(symbol);
|
|
return;
|
|
}
|
|
|
|
last = NULL; /* shut up gcc -Wall */
|
|
hash1 = 0; /* ditto */
|
|
|
|
/*
|
|
* Always evaluate subscript, it could have side effects.
|
|
*/
|
|
subs = concat_exp(tree); /* concat_exp returns string node */
|
|
|
|
if (symbol->var_array != NULL) {
|
|
hash1 = hash(subs->stptr, subs->stlen,
|
|
(unsigned long) symbol->array_size);
|
|
last = NULL;
|
|
for (bucket = symbol->var_array[hash1]; bucket != NULL;
|
|
last = bucket, bucket = bucket->ahnext) {
|
|
/*
|
|
* This used to use cmp_nodes() here. That's wrong.
|
|
* Array indexes are strings; compare as such, always!
|
|
*/
|
|
const char *s1_str;
|
|
size_t s1_len;
|
|
NODE *s2;
|
|
|
|
s1_str = bucket->ahname_str;
|
|
s1_len = bucket->ahname_len;
|
|
s2 = subs;
|
|
|
|
if (s1_len == s2->stlen) {
|
|
if (s1_len == 0 /* "" is a valid index */
|
|
|| STREQN(s1_str, s2->stptr, s1_len))
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
bucket = NULL; /* The array is empty. */
|
|
|
|
if (bucket == NULL) {
|
|
if (do_lint)
|
|
lintwarn(_("delete: index `%s' not in array `%s'"),
|
|
subs->stptr, array_vname(sym));
|
|
free_temp(subs);
|
|
return;
|
|
}
|
|
|
|
free_temp(subs);
|
|
|
|
if (last != NULL)
|
|
last->ahnext = bucket->ahnext;
|
|
else
|
|
symbol->var_array[hash1] = bucket->ahnext;
|
|
unref(bucket->ahvalue);
|
|
unref(bucket); /* unref() will free the ahname_str */
|
|
symbol->table_size--;
|
|
if (symbol->table_size <= 0) {
|
|
memset(symbol->var_array, '\0',
|
|
sizeof(NODE *) * symbol->array_size);
|
|
symbol->table_size = symbol->array_size = 0;
|
|
symbol->flags &= ~ARRAYMAXED;
|
|
free((char *) symbol->var_array);
|
|
symbol->var_array = NULL;
|
|
}
|
|
}
|
|
|
|
/* do_delete_loop --- simulate ``for (iggy in foo) delete foo[iggy]'' */
|
|
|
|
/*
|
|
* The primary hassle here is that `iggy' needs to have some arbitrary
|
|
* array index put in it before we can clear the array, we can't
|
|
* just replace the loop with `delete foo'.
|
|
*/
|
|
|
|
void
|
|
do_delete_loop(NODE *symbol, NODE *tree)
|
|
{
|
|
size_t i;
|
|
NODE **lhs;
|
|
Func_ptr after_assign = NULL;
|
|
|
|
symbol = get_array(symbol);
|
|
|
|
if (symbol->var_array == NULL)
|
|
return;
|
|
|
|
/* get first index value */
|
|
for (i = 0; i < symbol->array_size; i++) {
|
|
if (symbol->var_array[i] != NULL) {
|
|
lhs = get_lhs(tree->lnode, & after_assign, FALSE);
|
|
unref(*lhs);
|
|
*lhs = make_string(symbol->var_array[i]->ahname_str,
|
|
symbol->var_array[i]->ahname_len);
|
|
if (after_assign)
|
|
(*after_assign)();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* blast the array in one shot */
|
|
assoc_clear(symbol);
|
|
}
|
|
|
|
/* grow_table --- grow a hash table */
|
|
|
|
static void
|
|
grow_table(NODE *symbol)
|
|
{
|
|
NODE **old, **new, *chain, *next;
|
|
int i, j;
|
|
unsigned long hash1;
|
|
unsigned long oldsize, newsize;
|
|
/*
|
|
* This is an array of primes. We grow the table by an order of
|
|
* magnitude each time (not just doubling) so that growing is a
|
|
* rare operation. We expect, on average, that it won't happen
|
|
* more than twice. The final size is also chosen to be small
|
|
* enough so that MS-DOG mallocs can handle it. When things are
|
|
* very large (> 8K), we just double more or less, instead of
|
|
* just jumping from 8K to 64K.
|
|
*/
|
|
static const long sizes[] = { 13, 127, 1021, 8191, 16381, 32749, 65497,
|
|
#if ! defined(MSDOS) && ! defined(OS2) && ! defined(atarist)
|
|
131101, 262147, 524309, 1048583, 2097169,
|
|
4194319, 8388617, 16777259, 33554467,
|
|
67108879, 134217757, 268435459, 536870923,
|
|
1073741827
|
|
#endif
|
|
};
|
|
|
|
/* find next biggest hash size */
|
|
newsize = oldsize = symbol->array_size;
|
|
for (i = 0, j = sizeof(sizes)/sizeof(sizes[0]); i < j; i++) {
|
|
if (oldsize < sizes[i]) {
|
|
newsize = sizes[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (newsize == oldsize) { /* table already at max (!) */
|
|
symbol->flags |= ARRAYMAXED;
|
|
return;
|
|
}
|
|
|
|
/* allocate new table */
|
|
emalloc(new, NODE **, newsize * sizeof(NODE *), "grow_table");
|
|
memset(new, '\0', newsize * sizeof(NODE *));
|
|
|
|
/* brand new hash table, set things up and return */
|
|
if (symbol->var_array == NULL) {
|
|
symbol->table_size = 0;
|
|
goto done;
|
|
}
|
|
|
|
/* old hash table there, move stuff to new, free old */
|
|
old = symbol->var_array;
|
|
for (i = 0; i < oldsize; i++) {
|
|
if (old[i] == NULL)
|
|
continue;
|
|
|
|
for (chain = old[i]; chain != NULL; chain = next) {
|
|
next = chain->ahnext;
|
|
hash1 = hash(chain->ahname_str,
|
|
chain->ahname_len, newsize);
|
|
|
|
/* remove from old list, add to new */
|
|
chain->ahnext = new[hash1];
|
|
new[hash1] = chain;
|
|
}
|
|
}
|
|
free(old);
|
|
|
|
done:
|
|
/*
|
|
* note that symbol->table_size does not change if an old array,
|
|
* and is explicitly set to 0 if a new one.
|
|
*/
|
|
symbol->var_array = new;
|
|
symbol->array_size = newsize;
|
|
}
|
|
|
|
/* pr_node --- print simple node info */
|
|
|
|
static void
|
|
pr_node(NODE *n)
|
|
{
|
|
if ((n->flags & (NUMCUR|NUMBER)) != 0)
|
|
printf("%g", n->numbr);
|
|
else
|
|
printf("%.*s", (int) n->stlen, n->stptr);
|
|
}
|
|
|
|
/* assoc_dump --- dump the contents of an array */
|
|
|
|
NODE *
|
|
assoc_dump(NODE *symbol)
|
|
{
|
|
int i;
|
|
NODE *bucket;
|
|
|
|
if (symbol->var_array == NULL) {
|
|
printf(_("%s: empty (null)\n"), symbol->vname);
|
|
return tmp_number((AWKNUM) 0);
|
|
}
|
|
|
|
if (symbol->table_size == 0) {
|
|
printf(_("%s: empty (zero)\n"), symbol->vname);
|
|
return tmp_number((AWKNUM) 0);
|
|
}
|
|
|
|
printf(_("%s: table_size = %d, array_size = %d\n"), symbol->vname,
|
|
(int) symbol->table_size, (int) symbol->array_size);
|
|
|
|
for (i = 0; i < symbol->array_size; i++) {
|
|
for (bucket = symbol->var_array[i]; bucket != NULL;
|
|
bucket = bucket->ahnext) {
|
|
printf("%s: I: [len %d <%.*s>] V: [",
|
|
symbol->vname,
|
|
(int) bucket->ahname_len,
|
|
(int) bucket->ahname_len,
|
|
bucket->ahname_str);
|
|
pr_node(bucket->ahvalue);
|
|
printf("]\n");
|
|
}
|
|
}
|
|
|
|
return tmp_number((AWKNUM) 0);
|
|
}
|
|
|
|
/* do_adump --- dump an array: interface to assoc_dump */
|
|
|
|
NODE *
|
|
do_adump(NODE *tree)
|
|
{
|
|
NODE *r, *a;
|
|
|
|
a = tree->lnode;
|
|
|
|
if (a->type == Node_param_list) {
|
|
printf(_("%s: is parameter\n"), a->vname);
|
|
a = stack_ptr[a->param_cnt];
|
|
}
|
|
|
|
if (a->type == Node_array_ref) {
|
|
printf(_("%s: array_ref to %s\n"), a->vname,
|
|
a->orig_array->vname);
|
|
a = a->orig_array;
|
|
}
|
|
|
|
r = assoc_dump(a);
|
|
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* The following functions implement the builtin
|
|
* asort function. Initial work by Alan J. Broder,
|
|
* ajb@woti.com.
|
|
*/
|
|
|
|
/* dup_table --- duplicate input symbol table "symbol" */
|
|
|
|
static void
|
|
dup_table(NODE *symbol, NODE *newsymb)
|
|
{
|
|
NODE **old, **new, *chain, *bucket;
|
|
int i;
|
|
unsigned long cursize;
|
|
|
|
/* find the current hash size */
|
|
cursize = symbol->array_size;
|
|
|
|
new = NULL;
|
|
|
|
/* input is a brand new hash table, so there's nothing to copy */
|
|
if (symbol->var_array == NULL)
|
|
newsymb->table_size = 0;
|
|
else {
|
|
/* old hash table there, dupnode stuff into a new table */
|
|
|
|
/* allocate new table */
|
|
emalloc(new, NODE **, cursize * sizeof(NODE *), "dup_table");
|
|
memset(new, '\0', cursize * sizeof(NODE *));
|
|
|
|
/* do the copying/dupnode'ing */
|
|
old = symbol->var_array;
|
|
for (i = 0; i < cursize; i++) {
|
|
if (old[i] != NULL) {
|
|
for (chain = old[i]; chain != NULL;
|
|
chain = chain->ahnext) {
|
|
/* get a node for the linked list */
|
|
getnode(bucket);
|
|
bucket->type = Node_ahash;
|
|
bucket->flags |= MALLOC;
|
|
bucket->ahname_ref = 1;
|
|
|
|
/*
|
|
* copy the corresponding name and
|
|
* value from the original input list
|
|
*/
|
|
emalloc(bucket->ahname_str, char *, chain->ahname_len + 2, "dup_table");
|
|
bucket->ahname_len = chain->ahname_len;
|
|
|
|
memcpy(bucket->ahname_str, chain->ahname_str, chain->ahname_len);
|
|
bucket->ahname_str[bucket->ahname_len] = '\0';
|
|
|
|
bucket->ahvalue = dupnode(chain->ahvalue);
|
|
|
|
/*
|
|
* put the node on the corresponding
|
|
* linked list in the new table
|
|
*/
|
|
bucket->ahnext = new[i];
|
|
new[i] = bucket;
|
|
}
|
|
}
|
|
}
|
|
newsymb->table_size = symbol->table_size;
|
|
}
|
|
|
|
newsymb->var_array = new;
|
|
newsymb->array_size = cursize;
|
|
}
|
|
|
|
/* merge --- do a merge of two sorted lists */
|
|
|
|
static NODE *
|
|
merge(NODE *left, NODE *right)
|
|
{
|
|
NODE *ans, *cur;
|
|
|
|
/*
|
|
* The use of cmp_nodes() here means that IGNORECASE influences the
|
|
* comparison. This is OK, but it may be surprising. This comment
|
|
* serves to remind us that we know about this and that it's OK.
|
|
*/
|
|
if (cmp_nodes(left->ahvalue, right->ahvalue) <= 0) {
|
|
ans = cur = left;
|
|
left = left->ahnext;
|
|
} else {
|
|
ans = cur = right;
|
|
right = right->ahnext;
|
|
}
|
|
|
|
while (left != NULL && right != NULL) {
|
|
if (cmp_nodes(left->ahvalue, right->ahvalue) <= 0) {
|
|
cur->ahnext = left;
|
|
cur = left;
|
|
left = left->ahnext;
|
|
} else {
|
|
cur->ahnext = right;
|
|
cur = right;
|
|
right = right->ahnext;
|
|
}
|
|
}
|
|
|
|
cur->ahnext = (left != NULL ? left : right);
|
|
|
|
return ans;
|
|
}
|
|
|
|
/* merge_sort --- recursively sort the left and right sides of a list */
|
|
|
|
static NODE *
|
|
merge_sort(NODE *left, int size)
|
|
{
|
|
NODE *right, *tmp;
|
|
int i, half;
|
|
|
|
if (size <= 1)
|
|
return left;
|
|
|
|
/* walk down the list, till just one before the midpoint */
|
|
tmp = left;
|
|
half = size / 2;
|
|
for (i = 0; i < half-1; i++)
|
|
tmp = tmp->ahnext;
|
|
|
|
/* split the list into two parts */
|
|
right = tmp->ahnext;
|
|
tmp->ahnext = NULL;
|
|
|
|
/* sort the left and right parts of the list */
|
|
left = merge_sort(left, half);
|
|
right = merge_sort(right, size-half);
|
|
|
|
/* merge the two sorted parts of the list */
|
|
return merge(left, right);
|
|
}
|
|
|
|
|
|
/*
|
|
* assoc_from_list -- Populate an array with the contents of a list of NODEs,
|
|
* using increasing integers as the key.
|
|
*/
|
|
|
|
static void
|
|
assoc_from_list(NODE *symbol, NODE *list)
|
|
{
|
|
NODE *next;
|
|
unsigned long i = 0;
|
|
register int hash1;
|
|
char buf[100];
|
|
|
|
for (; list != NULL; list = next) {
|
|
next = list->ahnext;
|
|
|
|
/* make an int out of i++ */
|
|
i++;
|
|
sprintf(buf, "%lu", i);
|
|
assert(list->ahname_str == NULL);
|
|
assert(list->ahname_ref == 1);
|
|
emalloc(list->ahname_str, char *, strlen(buf) + 2, "assoc_from_list");
|
|
list->ahname_len = strlen(buf);
|
|
strcpy(list->ahname_str, buf);
|
|
|
|
/* find the bucket where it belongs */
|
|
hash1 = hash(list->ahname_str, list->ahname_len,
|
|
symbol->array_size);
|
|
|
|
/* link the node into the chain at that bucket */
|
|
list->ahnext = symbol->var_array[hash1];
|
|
symbol->var_array[hash1] = list;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* assoc_sort_inplace --- sort all the values in symbol[], replacing
|
|
* the sorted values back into symbol[], indexed by integers starting with 1.
|
|
*/
|
|
|
|
typedef enum asort_how { VALUE, INDEX } ASORT_TYPE;
|
|
|
|
static NODE *
|
|
assoc_sort_inplace(NODE *symbol, ASORT_TYPE how)
|
|
{
|
|
int i, num;
|
|
NODE *bucket, *next, *list;
|
|
|
|
if (symbol->var_array == NULL
|
|
|| symbol->array_size <= 0
|
|
|| symbol->table_size <= 0)
|
|
return tmp_number((AWKNUM) 0);
|
|
|
|
/* build a linked list out of all the entries in the table */
|
|
if (how == VALUE) {
|
|
list = NULL;
|
|
num = 0;
|
|
for (i = 0; i < symbol->array_size; i++) {
|
|
for (bucket = symbol->var_array[i]; bucket != NULL; bucket = next) {
|
|
next = bucket->ahnext;
|
|
if (bucket->ahname_ref == 1) {
|
|
free(bucket->ahname_str);
|
|
bucket->ahname_str = NULL;
|
|
bucket->ahname_len = 0;
|
|
} else {
|
|
NODE *r;
|
|
|
|
getnode(r);
|
|
*r = *bucket;
|
|
unref(bucket);
|
|
bucket = r;
|
|
bucket->flags |= MALLOC;
|
|
bucket->ahname_ref = 1;
|
|
bucket->ahname_str = NULL;
|
|
bucket->ahname_len = 0;
|
|
}
|
|
bucket->ahnext = list;
|
|
list = bucket;
|
|
num++;
|
|
}
|
|
symbol->var_array[i] = NULL;
|
|
}
|
|
} else { /* how == INDEX */
|
|
list = NULL;
|
|
num = 0;
|
|
for (i = 0; i < symbol->array_size; i++) {
|
|
for (bucket = symbol->var_array[i]; bucket != NULL; bucket = next) {
|
|
next = bucket->ahnext;
|
|
|
|
/* toss old value */
|
|
unref(bucket->ahvalue);
|
|
|
|
/* move index into value */
|
|
if (bucket->ahname_ref == 1) {
|
|
bucket->ahvalue = make_str_node(bucket->ahname_str,
|
|
bucket->ahname_len, ALREADY_MALLOCED);
|
|
bucket->ahname_str = NULL;
|
|
bucket->ahname_len = 0;
|
|
} else {
|
|
NODE *r;
|
|
|
|
bucket->ahvalue = make_string(bucket->ahname_str, bucket->ahname_len);
|
|
getnode(r);
|
|
*r = *bucket;
|
|
unref(bucket);
|
|
bucket = r;
|
|
bucket->flags |= MALLOC;
|
|
bucket->ahname_ref = 1;
|
|
bucket->ahname_str = NULL;
|
|
bucket->ahname_len = 0;
|
|
}
|
|
|
|
bucket->ahnext = list;
|
|
list = bucket;
|
|
num++;
|
|
}
|
|
symbol->var_array[i] = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sort the linked list of NODEs.
|
|
* (The especially nice thing about using a merge sort here is that
|
|
* we require absolutely no additional storage. This is handy if the
|
|
* array has grown to be very large.)
|
|
*/
|
|
list = merge_sort(list, num);
|
|
|
|
/*
|
|
* now repopulate the original array, using increasing
|
|
* integers as the key
|
|
*/
|
|
assoc_from_list(symbol, list);
|
|
|
|
return tmp_number((AWKNUM) num);
|
|
}
|
|
|
|
/* asort_actual --- do the actual work to sort the input array */
|
|
|
|
static NODE *
|
|
asort_actual(NODE *tree, ASORT_TYPE how)
|
|
{
|
|
NODE *array = get_array(tree->lnode);
|
|
|
|
if (tree->rnode != NULL) { /* 2nd optional arg */
|
|
NODE *dest = get_array(tree->rnode->lnode);
|
|
|
|
assoc_clear(dest);
|
|
dup_table(array, dest);
|
|
array = dest;
|
|
}
|
|
|
|
return assoc_sort_inplace(array, how);
|
|
}
|
|
|
|
/* do_asort --- sort array by value */
|
|
|
|
NODE *
|
|
do_asort(NODE *tree)
|
|
{
|
|
return asort_actual(tree, VALUE);
|
|
}
|
|
|
|
/* do_asorti --- sort array by index */
|
|
|
|
NODE *
|
|
do_asorti(NODE *tree)
|
|
{
|
|
return asort_actual(tree, INDEX);
|
|
}
|
|
|
|
/*
|
|
From bonzini@gnu.org Mon Oct 28 16:05:26 2002
|
|
Date: Mon, 28 Oct 2002 13:33:03 +0100
|
|
From: Paolo Bonzini <bonzini@gnu.org>
|
|
To: arnold@skeeve.com
|
|
Subject: Hash function
|
|
Message-ID: <20021028123303.GA6832@biancaneve>
|
|
|
|
Here is the hash function I'm using in GNU Smalltalk. The scrambling is
|
|
needed if you use powers of two as the table sizes. If you use primes it
|
|
is not needed.
|
|
|
|
To use double-hashing with power-of-two size, you should use the
|
|
_gst_hash_string(str, len) as the primary hash and
|
|
scramble(_gst_hash_string (str, len)) | 1 as the secondary hash.
|
|
|
|
Paolo
|
|
|
|
*/
|
|
/*
|
|
* ADR: Slightly modified to work w/in the context of gawk.
|
|
*/
|
|
|
|
static unsigned long
|
|
gst_hash_string(const char *str, size_t len, unsigned long hsize)
|
|
{
|
|
unsigned long hashVal = 1497032417; /* arbitrary value */
|
|
unsigned long ret;
|
|
|
|
while (len--) {
|
|
hashVal += *str++;
|
|
hashVal += (hashVal << 10);
|
|
hashVal ^= (hashVal >> 6);
|
|
}
|
|
|
|
ret = scramble(hashVal);
|
|
if (ret >= hsize)
|
|
ret %= hsize;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static unsigned long
|
|
scramble(unsigned long x)
|
|
{
|
|
if (sizeof(long) == 4) {
|
|
int y = ~x;
|
|
|
|
x += (y << 10) | (y >> 22);
|
|
x += (x << 6) | (x >> 26);
|
|
x -= (x << 16) | (x >> 16);
|
|
} else {
|
|
x ^= (~x) >> 31;
|
|
x += (x << 21) | (x >> 11);
|
|
x += (x << 5) | (x >> 27);
|
|
x += (x << 27) | (x >> 5);
|
|
x += (x << 31);
|
|
}
|
|
|
|
return x;
|
|
}
|