static int
compare_dict_entry(const void *a, const void *b, void *arg)
{ GET_LDARG(arg);
Word p = (Word)a+1;
Word q = (Word)b+1;
deRef(p);
deRef(q);
return (*p<*q ? -1 : *p>*q ? 1 : 0);
}
//------------------------------------------
EXPORT_C skRValue& skRValue::operator=(const skRValue& v)
//------------------------------------------
{
if (&v!=this){
if (m_Type==T_Object){
deRef();
}
m_Type=v.m_Type;
switch (m_Type){
case T_String:
m_String=v.m_String;
break;
case T_Bool:
m_Value.m_Bool=v.m_Value.m_Bool;
break;
case T_Char:
m_Value.m_Char=v.m_Value.m_Char;
break;
case T_Int:
m_Value.m_Int=v.m_Value.m_Int;
break;
#ifdef USE_FLOATING_POINT
case T_Float:
m_Value.m_Float=v.m_Value.m_Float;
break;
#endif
case T_Object:
m_Value.m_ObjectRef=v.m_Value.m_ObjectRef;
m_Value.m_ObjectRef->m_RefCount++;
break;
}
}
return *this;
}
//------------------------------------------
EXPORT_C skRValue& skRValue::operator=(Char value)
//------------------------------------------
{
if (m_Type==T_Object){
deRef();
}
m_Type=T_Char;
m_Value.m_Char=value;
return *this;
}
//------------------------------------------
EXPORT_C skRValue& skRValue::operator=(float value)
//------------------------------------------
{
if (m_Type==T_Object){
deRef();
}
m_Type=T_Float;
m_Value.m_Float=value;
return *this;
}
//------------------------------------------
EXPORT_C skRValue& skRValue::operator=(bool value)
//------------------------------------------
{
if (m_Type==T_Object){
deRef();
}
m_Type=T_Bool;
m_Value.m_Bool=value;
return *this;
}
//------------------------------------------
EXPORT_C skRValue& skRValue::operator=(const skString& value)
//------------------------------------------
{
if (m_Type==T_Object){
deRef();
}
m_Type=T_String;
m_String=value;
return *this;
}
int
PL_get_attr__LD(term_t t, term_t a ARG_LD)
{ Word p = valTermRef(t);
deRef(p);
if ( isAttVar(*p) )
{ Word ap = valPAttVar(*p);
*valTermRef(a) = makeRef(ap); /* reference, so we can assign */
succeed;
}
fail;
}
static char *
vName(Word adr)
{ GET_LD
static char name[32];
deRef(adr);
if (adr > (Word) lBase)
Ssprintf(name, "_L%ld", (Word)adr - (Word)lBase);
else
Ssprintf(name, "_G%ld", (Word)adr - (Word)gBase);
return name;
}
static void
unshare_attvar(Word p ARG_LD)
{ for(;;)
{ deRef(p);
if ( isTerm(*p) )
{ Functor t = valueTerm(*p);
word fd = (t->definition & ~BOTH_MASK);
if ( fd == FUNCTOR_att3 )
{ t->definition = fd | MARK_MASK;
p = &t->arguments[2];
}
} else
{ break;
}
}
}
static int
assign_in_dict(Word dp, Word val ARG_LD)
{ deRef(val);
if ( !canBind(*val) )
{ *dp = *val;
} else if ( isAttVar(*val) )
{ *dp = makeRef(val);
} else
{ if ( dp < val )
{ if ( unlikely(tTop+1 >= tMax) )
return TRAIL_OVERFLOW;
setVar(*dp);
Trail(val, makeRef(dp));
} else
{ *dp = makeRef(val);
}
}
return TRUE;
}
static int
get_dict_ex(term_t t, Word dp, int ex ARG_LD)
{ Word p = valTermRef(t);
deRef(p);
if ( isTerm(*p) )
{ Functor f = valueTerm(*p);
FunctorDef fd = valueFunctor(f->definition);
if ( fd->name == ATOM_dict &&
fd->arity%2 == 1 ) /* does *not* validate ordering */
{ *dp = *p;
return TRUE;
}
}
if ( !ex )
return FALSE;
PL_type_error("dict", t);
return FALSE;
}
static int
get_create_dict_ex(term_t t, term_t dt ARG_LD)
{ Word p = valTermRef(t);
deRef(p);
if ( isTerm(*p) )
{ Functor f = valueTerm(*p);
FunctorDef fd = valueFunctor(f->definition);
if ( fd->name == ATOM_dict &&
fd->arity%2 == 1 ) /* does *not* validate ordering */
{ *valTermRef(dt) = *p;
return TRUE;
}
}
if ( PL_get_dict_ex(t, 0, dt, DICT_GET_ALL) )
{ assert(isTerm(*valTermRef(dt)));
return TRUE;
}
return PL_type_error("dict", t);
}
static int
mark_for_copy(Word p, int flags ARG_LD)
{ Word start = p;
int walk_ref = FALSE;
Word buf[1024];
segstack stack;
initSegStack(&stack, sizeof(Word), sizeof(buf), buf);
for(;;)
{ switch(tag(*p))
{ case TAG_ATTVAR:
{ if ( flags & COPY_ATTRS )
{ if ( !pushForMark(&stack, p, walk_ref) )
{ clearSegStack(&stack);
return MEMORY_OVERFLOW;
}
walk_ref = TRUE;
p = valPAttVar(*p);
continue;
}
/*FALLTHROUGH*/
}
case TAG_VAR:
{ if ( virgin(*p) )
set_visited(*p);
else if ( visited_once(*p) )
set_shared(*p);
break;
}
case TAG_REFERENCE:
{ if ( !pushForMark(&stack, p, walk_ref) )
{ clearSegStack(&stack);
return MEMORY_OVERFLOW;
}
walk_ref = TRUE;
deRef(p);
continue;
}
case TAG_COMPOUND:
{ Functor t = valueTerm(*p);
int arity = arityFunctor(t->definition);
if ( virgin(t->definition) )
{ set_visited(t->definition);
} else
{ if ( visited_once(t->definition) )
set_shared(t->definition);
break;
}
if ( arity >= 1 )
{ if ( !pushForMark(&stack, p, walk_ref) )
{ clearSegStack(&stack);
return MEMORY_OVERFLOW;
}
walk_ref = FALSE;
p = &t->arguments[arity-1]; /* last argument */
continue;
}
}
}
if ( p == start )
{ clearSegStack(&stack);
return TRUE;
}
while ( walk_ref )
{ popForMark(&stack, &p, &walk_ref);
if ( isAttVar(*p) )
{ Word ap = valPAttVar(*p);
unshare_attvar(ap PASS_LD);
}
if ( p == start )
{ clearSegStack(&stack);
return TRUE;
}
}
p--;
if ( tagex(*p) == (TAG_ATOM|STG_GLOBAL) )
{ popForMark(&stack, &p, &walk_ref);
update_ground(p PASS_LD);
}
}
}
