/*-------------------------------------------------------------------------*
* PL_STREAM_LINE_COLUMN_3 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Stream_Line_Column_3(WamWord sora_word, WamWord line_word, WamWord col_word)
{
int stm;
StmInf *pstm;
PlLong offset, char_count, line_count, line_pos;
stm = Pl_Get_Stream_Or_Alias(sora_word, STREAM_CHECK_EXIST);
pstm = pl_stm_tbl[stm];
if (!pstm->prop.text)
Pl_Err_Permission(pl_permission_operation_access,
pl_permission_type_binary_stream, sora_word);
Pl_Stream_Get_Position(pstm, &offset, &char_count, &line_count, &line_pos);
return Pl_Un_Integer_Check(line_count + 1, line_word) &&
Pl_Un_Integer_Check(line_pos + 1, col_word);
}
/*-------------------------------------------------------------------------*
* PL_PRED_PROP_PROLOG_LINE_2 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Pred_Prop_Prolog_Line_2(WamWord pred_indic_word, WamWord pl_line_word)
{
int func, arity;
PredInf *pred;
func = Pl_Get_Pred_Indicator(pred_indic_word, TRUE, &arity);
if ((pred = Pl_Lookup_Pred(func, arity)) == NULL)
return FALSE;
return Pl_Un_Integer_Check(pred->pl_line, pl_line_word);
}
/*-------------------------------------------------------------------------*
* PL_FD_MIN_2 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Fd_Min_2(WamWord fdv_word, WamWord min_word)
{
WamWord word, tag_mask;
int n;
Fd_Deref_Check_Fd_Var(fdv_word, word, tag_mask);
if (tag_mask == TAG_INT_MASK)
n = UnTag_INT(word);
else
n = Min(UnTag_FDV(word));
return Pl_Un_Integer_Check(n, min_word);
}
/*-------------------------------------------------------------------------*
* PL_FD_SIZE_2 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Fd_Size_2(WamWord fdv_word, WamWord size_word)
{
WamWord word, tag_mask;
int n;
Fd_Deref_Check_Fd_Var(fdv_word, word, tag_mask);
if (tag_mask == TAG_INT_MASK)
n = 1;
else
n = Nb_Elem(UnTag_FDV(word));
return Pl_Un_Integer_Check(n, size_word);
}
/*-------------------------------------------------------------------------*
* PL_CHARACTER_COUNT_2 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Character_Count_2(WamWord sora_word, WamWord count_word)
{
int stm;
StmInf *pstm;
PlLong offset, char_count, line_count, line_pos;
stm = Pl_Get_Stream_Or_Alias(sora_word, STREAM_CHECK_EXIST);
pstm = pl_stm_tbl[stm];
Pl_Stream_Get_Position(pstm, &offset, &char_count, &line_count, &line_pos);
return Pl_Un_Integer_Check(char_count, count_word);
}
/*-------------------------------------------------------------------------*
* PL_PRED_WITHOUT_AUX_4 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Pred_Without_Aux_4(WamWord name_word, WamWord arity_word,
WamWord name1_word, WamWord arity1_word)
{
int func, arity;
int func1, arity1;
func = Pl_Rd_Atom_Check(name_word);
arity = Pl_Rd_Integer_Check(arity_word);
func1 = Pl_Pred_Without_Aux(func, arity, &arity1);
return Pl_Un_Atom_Check(func1, name1_word) &&
Pl_Un_Integer_Check(arity1, arity1_word);
}
/*-------------------------------------------------------------------------*
* PL_FATHER_OF_AUX_NAME_3 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Father_Of_Aux_Name_3(WamWord name_word, WamWord father_name_word,
WamWord father_arity_word)
{
int func, father_func, father_arity;
func = Pl_Rd_Atom_Check(name_word);
father_func = Pl_Father_Pred_Of_Aux(func, &father_arity);
if (father_func < 0)
return FALSE;
return Pl_Un_Atom_Check(father_func, father_name_word) &&
Pl_Un_Integer_Check(father_arity, father_arity_word);
}
/*-------------------------------------------------------------------------*
* PL_GET_PREDICATE_FILE_INFO_3 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Get_Predicate_File_Info_3(WamWord pred_indic_word,
WamWord pl_file_word, WamWord pl_line_word)
{
int func, arity;
PredInf *pred;
func = Pl_Get_Pred_Indicator(pred_indic_word, TRUE, &arity);
if ((pred = Pl_Lookup_Pred(func, arity)) == NULL)
return FALSE;
if (pred->pl_file == pl_atom_void || pred->pl_line == 0)
return FALSE;
return Pl_Un_Atom_Check(pred->pl_file, pl_file_word) &&
Pl_Un_Integer_Check(pred->pl_line, pl_line_word);
}
/*-------------------------------------------------------------------------*
* PL_FD_MAX_INTEGER_1 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Fd_Max_Integer_1(WamWord inf_word)
{
return Pl_Un_Integer_Check(INTERVAL_MAX_INTEGER, inf_word);
}
/*-------------------------------------------------------------------------*
* PL_FD_VECTOR_MAX_1 *
* *
*-------------------------------------------------------------------------*/
Bool
Pl_Fd_Vector_Max_1(WamWord max_word)
{
return Pl_Un_Integer_Check(pl_vec_max_integer, max_word);
}
/*-------------------------------------------------------------------------*
* PL_BLT_FUNCTOR *
* *
*-------------------------------------------------------------------------*/
Bool FC
Pl_Blt_Functor(WamWord term_word, WamWord functor_word, WamWord arity_word)
{
WamWord word, tag_mask;
WamWord *adr;
WamWord tag_functor;
int arity;
Bool res;
Pl_Set_C_Bip_Name("functor", 3);
DEREF(term_word, word, tag_mask);
if (tag_mask != TAG_REF_MASK)
{
if (tag_mask == TAG_LST_MASK)
res = Pl_Un_Atom_Check(ATOM_CHAR('.'), functor_word) &&
Pl_Un_Integer_Check(2, arity_word);
else if (tag_mask == TAG_STC_MASK)
{
adr = UnTag_STC(word);
res = Pl_Un_Atom_Check(Functor(adr), functor_word) &&
Pl_Un_Integer_Check(Arity(adr), arity_word);
}
else
res = Pl_Unify(word, functor_word) && Pl_Un_Integer_Check(0, arity_word);
goto finish;
}
/* tag_mask == TAG_REF_MASK */
DEREF(functor_word, word, tag_mask);
if (tag_mask == TAG_REF_MASK)
Pl_Err_Instantiation();
if (tag_mask != TAG_ATM_MASK && tag_mask != TAG_INT_MASK &&
tag_mask != TAG_FLT_MASK)
Pl_Err_Type(pl_type_atomic, functor_word);
tag_functor = tag_mask;
functor_word = word;
arity = Pl_Rd_Positive_Check(arity_word);
if (arity > MAX_ARITY)
Pl_Err_Representation(pl_representation_max_arity);
if (tag_functor == TAG_ATM_MASK && UnTag_ATM(functor_word) == ATOM_CHAR('.')
&& arity == 2)
{
res = (Pl_Get_List(term_word)) ? Pl_Unify_Void(2), TRUE : FALSE;
goto finish;
}
if (tag_functor == TAG_ATM_MASK && arity > 0)
{
res = (Pl_Get_Structure(UnTag_ATM(functor_word), arity, term_word)) ?
Pl_Unify_Void(arity), TRUE : FALSE;
goto finish;
}
if (arity != 0)
Pl_Err_Type(pl_type_atom, functor_word);
res = Pl_Unify(functor_word, term_word);
finish:
Pl_Unset_C_Bip_Name();
return res;
}
