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); } } }