/*-------------------------------------------------------------------------*
* PL_CURRENT_ALIAS_2 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Alias_2(WamWord stm_word, WamWord alias_word)
{
WamWord word, tag_mask;
int stm;
HashScan scan;
AliasInf *alias;
AliasInf *save_alias;
stm = Pl_Rd_Integer_Check(stm_word); /* stm is a valid stream entry */
DEREF(alias_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK)
return Pl_Find_Stream_By_Alias(Pl_Rd_Atom_Check(word)) == stm;
for (alias = (AliasInf *) Pl_Hash_First(pl_alias_tbl, &scan); alias;
alias = (AliasInf *) Pl_Hash_Next(&scan))
if (alias->stm == stm)
break;
if (alias == NULL)
return FALSE;
save_alias = alias;
for (;;)
{
alias = (AliasInf *) Pl_Hash_Next(&scan);
if (alias == NULL || alias->stm == stm)
break;
}
if (alias) /* non deterministic case */
{
A(0) = stm;
A(1) = alias_word;
A(2) = (WamWord) scan.endt;
A(3) = (WamWord) scan.cur_t;
A(4) = (WamWord) scan.cur_p;
A(5) = (WamWord) alias;
Pl_Create_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_ALIAS_ALT, 0),
6);
}
Pl_Get_Atom(save_alias->atom, alias_word);
return TRUE;
}
/*-------------------------------------------------------------------------*
* PL_CURRENT_PREDICATE_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Predicate_Alt_0(void)
{
WamWord name_word, arity_word;
HashScan scan;
PredInf *pred;
int which_preds;
int func, arity;
int func1, arity1;
Bool all;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_PREDICATE_ALT, 0),
0);
name_word = AB(B, 0);
arity_word = AB(B, 1);
which_preds = AB(B, 2);
scan.endt = (char *) AB(B, 3);
scan.cur_t = (char *) AB(B, 4);
scan.cur_p = (char *) AB(B, 5);
func = Tag_Mask_Of(name_word) == TAG_REF_MASK ? -1 : UnTag_ATM(name_word);
arity = Tag_Mask_Of(arity_word) == TAG_REF_MASK ? -1 : UnTag_INT(arity_word);
/* here func or arity == -1 (or both) */
all = (func == -1 && arity == -1);
for (;;)
{
pred = (PredInf *) Pl_Hash_Next(&scan);
if (pred == NULL)
{
Delete_Last_Choice_Point();
return FALSE;
}
func1 = Functor_Of(pred->f_n);
arity1 = Arity_Of(pred->f_n);
if ((all || func == func1 || arity == arity1) &&
Pred_Is_Ok(pred, func1, which_preds))
break;
}
/* non deterministic case */
#if 0 /* the following data is unchanged */
AB(B, 0) = name_word;
AB(B, 1) = arity_word;
AB(B, 2) = which_preds;
AB(B, 3) = (WamWord) scan.endt;
#endif
AB(B, 4) = (WamWord) scan.cur_t;
AB(B, 5) = (WamWord) scan.cur_p;
return Pl_Get_Atom(Functor_Of(pred->f_n), name_word) &&
Pl_Get_Integer(Arity_Of(pred->f_n), arity_word);
}
/*-------------------------------------------------------------------------*
* PL_CURRENT_ALIAS_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Alias_Alt_0(void)
{
int stm;
WamWord alias_word;
HashScan scan;
AliasInf *alias;
AliasInf *save_alias;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_ALIAS_ALT, 0), 0);
stm = AB(B, 0);
alias_word = AB(B, 1);
scan.endt = (char *) AB(B, 2);
scan.cur_t = (char *) AB(B, 3);
scan.cur_p = (char *) AB(B, 4);
alias = (AliasInf *) AB(B, 5);
save_alias = alias;
for (;;)
{
alias = (AliasInf *) Pl_Hash_Next(&scan);
if (alias == NULL || alias->stm == stm)
break;
}
if (alias) /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = stm;
AB(B, 1) = alias_word;
AB(B, 2) = (WamWord) scan.endt;
#endif
AB(B, 3) = (WamWord) scan.cur_t;
AB(B, 4) = (WamWord) scan.cur_p;
AB(B, 5) = (WamWord) alias;
}
else
Delete_Last_Choice_Point();
Pl_Get_Atom(save_alias->atom, alias_word);
return TRUE;
}
/*-------------------------------------------------------------------------*
* PL_CURRENT_PREDICATE_2 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Predicate_2(WamWord pred_indic_word, WamWord which_preds_word)
{
WamWord name_word, arity_word;
HashScan scan;
PredInf *pred;
int func, arity;
int func1, arity1;
int which_preds; /* 0=user, 1=user+bips, 2=user+bips+system */
Bool all;
func = Pl_Get_Pred_Indicator(pred_indic_word, FALSE, &arity);
name_word = pl_pi_name_word;
arity_word = pl_pi_arity_word;
which_preds = Pl_Rd_Integer(which_preds_word);
if (which_preds == 0 && !Flag_Value(FLAG_STRICT_ISO))
which_preds = 1;
#define Pred_Is_Ok(pred, func, which_preds) \
(which_preds == 2 || (pl_atom_tbl[func].name[0] != '$' && \
(which_preds == 1 || !(pred->prop & MASK_PRED_ANY_BUILTIN))))
if (func >= 0 && arity >= 0)
{
pred = Pl_Lookup_Pred(func, arity);
return pred && Pred_Is_Ok(pred, func, which_preds);
}
/* here func or arity == -1 (or both) */
all = (func == -1 && arity == -1);
pred = (PredInf *) Pl_Hash_First(pl_pred_tbl, &scan);
for (;;)
{
if (pred == NULL)
return FALSE;
func1 = Functor_Of(pred->f_n);
arity1 = Arity_Of(pred->f_n);
if ((all || func == func1 || arity == arity1) &&
Pred_Is_Ok(pred, func1, which_preds))
break;
pred = (PredInf *) Pl_Hash_Next(&scan);
}
/* non deterministic case */
A(0) = name_word;
A(1) = arity_word;
A(2) = which_preds;
A(3) = (WamWord) scan.endt;
A(4) = (WamWord) scan.cur_t;
A(5) = (WamWord) scan.cur_p;
Pl_Create_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_PREDICATE_ALT, 0),
6);
return Pl_Get_Atom(Functor_Of(pred->f_n), name_word) &&
Pl_Get_Integer(Arity_Of(pred->f_n), arity_word);
/*
return Pl_Un_Atom_Check(Functor_Of(pred->f_n), name_word) &&
Pl_Un_Integer_Check(Arity_Of(pred->f_n), arity_word);
*/
}
