/*-------------------------------------------------------------------------*
* PL_BETWEEN_ALT_0 *
* *
*-------------------------------------------------------------------------*/
void
Pl_Between_Alt_0(void)
{
PlLong l, u;
WamWord i_word;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(BETWEEN_ALT, 0), 0);
l = AB(B, 0);
u = AB(B, 1);
i_word = AB(B, 2);
/* here i_word is a variable */
if (l == u)
Delete_Last_Choice_Point();
else /* non deterministic case */
{
AB(B, 0) = l + 1;
#if 0 /* the following data is unchanged */
AB(B, 1) = u;
AB(B, 2) = i_word;
#endif
}
Pl_Get_Integer(l, i_word); /* always TRUE */
}
/*-------------------------------------------------------------------------*
* PL_CURRENT_ATOM_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Atom_Alt_0(void)
{
WamWord atom_word;
Bool hide;
int atom;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_ATOM_ALT, 0), 0);
atom_word = AB(B, 0);
hide = AB(B, 1);
atom = AB(B, 2);
for (;;)
{
atom = Pl_Find_Next_Atom(atom);
if (atom == -1)
{
Delete_Last_Choice_Point();
return FALSE;
}
if (!hide || pl_atom_tbl[atom].name[0] != '$')
break;
}
/* non deterministic case */
#if 0 /* the following data is unchanged */
AB(B, 0) = atom_word;
AB(B, 1) = hide;
#endif
AB(B, 2) = atom;
return Pl_Get_Atom(atom, atom_word);
}
/*-------------------------------------------------------------------------*
* PL_GROUP_SOLUTIONS_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Group_Solutions_Alt_0(void)
{
WamWord all_sol_word, gl_key_word, sol_word;
WamWord word;
WamWord key_word;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(GROUP_SOLUTIONS_ALT, 0),
0);
all_sol_word = AB(B, 0);
gl_key_word = AB(B, 1);
sol_word = AB(B, 2);
word = Group(all_sol_word, gl_key_word, &key_word);
if (word == NOT_A_WAM_WORD)
Delete_Last_Choice_Point();
else /* non deterministic case */
{
AB(B, 0) = word;
#if 0 /* the following data is unchanged */
AB(B, 1) = gl_key_word;
AB(B, 2) = sol_word;
#endif
}
Pl_Unify(key_word, gl_key_word);
return Pl_Unify(sol_word, all_sol_word);
}
/*-------------------------------------------------------------------------*
* PL_CURRENT_STREAM_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Stream_Alt_0(void)
{
WamWord stm_word;
int stm;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_STREAM_ALT, 0), 0);
stm_word = AB(B, 0);
stm = AB(B, 1);
for (; stm <= pl_stm_last_used; stm++)
if (pl_stm_tbl[stm])
break;
if (stm >= pl_stm_last_used)
{
Delete_Last_Choice_Point();
if (stm > pl_stm_last_used)
return FALSE;
}
else /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = stm_word;
#endif
AB(B, 1) = stm + 1;
}
return Pl_Get_Integer(stm, stm_word);
}
/*-------------------------------------------------------------------------*
* PL_CURRENT_MIRROR_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Current_Mirror_Alt_0(void)
{
/* int stm; */
WamWord m_stm_word;
StmLst *m;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(CURRENT_MIRROR_ALT, 0), 0);
/* stm = AB(B, 0); */
m_stm_word = AB(B, 1);
m = (StmLst *) AB(B, 2);
if (m->next) /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = stm;
AB(B, 1) = m_stm_word;
#endif
AB(B, 2) = (WamWord) m->next;
}
else
Delete_Last_Choice_Point();
return Pl_Get_Integer(m->stm, m_stm_word);
}
/*-------------------------------------------------------------------------*
* 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_SUB_ATOM_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Sub_Atom_Alt_0(void)
{
WamWord before_word, length_word, after_word, sub_atom_word;
AtomInf *patom;
AtomInf *psub_atom;
int b, l, a;
int b1, l1, a1;
int mask;
char *str;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(SUB_ATOM_ALT, 0), 0);
before_word = AB(B, 0);
length_word = AB(B, 1);
after_word = AB(B, 2);
sub_atom_word = AB(B, 3);
patom = (AtomInf *) AB(B, 4);
psub_atom = (AtomInf *) AB(B, 5);
mask = AB(B, 6);
b = AB(B, 7);
l = AB(B, 8);
a = AB(B, 9);
if (!Compute_Next_BLA(mask, patom, psub_atom, b, l, a, &b1, &l1, &a1))
Delete_Last_Choice_Point();
else /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = before_word;
AB(B, 1) = length_word;
AB(B, 2) = after_word;
AB(B, 3) = sub_atom_word;
AB(B, 4) = (WamWord) patom;
AB(B, 5) = (WamWord) psub_atom;
AB(B, 6) = mask;
#endif
AB(B, 7) = b1;
AB(B, 8) = l1;
AB(B, 9) = a1;
}
if (mask <= 7)
{
MALLOC_STR(l);
strncpy(str, patom->name + b, l);
str[l] = '\0';
Pl_Get_Atom(Create_Malloc_Atom(str), sub_atom_word);
Pl_Get_Integer(l, length_word);
}
return Pl_Get_Integer(b, before_word) && Pl_Get_Integer(a, after_word);
}
/*-------------------------------------------------------------------------*
* PL_FOREIGN_UPDATE_CHOICE *
* *
*-------------------------------------------------------------------------*/
void
Pl_Foreign_Update_Choice(CodePtr codep_alt, int arity, int choice_size)
{
pl_foreign_bkt_counter = AB(B, arity) + 1;
AB(B, arity) = pl_foreign_bkt_counter;
pl_foreign_bkt_buffer = (char *) (&(AB(B, arity + choice_size)));
if (pl_foreign_bkt_counter > 0)
{
Pl_Update_Choice_Point(codep_alt, arity);
}
}
/*-------------------------------------------------------------------------*
* 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_ATOM_CONCAT_ALT_0 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Atom_Concat_Alt_0(void)
{
WamWord atom1_word, atom2_word;
AtomInf *patom3;
char *name;
char *p;
char *str;
int l;
Pl_Update_Choice_Point((CodePtr) Prolog_Predicate(ATOM_CONCAT_ALT, 0), 0);
atom1_word = AB(B, 0);
atom2_word = AB(B, 1);
patom3 = (AtomInf *) AB(B, 2);
p = (char *) AB(B, 3);
if (*p == '\0')
Delete_Last_Choice_Point();
else /* non deterministic case */
{
#if 0 /* the following data is unchanged */
AB(B, 0) = atom1_word;
AB(B, 1) = atom2_word;
AB(B, 2) = (WamWord) patom3;
#endif
AB(B, 3) = (WamWord) (p + 1);
}
name = patom3->name;
l = p - name;
MALLOC_STR(l);
strncpy(str, name, l + 1);
str[l] = '\0';
if (!Pl_Get_Atom(Create_Malloc_Atom(str), atom1_word))
return FALSE;
l = patom3->prop.length - l;
MALLOC_STR(l);
strcpy(str, p);
return Pl_Get_Atom(Create_Malloc_Atom(str), atom2_word);
}