in erts/emulator/beam/utils.c [3101:3940]
Sint erts_cmp_compound(Eterm a, Eterm b, int exact, int eq_only)
{
#define PSTACK_TYPE struct erts_cmp_hashmap_state
struct erts_cmp_hashmap_state {
Sint wstack_rollback;
int was_exact;
Eterm *ap;
Eterm *bp;
Eterm min_key;
Sint cmp_res; /* result so far -1,0,+1 */
};
PSTACK_DECLARE(hmap_stack, 1);
WSTACK_DECLARE(stack);
WSTACK_DECLARE(b_stack); /* only used by hashmaps */
Eterm* aa;
Eterm* bb;
int i;
Sint j;
int a_tag;
int b_tag;
ErlNode *anode;
ErlNode *bnode;
Uint adata;
Uint bdata;
Uint alen;
Uint blen;
Uint32 *anum;
Uint32 *bnum;
/* The WSTACK contains naked Eterms and Operations marked with header-tags */
#define OP_BITS 4
#define OP_MASK 0xF
#define TERM_ARRAY_OP 0
#define SWITCH_EXACT_OFF_OP 1
#define HASHMAP_PHASE1_ARE_KEYS_EQUAL 2
#define HASHMAP_PHASE1_IS_MIN_KEY 3
#define HASHMAP_PHASE1_CMP_VALUES 4
#define HASHMAP_PHASE2_ARE_KEYS_EQUAL 5
#define HASHMAP_PHASE2_IS_MIN_KEY_A 6
#define HASHMAP_PHASE2_IS_MIN_KEY_B 7
#define OP_WORD(OP) (((OP) << _TAG_PRIMARY_SIZE) | TAG_PRIMARY_HEADER)
#define TERM_ARRAY_OP_WORD(SZ) OP_WORD(((SZ) << OP_BITS) | TERM_ARRAY_OP)
#define GET_OP(WORD) (ASSERT(is_header(WORD)), ((WORD) >> _TAG_PRIMARY_SIZE) & OP_MASK)
#define GET_OP_ARG(WORD) (ASSERT(is_header(WORD)), ((WORD) >> (OP_BITS + _TAG_PRIMARY_SIZE)))
#define RETURN_NEQ(cmp) { j=(cmp); ASSERT(j != 0); goto not_equal; }
#define ON_CMP_GOTO(cmp) if ((j=(cmp)) == 0) goto pop_next; else goto not_equal
#undef CMP_NODES
#define CMP_NODES(AN, BN) \
do { \
if((AN) != (BN)) { \
if((AN)->sysname != (BN)->sysname) \
RETURN_NEQ(erts_cmp_atoms((AN)->sysname, (BN)->sysname)); \
ASSERT((AN)->creation != (BN)->creation); \
RETURN_NEQ(((AN)->creation < (BN)->creation) ? -1 : 1); \
} \
} while (0)
bodyrecur:
j = 0;
tailrecur:
if (is_same(a,b)) { /* Equal values or pointers. */
goto pop_next;
}
tailrecur_ne:
/* deal with majority (?) cases by brute-force */
if (is_atom(a)) {
if (is_atom(b)) {
ON_CMP_GOTO(erts_cmp_atoms(a, b));
}
} else if (is_both_small(a, b)) {
ON_CMP_GOTO(signed_val(a) - signed_val(b));
}
/*
* Take care of cases where the types are the same.
*/
a_tag = 42; /* Suppress warning */
switch (primary_tag(a)) {
case TAG_PRIMARY_IMMED1:
switch ((a & _TAG_IMMED1_MASK) >> _TAG_PRIMARY_SIZE) {
case (_TAG_IMMED1_PORT >> _TAG_PRIMARY_SIZE):
if (is_internal_port(b)) {
bnode = erts_this_node;
bdata = internal_port_data(b);
} else if (is_external_port(b)) {
bnode = external_port_node(b);
bdata = external_port_data(b);
} else {
a_tag = PORT_DEF;
goto mixed_types;
}
anode = erts_this_node;
adata = internal_port_data(a);
port_common:
CMP_NODES(anode, bnode);
ON_CMP_GOTO((Sint)(adata - bdata));
case (_TAG_IMMED1_PID >> _TAG_PRIMARY_SIZE):
if (is_internal_pid(b)) {
adata = internal_pid_data(a);
bdata = internal_pid_data(b);
ON_CMP_GOTO((Sint)(adata - bdata));
}
else if (is_not_external_pid(b)) {
a_tag = PID_DEF;
goto mixed_types;
}
pid_common:
{
Uint32 a_pid_num, a_pid_ser;
Uint32 b_pid_num, b_pid_ser;
if (is_internal_pid(a)) {
a_pid_num = internal_pid_number(a);
a_pid_ser = internal_pid_serial(a);
anode = erts_this_node;
}
else {
ASSERT(is_external_pid(a));
a_pid_num = external_pid_number(a);
a_pid_ser = external_pid_serial(a);
anode = external_pid_node(a);
}
if (is_internal_pid(b)) {
b_pid_num = internal_pid_number(b);
b_pid_ser = internal_pid_serial(b);
bnode = erts_this_node;
}
else {
ASSERT(is_external_pid(b));
b_pid_num = external_pid_number(b);
b_pid_ser = external_pid_serial(b);
bnode = external_pid_node(b);
}
if (a_pid_ser != b_pid_ser)
RETURN_NEQ(a_pid_ser < b_pid_ser ? -1 : 1);
if (a_pid_num != b_pid_num)
RETURN_NEQ(a_pid_num < b_pid_num ? -1 : 1);
CMP_NODES(anode, bnode);
goto pop_next;
}
case (_TAG_IMMED1_SMALL >> _TAG_PRIMARY_SIZE):
a_tag = SMALL_DEF;
goto mixed_types;
case (_TAG_IMMED1_IMMED2 >> _TAG_PRIMARY_SIZE): {
switch ((a & _TAG_IMMED2_MASK) >> _TAG_IMMED1_SIZE) {
case (_TAG_IMMED2_ATOM >> _TAG_IMMED1_SIZE):
a_tag = ATOM_DEF;
goto mixed_types;
case (_TAG_IMMED2_NIL >> _TAG_IMMED1_SIZE):
a_tag = NIL_DEF;
goto mixed_types;
}
}
}
case TAG_PRIMARY_LIST:
if (is_not_list(b)) {
a_tag = LIST_DEF;
goto mixed_types;
}
aa = list_val(a);
bb = list_val(b);
while (1) {
Eterm atmp = CAR(aa);
Eterm btmp = CAR(bb);
if (!is_same(atmp,btmp)) {
WSTACK_PUSH2(stack,(UWord) CDR(bb),(UWord) CDR(aa));
a = atmp;
b = btmp;
goto tailrecur_ne;
}
atmp = CDR(aa);
btmp = CDR(bb);
if (is_same(atmp,btmp)) {
goto pop_next;
}
if (is_not_list(atmp) || is_not_list(btmp)) {
a = atmp;
b = btmp;
goto tailrecur_ne;
}
aa = list_val(atmp);
bb = list_val(btmp);
}
case TAG_PRIMARY_BOXED:
{
Eterm ahdr = *boxed_val(a);
switch ((ahdr & _TAG_HEADER_MASK) >> _TAG_PRIMARY_SIZE) {
case (_TAG_HEADER_ARITYVAL >> _TAG_PRIMARY_SIZE):
if (!is_tuple(b)) {
a_tag = TUPLE_DEF;
goto mixed_types;
}
aa = tuple_val(a);
bb = tuple_val(b);
/* compare the arities */
i = arityval(ahdr); /* get the arity*/
if (i != arityval(*bb)) {
RETURN_NEQ((int)(i - arityval(*bb)));
}
if (i == 0) {
goto pop_next;
}
++aa;
++bb;
goto term_array;
case (_TAG_HEADER_MAP >> _TAG_PRIMARY_SIZE) :
{
struct erts_cmp_hashmap_state* sp;
if (is_flatmap_header(ahdr)) {
if (!is_flatmap(b)) {
if (is_hashmap(b)) {
aa = (Eterm *)flatmap_val(a);
i = flatmap_get_size((flatmap_t*)aa) - hashmap_size(b);
ASSERT(i != 0);
RETURN_NEQ(i);
}
a_tag = MAP_DEF;
goto mixed_types;
}
aa = (Eterm *)flatmap_val(a);
bb = (Eterm *)flatmap_val(b);
i = flatmap_get_size((flatmap_t*)aa);
if (i != flatmap_get_size((flatmap_t*)bb)) {
RETURN_NEQ((int)(i - flatmap_get_size((flatmap_t*)bb)));
}
if (i == 0) {
goto pop_next;
}
aa += 2;
bb += 2;
if (exact) {
i += 1; /* increment for tuple-keys */
goto term_array;
}
else {
/* Value array */
WSTACK_PUSH3(stack,(UWord)(bb+1),(UWord)(aa+1),TERM_ARRAY_OP_WORD(i));
/* Switch back from 'exact' key compare */
WSTACK_PUSH(stack,OP_WORD(SWITCH_EXACT_OFF_OP));
/* Now do 'exact' compare of key tuples */
a = *aa;
b = *bb;
exact = 1;
goto bodyrecur;
}
}
if (!is_hashmap(b)) {
if (is_flatmap(b)) {
bb = (Eterm *)flatmap_val(b);
i = hashmap_size(a) - flatmap_get_size((flatmap_t*)bb);
ASSERT(i != 0);
RETURN_NEQ(i);
}
a_tag = MAP_DEF;
goto mixed_types;
}
i = hashmap_size(a) - hashmap_size(b);
if (i) {
RETURN_NEQ(i);
}
if (hashmap_size(a) == 0) {
goto pop_next;
}
/* Hashmap compare strategy:
Phase 1. While keys are identical
Do synchronous stepping through leafs of both trees in hash
order. Maintain value compare result of minimal key.
Phase 2. If key diff was found in phase 1
Ignore values from now on.
Continue iterate trees by always advancing the one
lagging behind hash-wise. Identical keys are skipped.
A minimal key can only be candidate as tie-breaker if we
have passed that hash value in the other tree (which means
the key did not exist in the other tree).
*/
sp = PSTACK_PUSH(hmap_stack);
hashmap_iterator_init(&stack, a, 0);
hashmap_iterator_init(&b_stack, b, 0);
sp->ap = hashmap_iterator_next(&stack);
sp->bp = hashmap_iterator_next(&b_stack);
sp->cmp_res = 0;
ASSERT(sp->ap && sp->bp);
a = CAR(sp->ap);
b = CAR(sp->bp);
sp->was_exact = exact;
exact = 1;
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE1_ARE_KEYS_EQUAL));
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
}
case (_TAG_HEADER_FLOAT >> _TAG_PRIMARY_SIZE):
if (!is_float(b)) {
a_tag = FLOAT_DEF;
goto mixed_types;
} else {
FloatDef af;
FloatDef bf;
GET_DOUBLE(a, af);
GET_DOUBLE(b, bf);
ON_CMP_GOTO(erts_float_comp(af.fd, bf.fd));
}
case (_TAG_HEADER_POS_BIG >> _TAG_PRIMARY_SIZE):
case (_TAG_HEADER_NEG_BIG >> _TAG_PRIMARY_SIZE):
if (!is_big(b)) {
a_tag = BIG_DEF;
goto mixed_types;
}
ON_CMP_GOTO(big_comp(a, b));
case (_TAG_HEADER_EXPORT >> _TAG_PRIMARY_SIZE):
if (!is_export(b)) {
a_tag = EXPORT_DEF;
goto mixed_types;
} else {
Export* a_exp = *((Export **) (export_val(a) + 1));
Export* b_exp = *((Export **) (export_val(b) + 1));
if ((j = erts_cmp_atoms(a_exp->info.mfa.module,
b_exp->info.mfa.module)) != 0) {
RETURN_NEQ(j);
}
if ((j = erts_cmp_atoms(a_exp->info.mfa.function,
b_exp->info.mfa.function)) != 0) {
RETURN_NEQ(j);
}
ON_CMP_GOTO((Sint) a_exp->info.mfa.arity - (Sint) b_exp->info.mfa.arity);
}
break;
case (_TAG_HEADER_FUN >> _TAG_PRIMARY_SIZE):
if (!is_fun(b)) {
a_tag = FUN_DEF;
goto mixed_types;
} else {
ErlFunThing* f1 = (ErlFunThing *) fun_val(a);
ErlFunThing* f2 = (ErlFunThing *) fun_val(b);
Sint diff;
diff = erts_cmp_atoms((f1->fe)->module, (f2->fe)->module);
if (diff != 0) {
RETURN_NEQ(diff);
}
diff = f1->fe->index - f2->fe->index;
if (diff != 0) {
RETURN_NEQ(diff);
}
diff = f1->fe->old_uniq - f2->fe->old_uniq;
if (diff != 0) {
RETURN_NEQ(diff);
}
diff = f1->num_free - f2->num_free;
if (diff != 0) {
RETURN_NEQ(diff);
}
i = f1->num_free;
if (i == 0) goto pop_next;
aa = f1->env;
bb = f2->env;
goto term_array;
}
case (_TAG_HEADER_EXTERNAL_PID >> _TAG_PRIMARY_SIZE):
if (!is_pid(b)) {
a_tag = EXTERNAL_PID_DEF;
goto mixed_types;
}
goto pid_common;
case (_TAG_HEADER_EXTERNAL_PORT >> _TAG_PRIMARY_SIZE):
if (is_internal_port(b)) {
bnode = erts_this_node;
bdata = internal_port_data(b);
} else if (is_external_port(b)) {
bnode = external_port_node(b);
bdata = external_port_data(b);
} else {
a_tag = EXTERNAL_PORT_DEF;
goto mixed_types;
}
anode = external_port_node(a);
adata = external_port_data(a);
goto port_common;
case (_TAG_HEADER_REF >> _TAG_PRIMARY_SIZE):
/*
* Note! When comparing refs we need to compare ref numbers
* (32-bit words), *not* ref data words.
*/
if (is_internal_ref(b)) {
bnode = erts_this_node;
blen = internal_ref_no_numbers(b);
bnum = internal_ref_numbers(b);
} else if(is_external_ref(b)) {
ExternalThing* bthing = external_thing_ptr(b);
bnode = bthing->node;
bnum = external_thing_ref_numbers(bthing);
blen = external_thing_ref_no_numbers(bthing);
} else {
a_tag = REF_DEF;
goto mixed_types;
}
anode = erts_this_node;
alen = internal_ref_no_numbers(a);
anum = internal_ref_numbers(a);
ref_common:
CMP_NODES(anode, bnode);
ASSERT(alen > 0 && blen > 0);
if (alen != blen) {
if (alen > blen) {
do {
if (anum[alen - 1] != 0)
RETURN_NEQ(1);
alen--;
} while (alen > blen);
}
else {
do {
if (bnum[blen - 1] != 0)
RETURN_NEQ(-1);
blen--;
} while (alen < blen);
}
}
ASSERT(alen == blen);
for (i = (Sint) alen - 1; i >= 0; i--)
if (anum[i] != bnum[i])
RETURN_NEQ(anum[i] < bnum[i] ? -1 : 1);
goto pop_next;
case (_TAG_HEADER_EXTERNAL_REF >> _TAG_PRIMARY_SIZE):
if (is_internal_ref(b)) {
bnode = erts_this_node;
blen = internal_ref_no_numbers(b);
bnum = internal_ref_numbers(b);
} else if (is_external_ref(b)) {
ExternalThing* bthing = external_thing_ptr(b);
bnode = bthing->node;
bnum = external_thing_ref_numbers(bthing);
blen = external_thing_ref_no_numbers(bthing);
} else {
a_tag = EXTERNAL_REF_DEF;
goto mixed_types;
}
{
ExternalThing* athing = external_thing_ptr(a);
anode = athing->node;
anum = external_thing_ref_numbers(athing);
alen = external_thing_ref_no_numbers(athing);
}
goto ref_common;
default:
/* Must be a binary */
ASSERT(is_binary(a));
if (!is_binary(b)) {
a_tag = BINARY_DEF;
goto mixed_types;
} else {
Uint a_size = binary_size(a);
Uint b_size = binary_size(b);
Uint a_bitsize;
Uint b_bitsize;
Uint a_bitoffs;
Uint b_bitoffs;
Uint min_size;
int cmp;
byte* a_ptr;
byte* b_ptr;
if (eq_only && a_size != b_size) {
RETURN_NEQ(a_size - b_size);
}
ERTS_GET_BINARY_BYTES(a, a_ptr, a_bitoffs, a_bitsize);
ERTS_GET_BINARY_BYTES(b, b_ptr, b_bitoffs, b_bitsize);
if ((a_bitsize | b_bitsize | a_bitoffs | b_bitoffs) == 0) {
min_size = (a_size < b_size) ? a_size : b_size;
if ((cmp = sys_memcmp(a_ptr, b_ptr, min_size)) != 0) {
RETURN_NEQ(cmp);
}
}
else {
a_size = (a_size << 3) + a_bitsize;
b_size = (b_size << 3) + b_bitsize;
min_size = (a_size < b_size) ? a_size : b_size;
if ((cmp = erts_cmp_bits(a_ptr,a_bitoffs,
b_ptr,b_bitoffs,min_size)) != 0) {
RETURN_NEQ(cmp);
}
}
ON_CMP_GOTO((Sint)(a_size - b_size));
}
}
}
}
/*
* Take care of the case that the tags are different.
*/
mixed_types:
{
FloatDef f1, f2;
Eterm big;
Eterm aw = a;
Eterm bw = b;
#define MAX_LOSSLESS_FLOAT ((double)((1LL << 53) - 2))
#define MIN_LOSSLESS_FLOAT ((double)(((1LL << 53) - 2)*-1))
#define BIG_ARITY_FLOAT_MAX (1024 / D_EXP) /* arity of max float as a bignum */
Eterm big_buf[BIG_NEED_SIZE(BIG_ARITY_FLOAT_MAX)];
b_tag = tag_val_def(bw);
switch(_NUMBER_CODE(a_tag, b_tag)) {
case SMALL_BIG:
j = big_sign(bw) ? 1 : -1;
break;
case BIG_SMALL:
j = big_sign(aw) ? -1 : 1;
break;
case SMALL_FLOAT:
if (exact) goto exact_fall_through;
GET_DOUBLE(bw, f2);
if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
/* Float is within the no loss limit */
f1.fd = signed_val(aw);
j = erts_float_comp(f1.fd, f2.fd);
}
#if ERTS_SIZEOF_ETERM == 8
else if (f2.fd > (double) (MAX_SMALL + 1)) {
/* Float is a positive bignum, i.e. bigger */
j = -1;
} else if (f2.fd < (double) (MIN_SMALL - 1)) {
/* Float is a negative bignum, i.e. smaller */
j = 1;
} else {
/* Float is a Sint but less precise */
j = signed_val(aw) - (Sint) f2.fd;
}
#else
else {
/* If float is positive it is bigger than small */
j = (f2.fd > 0.0) ? -1 : 1;
}
#endif /* ERTS_SIZEOF_ETERM == 8 */
break;
case FLOAT_BIG:
if (exact) goto exact_fall_through;
{
Wterm tmp = aw;
aw = bw;
bw = tmp;
}/* fall through */
case BIG_FLOAT:
if (exact) goto exact_fall_through;
GET_DOUBLE(bw, f2);
if ((f2.fd < (double) (MAX_SMALL + 1))
&& (f2.fd > (double) (MIN_SMALL - 1))) {
/* Float is a Sint */
j = big_sign(aw) ? -1 : 1;
} else if (big_arity(aw) > BIG_ARITY_FLOAT_MAX
|| pow(2.0,(big_arity(aw)-1)*D_EXP) > fabs(f2.fd)) {
/* If bignum size shows that it is bigger than the abs float */
j = big_sign(aw) ? -1 : 1;
} else if (big_arity(aw) < BIG_ARITY_FLOAT_MAX
&& (pow(2.0,(big_arity(aw))*D_EXP)-1.0) < fabs(f2.fd)) {
/* If bignum size shows that it is smaller than the abs float */
j = f2.fd < 0 ? 1 : -1;
} else if (f2.fd < MAX_LOSSLESS_FLOAT && f2.fd > MIN_LOSSLESS_FLOAT) {
/* Float is within the no loss limit */
if (big_to_double(aw, &f1.fd) < 0) {
j = big_sign(aw) ? -1 : 1;
} else {
j = erts_float_comp(f1.fd, f2.fd);
}
} else {
big = double_to_big(f2.fd, big_buf, sizeof(big_buf)/sizeof(Eterm));
j = big_comp(aw, big);
}
if (_NUMBER_CODE(a_tag, b_tag) == FLOAT_BIG) {
j = -j;
}
break;
case FLOAT_SMALL:
if (exact) goto exact_fall_through;
GET_DOUBLE(aw, f1);
if (f1.fd < MAX_LOSSLESS_FLOAT && f1.fd > MIN_LOSSLESS_FLOAT) {
/* Float is within the no loss limit */
f2.fd = signed_val(bw);
j = erts_float_comp(f1.fd, f2.fd);
}
#if ERTS_SIZEOF_ETERM == 8
else if (f1.fd > (double) (MAX_SMALL + 1)) {
/* Float is a positive bignum, i.e. bigger */
j = 1;
} else if (f1.fd < (double) (MIN_SMALL - 1)) {
/* Float is a negative bignum, i.e. smaller */
j = -1;
} else {
/* Float is a Sint but less precise it */
j = (Sint) f1.fd - signed_val(bw);
}
#else
else {
/* If float is positive it is bigger than small */
j = (f1.fd > 0.0) ? 1 : -1;
}
#endif /* ERTS_SIZEOF_ETERM == 8 */
break;
exact_fall_through:
default:
j = b_tag - a_tag;
}
}
if (j == 0) {
goto pop_next;
} else {
goto not_equal;
}
term_array: /* arrays in 'aa' and 'bb', length in 'i' */
ASSERT(i>0);
while (--i) {
a = *aa++;
b = *bb++;
if (!is_same(a, b)) {
if (is_atom(a) && is_atom(b)) {
if ((j = erts_cmp_atoms(a, b)) != 0) {
goto not_equal;
}
} else if (is_both_small(a, b)) {
if ((j = signed_val(a)-signed_val(b)) != 0) {
goto not_equal;
}
} else {
WSTACK_PUSH3(stack, (UWord)bb, (UWord)aa, TERM_ARRAY_OP_WORD(i));
goto tailrecur_ne;
}
}
}
a = *aa;
b = *bb;
goto tailrecur;
pop_next:
if (!WSTACK_ISEMPTY(stack)) {
UWord something = WSTACK_POP(stack);
struct erts_cmp_hashmap_state* sp;
if (primary_tag((Eterm) something) == TAG_PRIMARY_HEADER) { /* an operation */
switch (GET_OP(something)) {
case TERM_ARRAY_OP:
i = GET_OP_ARG(something);
aa = (Eterm*)WSTACK_POP(stack);
bb = (Eterm*) WSTACK_POP(stack);
goto term_array;
case SWITCH_EXACT_OFF_OP:
/* Done with exact compare of map keys, switch back */
ASSERT(exact);
exact = 0;
goto pop_next;
case HASHMAP_PHASE1_ARE_KEYS_EQUAL: {
sp = PSTACK_TOP(hmap_stack);
if (j) {
/* Key diff found, enter phase 2 */
if (hashmap_key_hash_cmp(sp->ap, sp->bp) < 0) {
sp->min_key = CAR(sp->ap);
sp->cmp_res = -1;
sp->ap = hashmap_iterator_next(&stack);
}
else {
sp->min_key = CAR(sp->bp);
sp->cmp_res = 1;
sp->bp = hashmap_iterator_next(&b_stack);
}
exact = 1; /* only exact key compares in phase 2 */
goto case_HASHMAP_PHASE2_LOOP;
}
/* No key diff found so far, compare values if min key */
if (sp->cmp_res) {
a = CAR(sp->ap);
b = sp->min_key;
exact = 1;
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE1_IS_MIN_KEY));
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
}
/* no min key-value found yet */
a = CDR(sp->ap);
b = CDR(sp->bp);
exact = sp->was_exact;
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE1_CMP_VALUES));
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
}
case HASHMAP_PHASE1_IS_MIN_KEY:
sp = PSTACK_TOP(hmap_stack);
if (j < 0) {
a = CDR(sp->ap);
b = CDR(sp->bp);
exact = sp->was_exact;
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE1_CMP_VALUES));
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
}
goto case_HASHMAP_PHASE1_LOOP;
case HASHMAP_PHASE1_CMP_VALUES:
sp = PSTACK_TOP(hmap_stack);
if (j) {
sp->cmp_res = j;
sp->min_key = CAR(sp->ap);
}
case_HASHMAP_PHASE1_LOOP:
sp->ap = hashmap_iterator_next(&stack);
sp->bp = hashmap_iterator_next(&b_stack);
if (!sp->ap) {
/* end of maps with identical keys */
ASSERT(!sp->bp);
j = sp->cmp_res;
exact = sp->was_exact;
(void) PSTACK_POP(hmap_stack);
ON_CMP_GOTO(j);
}
a = CAR(sp->ap);
b = CAR(sp->bp);
exact = 1;
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE1_ARE_KEYS_EQUAL));
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
case_HASHMAP_PHASE2_LOOP:
if (sp->ap && sp->bp) {
a = CAR(sp->ap);
b = CAR(sp->bp);
ASSERT(exact);
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE2_ARE_KEYS_EQUAL));
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
}
goto case_HASHMAP_PHASE2_NEXT_STEP;
case HASHMAP_PHASE2_ARE_KEYS_EQUAL:
sp = PSTACK_TOP(hmap_stack);
if (j == 0) {
/* keys are equal, skip them */
sp->ap = hashmap_iterator_next(&stack);
sp->bp = hashmap_iterator_next(&b_stack);
goto case_HASHMAP_PHASE2_LOOP;
}
/* fall through */
case_HASHMAP_PHASE2_NEXT_STEP:
if (sp->ap || sp->bp) {
if (hashmap_key_hash_cmp(sp->ap, sp->bp) < 0) {
ASSERT(sp->ap);
a = CAR(sp->ap);
b = sp->min_key;
ASSERT(exact);
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE2_IS_MIN_KEY_A));
}
else { /* hash_cmp > 0 */
ASSERT(sp->bp);
a = CAR(sp->bp);
b = sp->min_key;
ASSERT(exact);
WSTACK_PUSH(stack, OP_WORD(HASHMAP_PHASE2_IS_MIN_KEY_B));
}
sp->wstack_rollback = WSTACK_COUNT(stack);
goto bodyrecur;
}
/* End of both maps */
j = sp->cmp_res;
exact = sp->was_exact;
(void) PSTACK_POP(hmap_stack);
ON_CMP_GOTO(j);
case HASHMAP_PHASE2_IS_MIN_KEY_A:
sp = PSTACK_TOP(hmap_stack);
if (j < 0) {
sp->min_key = CAR(sp->ap);
sp->cmp_res = -1;
}
sp->ap = hashmap_iterator_next(&stack);
goto case_HASHMAP_PHASE2_LOOP;
case HASHMAP_PHASE2_IS_MIN_KEY_B:
sp = PSTACK_TOP(hmap_stack);
if (j < 0) {
sp->min_key = CAR(sp->bp);
sp->cmp_res = 1;
}
sp->bp = hashmap_iterator_next(&b_stack);
goto case_HASHMAP_PHASE2_LOOP;
default:
ASSERT(!"Invalid cmp op");
} /* switch */
}
a = (Eterm) something;
b = (Eterm) WSTACK_POP(stack);
goto tailrecur;
}
ASSERT(PSTACK_IS_EMPTY(hmap_stack));
PSTACK_DESTROY(hmap_stack);
WSTACK_DESTROY(stack);
WSTACK_DESTROY(b_stack);
return 0;
not_equal:
if (!PSTACK_IS_EMPTY(hmap_stack) && !eq_only) {
WSTACK_ROLLBACK(stack, PSTACK_TOP(hmap_stack)->wstack_rollback);
goto pop_next;
}
PSTACK_DESTROY(hmap_stack);
WSTACK_DESTROY(stack);
WSTACK_DESTROY(b_stack);
return j;
#undef CMP_NODES
}