array.c File Reference

#include "awk.h"

Go to the source code of this file.

Defines
#define	MAX_LEN   0
#define	HASHC
Typedefs
typedef enum asort_how	ASORT_TYPE
Enumerations
enum	asort_how { VALUE, INDEX }
Functions
static NODE *assoc_find	P ((NODE *symbol, NODE *subs, int hash1))
void	array_init ()
NODE *	get_actual (NODE *symbol, int canfatal)
char *	array_vname (register const NODE *symbol)
NODE *	concat_exp (register NODE *tree)
void	assoc_clear (NODE *symbol)
static unsigned long	awk_hash (register const char *s, register size_t len, unsigned long hsize)
static NODE *	assoc_find (NODE *symbol, register NODE *subs, int hash1)
NODE *	in_array (NODE *symbol, NODE *subs)
NODE **	assoc_lookup (NODE *symbol, NODE *subs, int reference)
void	do_delete (NODE *sym, NODE *tree)
void	do_delete_loop (NODE *symbol, NODE *tree)
static void	grow_table (NODE *symbol)
static void	pr_node (NODE *n)
NODE *	assoc_dump (NODE *symbol)
NODE *	do_adump (NODE *tree)
static void	dup_table (NODE *symbol, NODE *newsymb)
static NODE *	merge (NODE *left, NODE *right)
static NODE *	merge_sort (NODE *left, int size)
static void	assoc_from_list (NODE *symbol, NODE *list)
static NODE *	assoc_sort_inplace (NODE *symbol, ASORT_TYPE how)
static NODE *	asort_actual (NODE *tree, ASORT_TYPE how)
NODE *	do_asort (NODE *tree)
NODE *	do_asorti (NODE *tree)
static unsigned long	gst_hash_string (const char *str, size_t len, unsigned long hsize)
static unsigned long	scramble (unsigned long x)
Variables
static int	AVG_CHAIN_MAX = 2

---

Define Documentation

#define HASHC

Value: htmp = (h << 6); \ h = *s++ + htmp + (htmp << 10) - h Referenced by awk_hash().

#define MAX_LEN   0

Definition at line 134 of file array.c. Referenced by array_vname().

---

Typedef Documentation

typedef enum asort_how ASORT_TYPE

---

Enumeration Type Documentation

enum asort_how

Enumerator: VALUE  INDEX  Definition at line 999 of file array.c. { VALUE, INDEX } ASORT_TYPE;

---

Function Documentation

void array_init (   )

Definition at line 57 of file array.c. References AVG_CHAIN_MAX, getenv, gst_hash_string(), ISDIGIT, and NULL. Referenced by main(). { 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; }

char* array_vname (  register const NODE *  symbol  )

Definition at line 137 of file array.c. References _, emalloc, erealloc, len, MAX_LEN, n, Node_array_ref, Node_param_list, Node_var_array, NULL, and stack_ptr. Referenced by assoc_lookup(), do_delete(), interpret(), r_get_lhs(), and r_tree_eval(). { 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; } }

static NODE* asort_actual (  NODE *  tree, ASORT_TYPE  how )  [static]

Definition at line 1099 of file array.c. References assoc_clear(), assoc_sort_inplace(), dup_table(), get_array, and NULL. Referenced by do_asort(), and do_asorti(). { 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); }

void assoc_clear (  NODE *  symbol  )

Definition at line 303 of file array.c. References array_size, ARRAYMAXED, exp_node::flags, free(), i, NULL, and unref(). Referenced by asort_actual(), do_delete(), do_delete_loop(), do_match(), do_mkarray(), do_split(), do_stat(), pop_fcall(), and release_all_vars(). { 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; }

NODE* assoc_dump (  NODE *  symbol  )

Definition at line 763 of file array.c. References _, array_size, AWKNUM, i, NULL, pr_node(), and tmp_number. Referenced by do_adump(). { 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); }

static NODE* assoc_find (  NODE *  symbol, register NODE *  subs, int  hash1 )  [static]

Definition at line 414 of file array.c. References NULL, and STREQN. Referenced by assoc_lookup(), and in_array(). { 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; }

static void assoc_from_list (  NODE *  symbol, NODE *  list )  [static]

Definition at line 965 of file array.c. References emalloc, i, and NULL. Referenced by assoc_sort_inplace(). { 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; } }

NODE** assoc_lookup (  NODE *  symbol, NODE *  subs, int  reference )

Definition at line 479 of file array.c. References _, array_vname(), ARRAYMAXED, assoc_find(), AVG_CHAIN_MAX, do_lint, emalloc, exp_node::flags, force_string, free_temp, getnode, grow_table(), lintwarn, MALLOC, memcpy, Nnull_string, Node_ahash, Node_var_array, NULL, and exp_node::type. Referenced by do_fork(), do_match(), do_mkarray(), do_stat(), init_args(), load_environ(), load_procinfo(), nextfile(), r_get_lhs(), set_element(), and update_PROCINFO(). { 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); }

static NODE* assoc_sort_inplace (  NODE *  symbol, ASORT_TYPE  how )  [static]

Definition at line 1002 of file array.c. References ALREADY_MALLOCED, array_size, assoc_from_list(), AWKNUM, exp_node::flags, free(), getnode, i, make_str_node(), make_string, MALLOC, merge_sort(), NULL, tmp_number, unref(), and VALUE. Referenced by asort_actual(). { 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); }

static unsigned long awk_hash (  register const char *  s, register size_t  len, unsigned long  hsize )  [static]

Definition at line 327 of file array.c. References HASHC. { 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; }

NODE* concat_exp (  register NODE *  tree  )

Definition at line 257 of file array.c. References ALREADY_MALLOCED, emalloc, erealloc, exp_node::flags, force_string, free_temp, len, make_str_node(), memcpy, Node_expression_list, NULL, SUBSEP_node, TEMP, and tree_eval. Referenced by do_delete(), in_array(), and r_get_lhs(). { 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; }

NODE* do_adump (  NODE *  tree  )

Definition at line 800 of file array.c. References _, assoc_dump(), Node_array_ref, Node_param_list, stack_ptr, and exp_node::type. { 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; }

NODE* do_asort (  NODE *  tree  )

Definition at line 1117 of file array.c. References asort_actual(), and VALUE. { return asort_actual(tree, VALUE); }

NODE* do_asorti (  NODE *  tree  )

Definition at line 1125 of file array.c. References asort_actual(), and INDEX. { return asort_actual(tree, INDEX); }

void do_delete (  NODE *  sym, NODE *  tree )

Definition at line 560 of file array.c. References _, array_vname(), ARRAYMAXED, assoc_clear(), concat_exp(), do_lint, exp_node::flags, free(), free_temp, get_array, lintwarn, memset(), NULL, STREQN, and unref(). Referenced by interpret(). { 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; } }

void do_delete_loop (  NODE *  symbol, NODE *  tree )

Definition at line 643 of file array.c. References array_size, assoc_clear(), FALSE, get_array, get_lhs, i, make_string, NULL, and unref(). Referenced by interpret(). { 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); }

static void dup_table (  NODE *  symbol, NODE *  newsymb )  [static]

Definition at line 831 of file array.c. References dupnode, emalloc, exp_node::flags, getnode, i, MALLOC, memcpy, memset(), Node_ahash, NULL, and exp_node::type. Referenced by asort_actual(). { 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; }

NODE* get_actual (  NODE *  symbol, int  canfatal )

Definition at line 81 of file array.c. References _, cant_happen, fatal, exp_node::flags, FUNC, Node_array_ref, Node_param_list, Node_var_array, Node_var_new, NULL, stack_ptr, and exp_node::type. { 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; }

static void grow_table (  NODE *  symbol  )  [static]

Definition at line 674 of file array.c. References ARRAYMAXED, emalloc, exp_node::flags, free(), i, memset(), and NULL. Referenced by assoc_lookup(). { 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 |=