e576bb | 2002-10-11 | Martin Nilsson | |
|
aedfb1 | 2002-10-09 | Martin Nilsson | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "global.h"
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #include "main.h"
#include "object.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "mapping.h"
#include "svalue.h"
#include "array.h"
|
bb55f8 | 1997-03-16 | Fredrik Hübinette (Hubbe) | | #include "pike_macros.h"
|
b2d3e4 | 2000-12-01 | Fredrik Hübinette (Hubbe) | | #include "pike_error.h"
|
9aa6fa | 1997-05-19 | Fredrik Hübinette (Hubbe) | | #include "pike_memory.h"
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | | #include "pike_types.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #include "dynamic_buffer.h"
#include "interpret.h"
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #include "las.h"
|
c94c37 | 1996-03-28 | Fredrik Hübinette (Hubbe) | | #include "gc.h"
|
558827 | 1998-01-13 | Henrik Grubbström (Grubba) | | #include "stralloc.h"
|
37775c | 2004-04-06 | Martin Nilsson | | #include "pike_security.h"
|
d856cf | 2013-06-12 | Arne Goedeke | | #include "block_allocator.h"
|
f76b4c | 2000-05-11 | Henrik Grubbström (Grubba) | | #include "opcodes.h"
|
447e9b | 2001-09-06 | Fredrik Hübinette (Hubbe) | | #include "stuff.h"
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #define AVG_LINK_LENGTH 4
#define MIN_LINK_LENGTH 1
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | #define MAP_SLOTS(X) ((X)?((X)+((X)>>4)+8):0)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
struct mapping *first_mapping;
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | struct mapping *gc_internal_mapping = 0;
static struct mapping *gc_mark_mapping_pos = 0;
|
1f342f | 2000-02-04 | Fredrik Hübinette (Hubbe) | | #define unlink_mapping_data(M) do{ \
struct mapping_data *md_=(M); \
if(md_->hardlinks) { md_->hardlinks--; md_->valrefs--; } \
free_mapping_data(M); \
}while(0)
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #define MAPPING_DATA_SIZE(HSIZE, KEYPAIRS) \
|
d2361e | 2003-06-30 | Martin Stjernholm | | PTR_TO_INT(MD_KEYPAIRS(0, HSIZE) + KEYPAIRS)
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
d856cf | 2013-06-12 | Arne Goedeke | | static struct block_allocator mapping_allocator = BA_INIT_PAGES(sizeof(struct mapping), 2);
void count_memory_in_mappings(size_t * num, size_t * size) {
struct mapping *m;
double datasize = 0.0;
ba_count_all(&mapping_allocator, num, size);
for(m=first_mapping;m;m=m->next) {
datasize+=MAPPING_DATA_SIZE(m->data->hashsize, m->data->num_keypairs) / (double) m->data->refs;
}
*size += (size_t) datasize;
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
d856cf | 2013-06-12 | Arne Goedeke | | void really_free_mapping(struct mapping * m) {
#ifdef PIKE_DEBUG
if (m->refs) {
# ifdef DEBUG_MALLOC
describe_something(m, T_MAPPING, 0,2,0, NULL);
# endif
Pike_fatal("really free mapping on mapping with %d refs.\n", m->refs);
}
#endif
FREE_PROT(m);
unlink_mapping_data(m->data);
DOUBLEUNLINK(first_mapping, m);
GC_FREE(m);
ba_free(&mapping_allocator, m);
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
d856cf | 2013-06-12 | Arne Goedeke | | ATTRIBUTE((malloc))
static struct mapping * alloc_mapping() {
return ba_alloc(&mapping_allocator);
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
d856cf | 2013-06-12 | Arne Goedeke | | void free_all_mapping_blocks() {
ba_destroy(&mapping_allocator);
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | #define IF_ELSE_KEYPAIR_LOOP(X, Y) Y
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #define FREE_KEYPAIR(md, k) do { \
k->next = md->free_list; \
md->free_list = k; \
} while(0)
#else /* PIKE_MAPPING_KEYPAIR_LOOP */
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | #define IF_ELSE_KEYPAIR_LOOP(X, Y) X
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #define FREE_KEYPAIR(md, k) do { \
md->free_list--; \
if (k != md->free_list) { \
struct keypair **prev_; \
unsigned INT32 h_; \
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | INT32 e; \
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | /* Move the last keypair to the new hole. */ \
*k = *(md->free_list); \
|
903142 | 2011-04-05 | Arne Goedeke | | h_ = k->hval & ( md->hashsize - 1); \
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | prev_ = md->hash + h_; \
DO_IF_DEBUG( \
if (!*prev_) { \
|
f49b92 | 2007-10-03 | Henrik Grubbström (Grubba) | | Pike_fatal("Node to move not found!\n"); \
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | } \
); \
while (*prev_ != md->free_list) { \
prev_ = &((*prev_)->next); \
DO_IF_DEBUG( \
if (!*prev_) { \
|
f49b92 | 2007-10-03 | Henrik Grubbström (Grubba) | | Pike_fatal("Node to move not found!\n"); \
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | } \
); \
} \
*prev_ = k; \
} \
} while(0)
#endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
a4682e | 2012-09-26 | Henrik Grubbström (Grubba) | | void mapping_free_keypair(struct mapping_data *md, struct keypair *k)
{
FREE_KEYPAIR(md, k);
}
|
df160c | 2012-11-04 | Arne Goedeke | | static INLINE int check_type_contains(TYPE_FIELD types, const struct svalue * s) {
return (TYPEOF(*s) == PIKE_T_OBJECT || types & (BIT_OBJECT|(1 << TYPEOF(*s))));
}
|
aaf254 | 2012-11-15 | Arne Goedeke | | static INLINE int check_type_overlaps(TYPE_FIELD t1, TYPE_FIELD t2) {
|
e2891a | 2012-12-30 | Jonas Walldén | | return (!t1 && !t2) || t1 & t2 || (t1|t2) & BIT_OBJECT;
|
aaf254 | 2012-11-15 | Arne Goedeke | | }
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2dff75 | 2005-09-10 | Marek Habersack | |
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * It is used for debugging purposes only.
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | */
|
466b66 | 2008-01-05 | Martin Nilsson | | static void check_mapping_type_fields(const struct mapping *m)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | INT32 e;
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct keypair *k=0;
const struct mapping_data *md;
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | TYPE_FIELD ind_types, val_types;
ind_types=val_types=0;
|
fa666b | 2004-04-15 | Martin Nilsson | | md = m->data;
NEW_MAPPING_LOOP(md)
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | {
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if (TYPEOF(k->val) > MAX_TYPE)
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | | Pike_fatal("Invalid mapping keypair value type: %s\n",
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | get_name_of_type(TYPEOF(k->val)));
val_types |= 1 << TYPEOF(k->val);
if (TYPEOF(k->ind) > MAX_TYPE)
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | | Pike_fatal("Invalid maping keypair index type: %s\n",
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | get_name_of_type(TYPEOF(k->ind)));
ind_types |= 1 << TYPEOF(k->ind);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | }
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(val_types & ~(m->data->val_types))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping value types out of order!\n");
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(ind_types & ~(m->data->ind_types))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping indices types out of order!\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
f4d757 | 2001-04-15 | Martin Stjernholm | | static struct mapping_data empty_data =
|
938632 | 2011-07-21 | Henrik Grubbström (Grubba) | | { PIKE_CONSTANT_MEMOBJ_INIT(1, T_MAPPING_DATA), 1, 0,0,0,0,0,0, 0,
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | IF_ELSE_KEYPAIR_LOOP((struct keypair *)&empty_data.hash, 0), {0}};
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | static struct mapping_data weak_ind_empty_data =
|
938632 | 2011-07-21 | Henrik Grubbström (Grubba) | | { PIKE_CONSTANT_MEMOBJ_INIT(1, T_MAPPING_DATA), 1, 0,0,0,0,0,0, MAPPING_WEAK_INDICES,
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | IF_ELSE_KEYPAIR_LOOP((struct keypair *)&weak_ind_empty_data.hash, 0), {0}};
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | static struct mapping_data weak_val_empty_data =
|
938632 | 2011-07-21 | Henrik Grubbström (Grubba) | | { PIKE_CONSTANT_MEMOBJ_INIT(1, T_MAPPING_DATA), 1, 0,0,0,0,0,0, MAPPING_WEAK_VALUES,
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | IF_ELSE_KEYPAIR_LOOP((struct keypair *)&weak_val_empty_data.hash, 0), {0}};
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | static struct mapping_data weak_both_empty_data =
|
938632 | 2011-07-21 | Henrik Grubbström (Grubba) | | { PIKE_CONSTANT_MEMOBJ_INIT(1, T_MAPPING_DATA), 1, 0,0,0,0,0,0, MAPPING_WEAK,
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | IF_ELSE_KEYPAIR_LOOP((struct keypair *)&weak_both_empty_data.hash, 0), {0}};
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
2dff75 | 2005-09-10 | Marek Habersack | | |
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * struct. The size is the max number of indices that can fit in the
* allocated space.
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | */
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | static void init_mapping(struct mapping *m,
INT32 size,
INT16 flags)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md;
|
f5757f | 2000-08-11 | Henrik Grubbström (Grubba) | | ptrdiff_t e;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | INT32 hashsize;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
5eca4d | 2000-09-04 | Martin Stjernholm | | if (Pike_in_gc > GC_PASS_PREPARE && Pike_in_gc < GC_PASS_ZAP_WEAK)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Can't allocate a new mapping_data inside gc.\n");
if(size < 0) Pike_fatal("init_mapping with negative value.\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #endif
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | if(size)
{
|
87daf7 | 2011-09-06 | Arne Goedeke | | hashsize=find_next_power(size / AVG_LINK_LENGTH + 1);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
e=MAPPING_DATA_SIZE(hashsize, size);
|
0bf1f9 | 2014-04-27 | Martin Nilsson | | md=xcalloc(1,e);
|
7bf623 | 2000-04-23 | Martin Stjernholm | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | m->data=md;
md->hashsize=hashsize;
|
0bf1f9 | 2014-04-27 | Martin Nilsson | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->free_list=MD_KEYPAIRS(md, hashsize);
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | for(e=1;e<size;e++)
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | {
md->free_list[e-1].next = md->free_list + e;
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&md->free_list[e-1].ind);
mark_free_svalue (&md->free_list[e-1].val);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | }
|
0bf1f9 | 2014-04-27 | Martin Nilsson | |
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&md->free_list[e-1].ind);
mark_free_svalue (&md->free_list[e-1].val);
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
0bf1f9 | 2014-04-27 | Martin Nilsson | |
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | md->flags = flags;
|
0bf1f9 | 2014-04-27 | Martin Nilsson | |
|
938632 | 2011-07-21 | Henrik Grubbström (Grubba) | | #ifdef ATOMIC_SVALUE
md->ref_type = T_MAPPING_DATA;
#endif
|
0bf1f9 | 2014-04-27 | Martin Nilsson | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->num_keypairs=size;
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | }else{
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | switch (flags & MAPPING_WEAK) {
case 0: md = &empty_data; break;
case MAPPING_WEAK_INDICES: md = &weak_ind_empty_data; break;
case MAPPING_WEAK_VALUES: md = &weak_val_empty_data; break;
default: md = &weak_both_empty_data; break;
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | }
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | }
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | add_ref(md);
m->data=md;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
20b19f | 2000-02-09 | Fredrik Hübinette (Hubbe) | | m->debug_size = md->size;
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
2dff75 | 2005-09-10 | Marek Habersack | | |
7964ef | 2002-10-27 | Martin Nilsson | | * for 'size' values.
|
2dff75 | 2005-09-10 | Marek Habersack | | *
* @param size initial number of values
* @return the newly allocated mapping
* @see do_free_mapping
* @see free_mapping
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | */
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *debug_allocate_mapping(int size)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
struct mapping *m;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | m=alloc_mapping();
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
7bf623 | 2000-04-23 | Martin Stjernholm | | GC_ALLOC(m);
|
7e97c3 | 1999-01-21 | Fredrik Hübinette (Hubbe) | | INITIALIZE_PROT(m);
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | init_mapping(m,size,0);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
938632 | 2011-07-21 | Henrik Grubbström (Grubba) | | #ifdef ATOMIC_SVALUE
m->ref_type = T_MAPPING;
#endif
|
50ea68 | 2003-03-14 | Henrik Grubbström (Grubba) | | m->refs = 0;
add_ref(m);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | DOUBLELINK(first_mapping, m);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
return m;
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void really_free_mapping_data(struct mapping_data *md)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | INT32 e;
struct keypair *k;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(md);
|
7dd0d7 | 2000-09-14 | Martin Stjernholm | |
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
if (md->refs) {
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("really_free_mapping_data(): md has non-zero refs: %d\n",
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | | md->refs);
}
#endif /* PIKE_DEBUG */
|
7dd0d7 | 2000-09-14 | Martin Stjernholm | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | NEW_MAPPING_LOOP(md)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
free_svalue(& k->val);
free_svalue(& k->ind);
}
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(md);
|
553d23 | 2000-09-14 | Martin Stjernholm | | GC_FREE_BLOCK(md);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void do_free_mapping(struct mapping *m)
|
65b673 | 2000-07-07 | Martin Stjernholm | | {
if (m)
|
63040d | 2008-01-05 | Martin Nilsson | | inl_free_mapping(m);
|
65b673 | 2000-07-07 | Martin Stjernholm | | }
|
5e8344 | 2008-05-11 | Martin Stjernholm | | |
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * order in each hash chain. This is to prevent mappings from becoming
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | * inefficient just after being rehashed.
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | */
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | |
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | static void mapping_rehash_backwards_evil(struct mapping_data *md,
struct keypair *from)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | unsigned INT32 h;
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | struct keypair *k, *prev = NULL, *next;
if(!(k = from)) return;
while ((next = k->next)) {
k->next = prev;
prev = k;
k = next;
}
k->next = prev;
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
|
b2525a | 2013-01-01 | Henrik Grubbström (Grubba) | | prev = k;
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
|
b2525a | 2013-01-01 | Henrik Grubbström (Grubba) | | while ((from = prev)) {
prev = from->next;
from->next = next;
next = from;
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | if (md->flags & MAPPING_WEAK) {
switch(md->flags & MAPPING_WEAK) {
default:
Pike_fatal("Instable mapping data flags.\n");
case MAPPING_WEAK_INDICES:
|
c69ce7 | 2013-08-03 | Arne Goedeke | | if (!REFCOUNTED_TYPE(TYPEOF(from->ind)) ||
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->ind.u.refs > 1)) {
goto keep_keypair;
}
break;
case MAPPING_WEAK_VALUES:
|
c69ce7 | 2013-08-03 | Arne Goedeke | | if (!REFCOUNTED_TYPE(TYPEOF(from->val)) ||
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->val.u.refs > 1)) {
goto keep_keypair;
}
break;
case MAPPING_WEAK:
|
dee7fc | 2013-01-01 | Henrik Grubbström (Grubba) | |
|
5fd9ea | 2013-06-11 | Henrik Grubbström (Grubba) | | if ((!REFCOUNTED_TYPE(TYPEOF(from->ind)) ||
|
dee7fc | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->ind.u.refs > 1)) &&
|
5fd9ea | 2013-06-11 | Henrik Grubbström (Grubba) | | (!REFCOUNTED_TYPE(TYPEOF(from->val)) ||
|
dee7fc | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->val.u.refs > 1))) {
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | goto keep_keypair;
}
break;
}
free_svalue(&from->ind);
free_svalue(&from->val);
continue;
}
keep_keypair:
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
k=md->free_list;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | if(!k) Pike_fatal("Error in rehash: not enough keypairs.\n");
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | #endif
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | md->free_list=k->next;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #else /* PIKE_MAPPING_KEYPAIR_LOOP */
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | md->free_list++;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
*k=*from;
h=k->hval;
|
903142 | 2011-04-05 | Arne Goedeke | | h&=md->hashsize - 1;
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | k->next=md->hash[h];
md->hash[h]=k;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | md->ind_types |= 1<< (TYPEOF(k->ind));
md->val_types |= 1<< (TYPEOF(k->val));
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | md->size++;
}
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | }
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | |
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | static void mapping_rehash_backwards_good(struct mapping_data *md,
struct keypair *from)
{
unsigned INT32 h;
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | struct keypair *k, *prev = NULL, *next;
if(!(k = from)) return;
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
while ((next = k->next)) {
k->next = prev;
prev = k;
k = next;
}
k->next = prev;
|
b2525a | 2013-01-01 | Henrik Grubbström (Grubba) | | prev = k;
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
|
b2525a | 2013-01-01 | Henrik Grubbström (Grubba) | | while ((from = prev)) {
prev = from->next;
from->next = next;
next = from;
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | if (md->flags & MAPPING_WEAK) {
switch(md->flags & MAPPING_WEAK) {
default:
Pike_fatal("Instable mapping data flags.\n");
case MAPPING_WEAK_INDICES:
|
5fd9ea | 2013-06-11 | Henrik Grubbström (Grubba) | | if (REFCOUNTED_TYPE(TYPEOF(from->ind)) &&
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->ind.u.refs > 1)) {
goto keep_keypair;
}
break;
case MAPPING_WEAK_VALUES:
|
5fd9ea | 2013-06-11 | Henrik Grubbström (Grubba) | | if (REFCOUNTED_TYPE(TYPEOF(from->val)) &&
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->val.u.refs > 1)) {
goto keep_keypair;
}
break;
case MAPPING_WEAK:
|
dee7fc | 2013-01-01 | Henrik Grubbström (Grubba) | |
|
5fd9ea | 2013-06-11 | Henrik Grubbström (Grubba) | | if ((!REFCOUNTED_TYPE(TYPEOF(from->ind)) ||
|
dee7fc | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->ind.u.refs > 1)) &&
|
5fd9ea | 2013-06-11 | Henrik Grubbström (Grubba) | | (!REFCOUNTED_TYPE(TYPEOF(from->val)) ||
|
dee7fc | 2013-01-01 | Henrik Grubbström (Grubba) | | (*from->val.u.refs > 1))) {
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | | goto keep_keypair;
}
break;
}
continue;
}
keep_keypair:
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
k=md->free_list;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | if(!k) Pike_fatal("Error in rehash: not enough keypairs.\n");
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | #endif
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | md->free_list=k->next;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #else /* PIKE_MAPPING_KEYPAIR_LOOP */
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | md->free_list++;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | |
k->hval=from->hval;
assign_svalue_no_free(&k->ind, &from->ind);
assign_svalue_no_free(&k->val, &from->val);
h=k->hval;
|
903142 | 2011-04-05 | Arne Goedeke | | h&=md->hashsize - 1;
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | k->next=md->hash[h];
md->hash[h]=k;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | md->ind_types |= 1<< (TYPEOF(k->ind));
md->val_types |= 1<< (TYPEOF(k->val));
|
9e7ce5 | 2006-01-19 | Henrik Grubbström (Grubba) | | md->size++;
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
2dff75 | 2005-09-10 | Marek Habersack | | |
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * values can be fitted into the mapping. It takes a bit of time to
* run, but is used seldom enough not to degrade preformance significantly.
|
2dff75 | 2005-09-10 | Marek Habersack | | *
* @param m the mapping to be rehashed
* @param new_size new mappingsize
* @return the rehashed mapping
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | */
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | static struct mapping *rehash(struct mapping *m, int new_size)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md, *new_md;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | INT32 tmp=m->data->size;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | INT32 e;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | md=m->data;
|
27bec9 | 2000-02-15 | Henrik Grubbström (Grubba) | | debug_malloc_touch(md);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | if(md->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
#endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
1fbbfd | 2011-09-04 | Henrik Grubbström (Grubba) | |
if ((md->hashsize == new_size) && (md->refs == 1)) return m;
|
940651 | 2008-06-26 | Henrik Grubbström (Grubba) | |
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | init_mapping(m, new_size, md->flags);
|
616b62 | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | new_md=m->data;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
if(md->refs>1)
{
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | |
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | for(e=0;e<md->hashsize;e++)
mapping_rehash_backwards_good(new_md, md->hash[e]);
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | |
|
1f342f | 2000-02-04 | Fredrik Hübinette (Hubbe) | | unlink_mapping_data(md);
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | }else{
|
bb5e46 | 2013-01-01 | Henrik Grubbström (Grubba) | |
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | for(e=0;e<md->hashsize;e++)
mapping_rehash_backwards_evil(new_md, md->hash[e]);
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | |
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(md);
|
553d23 | 2000-09-14 | Martin Stjernholm | | GC_FREE_BLOCK(md);
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | }
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
#ifdef PIKE_DEBUG
|
558f13 | 2013-01-29 | Henrik Grubbström (Grubba) | | if((m->data->size != tmp) &&
((m->data->size > tmp) || !(m->data->flags & MAPPING_WEAK)))
Pike_fatal("Rehash failed, size not same any more (%ld != %ld).\n",
(long)m->data->size, (long)tmp);
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #endif
#ifdef MAPPING_SIZE_DEBUG
|
20b19f | 2000-02-09 | Fredrik Hübinette (Hubbe) | | m->debug_size = m->data->size;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | return m;
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
#define LOW_RELOC(X) X= (void *) ((char *)(X) + off);
#define RELOC(X) if(X) LOW_RELOC(X)
struct mapping_data *copy_mapping_data(struct mapping_data *md)
{
|
f5757f | 2000-08-11 | Henrik Grubbström (Grubba) | | long e;
ptrdiff_t size, off;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *nmd;
struct keypair *keypairs;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef PIKE_DEBUG
if (Pike_in_gc > GC_PASS_PREPARE && Pike_in_gc < GC_PASS_ZAP_WEAK)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Can't allocate a new mapping_data inside gc.\n");
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(md);
size=MAPPING_DATA_SIZE(md->hashsize, md->num_keypairs);
nmd=(struct mapping_data *)xalloc(size);
MEMCPY(nmd, md, size);
off=((char *)nmd) - ((char *)md);
RELOC(nmd->free_list);
for(e=0;e<nmd->hashsize;e++) RELOC(nmd->hash[e]);
keypairs=MD_KEYPAIRS(nmd, nmd->hashsize);
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | for(e=0;e<nmd->num_keypairs;e++)
{
RELOC(keypairs[e].next);
add_ref_svalue(& keypairs[e].ind);
add_ref_svalue(& keypairs[e].val);
}
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #else /* PIKE_MAPPING_KEYPAIR_LOOP */
for(e=0;e<nmd->size;e++)
{
RELOC(keypairs[e].next);
add_ref_svalue(& keypairs[e].ind);
add_ref_svalue(& keypairs[e].val);
}
#endif /* PIKE_MAPPING_KEYPAIR_LOOP */
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
50ea68 | 2003-03-14 | Henrik Grubbström (Grubba) | | nmd->refs=0;
add_ref(nmd);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | nmd->valrefs=0;
nmd->hardlinks=0;
|
aa95de | 2008-06-24 | Henrik Grubbström (Grubba) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->hardlinks)
{
#ifdef PIKE_DEBUG
if(md->refs <= 0 || md->valrefs<=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Hardlink without refs/valrefs!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
md->hardlinks--;
md->valrefs--;
}
|
50ea68 | 2003-03-14 | Henrik Grubbström (Grubba) | | sub_ref(md);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
return nmd;
}
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #define MAPPING_DATA_IN_USE(MD) ((MD)->refs != (MD)->hardlinks + 1)
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #define LOW_FIND(FUN, KEY, FOUND, NOT_FOUND) do { \
md=m->data; \
add_ref(md); \
if(md->hashsize) \
{ \
|
903142 | 2011-04-05 | Arne Goedeke | | h=h2 & (md->hashsize - 1); \
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | DO_IF_DEBUG( if(d_flag > 1) check_mapping_type_fields(m); ) \
|
df160c | 2012-11-04 | Arne Goedeke | | if(check_type_contains(md->ind_types, key)) \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | { \
for(prev= md->hash + h;(k=*prev);prev=&k->next) \
{ \
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | if(h2 == k->hval && FUN(& k->ind, KEY)) \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | { \
FOUND; \
} \
} \
} \
} \
NOT_FOUND; \
}while(0)
#define LOW_FIND2(FUN, KEY, FOUND, NOT_FOUND) do { \
struct keypair *k2; \
md=m->data; \
add_ref(md); \
if(md->hashsize) \
{ \
|
903142 | 2011-04-05 | Arne Goedeke | | h=h2 & (md->hashsize-1); \
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | DO_IF_DEBUG( if(d_flag > 1) check_mapping_type_fields(m); ) \
|
df160c | 2012-11-04 | Arne Goedeke | | if(check_type_contains(md->ind_types, key)) \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | { \
|
903142 | 2011-04-05 | Arne Goedeke | | k2=omd->hash[h2 & (omd->hashsize - 1)]; \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | prev= md->hash + h; \
for(;(k=*prev) && k2;(prev=&k->next),(k2=k2->next)) \
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | if(!(h2 == k->hval && is_identical(&k2->ind, &k->ind))) \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | break; \
for(;(k=*prev);prev=&k->next) \
{ \
if(FUN(& k->ind, KEY)) \
{ \
FOUND; \
} \
} \
} \
} \
NOT_FOUND; \
}while(0)
#define SAME_DATA(SAME,NOT_SAME) \
if(m->data == md) \
{ \
SAME; \
}else{ \
NOT_SAME; \
}
#define FIND() do{ \
LOW_FIND(is_eq, key, \
omd=md; \
SAME_DATA( break, \
struct svalue *tmp=&k->ind; \
LOW_FIND(is_identical, tmp, break, ;); \
free_mapping_data(omd)), \
break); \
free_mapping_data(md); \
}while(0)
#define COPYMAP2() do { \
|
aa45cf | 2000-08-07 | Henrik Grubbström (Grubba) | | ptrdiff_t off; \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | m->data=copy_mapping_data(m->data); \
debug_malloc_touch(m->data); \
|
d3018a | 2000-01-30 | Fredrik Hübinette (Hubbe) | | DO_IF_DEBUG( if(d_flag>1) check_mapping(m); ) \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | off=((char *)m->data)-((char *)md); \
LOW_RELOC(k); \
LOW_RELOC(prev); \
md=m->data; \
}while(0)
#define PREPARE_FOR_DATA_CHANGE2() \
if(md->valrefs) COPYMAP2()
#define PREPARE_FOR_INDEX_CHANGE2() \
if(md->refs>1) COPYMAP2()
#define PROPAGATE() do { \
if(md->refs==1) \
{ \
|
903142 | 2011-04-05 | Arne Goedeke | | h=h2 & (md->hashsize - 1); \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | *prev=k->next; \
k->next=md->hash[h]; \
md->hash[h]=k; \
} \
}while(0)
#define COPYMAP() do { \
|
d1f271 | 2000-08-07 | Henrik Grubbström (Grubba) | | ptrdiff_t off; \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | m->data=copy_mapping_data(m->data); \
debug_malloc_touch(m->data); \
off=((char *)m->data)-((char *)md); \
LOW_RELOC(k); \
free_mapping_data(md); \
md=m->data; \
|
50ea68 | 2003-03-14 | Henrik Grubbström (Grubba) | | add_ref(md); \
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | }while(0)
#define PREPARE_FOR_DATA_CHANGE() \
if(md->valrefs) COPYMAP()
#define PREPARE_FOR_INDEX_CHANGE() \
if(md->refs>1) COPYMAP()
|
2dff75 | 2005-09-10 | Marek Habersack | | |
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | * very often.
*/
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_fix_type_field(struct mapping *m)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | INT32 e;
struct keypair *k;
TYPE_FIELD ind_types, val_types;
val_types = ind_types = 0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | NEW_MAPPING_LOOP(m->data)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | val_types |= 1 << TYPEOF(k->val);
ind_types |= 1 << TYPEOF(k->ind);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(val_types & ~(m->data->val_types))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping value types out of order!\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(ind_types & ~(m->data->ind_types))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping indices types out of order!\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | m->data->val_types = val_types;
m->data->ind_types = ind_types;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
5eca4d | 2000-09-04 | Martin Stjernholm | | PMOD_EXPORT void mapping_set_flags(struct mapping *m, int flags)
{
struct mapping_data *md = m->data;
|
a0d7f3 | 2003-08-20 | Henrik Grubbström (Grubba) | |
if ((md->flags != flags) && (md->refs > 1)) {
|
f25837 | 2000-09-08 | Henrik Grubbström (Grubba) | | struct keypair *k = NULL, *prev = NULL;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | COPYMAP2();
|
a0d7f3 | 2003-08-20 | Henrik Grubbström (Grubba) | | md = m->data;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | }
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | if(flags & MAPPING_WEAK)
|
c0e91b | 2001-01-25 | Fredrik Hübinette (Hubbe) | | {
debug_malloc_touch(m);
debug_malloc_touch(md);
}
else
{
debug_malloc_touch(m);
debug_malloc_touch(md);
}
#endif
|
5eca4d | 2000-09-04 | Martin Stjernholm | | md->flags = flags;
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void low_mapping_insert(struct mapping *m,
|
9cc28d | 2004-05-28 | Henrik Grubbström (Grubba) | | const struct svalue *key,
const struct svalue *val,
int overwrite)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | unsigned INT32 h,h2;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct keypair *k, **prev;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md, *omd;
#ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | h2=hash_svalue(key);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
LOW_FIND(is_eq, key,
struct svalue *tmp=&k->ind;
SAME_DATA(goto mi_set_value,
omd=md;
LOW_FIND(is_identical, tmp,
free_mapping_data(omd);
goto mi_set_value,
free_mapping_data(omd);
goto mi_do_nothing)),
Z:
SAME_DATA(goto mi_insert,
omd=md;
LOW_FIND2(is_eq, key,
free_mapping_data(omd);
goto mi_do_nothing,
free_mapping_data(omd);
goto Z)));
mi_do_nothing:
free_mapping_data(md);
return;
mi_set_value:
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m->data != md)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Wrong dataset in mapping_insert!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | free_mapping_data(md);
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | if(!overwrite) return;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | PREPARE_FOR_DATA_CHANGE2();
PROPAGATE();
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | md->val_types |= 1 << TYPEOF(*val);
if (overwrite == 2 && TYPEOF(*key) == T_OBJECT)
|
a1202e | 2003-11-09 | Martin Stjernholm | |
assign_svalue (&k->ind, key);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | assign_svalue(& k->val, val);
#ifdef PIKE_DEBUG
if(d_flag>1) check_mapping(m);
#endif
return;
mi_insert:
#ifdef PIKE_DEBUG
if(m->data != md)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Wrong dataset in mapping_insert!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
#endif
free_mapping_data(md);
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | if(
#ifndef PIKE_MAPPING_KEYPAIR_LOOP
(!md->free_list) ||
#else /* PIKE_MAPPING_KEYPAIR_LOOP */
(md->size >= md->num_keypairs) ||
#endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
md->refs>1)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | rehash(m, md->size * 2 + 2);
md=m->data;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
903142 | 2011-04-05 | Arne Goedeke | | h=h2 & ( md->hashsize - 1);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
k=md->free_list;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->free_list=k->next;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #else /* PIKE_MAPPING_KEYPAIR_LOOP */
md->free_list++;
#endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | k->next=md->hash[h];
md->hash[h]=k;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | md->ind_types |= 1 << TYPEOF(*key);
md->val_types |= 1 << TYPEOF(*val);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | assign_svalue_no_free(& k->ind, key);
assign_svalue_no_free(& k->val, val);
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | k->hval = h2;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->size++;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
10da6b | 2000-04-15 | Fredrik Hübinette (Hubbe) | | if(m->data ==md)
m->debug_size++;
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_insert(struct mapping *m,
|
9cc28d | 2004-05-28 | Henrik Grubbström (Grubba) | | const struct svalue *key,
const struct svalue *val)
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | {
low_mapping_insert(m,key,val,1);
}
|
a1202e | 2003-11-09 | Martin Stjernholm | |
#define mapping_insert(M, KEY, VAL) low_mapping_insert ((M), (KEY), (VAL), 1)
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT union anything *mapping_get_item_ptr(struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct svalue *key,
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | TYPE_T t)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | unsigned INT32 h, h2;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct keypair *k, **prev;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md,*omd;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(m->data);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #endif
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | h2=hash_svalue(key);
LOW_FIND(is_eq, key,
struct svalue *tmp=&k->ind;
SAME_DATA(goto mg_set_value,
omd=md;
LOW_FIND(is_identical, tmp,
free_mapping_data(omd);
goto mg_set_value,
free_mapping_data(omd);
goto mg_do_nothing)),
Z:
SAME_DATA(goto mg_insert,
omd=md;
LOW_FIND2(is_eq, key,
free_mapping_data(omd);
goto mg_do_nothing,
free_mapping_data(omd);
goto Z)));
mg_do_nothing:
free_mapping_data(md);
return 0;
mg_set_value:
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m->data != md)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Wrong dataset in mapping_get_item_ptr!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag)
check_mapping(m);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | free_mapping_data(md);
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if(TYPEOF(k->val) == t)
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | {
PREPARE_FOR_DATA_CHANGE2();
PROPAGATE();
return & ( k->val.u );
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | return 0;
mg_insert:
#ifdef PIKE_DEBUG
if(m->data != md)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Wrong dataset in mapping_get_item_ptr!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag)
check_mapping(m);
#endif
free_mapping_data(md);
if(t != T_INT) return 0;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | if(
#ifndef PIKE_MAPPING_KEYPAIR_LOOP
!(md->free_list) ||
#else /* PIKE_MAPPING_KEYPAIR_LOOP */
(md->size >= md->num_keypairs) ||
#endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
md->refs>1)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | rehash(m, md->size * 2 + 2);
md=m->data;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
903142 | 2011-04-05 | Arne Goedeke | | h=h2 & ( md->hashsize - 1);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | k=md->free_list;
#ifndef PIKE_MAPPING_KEYPAIR_LOOP
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->free_list=k->next;
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | #else /* PIKE_MAPPING_KEYPAIR_LOOP */
md->free_list++;
#endif /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | k->next=md->hash[h];
md->hash[h]=k;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | assign_svalue_no_free(& k->ind, key);
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(k->val, T_INT, NUMBER_NUMBER, integer, 0);
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | | k->hval = h2;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | md->ind_types |= 1 << TYPEOF(*key);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->val_types |= BIT_INT;
md->size++;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
10da6b | 2000-04-15 | Fredrik Hübinette (Hubbe) | | if(m->data ==md)
m->debug_size++;
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | if(d_flag > 1) check_mapping_type_fields(m);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
return & ( k->val.u );
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void map_delete_no_free(struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct svalue *key,
|
ea0be6 | 1999-11-11 | Fredrik Hübinette (Hubbe) | | struct svalue *to)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | unsigned INT32 h,h2;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct keypair *k, **prev;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md,*omd;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
h2=hash_svalue(key);
LOW_FIND(is_eq, key,
struct svalue *tmp=&k->ind;
SAME_DATA(goto md_remove_value,
omd=md;
LOW_FIND(is_identical, tmp,
free_mapping_data(omd);
goto md_remove_value,
free_mapping_data(omd);
goto md_do_nothing)),
goto md_do_nothing);
md_do_nothing:
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | free_mapping_data(md);
|
ea0be6 | 1999-11-11 | Fredrik Hübinette (Hubbe) | | if(to)
{
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(*to, T_INT, NUMBER_UNDEFINED, integer, 0);
|
ea0be6 | 1999-11-11 | Fredrik Hübinette (Hubbe) | | }
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | return;
md_remove_value:
#ifdef PIKE_DEBUG
if(md->refs <= 1)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Too few refs i mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m->data != md)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Wrong dataset in mapping_delete!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
free_mapping_data(md);
PREPARE_FOR_INDEX_CHANGE2();
*prev=k->next;
free_svalue(& k->ind);
if(to)
|
6dea23 | 2008-01-28 | Martin Stjernholm | | move_svalue (to, &k->val);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | else
free_svalue(& k->val);
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | FREE_KEYPAIR(md, k);
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&md->free_list->ind);
mark_free_svalue (&md->free_list->val);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
md->size--;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
10da6b | 2000-04-15 | Fredrik Hübinette (Hubbe) | | if(m->data ==md)
m->debug_size--;
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->size < (md->hashsize + 1) * MIN_LINK_LENGTH)
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | {
debug_malloc_touch(m);
|
992e8f | 2008-06-27 | Henrik Grubbström (Grubba) | | rehash(m, MAP_SLOTS(m->data->size));
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | }
|
aa95de | 2008-06-24 | Henrik Grubbström (Grubba) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(d_flag>1) check_mapping(m);
#endif
return;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void check_mapping_for_destruct(struct mapping *m)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | INT32 e;
struct keypair *k, **prev;
TYPE_FIELD ind_types, val_types;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md=m->data;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
853b83 | 2000-12-14 | Martin Stjernholm | | if (Pike_in_gc > GC_PASS_PREPARE && Pike_in_gc < GC_PASS_FREE)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("check_mapping_for_destruct called in invalid pass inside gc.\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(!md->size) return;
if((md->ind_types | md->val_types) & (BIT_OBJECT | BIT_FUNCTION))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | val_types = ind_types = 0;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->val_types |= BIT_INT;
for(e=0;e<md->hashsize;e++)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | for(prev= md->hash + e;(k=*prev);)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
853b83 | 2000-12-14 | Martin Stjernholm | | check_destructed(& k->val);
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if((TYPEOF(k->ind) == T_OBJECT || TYPEOF(k->ind) == T_FUNCTION) &&
|
4ab0aa | 1996-09-23 | Fredrik Hübinette (Hubbe) | | !k->ind.u.object->prog)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
c5ae92 | 2000-04-16 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
5eca4d | 2000-09-04 | Martin Stjernholm | | debug_malloc_touch(md);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | PREPARE_FOR_INDEX_CHANGE2();
|
853b83 | 2000-12-14 | Martin Stjernholm | | *prev=k->next;
free_svalue(& k->ind);
free_svalue(& k->val);
|
df9b62 | 2001-05-27 | Henrik Grubbström (Grubba) | | FREE_KEYPAIR(md, k);
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&md->free_list->ind);
mark_free_svalue (&md->free_list->val);
|
853b83 | 2000-12-14 | Martin Stjernholm | | md->size--;
|
aa95de | 2008-06-24 | Henrik Grubbström (Grubba) | |
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
853b83 | 2000-12-14 | Martin Stjernholm | | if(m->data ==md)
{
m->debug_size++;
debug_malloc_touch(m);
}
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | #endif
|
853b83 | 2000-12-14 | Martin Stjernholm | | debug_malloc_touch(md);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }else{
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | val_types |= 1 << TYPEOF(k->val);
ind_types |= 1 << TYPEOF(k->ind);
|
cb859e | 1996-09-23 | Fredrik Hübinette (Hubbe) | | prev=&k->next;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
}
}
|
5eca4d | 2000-09-04 | Martin Stjernholm | |
|
cfa62c | 2001-11-12 | Martin Stjernholm | | md->val_types = val_types;
md->ind_types = ind_types;
|
992e8f | 2008-06-27 | Henrik Grubbström (Grubba) | | if(MAP_SLOTS(md->size) < md->hashsize * MIN_LINK_LENGTH)
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | {
debug_malloc_touch(m);
|
992e8f | 2008-06-27 | Henrik Grubbström (Grubba) | | rehash(m, MAP_SLOTS(md->size));
|
59e53e | 2000-01-31 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
5eca4d | 2000-09-04 | Martin Stjernholm | | if(d_flag>1) check_mapping(m);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct svalue *low_mapping_lookup(struct mapping *m,
|
9cc28d | 2004-05-28 | Henrik Grubbström (Grubba) | | const struct svalue *key)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | unsigned INT32 h,h2;
struct keypair *k=0, **prev=0;
struct mapping_data *md, *omd;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(d_flag>1) check_mapping(m);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | h2=hash_svalue(key);
#ifdef PIKE_DEBUG
if(d_flag > 1) check_mapping_type_fields(m);
#endif
FIND();
if(k)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | PROPAGATE();
return &k->val;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | return 0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct svalue *low_mapping_string_lookup(struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | struct pike_string *p)
|
14dae9 | 1997-01-26 | Fredrik Hübinette (Hubbe) | | {
struct svalue tmp;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(tmp, T_STRING, 0, string, p);
|
14dae9 | 1997-01-26 | Fredrik Hübinette (Hubbe) | | return low_mapping_lookup(m, &tmp);
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_string_insert(struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | struct pike_string *p,
const struct svalue *val)
|
a28dd2 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | {
struct svalue tmp;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(tmp, T_STRING, 0, string, p);
|
a28dd2 | 1998-04-23 | Fredrik Hübinette (Hubbe) | | mapping_insert(m, &tmp, val);
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_string_insert_string(struct mapping *m,
|
ea0be6 | 1999-11-11 | Fredrik Hübinette (Hubbe) | | struct pike_string *p,
struct pike_string *val)
{
struct svalue tmp;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(tmp, T_STRING, 0, string, val);
|
ea0be6 | 1999-11-11 | Fredrik Hübinette (Hubbe) | | mapping_string_insert(m, p, &tmp);
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct svalue *simple_mapping_string_lookup(struct mapping *m,
|
adb3b1 | 2004-03-22 | Martin Stjernholm | | const char *p)
|
85f59e | 1998-01-08 | Fredrik Hübinette (Hubbe) | | {
struct pike_string *tmp;
if((tmp=findstring(p)))
return low_mapping_string_lookup(m,tmp);
return 0;
}
|
f49b92 | 2007-10-03 | Henrik Grubbström (Grubba) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct svalue *mapping_mapping_lookup(struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct svalue *key1,
const struct svalue *key2,
|
f49b92 | 2007-10-03 | Henrik Grubbström (Grubba) | | int create)
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | {
struct svalue tmp;
struct mapping *m2;
struct svalue *s=low_mapping_lookup(m, key1);
|
1e3853 | 1999-10-28 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if(!s || TYPEOF(*s) != T_MAPPING)
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | {
if(!create) return 0;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(tmp, T_MAPPING, 0, mapping, allocate_mapping(5));
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | mapping_insert(m, key1, &tmp);
|
1e3853 | 1999-10-28 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(tmp.u.mapping);
free_mapping(tmp.u.mapping);
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | s=&tmp;
}
m2=s->u.mapping;
|
1e3853 | 1999-10-28 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m2);
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | s=low_mapping_lookup(m2, key2);
if(s) return s;
if(!create) return 0;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(tmp, T_INT, NUMBER_UNDEFINED, integer, 0);
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | |
mapping_insert(m2, key2, &tmp);
|
1e3853 | 1999-10-28 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m2);
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | |
return low_mapping_lookup(m2, key2);
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct svalue *mapping_mapping_string_lookup(struct mapping *m,
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | struct pike_string *key1,
struct pike_string *key2,
int create)
{
struct svalue k1,k2;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(k1, T_STRING, 0, string, key1);
SET_SVAL(k2, T_STRING, 0, string, key2);
|
8a5d44 | 1999-10-19 | Fredrik Hübinette (Hubbe) | | return mapping_mapping_lookup(m,&k1,&k2,create);
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_index_no_free(struct svalue *dest,
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct svalue *key)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct svalue *p;
|
4206f0 | 2006-11-07 | Martin Stjernholm | | if(!IS_DESTRUCTED (key) && (p=low_mapping_lookup(m,key)))
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
4139a2 | 2008-01-28 | Martin Stjernholm | | assign_svalue_no_free(dest, p);
|
93d1e4 | 2008-01-27 | Henrik Grubbström (Grubba) | |
|
4139a2 | 2008-01-28 | Martin Stjernholm | |
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if(TYPEOF(*p) == T_INT)
SET_SVAL_SUBTYPE(*dest, NUMBER_NUMBER);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }else{
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(*dest, T_INT, NUMBER_UNDEFINED, integer, 0);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct array *mapping_indices(struct mapping *m)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | INT32 e;
struct array *a;
struct svalue *s;
struct keypair *k;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
0279c8 | 2000-09-24 | Henrik Grubbström (Grubba) | | check_mapping_for_destruct(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | a=allocate_array(m->data->size);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | s=ITEM(a);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
NEW_MAPPING_LOOP(m->data) assign_svalue(s++, & k->ind);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | a->type_field = m->data->ind_types;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | if(d_flag > 1) check_mapping_type_fields(m);
#endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | return a;
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct array *mapping_values(struct mapping *m)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
INT32 e;
struct keypair *k;
struct array *a;
struct svalue *s;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
0279c8 | 2000-09-24 | Henrik Grubbström (Grubba) | | check_mapping_for_destruct(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | a=allocate_array(m->data->size);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | s=ITEM(a);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
NEW_MAPPING_LOOP(m->data) assign_svalue(s++, & k->val);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | a->type_field = m->data->val_types;
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | if(d_flag > 1) check_mapping_type_fields(m);
#endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
return a;
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct array *mapping_to_array(struct mapping *m)
|
2043ba | 1998-02-10 | Fredrik Hübinette (Hubbe) | | {
INT32 e;
struct keypair *k;
struct array *a;
struct svalue *s;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
#ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
a=allocate_array(m->data->size);
|
2043ba | 1998-02-10 | Fredrik Hübinette (Hubbe) | | s=ITEM(a);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
NEW_MAPPING_LOOP(m->data)
|
2043ba | 1998-02-10 | Fredrik Hübinette (Hubbe) | | {
struct array *b=allocate_array(2);
assign_svalue(b->item+0, & k->ind);
assign_svalue(b->item+1, & k->val);
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | b->type_field = (1 << TYPEOF(k->ind)) | (1 << TYPEOF(k->val));
SET_SVAL(*s, T_ARRAY, 0, array, b);
|
1757d8 | 1998-05-12 | Fredrik Hübinette (Hubbe) | | s++;
|
2043ba | 1998-02-10 | Fredrik Hübinette (Hubbe) | | }
a->type_field = BIT_ARRAY;
return a;
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_replace(struct mapping *m,struct svalue *from, struct svalue *to)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
INT32 e;
struct keypair *k;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md=m->data;
if(md->size)
{
add_ref(md);
NEW_MAPPING_LOOP(md)
{
if(is_eq(& k->val, from))
{
PREPARE_FOR_DATA_CHANGE();
assign_svalue(& k->val, to);
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | md->val_types |= 1<<TYPEOF(*to);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | }
}
free_mapping_data(md);
}
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | if(d_flag > 1) check_mapping_type_fields(m);
#endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *mkmapping(struct array *ind, struct array *val)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
struct mapping *m;
struct svalue *i,*v;
INT32 e;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | if(ind->size != val->size)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("mkmapping on different sized arrays.\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | #endif
m=allocate_mapping(MAP_SLOTS(ind->size));
i=ITEM(ind);
v=ITEM(val);
|
a1202e | 2003-11-09 | Martin Stjernholm | | for(e=0;e<ind->size;e++) low_mapping_insert(m, i++, v++, 2);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
return m;
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *copy_mapping(struct mapping *m)
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | {
struct mapping *n;
#ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
n=allocate_mapping(0);
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | | debug_malloc_touch(n->data);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | free_mapping_data(n->data);
n->data=m->data;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
e945ee | 2000-02-09 | Fredrik Hübinette (Hubbe) | | n->debug_size=n->data->size;
#endif
|
50ea68 | 2003-03-14 | Henrik Grubbström (Grubba) | | add_ref(n->data);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | n->data->valrefs++;
n->data->hardlinks++;
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | | debug_malloc_touch(n->data);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | return n;
}
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | |
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | static struct mapping *destructive_copy_mapping(struct mapping *m)
{
if ((m->refs == 1) && !m->data->hardlinks &&
!(m->data->flags & MAPPING_WEAK)) {
add_ref(m);
return m;
}
return copy_mapping(m);
}
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | static struct mapping *subtract_mappings(struct mapping *a, struct mapping *b)
{
struct mapping *res;
struct keypair *k;
struct mapping_data *a_md = a->data;
struct mapping_data *b_md = b->data;
INT32 e;
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | ONERROR err;
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | |
if (!a_md->size || !b_md->size || !a_md->hashsize || !b_md->hashsize) {
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | return destructive_copy_mapping(a);
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | }
if (a_md == b_md) {
return allocate_mapping(0);
}
if (a_md->size < b_md->size) {
res = allocate_mapping(a_md->size);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | SET_ONERROR(err, do_free_mapping, res);
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | NEW_MAPPING_LOOP(a_md) {
|
903142 | 2011-04-05 | Arne Goedeke | | size_t h = k->hval & ( b_md->hashsize - 1);
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | struct keypair *k2;
for (k2 = b_md->hash[h]; k2; k2 = k2->next) {
if ((k2->hval == k->hval) && is_eq(&k2->ind, &k->ind)) {
break;
}
}
if (!k2) {
mapping_insert(res, &k->ind, &k->val);
}
}
} else {
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | res = destructive_copy_mapping(a);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | SET_ONERROR(err, do_free_mapping, res);
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | NEW_MAPPING_LOOP(b_md) {
map_delete(res, &k->ind);
}
}
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | UNSET_ONERROR(err);
return res;
}
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | |
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | static struct mapping *and_mappings(struct mapping *a, struct mapping *b)
{
struct mapping *res;
struct keypair *k;
struct mapping_data *a_md = a->data;
struct mapping_data *b_md = b->data;
INT32 e;
ONERROR err;
if (!a_md->size || !b_md->size) return allocate_mapping(0);
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | if (a_md == b_md) return destructive_copy_mapping(a);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | |
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | | res = copy_mapping(b);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | SET_ONERROR(err, do_free_mapping, res);
NEW_MAPPING_LOOP(b_md) {
|
903142 | 2011-04-05 | Arne Goedeke | | size_t h = k->hval & ( a_md->hashsize - 1);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | struct keypair *k2;
for (k2 = a_md->hash[h]; k2; k2 = k2->next) {
if ((k2->hval == k->hval) && is_eq(&k2->ind, &k->ind)) {
break;
}
}
if (!k2) {
map_delete(res, &k->ind);
}
}
UNSET_ONERROR(err);
return res;
}
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | |
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | static struct mapping *or_mappings(struct mapping *a, struct mapping *b)
{
struct mapping *res;
struct keypair *k;
struct mapping_data *a_md = a->data;
struct mapping_data *b_md = b->data;
INT32 e;
ONERROR err;
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | if (!a_md->size) return destructive_copy_mapping(b);
if (!b_md->size) return destructive_copy_mapping(a);
if (a_md == b_md) return destructive_copy_mapping(a);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | |
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | | if (a_md->size <= b_md->size) {
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | res = destructive_copy_mapping(b);
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | | SET_ONERROR(err, do_free_mapping, res);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | |
|
6c9d31 | 2008-06-29 | Henrik Grubbström (Grubba) | | if (!b_md->hashsize) {
Pike_fatal("Invalid hashsize.\n");
}
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | |
NEW_MAPPING_LOOP(a_md) {
|
903142 | 2011-04-05 | Arne Goedeke | | size_t h = k->hval & ( b_md->hashsize - 1);
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | | struct keypair *k2;
for (k2 = b_md->hash[h]; k2; k2 = k2->next) {
if ((k2->hval == k->hval) && is_eq(&k2->ind, &k->ind)) {
break;
}
}
if (!k2) {
mapping_insert(res, &k->ind, &k->val);
|
6c9d31 | 2008-06-29 | Henrik Grubbström (Grubba) | | b_md = b->data;
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | }
}
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | | UNSET_ONERROR(err);
} else {
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | res = destructive_copy_mapping(a);
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | | SET_ONERROR(err, do_free_mapping, res);
NEW_MAPPING_LOOP(b_md) {
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | mapping_insert(res, &k->ind, &k->val);
}
|
8840ea | 2008-06-28 | Henrik Grubbström (Grubba) | | UNSET_ONERROR(err);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | }
return res;
}
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | |
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | static struct mapping *xor_mappings(struct mapping *a, struct mapping *b)
{
struct mapping *res;
struct keypair *k;
struct mapping_data *a_md = a->data;
struct mapping_data *b_md = b->data;
INT32 e;
ONERROR err;
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | if (!a_md->size) return destructive_copy_mapping(b);
if (!b_md->size) return destructive_copy_mapping(a);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | if (a_md == b_md) return allocate_mapping(0);
if (a_md->size > b_md->size) {
struct mapping *tmp = a;
a = b;
b = tmp;
a_md = b_md;
b_md = b->data;
}
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | | res = destructive_copy_mapping(b);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | SET_ONERROR(err, do_free_mapping, res);
NEW_MAPPING_LOOP(a_md) {
|
903142 | 2011-04-05 | Arne Goedeke | | size_t h = k->hval & ( b_md->hashsize - 1);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | struct keypair *k2;
for (k2 = b_md->hash[h]; k2; k2 = k2->next) {
if ((k2->hval == k->hval) && is_eq(&k2->ind, &k->ind)) {
break;
}
}
if (!k2) {
mapping_insert(res, &k->ind, &k->val);
} else {
map_delete(res, &k2->ind);
}
|
6c9d31 | 2008-06-29 | Henrik Grubbström (Grubba) | | b_md = b->data;
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | }
UNSET_ONERROR(err);
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | return res;
}
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *merge_mappings(struct mapping *a, struct mapping *b, INT32 op)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
a5cd6a | 2001-09-24 | Henrik Grubbström (Grubba) | | ONERROR r1,r2,r3,r4;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct array *ai, *av;
struct array *bi, *bv;
struct array *ci, *cv;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | INT32 *zipper;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct mapping *m;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(a->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(b->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | switch (op) {
case PIKE_ARRAY_OP_SUB:
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | return subtract_mappings(a, b);
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | | case PIKE_ARRAY_OP_AND:
return and_mappings(a, b);
case PIKE_ARRAY_OP_OR:
return or_mappings(a, b);
case PIKE_ARRAY_OP_XOR:
return xor_mappings(a, b);
|
4d3809 | 2003-11-12 | Henrik Grubbström (Grubba) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | ai=mapping_indices(a);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r1,do_free_array,ai);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | av=mapping_values(a);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r2,do_free_array,av);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | if(ai->size > 1)
{
zipper=get_set_order(ai);
order_array(ai, zipper);
order_array(av, zipper);
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(zipper);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
bi=mapping_indices(b);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r3,do_free_array,bi);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | bv=mapping_values(b);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r4,do_free_array,bv);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | if(bi->size > 1)
{
zipper=get_set_order(bi);
order_array(bi, zipper);
order_array(bv, zipper);
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(zipper);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
zipper=merge(ai,bi,op);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | ci=array_zip(ai,bi,zipper);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | |
UNSET_ONERROR(r4); free_array(bi);
UNSET_ONERROR(r3); free_array(ai);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | cv=array_zip(av,bv,zipper);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | |
UNSET_ONERROR(r2); free_array(bv);
UNSET_ONERROR(r1); free_array(av);
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(zipper);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
m=mkmapping(ci, cv);
free_array(ci);
free_array(cv);
return m;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
649131 | 2003-11-12 | Henrik Grubbström (Grubba) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *merge_mapping_array_ordered(struct mapping *a,
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | struct array *b, INT32 op)
{
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | ONERROR r1,r2;
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | struct array *ai, *av;
|
37b878 | 2000-11-02 | Henrik Grubbström (Grubba) | | struct array *ci = NULL, *cv = NULL;
INT32 *zipper = NULL;
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | struct mapping *m;
ai=mapping_indices(a);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r1,do_free_array,ai);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | av=mapping_values(a);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r2,do_free_array,av);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | if(ai->size > 1)
{
zipper=get_set_order(ai);
order_array(ai, zipper);
order_array(av, zipper);
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(zipper);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | }
switch (op)
{
case PIKE_ARRAY_OP_AND:
zipper=merge(b,ai,op);
ci=array_zip(b,ai,zipper);
cv=array_zip(b,av,zipper);
break;
case PIKE_ARRAY_OP_SUB:
zipper=merge(ai,b,op);
ci=array_zip(ai,b,zipper);
cv=array_zip(av,b,zipper);
break;
default:
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("merge_mapping_array on other than AND or SUB\n");
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | }
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | UNSET_ONERROR(r2); free_array(av);
UNSET_ONERROR(r1); free_array(ai);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | |
|
26bb95 | 2014-04-27 | Martin Nilsson | | free(zipper);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | |
m=mkmapping(ci, cv);
free_array(ci);
free_array(cv);
return m;
}
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *merge_mapping_array_unordered(struct mapping *a,
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | struct array *b, INT32 op)
{
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | ONERROR r1;
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | struct array *b_temp;
INT32 *zipper;
struct mapping *m;
if (b->size>1)
{
zipper=get_set_order(b);
b_temp=reorder_and_copy_array(b,zipper);
|
f43d4d | 2003-06-02 | Martin Stjernholm | | free (zipper);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | SET_ONERROR(r1,do_free_array,b_temp);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | m=merge_mapping_array_ordered(a,b_temp,op);
|
49398c | 2000-11-08 | Fredrik Hübinette (Hubbe) | | UNSET_ONERROR(r1); free_array(b_temp);
|
2ad6b7 | 2000-01-29 | Mirar (Pontus Hagland) | | }
else
m=merge_mapping_array_ordered(a,b,op);
return m;
}
|
9e63a7 | 2008-06-29 | Henrik Grubbström (Grubba) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *add_mappings(struct svalue *argp, INT32 args)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
5cd151 | 1998-04-27 | Fredrik Hübinette (Hubbe) | | INT32 e,d;
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | struct mapping *ret=0;
|
5cd151 | 1998-04-27 | Fredrik Hübinette (Hubbe) | | struct keypair *k;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | for(e=d=0;d<args;d++)
{
|
aa95de | 2008-06-24 | Henrik Grubbström (Grubba) | | struct mapping *m = argp[d].u.mapping;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
aa95de | 2008-06-24 | Henrik Grubbström (Grubba) | | if(d_flag>1) check_mapping(m);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
aa95de | 2008-06-24 | Henrik Grubbström (Grubba) | | e += m->data->size;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | }
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | if(!e) return allocate_mapping(0);
d=0;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | for(;d<args;d++)
|
50d1d6 | 2000-04-30 | Fredrik Hübinette (Hubbe) | | {
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | struct mapping *m=argp[d].u.mapping;
struct mapping_data *md=m->data;
if(md->size == 0) continue;
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | if(!(md->flags & MAPPING_WEAK))
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | {
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | #if 1 /* major optimization */
|
ab59f4 | 2001-11-25 | Martin Stjernholm | | if(e==md->size)
return copy_mapping(m);
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | #endif
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | if(m->refs == 1 && !md->hardlinks)
{
add_ref( ret=m );
d++;
break;
}
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | }
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | ret=allocate_mapping(MAP_SLOTS(e));
break;
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | |
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | }
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | |
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | for(;d<args;d++)
{
struct mapping *m=argp[d].u.mapping;
struct mapping_data *md=m->data;
add_ref(md);
NEW_MAPPING_LOOP(md)
|
a1202e | 2003-11-09 | Martin Stjernholm | | low_mapping_insert(ret, &k->ind, &k->val, 2);
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | free_mapping_data(md);
|
50d1d6 | 2000-04-30 | Fredrik Hübinette (Hubbe) | | }
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(!ret)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("add_mappings is confused!\n");
|
59791f | 2000-09-08 | Fredrik Hübinette (Hubbe) | | #endif
return ret;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT int mapping_equal_p(struct mapping *a, struct mapping *b, struct processing *p)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct processing curr;
struct keypair *k;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md;
INT32 e,eq=1;
#ifdef PIKE_DEBUG
if(a->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(b->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
if(a==b) return 1;
|
5eca4d | 2000-09-04 | Martin Stjernholm | |
|
a0d7f3 | 2003-08-20 | Henrik Grubbström (Grubba) | | if (a->data == b->data) return 1;
|
14b913 | 2008-06-25 | Henrik Grubbström (Grubba) | |
if ((a->data->flags | b->data->flags) & MAPPING_WEAK) return 0;
|
a0d7f3 | 2003-08-20 | Henrik Grubbström (Grubba) | |
|
5eca4d | 2000-09-04 | Martin Stjernholm | | check_mapping_for_destruct(a);
check_mapping_for_destruct(b);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(m_sizeof(a) != m_sizeof(b)) return 0;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
aaf254 | 2012-11-15 | Arne Goedeke | | if (!check_type_overlaps(a->data->ind_types, b->data->ind_types) ||
!check_type_overlaps(a->data->val_types, b->data->val_types)) return 0;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | curr.pointer_a = a;
curr.pointer_b = b;
curr.next = p;
for( ;p ;p=p->next)
if(p->pointer_a == (void *)a && p->pointer_b == (void *)b)
return 1;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md=a->data;
md->valrefs++;
add_ref(md);
NEW_MAPPING_LOOP(md)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
struct svalue *s;
|
9c6f7d | 1997-04-15 | Fredrik Hübinette (Hubbe) | | if((s=low_mapping_lookup(b, & k->ind)))
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(!low_is_equal(s, &k->val, &curr))
{
eq=0;
break;
}
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }else{
|
411212 | 2001-09-04 | Fredrik Hübinette (Hubbe) | | INT32 d;
struct mapping_data *bmd = b->data;
struct keypair *kp;
bmd->valrefs++;
add_ref(bmd);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | eq=0;
|
411212 | 2001-09-04 | Fredrik Hübinette (Hubbe) | | for(d=0;d<(bmd)->hashsize;d++)
{
for(kp=bmd->hash[d];kp;kp=kp->next)
{
if(low_is_equal(&k->ind, &kp->ind, &curr) &&
low_is_equal(&k->val, &kp->val, &curr))
{
eq=1;
break;
}
}
}
bmd->valrefs--;
free_mapping_data(bmd);
if(!eq) break;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->valrefs--;
free_mapping_data(md);
return eq;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
void describe_mapping(struct mapping *m,struct processing *p,int indent)
{
struct processing doing;
|
674fae | 2000-01-14 | Fredrik Noring | | struct array *a;
JMP_BUF catch;
ONERROR err;
INT32 e,d;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | char buf[40];
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
if(! m->data->size)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
my_strcat("([ ])");
return;
}
doing.next=p;
doing.pointer_a=(void *)m;
for(e=0;p;e++,p=p->next)
{
if(p->pointer_a == (void *)m)
{
|
f90e54 | 1995-08-17 | Fredrik Hübinette (Hubbe) | | sprintf(buf,"@%ld",(long)e);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | my_strcat(buf);
return;
}
}
|
d1cac5 | 2000-09-07 | Henrik Grubbström (Grubba) | |
|
d78662 | 2007-03-09 | Martin Stjernholm | | if (Pike_in_gc > GC_PASS_PREPARE && Pike_in_gc < GC_PASS_FREE) {
|
5f45a7 | 2001-12-16 | Martin Stjernholm | |
struct keypair *k;
int notfirst = 0;
if (m->data->size == 1) {
my_strcat("([ /* 1 element */\n");
} else {
sprintf(buf, "([ /* %ld elements */\n", (long)m->data->size);
my_strcat(buf);
}
NEW_MAPPING_LOOP(m->data) {
if (notfirst) my_strcat(",\n");
else notfirst = 1;
for(d = 0; d < indent; d++)
my_putchar(' ');
describe_svalue(&k->ind, indent+2, &doing);
|
fe35fe | 2003-09-23 | Martin Stjernholm | | my_strcat (": ");
|
5f45a7 | 2001-12-16 | Martin Stjernholm | | describe_svalue(&k->val, indent+2, &doing);
}
my_putchar('\n');
for(e=2; e<indent; e++) my_putchar(' ');
my_strcat("])");
return;
}
|
674fae | 2000-01-14 | Fredrik Noring | | a = mapping_indices(m);
SET_ONERROR(err, do_free_array, a);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
853b83 | 2000-12-14 | Martin Stjernholm | | if(! m->data->size) {
my_strcat("([ ])");
}
else {
|
97ebb3 | 2003-01-09 | Henrik Grubbström (Grubba) | | int save_t_flag = Pike_interpreter.trace_level;
|
8f6a98 | 2009-09-22 | Henrik Grubbström (Grubba) | | dynamic_buffer save_buf;
|
f7b1eb | 2001-02-08 | Martin Stjernholm | |
|
853b83 | 2000-12-14 | Martin Stjernholm | | if (m->data->size == 1) {
my_strcat("([ /* 1 element */\n");
} else {
sprintf(buf, "([ /* %ld elements */\n", (long)m->data->size);
my_strcat(buf);
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
8f6a98 | 2009-09-22 | Henrik Grubbström (Grubba) | | save_buffer (&save_buf);
|
97ebb3 | 2003-01-09 | Henrik Grubbström (Grubba) | | Pike_interpreter.trace_level = 0;
|
c1b8f0 | 2001-07-02 | Martin Stjernholm | | if(SETJMP(catch)) {
free_svalue(&throw_value);
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&throw_value);
|
c1b8f0 | 2001-07-02 | Martin Stjernholm | | }
else
|
853b83 | 2000-12-14 | Martin Stjernholm | | sort_array_destructively(a);
UNSETJMP(catch);
|
97ebb3 | 2003-01-09 | Henrik Grubbström (Grubba) | | Pike_interpreter.trace_level = save_t_flag;
|
8f6a98 | 2009-09-22 | Henrik Grubbström (Grubba) | | restore_buffer (&save_buf);
|
853b83 | 2000-12-14 | Martin Stjernholm | |
for(e = 0; e < a->size; e++)
{
struct svalue *tmp;
if(e)
my_strcat(",\n");
|
674fae | 2000-01-14 | Fredrik Noring | |
|
853b83 | 2000-12-14 | Martin Stjernholm | | for(d = 0; d < indent; d++)
my_putchar(' ');
|
8f6a98 | 2009-09-22 | Henrik Grubbström (Grubba) | |
|
853b83 | 2000-12-14 | Martin Stjernholm | | describe_svalue(ITEM(a)+e, indent+2, &doing);
|
fe35fe | 2003-09-23 | Martin Stjernholm | | my_strcat (": ");
|
ab1b1e | 2001-01-17 | Fredrik Hübinette (Hubbe) | | {
|
97ebb3 | 2003-01-09 | Henrik Grubbström (Grubba) | | int save_t_flag=Pike_interpreter.trace_level;
Pike_interpreter.trace_level=0;
|
ab1b1e | 2001-01-17 | Fredrik Hübinette (Hubbe) | |
tmp=low_mapping_lookup(m, ITEM(a)+e);
|
97ebb3 | 2003-01-09 | Henrik Grubbström (Grubba) | | Pike_interpreter.trace_level=save_t_flag;
|
ab1b1e | 2001-01-17 | Fredrik Hübinette (Hubbe) | | }
if(tmp)
|
853b83 | 2000-12-14 | Martin Stjernholm | | describe_svalue(tmp, indent+2, &doing);
else
my_strcat("** gone **");
}
my_putchar('\n');
for(e=2; e<indent; e++) my_putchar(' ');
my_strcat("])");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
674fae | 2000-01-14 | Fredrik Noring | | UNSET_ONERROR(err);
free_array(a);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | | node *make_node_from_mapping(struct mapping *m)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | mapping_fix_type_field(m);
|
84387d | 2001-09-24 | Fredrik Hübinette (Hubbe) | | if(!mapping_is_constant(m,0))
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | struct array *ind, *val;
node *n;
ind=mapping_indices(m);
|
69d94d | 1997-04-23 | Fredrik Hübinette (Hubbe) | | val=mapping_values(m);
|
3c04e8 | 1997-03-13 | Fredrik Hübinette (Hubbe) | | n=mkefuncallnode("mkmapping",
mknode(F_ARG_LIST,
make_node_from_array(ind),
make_node_from_array(val)));
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | free_array(ind);
free_array(val);
return n;
}else{
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | struct svalue s;
|
3c04e8 | 1997-03-13 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(!m->data->size)
|
3c04e8 | 1997-03-13 | Fredrik Hübinette (Hubbe) | | return mkefuncallnode("aggregate_mapping",0);
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(s, T_MAPPING, 0, mapping, m);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | return mkconstantsvaluenode(&s);
}
}
|
ce4d67 | 2001-01-31 | Henrik Grubbström (Grubba) | | |
c9e820 | 2001-04-14 | Johan Sundström | | *! creates a mapping of those pairs. Generally, the mapping literal
|
f79bd8 | 2003-04-01 | Martin Nilsson | | *! syntax is handier: @expr{([ key1:val1, key2:val2, ... ])@}
|
ce4d67 | 2001-01-31 | Henrik Grubbström (Grubba) | | *!
*! @seealso
*! @[sizeof()], @[mappingp()], @[mkmapping()]
*/
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void f_aggregate_mapping(INT32 args)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
INT32 e;
struct mapping *m;
if(args & 1)
|
b2d3e4 | 2000-12-01 | Fredrik Hübinette (Hubbe) | | Pike_error("Uneven number of arguments to aggregate_mapping.\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | m=allocate_mapping(MAP_SLOTS(args / 2));
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
e3b4c7 | 2004-07-02 | Henrik Grubbström (Grubba) | | for(e=-args;e<0;e+=2) {
STACK_LEVEL_START(-e);
low_mapping_insert(m, Pike_sp+e, Pike_sp+e+1, 2);
STACK_LEVEL_DONE(-e);
}
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | pop_n_elems(args);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(d_flag)
check_mapping(m);
#endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | push_mapping(m);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT struct mapping *copy_mapping_recursively(struct mapping *m,
|
9cc28d | 2004-05-28 | Henrik Grubbström (Grubba) | | struct mapping *p)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
65dc53 | 2010-07-11 | Martin Stjernholm | | int not_complex;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | struct mapping *ret;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | INT32 e;
struct keypair *k;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md;
#ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
20b19f | 2000-02-09 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | | if(d_flag > 1) check_mapping_type_fields(m);
|
20b19f | 2000-02-09 | Fredrik Hübinette (Hubbe) | | #endif
|
65dc53 | 2010-07-11 | Martin Stjernholm | | if((m->data->val_types | m->data->ind_types) & BIT_COMPLEX) {
not_complex = 0;
ret=allocate_mapping(MAP_SLOTS(m->data->size));
}
else {
not_complex = 1;
ret = copy_mapping(m);
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
0f5a82 | 2010-07-11 | Jonas Wallden | | if (p) {
|
65dc53 | 2010-07-11 | Martin Stjernholm | | struct svalue aa, bb;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(aa, T_MAPPING, 0, mapping, m);
SET_SVAL(bb, T_MAPPING, 0, mapping, ret);
|
0f5a82 | 2010-07-11 | Jonas Wallden | | mapping_insert(p, &aa, &bb);
}
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
65dc53 | 2010-07-11 | Martin Stjernholm | | if (not_complex)
return ret;
|
a12df9 | 2000-09-17 | Henrik Grubbström (Grubba) | | ret->data->flags = m->data->flags;
|
f15240 | 1996-06-21 | Fredrik Hübinette (Hubbe) | | check_stack(2);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md=m->data;
md->valrefs++;
add_ref(md);
|
c193a6 | 2000-09-07 | Fredrik Hübinette (Hubbe) | | NEW_MAPPING_LOOP(md)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
e3b4c7 | 2004-07-02 | Henrik Grubbström (Grubba) | |
push_int(0);
push_int(0);
copy_svalues_recursively_no_free(Pike_sp-2,&k->ind, 1, p);
copy_svalues_recursively_no_free(Pike_sp-1,&k->val, 1, p);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
a1202e | 2003-11-09 | Martin Stjernholm | | low_mapping_insert(ret, Pike_sp-2, Pike_sp-1, 2);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | pop_n_elems(2);
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md->valrefs--;
free_mapping_data(md);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
return ret;
}
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
1f2133 | 2000-07-28 | Fredrik Hübinette (Hubbe) | | PMOD_EXPORT void mapping_search_no_free(struct svalue *to,
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | struct mapping *m,
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct svalue *look_for,
const struct svalue *key )
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md, *omd;
#ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
md=m->data;
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->size)
{
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | | unsigned INT32 h2,h=0;
struct keypair *k=md->hash[0], **prev;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(key)
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | {
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | | h2=hash_svalue(key);
FIND();
if(!k)
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | {
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(*to, T_INT, NUMBER_UNDEFINED, integer, 0);
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | | return;
}
|
a11c9f | 2000-02-05 | Fredrik Hübinette (Hubbe) | | k=k->next;
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | | }
md=m->data;
if(md->size)
{
md->valrefs++;
add_ref(md);
if(h < (unsigned INT32)md->hashsize)
{
while(1)
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | {
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | | while(k)
{
if(is_eq(look_for, &k->val))
{
assign_svalue_no_free(to,&k->ind);
md->valrefs--;
free_mapping_data(md);
return;
}
k=k->next;
}
h++;
if(h>= (unsigned INT32)md->hashsize)
break;
k=md->hash[h];
|
9076fa | 1997-02-17 | Fredrik Hübinette (Hubbe) | | }
}
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | }
|
9001b4 | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
md->valrefs--;
free_mapping_data(md);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | SET_SVAL(*to, T_INT, NUMBER_UNDEFINED, integer, 0);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
466b66 | 2008-01-05 | Martin Nilsson | | void check_mapping(const struct mapping *m)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
|
e2d522 | 1998-05-16 | Fredrik Hübinette (Hubbe) | | int e,num;
struct keypair *k;
|
466b66 | 2008-01-05 | Martin Nilsson | | const struct mapping_data *md;
|
c5ae92 | 2000-04-16 | Fredrik Hübinette (Hubbe) | |
static int in_check_mapping;
if(in_check_mapping) return;
in_check_mapping=1;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | md=m->data;
|
e2d522 | 1998-05-16 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(m->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping has zero refs.\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(!m->data)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping has no data block.\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | | if (!m->data->refs)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping data block has zero refs.\n");
|
765de0 | 2000-01-28 | Henrik Grubbström (Grubba) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(m->next && m->next->prev != m)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping ->next->prev != mapping.\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
20b19f | 2000-02-09 | Fredrik Hübinette (Hubbe) | | if(m->debug_size != md->size)
|
a4033e | 2000-04-14 | Fredrik Hübinette (Hubbe) | | {
|
d9ad01 | 2000-04-16 | Fredrik Hübinette (Hubbe) | | if(Pike_in_gc)
{
|
3a5f8e | 2010-02-21 | Stephen R. van den Berg | | fprintf(stderr,"Pike was in GC stage %d when this fatal occurred:\n",Pike_in_gc);
|
d9ad01 | 2000-04-16 | Fredrik Hübinette (Hubbe) | | Pike_in_gc=0;
}
|
c5ae92 | 2000-04-16 | Fredrik Hübinette (Hubbe) | | fprintf(stderr,"--MAPPING ZAPPING (%d!=%d), mapping:\n",m->debug_size,md->size);
|
a4033e | 2000-04-14 | Fredrik Hübinette (Hubbe) | | describe(m);
|
c5ae92 | 2000-04-16 | Fredrik Hübinette (Hubbe) | | fprintf(stderr,"--MAPPING ZAPPING (%d!=%d), mapping data:\n",m->debug_size,md->size);
|
a4033e | 2000-04-14 | Fredrik Hübinette (Hubbe) | | describe(md);
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping zapping detected (%d != %d)!\n",m->debug_size,md->size);
|
a4033e | 2000-04-14 | Fredrik Hübinette (Hubbe) | | }
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #endif
|
9e398c | 2000-02-08 | Fredrik Hübinette (Hubbe) | |
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | if(m->prev)
{
if(m->prev->next != m)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping ->prev->next != mapping.\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }else{
if(first_mapping != m)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping ->prev == 0 but first_mapping != mapping.\n");
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->valrefs <0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("md->valrefs < 0\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->hardlinks <0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("md->valrefs < 0\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->refs < md->valrefs+1)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("md->refs < md->valrefs+1\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->valrefs < md->hardlinks)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("md->refs < md->valrefs+1\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->hashsize < 0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Assert: I don't think he's going to make it Jim.\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->size < 0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Core breach, evacuate ship!\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->num_keypairs < 0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Starboard necell on fire!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->size > md->num_keypairs)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Pretty mean hashtable there buster!\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
1fbbfd | 2011-09-04 | Henrik Grubbström (Grubba) | | if(md->hashsize & (md->hashsize - 1))
Pike_fatal("Invalid hashtable size: 0x%08lx\n", (long)md->hashsize);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->hashsize > md->num_keypairs)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Pretty mean hashtable there buster %d > %d (2)!\n",md->hashsize,md->num_keypairs);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
if(md->num_keypairs > (md->hashsize + 3) * AVG_LINK_LENGTH)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping from hell detected, attempting to send it back...\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->size > 0 && (!md->ind_types || !md->val_types))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping type fields are... wrong.\n");
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
e2d522 | 1998-05-16 | Fredrik Hübinette (Hubbe) | | num=0;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | NEW_MAPPING_LOOP(md)
|
e2d522 | 1998-05-16 | Fredrik Hübinette (Hubbe) | | {
num++;
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if (TYPEOF(k->ind) > MAX_TYPE)
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | | Pike_fatal("Invalid maping keypair index type: %s\n",
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | get_name_of_type(TYPEOF(k->ind)));
if(! ( (1 << TYPEOF(k->ind)) & (md->ind_types) ))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping indices type field lies.\n");
|
e2d522 | 1998-05-16 | Fredrik Hübinette (Hubbe) | |
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | if (TYPEOF(k->val) > MAX_TYPE)
|
8696e6 | 2008-07-16 | Henrik Grubbström (Grubba) | | Pike_fatal("Invalid mapping keypair value type: %s\n",
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | get_name_of_type(TYPEOF(k->val)));
if(! ( (1 << TYPEOF(k->val)) & (md->val_types) ))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Mapping values type field lies.\n");
|
59edba | 1998-08-05 | Fredrik Hübinette (Hubbe) | |
|
0e46fc | 1998-08-05 | Fredrik Hübinette (Hubbe) | | check_svalue(& k->ind);
check_svalue(& k->val);
|
54beb2 | 2000-02-01 | Fredrik Hübinette (Hubbe) | |
|
e2d522 | 1998-05-16 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | if(md->size != num)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Shields are failing, hull integrity down to 20%%\n");
|
c5ae92 | 2000-04-16 | Fredrik Hübinette (Hubbe) | |
in_check_mapping=0;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void check_all_mappings(void)
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | {
struct mapping *m;
for(m=first_mapping;m;m=m->next)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | check_mapping(m);
}
#endif
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | |
|
5e8344 | 2008-05-11 | Martin Stjernholm | | static void visit_mapping_data (struct mapping_data *md, int action,
|
95258e | 2014-06-17 | Henrik Grubbström (Grubba) | | void *extra)
|
5e8344 | 2008-05-11 | Martin Stjernholm | | {
switch (action) {
#ifdef PIKE_DEBUG
default:
Pike_fatal ("Unknown visit action %d.\n", action);
case VISIT_NORMAL:
case VISIT_COMPLEX_ONLY:
break;
#endif
case VISIT_COUNT_BYTES:
mc_counted_bytes += MAPPING_DATA_SIZE (md->hashsize, md->num_keypairs);
break;
}
if ((md->ind_types | md->val_types) &
(action & VISIT_COMPLEX_ONLY ? BIT_COMPLEX : BIT_REF_TYPES)) {
int ind_ref_type =
md->flags & MAPPING_WEAK_INDICES ? REF_TYPE_WEAK : REF_TYPE_NORMAL;
int val_ref_type =
md->flags & MAPPING_WEAK_VALUES ? REF_TYPE_WEAK : REF_TYPE_NORMAL;
INT32 e;
struct keypair *k;
NEW_MAPPING_LOOP (md) {
|
23b699 | 2014-06-17 | Henrik Grubbström (Grubba) | | visit_svalue (&k->ind, ind_ref_type, extra);
visit_svalue (&k->val, val_ref_type, extra);
|
5e8344 | 2008-05-11 | Martin Stjernholm | | }
}
}
|
95258e | 2014-06-17 | Henrik Grubbström (Grubba) | | PMOD_EXPORT void visit_mapping (struct mapping *m, int action, void *extra)
|
5e8344 | 2008-05-11 | Martin Stjernholm | | {
switch (action) {
#ifdef PIKE_DEBUG
default:
Pike_fatal ("Unknown visit action %d.\n", action);
case VISIT_NORMAL:
case VISIT_COMPLEX_ONLY:
break;
#endif
case VISIT_COUNT_BYTES:
mc_counted_bytes += sizeof (struct mapping);
break;
}
visit_ref (m->data, REF_TYPE_INTERNAL,
|
95258e | 2014-06-17 | Henrik Grubbström (Grubba) | | (visit_thing_fn *) &visit_mapping_data, extra);
|
5e8344 | 2008-05-11 | Martin Stjernholm | | }
|
853b83 | 2000-12-14 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
#define DO_IF_MAPPING_SIZE_DEBUG(x) x
#else
#define DO_IF_MAPPING_SIZE_DEBUG(x)
#endif
|
e1a35e | 2003-09-08 | Martin Stjernholm | | #define GC_RECURSE_MD_IN_USE(MD, RECURSE_FN, IND_TYPES, VAL_TYPES) do { \
|
853b83 | 2000-12-14 | Martin Stjernholm | | INT32 e; \
struct keypair *k; \
|
c1089d | 2001-12-02 | Martin Stjernholm | | IND_TYPES = MD->ind_types; \
NEW_MAPPING_LOOP(MD) { \
if (!IS_DESTRUCTED(&k->ind) && RECURSE_FN(&k->ind, 1)) { \
|
e1a35e | 2003-09-08 | Martin Stjernholm | | DO_IF_DEBUG(Pike_fatal("Didn't expect an svalue zapping now.\n")); \
|
853b83 | 2000-12-14 | Martin Stjernholm | | } \
|
c1089d | 2001-12-02 | Martin Stjernholm | | RECURSE_FN(&k->val, 1); \
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | VAL_TYPES |= 1 << TYPEOF(k->val); \
|
853b83 | 2000-12-14 | Martin Stjernholm | | } \
} while (0)
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | #ifdef PIKE_MAPPING_KEYPAIR_LOOP
|
5e8344 | 2008-05-11 | Martin Stjernholm | | #error Broken code below!
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | #define GC_RECURSE(M, MD, REC_KEYPAIR, TYPE, IND_TYPES, VAL_TYPES) do { \
int remove; \
struct keypair *k,**prev_; \
/* no locking required (no is_eq) */ \
for(k = MD_KEYPAIRS(md, md->hashsize);k < MD->free_list;) \
{ \
REC_KEYPAIR(remove, \
PIKE_CONCAT(TYPE, _svalues), \
PIKE_CONCAT(TYPE, _weak_svalues), \
PIKE_CONCAT(TYPE, _without_recurse), \
PIKE_CONCAT(TYPE, _weak_without_recurse)); \
if (remove) { \
/* Find and unlink k. */ \
unsigned INT32 h_; \
|
903142 | 2011-04-05 | Arne Goedeke | | h_ = k->hval & ( md->hashsize - 1); \
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | prev_ = md->hash + h_; \
DO_IF_DEBUG( \
if (!*prev_) { \
Pike_fatal("Node to unlink not found!\n"); \
} \
); \
while (*prev_ != k) { \
prev_ = &((*prev_)->next); \
DO_IF_DEBUG( \
if (!*prev_) { \
Pike_fatal("Node to unlink not found!\n"); \
} \
); \
} \
(*prev_)->next = k->next; \
FREE_KEYPAIR(MD, k); \
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&MD->free_list->ind); \
mark_free_svalue (&MD->free_list->val); \
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | MD->size--; \
DO_IF_MAPPING_SIZE_DEBUG( \
if(M->data ==MD) \
M->debug_size--; \
); \
} else { \
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | VAL_TYPES |= 1 << TYPEOF(k->val); \
IND_TYPES |= 1 << TYPEOF(k->ind); \
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | k++; \
} \
} \
} while (0)
#else /* !PIKE_MAPPING_KEYPAIR_LOOP */
|
e1a35e | 2003-09-08 | Martin Stjernholm | | #define GC_RECURSE(M, MD, REC_KEYPAIR, TYPE, IND_TYPES, VAL_TYPES) do { \
|
853b83 | 2000-12-14 | Martin Stjernholm | | INT32 e; \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | int remove; \
|
853b83 | 2000-12-14 | Martin Stjernholm | | struct keypair *k,**prev; \
/* no locking required (no is_eq) */ \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | for(e=0;e<MD->hashsize;e++) \
|
853b83 | 2000-12-14 | Martin Stjernholm | | { \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | for(prev= MD->hash + e;(k=*prev);) \
|
853b83 | 2000-12-14 | Martin Stjernholm | | { \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | REC_KEYPAIR(remove, \
PIKE_CONCAT(TYPE, _svalues), \
PIKE_CONCAT(TYPE, _weak_svalues), \
PIKE_CONCAT(TYPE, _without_recurse), \
PIKE_CONCAT(TYPE, _weak_without_recurse)); \
if (remove) \
|
853b83 | 2000-12-14 | Martin Stjernholm | | { \
*prev=k->next; \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | FREE_KEYPAIR(MD, k); \
|
1ab4ac | 2008-01-26 | Martin Stjernholm | | mark_free_svalue (&MD->free_list->ind); \
mark_free_svalue (&MD->free_list->val); \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | MD->size--; \
|
853b83 | 2000-12-14 | Martin Stjernholm | | DO_IF_MAPPING_SIZE_DEBUG( \
|
e1a35e | 2003-09-08 | Martin Stjernholm | | if(M->data ==MD) \
M->debug_size--; \
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | ); \
|
853b83 | 2000-12-14 | Martin Stjernholm | | }else{ \
|
017b57 | 2011-10-28 | Henrik Grubbström (Grubba) | | VAL_TYPES |= 1 << TYPEOF(k->val); \
IND_TYPES |= 1 << TYPEOF(k->ind); \
|
853b83 | 2000-12-14 | Martin Stjernholm | | prev=&k->next; \
} \
} \
} \
} while (0)
|
d4741b | 2007-10-04 | Henrik Grubbström (Grubba) | | #endif /* PIKE_MAPPING_KEYPAIR_LOOP */
|
853b83 | 2000-12-14 | Martin Stjernholm | |
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | #define GC_REC_KP(REMOVE, N_REC, W_REC, N_TST, W_TST) do { \
if ((REMOVE = N_REC(&k->ind, 1))) \
gc_free_svalue(&k->val); \
else \
N_REC(&k->val, 1); \
} while (0)
#define GC_REC_KP_IND(REMOVE, N_REC, W_REC, N_TST, W_TST) do { \
if ((REMOVE = W_REC(&k->ind, 1))) \
gc_free_svalue(&k->val); \
else \
N_REC(&k->val, 1); \
} while (0)
#define GC_REC_KP_VAL(REMOVE, N_REC, W_REC, N_TST, W_TST) do { \
if ((REMOVE = N_TST(&k->ind))) /* Don't recurse now. */ \
gc_free_svalue(&k->val); \
else if ((REMOVE = W_REC(&k->val, 1))) \
gc_free_svalue(&k->ind); \
else \
N_REC(&k->ind, 1); /* Now we can recurse the index. */ \
} while (0)
#define GC_REC_KP_BOTH(REMOVE, N_REC, W_REC, N_TST, W_TST) do { \
if ((REMOVE = W_TST(&k->ind))) /* Don't recurse now. */ \
gc_free_svalue(&k->val); \
else if ((REMOVE = W_REC(&k->val, 1))) \
gc_free_svalue(&k->ind); \
else \
W_REC(&k->ind, 1); /* Now we can recurse the index. */ \
|
853b83 | 2000-12-14 | Martin Stjernholm | | } while (0)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
void gc_mark_mapping_as_referenced(struct mapping *m)
{
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
if(m->data->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | #endif
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(m->data);
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | |
|
613c34 | 2009-11-28 | Martin Stjernholm | | if(gc_mark(m, T_MAPPING))
|
e1a35e | 2003-09-08 | Martin Stjernholm | | GC_ENTER (m, T_MAPPING) {
struct mapping_data *md = m->data;
if (m == gc_mark_mapping_pos)
gc_mark_mapping_pos = m->next;
if (m == gc_internal_mapping)
gc_internal_mapping = m->next;
else {
DOUBLEUNLINK(first_mapping, m);
DOUBLELINK(first_mapping, m);
|
853b83 | 2000-12-14 | Martin Stjernholm | | }
|
e1a35e | 2003-09-08 | Martin Stjernholm | |
|
613c34 | 2009-11-28 | Martin Stjernholm | | if(gc_mark(md, T_MAPPING_DATA) &&
((md->ind_types | md->val_types) & BIT_COMPLEX)) {
|
5e8344 | 2008-05-11 | Martin Stjernholm | | TYPE_FIELD ind_types = 0, val_types = 0;
if (MAPPING_DATA_IN_USE(md)) {
debug_malloc_touch(m);
debug_malloc_touch(md);
GC_RECURSE_MD_IN_USE(md, gc_mark_svalues, ind_types, val_types);
gc_assert_checked_as_nonweak(md);
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | }
|
5e8344 | 2008-05-11 | Martin Stjernholm | | else
switch (md->flags & MAPPING_WEAK) {
case 0:
debug_malloc_touch(m);
debug_malloc_touch(md);
GC_RECURSE(m, md, GC_REC_KP, gc_mark, ind_types, val_types);
gc_assert_checked_as_nonweak(md);
break;
case MAPPING_WEAK_INDICES:
debug_malloc_touch(m);
debug_malloc_touch(md);
GC_RECURSE(m, md, GC_REC_KP_IND, gc_mark, ind_types, val_types);
gc_assert_checked_as_weak(md);
break;
case MAPPING_WEAK_VALUES:
debug_malloc_touch(m);
debug_malloc_touch(md);
GC_RECURSE(m, md, GC_REC_KP_VAL, gc_mark, ind_types, val_types);
gc_assert_checked_as_weak(md);
break;
default:
debug_malloc_touch(m);
debug_malloc_touch(md);
GC_RECURSE(m, md, GC_REC_KP_BOTH, gc_mark, ind_types, val_types);
gc_assert_checked_as_weak(md);
break;
|
e1a35e | 2003-09-08 | Martin Stjernholm | | }
|
5e8344 | 2008-05-11 | Martin Stjernholm | | md->val_types = val_types;
md->ind_types = ind_types;
|
e1a35e | 2003-09-08 | Martin Stjernholm | | }
} GC_LEAVE;
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
45d87e | 2000-07-18 | Martin Stjernholm | | void real_gc_cycle_check_mapping(struct mapping *m, int weak)
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | {
|
e1a35e | 2003-09-08 | Martin Stjernholm | | GC_CYCLE_ENTER(m, T_MAPPING, weak) {
|
5eca4d | 2000-09-04 | Martin Stjernholm | | struct mapping_data *md = m->data;
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(md);
|
5eca4d | 2000-09-04 | Martin Stjernholm | |
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | #ifdef PIKE_DEBUG
|
5eca4d | 2000-09-04 | Martin Stjernholm | | if(md->refs <=0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zero refs in mapping->data\n");
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | #endif
|
853b83 | 2000-12-14 | Martin Stjernholm | | if ((md->ind_types | md->val_types) & BIT_COMPLEX) {
TYPE_FIELD ind_types = 0, val_types = 0;
|
5eca4d | 2000-09-04 | Martin Stjernholm | | if (MAPPING_DATA_IN_USE(md)) {
|
0b5d2b | 2001-06-05 | Martin Stjernholm | |
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(md);
|
853b83 | 2000-12-14 | Martin Stjernholm | | GC_RECURSE_MD_IN_USE(md, gc_cycle_check_svalues, ind_types, val_types);
|
595dac | 2000-09-30 | Martin Stjernholm | | gc_assert_checked_as_nonweak(md);
|
5eca4d | 2000-09-04 | Martin Stjernholm | | }
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | else
switch (md->flags & MAPPING_WEAK) {
case 0:
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(md);
|
e1a35e | 2003-09-08 | Martin Stjernholm | | GC_RECURSE(m, md, GC_REC_KP, gc_cycle_check, ind_types, val_types);
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | gc_assert_checked_as_nonweak(md);
break;
case MAPPING_WEAK_INDICES:
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(md);
|
e1a35e | 2003-09-08 | Martin Stjernholm | | GC_RECURSE(m, md, GC_REC_KP_IND, gc_cycle_check, ind_types, val_types);
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | gc_assert_checked_as_weak(md);
break;
case MAPPING_WEAK_VALUES:
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(md);
|
e1a35e | 2003-09-08 | Martin Stjernholm | | GC_RECURSE(m, md, GC_REC_KP_VAL, gc_cycle_check, ind_types, val_types);
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | gc_assert_checked_as_weak(md);
break;
default:
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(md);
|
e1a35e | 2003-09-08 | Martin Stjernholm | | GC_RECURSE(m, md, GC_REC_KP_BOTH, gc_cycle_check, ind_types, val_types);
|
0b5d2b | 2001-06-05 | Martin Stjernholm | | gc_assert_checked_as_weak(md);
break;
}
|
853b83 | 2000-12-14 | Martin Stjernholm | | md->val_types = val_types;
md->ind_types = ind_types;
|
45d87e | 2000-07-18 | Martin Stjernholm | | }
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | } GC_CYCLE_LEAVE;
}
|
5e8344 | 2008-05-11 | Martin Stjernholm | | static void gc_check_mapping(struct mapping *m)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
5e8344 | 2008-05-11 | Martin Stjernholm | | struct mapping_data *md = m->data;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
5e8344 | 2008-05-11 | Martin Stjernholm | | if((md->ind_types | md->val_types) & BIT_COMPLEX)
GC_ENTER (m, T_MAPPING) {
INT32 e;
struct keypair *k;
if(!debug_gc_check (md, " as mapping data block of a mapping")) {
if (!(md->flags & MAPPING_WEAK) || MAPPING_DATA_IN_USE(md))
NEW_MAPPING_LOOP(md)
{
debug_gc_check_svalues(&k->ind, 1, " as mapping index");
debug_gc_check_svalues(&k->val, 1, " as mapping value");
}
else {
switch (md->flags & MAPPING_WEAK) {
case MAPPING_WEAK_INDICES:
NEW_MAPPING_LOOP(md)
{
debug_gc_check_weak_svalues(&k->ind, 1, " as mapping index");
debug_gc_check_svalues(&k->val, 1, " as mapping value");
}
break;
case MAPPING_WEAK_VALUES:
NEW_MAPPING_LOOP(md)
{
debug_gc_check_svalues(&k->ind, 1, " as mapping index");
debug_gc_check_weak_svalues(&k->val, 1, " as mapping value");
}
break;
default:
NEW_MAPPING_LOOP(md)
{
debug_gc_check_weak_svalues(&k->ind, 1, " as mapping index");
debug_gc_check_weak_svalues(&k->val, 1, " as mapping value");
}
break;
}
gc_checked_as_weak(md);
|
ad8d05 | 2008-05-02 | Martin Stjernholm | | }
|
5e8344 | 2008-05-11 | Martin Stjernholm | | }
} GC_LEAVE;
|
20513c | 2000-04-12 | Fredrik Hübinette (Hubbe) | | }
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | |
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | unsigned gc_touch_all_mappings(void)
|
7bf623 | 2000-04-23 | Martin Stjernholm | | {
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | unsigned n = 0;
|
7bf623 | 2000-04-23 | Martin Stjernholm | | struct mapping *m;
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | if (first_mapping && first_mapping->prev)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Error in mapping link list.\n");
|
7bf623 | 2000-04-23 | Martin Stjernholm | | for (m = first_mapping; m; m = m->next) {
debug_gc_touch(m);
n++;
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | if (m->next && m->next->prev != m)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Error in mapping link list.\n");
|
7bf623 | 2000-04-23 | Martin Stjernholm | | }
return n;
}
|
20513c | 2000-04-12 | Fredrik Hübinette (Hubbe) | | void gc_check_all_mappings(void)
{
struct mapping *m;
for(m=first_mapping;m;m=m->next)
{
#ifdef DEBUG_MALLOC
|
5e8344 | 2008-05-11 | Martin Stjernholm | | if (((int) PTR_TO_INT (m->data)) == 0x55555555) {
|
20513c | 2000-04-12 | Fredrik Hübinette (Hubbe) | | fprintf(stderr, "** Zapped mapping in list of active mappings!\n");
|
6e7eea | 2001-08-22 | Henrik Grubbström (Grubba) | | describe_something(m, T_MAPPING, 0,2,0, NULL);
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Zapped mapping in list of active mappings!\n");
|
20513c | 2000-04-12 | Fredrik Hübinette (Hubbe) | | }
#endif /* DEBUG_MALLOC */
|
5e8344 | 2008-05-11 | Martin Stjernholm | | gc_check_mapping(m);
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
081629 | 2000-07-03 | Martin Stjernholm | | if(d_flag > 1) check_mapping_type_fields(m);
|
5267b7 | 1995-08-09 | Fredrik Hübinette (Hubbe) | | #endif
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
}
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void gc_mark_all_mappings(void)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | gc_mark_mapping_pos = gc_internal_mapping;
while (gc_mark_mapping_pos) {
struct mapping *m = gc_mark_mapping_pos;
gc_mark_mapping_pos = m->next;
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | |
debug_malloc_touch(m);
debug_malloc_touch(m->data);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | if(gc_is_referenced(m))
gc_mark_mapping_as_referenced(m);
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | }
}
void gc_cycle_check_all_mappings(void)
{
struct mapping *m;
for (m = gc_internal_mapping; m; m = m->next) {
|
45d87e | 2000-07-18 | Martin Stjernholm | | real_gc_cycle_check_mapping(m, 0);
gc_cycle_run_queue();
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | }
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
45d87e | 2000-07-18 | Martin Stjernholm | | void gc_zap_ext_weak_refs_in_mappings(void)
{
gc_mark_mapping_pos = first_mapping;
while (gc_mark_mapping_pos != gc_internal_mapping && gc_ext_weak_refs) {
struct mapping *m = gc_mark_mapping_pos;
gc_mark_mapping_pos = m->next;
gc_mark_mapping_as_referenced(m);
}
|
e1a35e | 2003-09-08 | Martin Stjernholm | | gc_mark_discard_queue();
|
45d87e | 2000-07-18 | Martin Stjernholm | | }
|
88cf4f | 2003-01-11 | Martin Stjernholm | | size_t gc_free_all_unreferenced_mappings(void)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
struct mapping *m,*next;
|
57a4ab | 2000-01-27 | Fredrik Hübinette (Hubbe) | | struct mapping_data *md;
|
a1b387 | 2003-01-11 | Martin Stjernholm | | size_t unreferenced = 0;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | |
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | for(m=gc_internal_mapping;m;m=next)
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | {
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | debug_malloc_touch(m);
debug_malloc_touch(m->data);
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | if(gc_do_free(m))
{
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | |
|
27bec9 | 2000-02-15 | Henrik Grubbström (Grubba) | | md = m->data;
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | |
debug_malloc_touch(m);
debug_malloc_touch(md);
|
27bec9 | 2000-02-15 | Henrik Grubbström (Grubba) | |
|
1f342f | 2000-02-04 | Fredrik Hübinette (Hubbe) | | m->data=&empty_data;
|
9a6d00 | 2001-06-26 | Fredrik Hübinette (Hubbe) | | add_ref(m->data);
|
27bec9 | 2000-02-15 | Henrik Grubbström (Grubba) | |
unlink_mapping_data(md);
|
5eca4d | 2000-09-04 | Martin Stjernholm | | #ifdef MAPPING_SIZE_DEBUG
|
e945ee | 2000-02-09 | Fredrik Hübinette (Hubbe) | | m->debug_size=0;
#endif
|
e2d9e6 | 2000-06-10 | Martin Stjernholm | | gc_free_extra_ref(m);
|
69ee4b | 2000-04-06 | Fredrik Hübinette (Hubbe) | | SET_NEXT_AND_FREE(m, free_mapping);
|
3b589f | 1999-02-04 | Fredrik Hübinette (Hubbe) | | }
else
{
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | next=m->next;
}
|
a1b387 | 2003-01-11 | Martin Stjernholm | | unreferenced++;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
88cf4f | 2003-01-11 | Martin Stjernholm | |
|
a1b387 | 2003-01-11 | Martin Stjernholm | | return unreferenced;
|
515b6c | 1996-06-09 | Fredrik Hübinette (Hubbe) | | }
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | |
void simple_describe_mapping(struct mapping *m)
{
|
9fa0ee | 2003-11-09 | Martin Stjernholm | | dynamic_buffer save_buf;
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | char *s;
|
9fa0ee | 2003-11-09 | Martin Stjernholm | | init_buf(&save_buf);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | describe_mapping(m,0,2);
|
9fa0ee | 2003-11-09 | Martin Stjernholm | | s=simple_free_buf(&save_buf);
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | fprintf(stderr,"%s\n",s);
free(s);
}
void debug_dump_mapping(struct mapping *m)
{
|
5eca4d | 2000-09-04 | Martin Stjernholm | | fprintf(stderr, "Refs=%d, next=%p, prev=%p",
m->refs, m->next, m->prev);
|
f5757f | 2000-08-11 | Henrik Grubbström (Grubba) | | if (((ptrdiff_t)m->data) & 3) {
|
18bc0c | 2000-03-08 | Henrik Grubbström (Grubba) | | fprintf(stderr, ", data=%p (unaligned)\n", m->data);
} else {
|
5eca4d | 2000-09-04 | Martin Stjernholm | | fprintf(stderr, ", flags=0x%x, size=%d, hashsize=%d\n",
m->data->flags, m->data->size, m->data->hashsize);
|
86f186 | 2004-03-16 | Martin Stjernholm | | fprintf(stderr, "Indices type field =");
|
18bc0c | 2000-03-08 | Henrik Grubbström (Grubba) | | debug_dump_type_field(m->data->ind_types);
fprintf(stderr, "\n");
|
86f186 | 2004-03-16 | Martin Stjernholm | | fprintf(stderr, "Values type field =");
|
18bc0c | 2000-03-08 | Henrik Grubbström (Grubba) | | debug_dump_type_field(m->data->val_types);
fprintf(stderr, "\n");
|
375bed | 2000-03-08 | Henrik Grubbström (Grubba) | | simple_describe_mapping(m);
|
18bc0c | 2000-03-08 | Henrik Grubbström (Grubba) | | }
|
61e9a0 | 1998-01-25 | Fredrik Hübinette (Hubbe) | | }
#endif
|
84387d | 2001-09-24 | Fredrik Hübinette (Hubbe) | | int mapping_is_constant(struct mapping *m,
struct processing *p)
{
|
c7ad76 | 2001-10-03 | Fredrik Hübinette (Hubbe) | | int ret=1;
|
84387d | 2001-09-24 | Fredrik Hübinette (Hubbe) | | INT32 e;
struct keypair *k;
struct mapping_data *md=m->data;
if( (md->ind_types | md->val_types) & ~(BIT_INT|BIT_FLOAT|BIT_STRING))
{
md->valrefs++;
add_ref(md);
NEW_MAPPING_LOOP(md)
{
|
c7ad76 | 2001-10-03 | Fredrik Hübinette (Hubbe) | | if(!svalues_are_constant(&k->ind, 1, md->ind_types, p) ||
!svalues_are_constant(&k->val, 1, md->val_types, p))
{
ret=0;
e=md->hashsize;
break;
}
|
84387d | 2001-09-24 | Fredrik Hübinette (Hubbe) | | }
md->valrefs--;
free_mapping_data(md);
}
|
c7ad76 | 2001-10-03 | Fredrik Hübinette (Hubbe) | | return ret;
|
84387d | 2001-09-24 | Fredrik Hübinette (Hubbe) | | }
|