diogo
/
yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

get rid of PROTO

This commit is contained in:
Vitor Santos Costa 2013-04-25 17:15:04 -05:00
parent 24a75525c0
commit 743c9c69fb
64 changed files with 1302 additions and 1315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
C/adtdefs.c
View File

@ -26,9 +26,8 @@ static char SccsId[] = "%W% %G%";
#endif #endif
#include "Yap.h" #include "Yap.h"
ADDR STD_PROTO(Yap_PreAllocCodeSpace, (void)); static Prop PredPropByFunc(Functor, Term);
Prop STD_PROTO(PredPropByFunc,(Functor, Term)); static Prop PredPropByAtom(Atom, Term);
Prop STD_PROTO(PredPropByAtom,(Atom, Term));
#include "Yatom.h" #include "Yatom.h"
#include "yapio.h" #include "yapio.h"
#include <stdio.h> #include <stdio.h>

4
C/agc.c
View File

@ -32,8 +32,8 @@ static char SccsId[] = "@(#)agc.c 1.3 3/15/90";
#define errout GLOBAL_stderr #define errout GLOBAL_stderr
#endif #endif
STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS)); static void RestoreEntries(PropEntry *, int USES_REGS);
STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS)); static void CleanCode(PredEntry * USES_REGS);
#define AtomMarkedBit 1 #define AtomMarkedBit 1

12
C/alloc.c
View File

@ -482,11 +482,11 @@ Yap_givemallinfo(void)
#if !USE_DL_MALLOC #if !USE_DL_MALLOC
STATIC_PROTO(void FreeBlock, (BlockHeader *)); static void FreeBlock(BlockHeader *);
STATIC_PROTO(BlockHeader *GetBlock, (unsigned long int)); static BlockHeader *GetBlock(unsigned long int);
STATIC_PROTO(char *AllocHeap, (unsigned long int)); static char *AllocHeap(unsigned long int);
STATIC_PROTO(void RemoveFromFreeList, (BlockHeader *)); static void RemoveFromFreeList(BlockHeader *);
STATIC_PROTO(void AddToFreeList, (BlockHeader *)); static void AddToFreeList(BlockHeader *);
#define MinHGap 256*K #define MinHGap 256*K
@ -1273,7 +1273,7 @@ Yap_FreeWorkSpace(void)
\***********************************************************************/ \***********************************************************************/
#ifdef _AIX #ifdef _AIX
char *STD_PROTO(sbrk, (int)); char *sbrk(int);
#endif #endif

120
C/amasm.c
View File

@ -214,73 +214,73 @@ typedef struct clause_info_struct {
struct pred_entry *CurrentPred; struct pred_entry *CurrentPred;
} clause_info; } clause_info;
STATIC_PROTO(OPREG Var_Ref, (Ventry *, int)); static OPREG Var_Ref(Ventry *, int);
STATIC_PROTO(wamreg emit_xreg, (CELL)); static wamreg emit_xreg(CELL);
STATIC_PROTO(yslot emit_yreg, (CELL)); static yslot emit_yreg(CELL);
STATIC_PROTO(wamreg emit_x, (CELL)); static wamreg emit_x(CELL);
STATIC_PROTO(yslot emit_y, (Ventry *)); static yslot emit_y(Ventry *);
STATIC_PROTO(yamop *emit_a, (CELL)); static yamop *emit_a(CELL);
STATIC_PROTO(CELL *emit_bmlabel, (CELL, struct intermediates *)); static CELL *emit_bmlabel(CELL, struct intermediates *);
STATIC_PROTO(yamop *emit_ilabel, (CELL, struct intermediates *)); static yamop *emit_ilabel(CELL, struct intermediates *);
STATIC_PROTO(Functor emit_f, (CELL)); static Functor emit_f(CELL);
STATIC_PROTO(CELL emit_c, (CELL)); static CELL emit_c(CELL);
STATIC_PROTO(COUNT emit_count, (CELL)); static COUNT emit_count(CELL);
STATIC_PROTO(OPCODE emit_op, (op_numbers)); static OPCODE emit_op(op_numbers);
STATIC_PROTO(yamop *a_cle, (op_numbers, yamop *, int, struct intermediates *)); static yamop *a_cle(op_numbers, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_e, (op_numbers, yamop *, int)); static yamop *a_e(op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_ue, (op_numbers, op_numbers, yamop *, int)); static yamop *a_ue(op_numbers, op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_v, (op_numbers, op_numbers, yamop *, int, struct PSEUDO *)); static yamop *a_v(op_numbers, op_numbers, yamop *, int, struct PSEUDO *);
STATIC_PROTO(yamop *a_uv, (Ventry *,op_numbers, op_numbers, op_numbers, op_numbers, yamop *, int)); static yamop *a_uv(Ventry *,op_numbers, op_numbers, op_numbers, op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_vr, (op_numbers, op_numbers, yamop *, int, struct intermediates *)); static yamop *a_vr(op_numbers, op_numbers, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_rv, (op_numbers, op_numbers, OPREG, yamop *, int, struct PSEUDO *)); static yamop *a_rv(op_numbers, op_numbers, OPREG, yamop *, int, struct PSEUDO *);
STATIC_PROTO(yamop *a_vv, (op_numbers, op_numbers, yamop *, int, struct intermediates *)); static yamop *a_vv(op_numbers, op_numbers, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_glist, (int *, yamop *, int, struct intermediates *)); static yamop *a_glist(int *, yamop *, int, struct intermediates *);
STATIC_PROTO(void a_pair, (CELL *, int, struct intermediates *)); static void a_pair(CELL *, int, struct intermediates *);
STATIC_PROTO(yamop *a_f, (CELL, op_numbers, yamop *, int)); static yamop *a_f(CELL, op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_c, (CELL, op_numbers, yamop *, int)); static yamop *a_c(CELL, op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_uc, (CELL, op_numbers, op_numbers, yamop *, int)); static yamop *a_uc(CELL, op_numbers, op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_n, (op_numbers, int, yamop *, int)); static yamop *a_n(op_numbers, int, yamop *, int);
STATIC_PROTO(yamop *a_un, (op_numbers, op_numbers, int, yamop *, int)); static yamop *a_un(op_numbers, op_numbers, int, yamop *, int);
STATIC_PROTO(yamop *a_nc, (CELL, op_numbers, int, yamop *, int)); static yamop *a_nc(CELL, op_numbers, int, yamop *, int);
STATIC_PROTO(yamop *a_unc, (CELL, op_numbers, op_numbers, int, yamop *, int)); static yamop *a_unc(CELL, op_numbers, op_numbers, int, yamop *, int);
STATIC_PROTO(yamop *a_r, (CELL, op_numbers, yamop *, int)); static yamop *a_r(CELL, op_numbers, yamop *, int);
STATIC_PROTO(yamop *a_p, (op_numbers, clause_info *, yamop *, int, struct intermediates *)); static yamop *a_p(op_numbers, clause_info *, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_pl, (op_numbers, PredEntry *, yamop *, int)); static yamop *a_pl(op_numbers, PredEntry *, yamop *, int);
STATIC_PROTO(yamop *a_l, (CELL, op_numbers, yamop *, int, struct intermediates *)); static yamop *a_l(CELL, op_numbers, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_hx, (op_numbers, union clause_obj *, int, yamop *, int, struct intermediates *)); static yamop *a_hx(op_numbers, union clause_obj *, int, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_if, (op_numbers, union clause_obj *, int, yamop *, int, struct intermediates *cip)); static yamop *a_if(op_numbers, union clause_obj *, int, yamop *, int, struct intermediates *cip);
STATIC_PROTO(yamop *a_cut, (clause_info *,yamop *, int, struct intermediates *)); static yamop *a_cut(clause_info *,yamop *, int, struct intermediates *);
#ifdef YAPOR #ifdef YAPOR
STATIC_PROTO(yamop *a_try, (op_numbers, CELL, CELL, int, int, yamop *, int, struct intermediates *)); static yamop *a_try(op_numbers, CELL, CELL, int, int, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_either, (op_numbers, CELL, CELL, int, yamop *, int, struct intermediates *)); static yamop *a_either(op_numbers, CELL, CELL, int, yamop *, int, struct intermediates *);
#else #else
STATIC_PROTO(yamop *a_try, (op_numbers, CELL, CELL, yamop *, int, struct intermediates *)); static yamop *a_try(op_numbers, CELL, CELL, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_either, (op_numbers, CELL, CELL, yamop *, int, struct intermediates *)); static yamop *a_either(op_numbers, CELL, CELL, yamop *, int, struct intermediates *);
#endif /* YAPOR */ #endif /* YAPOR */
STATIC_PROTO(yamop *a_gl, (op_numbers, yamop *, int, struct PSEUDO *, struct intermediates * CACHE_TYPE)); static yamop *a_gl(op_numbers, yamop *, int, struct PSEUDO *, struct intermediates * CACHE_TYPE);
STATIC_PROTO(yamop *a_bfunc, (CELL, clause_info *, yamop *, int, struct intermediates *)); static yamop *a_bfunc(CELL, clause_info *, yamop *, int, struct intermediates *);
STATIC_PROTO( static
COUNT compile_cmp_flags, (char *)); COUNT compile_cmp_flags(char *);
STATIC_PROTO(yamop *a_igl, (CELL, op_numbers, yamop *, int, struct intermediates *)); static yamop *a_igl(CELL, op_numbers, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_xigl, (op_numbers, yamop *, int, struct PSEUDO *)); static yamop *a_xigl(op_numbers, yamop *, int, struct PSEUDO *);
STATIC_PROTO(yamop *a_ucons, (int *, compiler_vm_op, yamop *, int, struct intermediates *)); static yamop *a_ucons(int *, compiler_vm_op, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_uvar, (yamop *, int, struct intermediates *)); static yamop *a_uvar(yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_wvar, (yamop *, int, struct intermediates *)); static yamop *a_wvar(yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *do_pass, (int, yamop **, int, int *, int *,struct intermediates *, UInt CACHE_TYPE)); static yamop *do_pass(int, yamop **, int, int *, int *,struct intermediates *, UInt CACHE_TYPE);
#ifdef DEBUG_OPCODES #ifdef DEBUG_OPCODES
STATIC_PROTO(void DumpOpCodes, (void)); static void DumpOpCodes(void);
#endif #endif
#ifdef SFUNC #ifdef SFUNC
STATIC_PROTO(void a_vsf, (int, yamop *, int, struct PSEUDO *)); static void a_vsf(int, yamop *, int, struct PSEUDO *);
STATIC_PROTO(void a_asf, (int, yamop *, int, struct PSEUDO *)); static void a_asf(int, yamop *, int, struct PSEUDO *);
#endif #endif
STATIC_PROTO(yamop *check_alloc, (clause_info *, yamop *, int, struct intermediates *)); static yamop *check_alloc(clause_info *, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_deallocate, (clause_info *, yamop *, int, struct intermediates *)); static yamop *a_deallocate(clause_info *, yamop *, int, struct intermediates *);
STATIC_PROTO(yamop *a_bmap, (yamop *, int, struct PSEUDO *)); static yamop *a_bmap(yamop *, int, struct PSEUDO *);
STATIC_PROTO(void a_fetch_vv, (cmp_op_info *, int, struct intermediates *)); static void a_fetch_vv(cmp_op_info *, int, struct intermediates *);
STATIC_PROTO(void a_fetch_cv, (cmp_op_info *, int, struct intermediates *)); static void a_fetch_cv(cmp_op_info *, int, struct intermediates *);
STATIC_PROTO(void a_fetch_vc, (cmp_op_info *, int, struct intermediates *)); static void a_fetch_vc(cmp_op_info *, int, struct intermediates *);
STATIC_PROTO(yamop *a_f2, (cmp_op_info *, yamop *, int, struct intermediates *)); static yamop *a_f2(cmp_op_info *, yamop *, int, struct intermediates *);
#define CELLSIZE sizeof(CELL) #define CELLSIZE sizeof(CELL)

6
C/analyst.c
View File

@ -31,9 +31,9 @@ static char SccsId[] = "%W% %G%";
STATIC_PROTO(Int p_reset_op_counters, (void)); static Int p_reset_op_counters(void);
STATIC_PROTO(Int p_show_op_counters, (void)); static Int p_show_op_counters(void);
STATIC_PROTO(Int p_show_ops_by_group, (void)); static Int p_show_ops_by_group(void);
static Int static Int
p_reset_op_counters() p_reset_op_counters()

24
C/arrays.c
View File

@ -34,9 +34,9 @@ extern int errno;
#endif #endif
#endif #endif
STATIC_PROTO(Int p_compile_array_refs, ( USES_REGS1 )); static Int p_compile_array_refs( USES_REGS1 );
STATIC_PROTO(Int p_array_refs_compiled, ( USES_REGS1 )); static Int p_array_refs_compiled( USES_REGS1 );
STATIC_PROTO(Int p_sync_mmapped_arrays, ( USES_REGS1 )); static Int p_sync_mmapped_arrays( USES_REGS1 );
/* /*
* *
@ -122,15 +122,15 @@ STATIC_PROTO(Int p_sync_mmapped_arrays, ( USES_REGS1 ));
* *
*/ */
STATIC_PROTO(Int p_create_array, ( USES_REGS1 )); static Int p_create_array( USES_REGS1 );
STATIC_PROTO(Int p_create_mmapped_array, ( USES_REGS1 )); static Int p_create_mmapped_array( USES_REGS1 );
STATIC_PROTO(Int p_array_references, ( USES_REGS1 )); static Int p_array_references( USES_REGS1 );
STATIC_PROTO(Int p_create_static_array, ( USES_REGS1 )); static Int p_create_static_array( USES_REGS1 );
STATIC_PROTO(Int p_resize_static_array, ( USES_REGS1 )); static Int p_resize_static_array( USES_REGS1 );
STATIC_PROTO(Int p_close_static_array, ( USES_REGS1 )); static Int p_close_static_array( USES_REGS1 );
STATIC_PROTO(Int p_access_array, ( USES_REGS1 )); static Int p_access_array( USES_REGS1 );
STATIC_PROTO(Int p_assign_static, ( USES_REGS1 )); static Int p_assign_static( USES_REGS1 );
STATIC_PROTO(Int p_assign_dynamic, ( USES_REGS1 )); static Int p_assign_dynamic( USES_REGS1 );
#if HAVE_MMAP #if HAVE_MMAP

376
C/c_interface.c
View File

@ -377,196 +377,196 @@
#define X_API #define X_API
#endif #endif
X_API Term STD_PROTO(YAP_A,(int)); X_API Term YAP_A(int);
X_API Term STD_PROTO(YAP_Deref,(Term)); X_API Term YAP_Deref(Term);
X_API Term STD_PROTO(YAP_MkVarTerm,(void)); X_API Term YAP_MkVarTerm(void);
X_API Bool STD_PROTO(YAP_IsVarTerm,(Term)); X_API Bool YAP_IsVarTerm(Term);
X_API Bool STD_PROTO(YAP_IsNonVarTerm,(Term)); X_API Bool YAP_IsNonVarTerm(Term);
X_API Bool STD_PROTO(YAP_IsIntTerm,(Term)); X_API Bool YAP_IsIntTerm(Term);
X_API Bool STD_PROTO(YAP_IsLongIntTerm,(Term)); X_API Bool YAP_IsLongIntTerm(Term);
X_API Bool STD_PROTO(YAP_IsBigNumTerm,(Term)); X_API Bool YAP_IsBigNumTerm(Term);
X_API Bool STD_PROTO(YAP_IsNumberTerm,(Term)); X_API Bool YAP_IsNumberTerm(Term);
X_API Bool STD_PROTO(YAP_IsRationalTerm,(Term)); X_API Bool YAP_IsRationalTerm(Term);
X_API Bool STD_PROTO(YAP_IsFloatTerm,(Term)); X_API Bool YAP_IsFloatTerm(Term);
X_API Bool STD_PROTO(YAP_IsDbRefTerm,(Term)); X_API Bool YAP_IsDbRefTerm(Term);
X_API Bool STD_PROTO(YAP_IsAtomTerm,(Term)); X_API Bool YAP_IsAtomTerm(Term);
X_API Bool STD_PROTO(YAP_IsPairTerm,(Term)); X_API Bool YAP_IsPairTerm(Term);
X_API Bool STD_PROTO(YAP_IsApplTerm,(Term)); X_API Bool YAP_IsApplTerm(Term);
X_API Bool STD_PROTO(YAP_IsCompoundTerm,(Term)); X_API Bool YAP_IsCompoundTerm(Term);
X_API Bool STD_PROTO(YAP_IsExternalDataInStackTerm,(Term)); X_API Bool YAP_IsExternalDataInStackTerm(Term);
X_API Bool STD_PROTO(YAP_IsOpaqueObjectTerm,(Term, int)); X_API Bool YAP_IsOpaqueObjectTerm(Term, int);
X_API Term STD_PROTO(YAP_MkIntTerm,(Int)); X_API Term YAP_MkIntTerm(Int);
X_API Term STD_PROTO(YAP_MkBigNumTerm,(void *)); X_API Term YAP_MkBigNumTerm(void *);
X_API Term STD_PROTO(YAP_MkRationalTerm,(void *)); X_API Term YAP_MkRationalTerm(void *);
X_API Int STD_PROTO(YAP_IntOfTerm,(Term)); X_API Int YAP_IntOfTerm(Term);
X_API void STD_PROTO(YAP_BigNumOfTerm,(Term, void *)); X_API void YAP_BigNumOfTerm(Term, void *);
X_API void STD_PROTO(YAP_RationalOfTerm,(Term, void *)); X_API void YAP_RationalOfTerm(Term, void *);
X_API Term STD_PROTO(YAP_MkFloatTerm,(flt)); X_API Term YAP_MkFloatTerm(flt);
X_API flt STD_PROTO(YAP_FloatOfTerm,(Term)); X_API flt YAP_FloatOfTerm(Term);
X_API Term STD_PROTO(YAP_MkAtomTerm,(Atom)); X_API Term YAP_MkAtomTerm(Atom);
X_API Atom STD_PROTO(YAP_AtomOfTerm,(Term)); X_API Atom YAP_AtomOfTerm(Term);
X_API Atom STD_PROTO(YAP_LookupAtom,(char *)); X_API Atom YAP_LookupAtom(char *);
X_API Atom STD_PROTO(YAP_LookupWideAtom,(wchar_t *)); X_API Atom YAP_LookupWideAtom(wchar_t *);
X_API size_t STD_PROTO(YAP_AtomNameLength,(Atom)); X_API size_t YAP_AtomNameLength(Atom);
X_API Atom STD_PROTO(YAP_FullLookupAtom,(char *)); X_API Atom YAP_FullLookupAtom(char *);
X_API int STD_PROTO(YAP_IsWideAtom,(Atom)); X_API int YAP_IsWideAtom(Atom);
X_API char *STD_PROTO(YAP_AtomName,(Atom)); X_API char *YAP_AtomName(Atom);
X_API wchar_t *STD_PROTO(YAP_WideAtomName,(Atom)); X_API wchar_t *YAP_WideAtomName(Atom);
X_API Term STD_PROTO(YAP_MkPairTerm,(Term,Term)); X_API Term YAP_MkPairTerm(Term,Term);
X_API Term STD_PROTO(YAP_MkListFromTerms,(Term *,Int)); X_API Term YAP_MkListFromTerms(Term *,Int);
X_API Term STD_PROTO(YAP_MkNewPairTerm,(void)); X_API Term YAP_MkNewPairTerm(void);
X_API Term STD_PROTO(YAP_HeadOfTerm,(Term)); X_API Term YAP_HeadOfTerm(Term);
X_API Term STD_PROTO(YAP_TailOfTerm,(Term)); X_API Term YAP_TailOfTerm(Term);
X_API Int STD_PROTO(YAP_SkipList,(Term *, Term **)); X_API Int YAP_SkipList(Term *, Term **);
X_API Term STD_PROTO(YAP_MkApplTerm,(Functor,UInt,Term *)); X_API Term YAP_MkApplTerm(Functor,UInt,Term *);
X_API Term STD_PROTO(YAP_MkNewApplTerm,(Functor,UInt)); X_API Term YAP_MkNewApplTerm(Functor,UInt);
X_API Functor STD_PROTO(YAP_FunctorOfTerm,(Term)); X_API Functor YAP_FunctorOfTerm(Term);
X_API Term STD_PROTO(YAP_ArgOfTerm,(Int,Term)); X_API Term YAP_ArgOfTerm(Int,Term);
X_API Term *STD_PROTO(YAP_ArgsOfTerm,(Term)); X_API Term *YAP_ArgsOfTerm(Term);
X_API Functor STD_PROTO(YAP_MkFunctor,(Atom,Int)); X_API Functor YAP_MkFunctor(Atom,Int);
X_API Atom STD_PROTO(YAP_NameOfFunctor,(Functor)); X_API Atom YAP_NameOfFunctor(Functor);
X_API Int STD_PROTO(YAP_ArityOfFunctor,(Functor)); X_API Int YAP_ArityOfFunctor(Functor);
X_API void *STD_PROTO(YAP_ExtraSpace,(void)); X_API void *YAP_ExtraSpace(void);
X_API void STD_PROTO(YAP_cut_up,(void)); X_API void YAP_cut_up(void);
X_API Int STD_PROTO(YAP_Unify,(Term,Term)); X_API Int YAP_Unify(Term,Term);
X_API int STD_PROTO(YAP_Unifiable,(Term,Term)); X_API int YAP_Unifiable(Term,Term);
X_API int STD_PROTO(YAP_Reset,(void)); X_API int YAP_Reset(void);
X_API Int STD_PROTO(YAP_ListLength,(Term)); X_API Int YAP_ListLength(Term);
X_API Int STD_PROTO(YAP_Init,(YAP_init_args *)); X_API Int YAP_Init(YAP_init_args *);
X_API Int STD_PROTO(YAP_FastInit,(char *)); X_API Int YAP_FastInit(char *);
X_API PredEntry *STD_PROTO(YAP_FunctorToPred,(Functor)); X_API PredEntry *YAP_FunctorToPred(Functor);
X_API PredEntry *STD_PROTO(YAP_AtomToPred,(Atom)); X_API PredEntry *YAP_AtomToPred(Atom);
X_API PredEntry *STD_PROTO(YAP_FunctorToPredInModule,(Functor, Term)); X_API PredEntry *YAP_FunctorToPredInModule(Functor, Term);
X_API PredEntry *STD_PROTO(YAP_AtomToPredInModule,(Atom, Term)); X_API PredEntry *YAP_AtomToPredInModule(Atom, Term);
X_API Int STD_PROTO(YAP_CallProlog,(Term)); X_API Int YAP_CallProlog(Term);
X_API void *STD_PROTO(YAP_AllocSpaceFromYap,(size_t)); X_API void *YAP_AllocSpaceFromYap(size_t);
X_API void *STD_PROTO(YAP_ReallocSpaceFromYap,(void*,size_t)); X_API void *YAP_ReallocSpaceFromYap(void*,size_t);
X_API void STD_PROTO(YAP_FreeSpaceFromYap,(void *)); X_API void YAP_FreeSpaceFromYap(void *);
X_API int STD_PROTO(YAP_StringToBuffer, (Term, char *, unsigned int)); X_API int YAP_StringToBuffer(Term, char *, unsigned int);
X_API Term STD_PROTO(YAP_ReadBuffer, (char *,Term *)); X_API Term YAP_ReadBuffer(char *,Term *);
X_API Term STD_PROTO(YAP_FloatsToList, (double *, size_t)); X_API Term YAP_FloatsToList(double *, size_t);
X_API Int STD_PROTO(YAP_ListToFloats, (Term, double *, size_t)); X_API Int YAP_ListToFloats(Term, double *, size_t);
X_API Term STD_PROTO(YAP_IntsToList, (Int *, size_t)); X_API Term YAP_IntsToList(Int *, size_t);
X_API Int STD_PROTO(YAP_ListToInts, (Term, Int *, size_t)); X_API Int YAP_ListToInts(Term, Int *, size_t);
X_API Term STD_PROTO(YAP_BufferToString, (char *)); X_API Term YAP_BufferToString(char *);
X_API Term STD_PROTO(YAP_NBufferToString, (char *, size_t)); X_API Term YAP_NBufferToString(char *, size_t);
X_API Term STD_PROTO(YAP_WideBufferToString, (wchar_t *)); X_API Term YAP_WideBufferToString(wchar_t *);
X_API Term STD_PROTO(YAP_NWideBufferToString, (wchar_t *, size_t)); X_API Term YAP_NWideBufferToString(wchar_t *, size_t);
X_API Term STD_PROTO(YAP_BufferToAtomList, (char *)); X_API Term YAP_BufferToAtomList(char *);
X_API Term STD_PROTO(YAP_NBufferToAtomList, (char *,size_t)); X_API Term YAP_NBufferToAtomList(char *,size_t);
X_API Term STD_PROTO(YAP_WideBufferToAtomList, (wchar_t *)); X_API Term YAP_WideBufferToAtomList(wchar_t *);
X_API Term STD_PROTO(YAP_NWideBufferToAtomList, (wchar_t *, size_t)); X_API Term YAP_NWideBufferToAtomList(wchar_t *, size_t);
X_API Term STD_PROTO(YAP_NWideBufferToAtomDiffList, (wchar_t *, Term, size_t)); X_API Term YAP_NWideBufferToAtomDiffList(wchar_t *, Term, size_t);
X_API Term STD_PROTO(YAP_BufferToDiffList, (char *, Term)); X_API Term YAP_BufferToDiffList(char *, Term);
X_API Term STD_PROTO(YAP_NBufferToDiffList, (char *, Term, size_t)); X_API Term YAP_NBufferToDiffList(char *, Term, size_t);
X_API Term STD_PROTO(YAP_WideBufferToDiffList, (wchar_t *, Term)); X_API Term YAP_WideBufferToDiffList(wchar_t *, Term);
X_API Term STD_PROTO(YAP_NWideBufferToDiffList, (wchar_t *, Term, size_t)); X_API Term YAP_NWideBufferToDiffList(wchar_t *, Term, size_t);
X_API void STD_PROTO(YAP_Error,(int, Term, char *, ...)); X_API void YAP_Error(int, Term, char *, ...);
X_API Int STD_PROTO(YAP_RunPredicate,(PredEntry *, Term *)); X_API Int YAP_RunPredicate(PredEntry *, Term *);
X_API Int STD_PROTO(YAP_RunGoal,(Term)); X_API Int YAP_RunGoal(Term);
X_API Int STD_PROTO(YAP_RunGoalOnce,(Term)); X_API Int YAP_RunGoalOnce(Term);
X_API int STD_PROTO(YAP_RestartGoal,(void)); X_API int YAP_RestartGoal(void);
X_API int STD_PROTO(YAP_ShutdownGoal,(int)); X_API int YAP_ShutdownGoal(int);
X_API int STD_PROTO(YAP_EnterGoal,(PredEntry *, Term *, YAP_dogoalinfo *)); X_API int YAP_EnterGoal(PredEntry *, Term *, YAP_dogoalinfo *);
X_API int STD_PROTO(YAP_RetryGoal,(YAP_dogoalinfo *)); X_API int YAP_RetryGoal(YAP_dogoalinfo *);
X_API int STD_PROTO(YAP_LeaveGoal,(int, YAP_dogoalinfo *)); X_API int YAP_LeaveGoal(int, YAP_dogoalinfo *);
X_API int STD_PROTO(YAP_GoalHasException,(Term *)); X_API int YAP_GoalHasException(Term *);
X_API void STD_PROTO(YAP_ClearExceptions,(void)); X_API void YAP_ClearExceptions(void);
X_API int STD_PROTO(YAP_ContinueGoal,(void)); X_API int YAP_ContinueGoal(void);
X_API void STD_PROTO(YAP_PruneGoal,(YAP_dogoalinfo *)); X_API void YAP_PruneGoal(YAP_dogoalinfo *);
X_API IOSTREAM *STD_PROTO(YAP_TermToStream,(Term)); X_API IOSTREAM *YAP_TermToStream(Term);
X_API IOSTREAM *STD_PROTO(YAP_InitConsult,(int, char *)); X_API IOSTREAM *YAP_InitConsult(int, char *);
X_API void STD_PROTO(YAP_EndConsult,(IOSTREAM *)); X_API void YAP_EndConsult(IOSTREAM *);
X_API Term STD_PROTO(YAP_Read, (IOSTREAM *)); X_API Term YAP_Read(IOSTREAM *);
X_API void STD_PROTO(YAP_Write, (Term, IOSTREAM *, int)); X_API void YAP_Write(Term, IOSTREAM *, int);
X_API Term STD_PROTO(YAP_CopyTerm, (Term)); X_API Term YAP_CopyTerm(Term);
X_API int STD_PROTO(YAP_WriteBuffer, (Term, char *, size_t, int)); X_API int YAP_WriteBuffer(Term, char *, size_t, int);
X_API char *STD_PROTO(YAP_WriteDynamicBuffer, (Term, char *, size_t, size_t *, int *, int)); X_API char *YAP_WriteDynamicBuffer(Term, char *, size_t, size_t *, int *, int);
X_API char *STD_PROTO(YAP_CompileClause, (Term)); X_API char *YAP_CompileClause(Term);
X_API void STD_PROTO(YAP_PutValue, (Atom,Term)); X_API void YAP_PutValue(Atom,Term);
X_API Term STD_PROTO(YAP_GetValue, (Atom)); X_API Term YAP_GetValue(Atom);
X_API int STD_PROTO(YAP_CompareTerms, (Term,Term)); X_API int YAP_CompareTerms(Term,Term);
X_API void STD_PROTO(YAP_Exit, (int)); X_API void YAP_Exit(int);
X_API void STD_PROTO(YAP_InitSocks, (char *, long)); X_API void YAP_InitSocks(char *, long);
X_API void STD_PROTO(YAP_SetOutputMessage, (void)); X_API void YAP_SetOutputMessage(void);
X_API int STD_PROTO(YAP_StreamToFileNo, (Term)); X_API int YAP_StreamToFileNo(Term);
X_API void STD_PROTO(YAP_CloseAllOpenStreams,(void)); X_API void YAP_CloseAllOpenStreams(void);
X_API void STD_PROTO(YAP_FlushAllStreams,(void)); X_API void YAP_FlushAllStreams(void);
X_API Int STD_PROTO(YAP_CurrentSlot,(void)); X_API Int YAP_CurrentSlot(void);
X_API Int STD_PROTO(YAP_NewSlots,(int)); X_API Int YAP_NewSlots(int);
X_API Int STD_PROTO(YAP_InitSlot,(Term)); X_API Int YAP_InitSlot(Term);
X_API Term STD_PROTO(YAP_GetFromSlot,(Int)); X_API Term YAP_GetFromSlot(Int);
X_API Term *STD_PROTO(YAP_AddressFromSlot,(Int)); X_API Term *YAP_AddressFromSlot(Int);
X_API Term *STD_PROTO(YAP_AddressOfTermInSlot,(Int)); X_API Term *YAP_AddressOfTermInSlot(Int);
X_API void STD_PROTO(YAP_PutInSlot,(Int, Term)); X_API void YAP_PutInSlot(Int, Term);
X_API int STD_PROTO(YAP_RecoverSlots,(int)); X_API int YAP_RecoverSlots(int);
X_API Int STD_PROTO(YAP_ArgsToSlots,(int)); X_API Int YAP_ArgsToSlots(int);
X_API void STD_PROTO(YAP_SlotsToArgs,(int, Int)); X_API void YAP_SlotsToArgs(int, Int);
X_API void STD_PROTO(YAP_Throw,(Term)); X_API void YAP_Throw(Term);
X_API void STD_PROTO(YAP_AsyncThrow,(Term)); X_API void YAP_AsyncThrow(Term);
X_API void STD_PROTO(YAP_Halt,(int)); X_API void YAP_Halt(int);
X_API Term *STD_PROTO(YAP_TopOfLocalStack,(void)); X_API Term *YAP_TopOfLocalStack(void);
X_API void *STD_PROTO(YAP_Predicate,(Atom,UInt,Term)); X_API void *YAP_Predicate(Atom,UInt,Term);
X_API void STD_PROTO(YAP_PredicateInfo,(void *,Atom *,UInt *,Term *)); X_API void YAP_PredicateInfo(void *,Atom *,UInt *,Term *);
X_API void STD_PROTO(YAP_UserCPredicate,(char *,CPredicate,UInt)); X_API void YAP_UserCPredicate(char *,CPredicate,UInt);
X_API void STD_PROTO(YAP_UserBackCPredicate,(char *,CPredicate,CPredicate,UInt,unsigned int)); X_API void YAP_UserBackCPredicate(char *,CPredicate,CPredicate,UInt,unsigned int);
X_API void STD_PROTO(YAP_UserCPredicateWithArgs,(char *,CPredicate,UInt,Term)); X_API void YAP_UserCPredicateWithArgs(char *,CPredicate,UInt,Term);
#ifdef CUT_C #ifdef CUT_C
X_API void STD_PROTO(YAP_UserBackCutCPredicate,(char *,CPredicate,CPredicate,CPredicate,UInt,unsigned int)); X_API void YAP_UserBackCutCPredicate(char *,CPredicate,CPredicate,CPredicate,UInt,unsigned int);
X_API void *STD_PROTO(YAP_ExtraSpaceCut,(void)); X_API void *YAP_ExtraSpaceCut(void);
#endif #endif
X_API Term STD_PROTO(YAP_SetCurrentModule,(Term)); X_API Term YAP_SetCurrentModule(Term);
X_API Term STD_PROTO(YAP_CurrentModule,(void)); X_API Term YAP_CurrentModule(void);
X_API Term STD_PROTO(YAP_CreateModule,(Atom)); X_API Term YAP_CreateModule(Atom);
X_API Term STD_PROTO(YAP_StripModule,(Term, Term *)); X_API Term YAP_StripModule(Term, Term *);
X_API int STD_PROTO(YAP_ThreadSelf,(void)); X_API int YAP_ThreadSelf(void);
X_API int STD_PROTO(YAP_ThreadCreateEngine,(struct thread_attr_struct *)); X_API int YAP_ThreadCreateEngine(struct thread_attr_struct *);
X_API int STD_PROTO(YAP_ThreadAttachEngine,(int)); X_API int YAP_ThreadAttachEngine(int);
X_API int STD_PROTO(YAP_ThreadDetachEngine,(int)); X_API int YAP_ThreadDetachEngine(int);
X_API int STD_PROTO(YAP_ThreadDestroyEngine,(int)); X_API int YAP_ThreadDestroyEngine(int);
X_API Term STD_PROTO(YAP_MkBlobTerm,(unsigned int)); X_API Term YAP_MkBlobTerm(unsigned int);
X_API void *STD_PROTO(YAP_BlobOfTerm,(Term)); X_API void *YAP_BlobOfTerm(Term);
X_API Term STD_PROTO(YAP_TermNil,(void)); X_API Term YAP_TermNil(void);
X_API int STD_PROTO(YAP_IsTermNil,(Term)); X_API int YAP_IsTermNil(Term);
X_API int STD_PROTO(YAP_AtomGetHold,(Atom)); X_API int YAP_AtomGetHold(Atom);
X_API int STD_PROTO(YAP_AtomReleaseHold,(Atom)); X_API int YAP_AtomReleaseHold(Atom);
X_API Agc_hook STD_PROTO(YAP_AGCRegisterHook,(Agc_hook)); X_API Agc_hook YAP_AGCRegisterHook(Agc_hook);
X_API int STD_PROTO(YAP_HaltRegisterHook,(HaltHookFunc, void *)); X_API int YAP_HaltRegisterHook(HaltHookFunc, void *);
X_API char *STD_PROTO(YAP_cwd,(void)); X_API char *YAP_cwd(void);
X_API Term STD_PROTO(YAP_OpenList,(int)); X_API Term YAP_OpenList(int);
X_API Term STD_PROTO(YAP_ExtendList,(Term, Term)); X_API Term YAP_ExtendList(Term, Term);
X_API int STD_PROTO(YAP_CloseList,(Term, Term)); X_API int YAP_CloseList(Term, Term);
X_API int STD_PROTO(YAP_IsAttVar,(Term)); X_API int YAP_IsAttVar(Term);
X_API Term STD_PROTO(YAP_AttsOfVar,(Term)); X_API Term YAP_AttsOfVar(Term);
X_API int STD_PROTO(YAP_FileNoFromStream,(Term)); X_API int YAP_FileNoFromStream(Term);
X_API void *STD_PROTO(YAP_FileDescriptorFromStream,(Term)); X_API void *YAP_FileDescriptorFromStream(Term);
X_API void *STD_PROTO(YAP_Record,(Term)); X_API void *YAP_Record(Term);
X_API Term STD_PROTO(YAP_Recorded,(void *)); X_API Term YAP_Recorded(void *);
X_API int STD_PROTO(YAP_Erase,(void *)); X_API int YAP_Erase(void *);
X_API int STD_PROTO(YAP_Variant,(Term, Term)); X_API int YAP_Variant(Term, Term);
X_API Int STD_PROTO(YAP_NumberVars,(Term, Int)); X_API Int YAP_NumberVars(Term, Int);
X_API Term STD_PROTO(YAP_UnNumberVars,(Term)); X_API Term YAP_UnNumberVars(Term);
X_API int STD_PROTO(YAP_IsNumberedVariable,(Term)); X_API int YAP_IsNumberedVariable(Term);
X_API int STD_PROTO(YAP_ExactlyEqual,(Term, Term)); X_API int YAP_ExactlyEqual(Term, Term);
X_API Int STD_PROTO(YAP_TermHash,(Term, Int, Int, int)); X_API Int YAP_TermHash(Term, Int, Int, int);
X_API void STD_PROTO(YAP_signal,(int)); X_API void YAP_signal(int);
X_API int STD_PROTO(YAP_SetYAPFlag,(yap_flag_t, int)); X_API int YAP_SetYAPFlag(yap_flag_t, int);
X_API Int STD_PROTO(YAP_VarSlotToNumber,(Int)); X_API Int YAP_VarSlotToNumber(Int);
X_API Term STD_PROTO(YAP_ModuleUser,(void)); X_API Term YAP_ModuleUser(void);
X_API Int STD_PROTO(YAP_NumberOfClausesForPredicate,(PredEntry *)); X_API Int YAP_NumberOfClausesForPredicate(PredEntry *);
X_API int STD_PROTO(YAP_MaxOpPriority,(Atom, Term)); X_API int YAP_MaxOpPriority(Atom, Term);
X_API int STD_PROTO(YAP_OpInfo,(Atom, Term, int, int *, int *)); X_API int YAP_OpInfo(Atom, Term, int, int *, int *);
X_API Term STD_PROTO(YAP_AllocExternalDataInStack,(size_t)); X_API Term YAP_AllocExternalDataInStack(size_t);
X_API void *STD_PROTO(YAP_ExternalDataInStackFromTerm,(Term)); X_API void *YAP_ExternalDataInStackFromTerm(Term);
X_API int STD_PROTO(YAP_NewOpaqueType,(void *)); X_API int YAP_NewOpaqueType(void *);
X_API Term STD_PROTO(YAP_NewOpaqueObject,(int, size_t)); X_API Term YAP_NewOpaqueObject(int, size_t);
X_API void *STD_PROTO(YAP_OpaqueObjectFromTerm,(Term)); X_API void *YAP_OpaqueObjectFromTerm(Term);
X_API int STD_PROTO(YAP_Argv,(char *** argvp)); X_API int YAP_Argv(char *** argvp);
X_API YAP_tag_t STD_PROTO(YAP_TagOfTerm,(Term)); X_API YAP_tag_t YAP_TagOfTerm(Term);
X_API size_t STD_PROTO(YAP_ExportTerm,(Term, char *, size_t)); X_API size_t YAP_ExportTerm(Term, char *, size_t);
X_API size_t STD_PROTO(YAP_SizeOfExportedTerm,(char *)); X_API size_t YAP_SizeOfExportedTerm(char *);
X_API Term STD_PROTO(YAP_ImportTerm,(char *)); X_API Term YAP_ImportTerm(char *);
X_API int STD_PROTO(YAP_RequiresExtraStack,(size_t)); X_API int YAP_RequiresExtraStack(size_t);
static UInt static UInt
current_arity(void) current_arity(void)

90
C/cdmgr.c
View File

@ -473,53 +473,53 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
#endif #endif
STATIC_PROTO(void retract_all, (PredEntry *, int)); static void retract_all(PredEntry *, int);
STATIC_PROTO(void add_first_static, (PredEntry *, yamop *, int)); static void add_first_static(PredEntry *, yamop *, int);
STATIC_PROTO(void add_first_dynamic, (PredEntry *, yamop *, int)); static void add_first_dynamic(PredEntry *, yamop *, int);
STATIC_PROTO(void asserta_stat_clause, (PredEntry *, yamop *, int)); static void asserta_stat_clause(PredEntry *, yamop *, int);
STATIC_PROTO(void asserta_dynam_clause, (PredEntry *, yamop *)); static void asserta_dynam_clause(PredEntry *, yamop *);
STATIC_PROTO(void assertz_stat_clause, (PredEntry *, yamop *, int)); static void assertz_stat_clause(PredEntry *, yamop *, int);
STATIC_PROTO(void assertz_dynam_clause, (PredEntry *, yamop *)); static void assertz_dynam_clause(PredEntry *, yamop *);
STATIC_PROTO(void expand_consult, ( void )); static void expand_consult( void );
STATIC_PROTO(int not_was_reconsulted, (PredEntry *, Term, int)); static int not_was_reconsulted(PredEntry *, Term, int);
STATIC_PROTO(int RemoveIndexation, (PredEntry *)); static int RemoveIndexation(PredEntry *);
STATIC_PROTO(int static_in_use, (PredEntry *, int)); static int static_in_use(PredEntry *, int);
#if !defined(YAPOR) && !defined(THREADS) #if !defined(YAPOR) && !defined(THREADS)
STATIC_PROTO(Int search_for_static_predicate_in_use, (PredEntry *, int)); static Int search_for_static_predicate_in_use(PredEntry *, int);
STATIC_PROTO(void mark_pred, (int, PredEntry *)); static void mark_pred(int, PredEntry *);
STATIC_PROTO(void do_toggle_static_predicates_in_use, (int)); static void do_toggle_static_predicates_in_use(int);
#endif #endif
STATIC_PROTO(Int p_number_of_clauses, ( USES_REGS1 )); static Int p_number_of_clauses( USES_REGS1 );
STATIC_PROTO(Int p_compile, ( USES_REGS1 )); static Int p_compile( USES_REGS1 );
STATIC_PROTO(Int p_compile_dynamic, ( USES_REGS1 )); static Int p_compile_dynamic( USES_REGS1 );
STATIC_PROTO(Int p_purge_clauses, ( USES_REGS1 )); static Int p_purge_clauses( USES_REGS1 );
STATIC_PROTO(Int p_setspy, ( USES_REGS1 )); static Int p_setspy( USES_REGS1 );
STATIC_PROTO(Int p_rmspy, ( USES_REGS1 )); static Int p_rmspy( USES_REGS1 );
STATIC_PROTO(Int p_startconsult, ( USES_REGS1 )); static Int p_startconsult( USES_REGS1 );
STATIC_PROTO(Int p_showconslultlev, ( USES_REGS1 )); static Int p_showconslultlev( USES_REGS1 );
STATIC_PROTO(Int p_endconsult, ( USES_REGS1 )); static Int p_endconsult( USES_REGS1 );
STATIC_PROTO(Int p_undefined, ( USES_REGS1 )); static Int p_undefined( USES_REGS1 );
STATIC_PROTO(Int p_in_use, ( USES_REGS1 )); static Int p_in_use( USES_REGS1 );
STATIC_PROTO(Int p_new_multifile, ( USES_REGS1 )); static Int p_new_multifile( USES_REGS1 );
STATIC_PROTO(Int p_is_multifile, ( USES_REGS1 )); static Int p_is_multifile( USES_REGS1 );
STATIC_PROTO(Int p_optimizer_on, ( USES_REGS1 )); static Int p_optimizer_on( USES_REGS1 );
STATIC_PROTO(Int p_optimizer_off, ( USES_REGS1 )); static Int p_optimizer_off( USES_REGS1 );
STATIC_PROTO(Int p_is_dynamic, ( USES_REGS1 )); static Int p_is_dynamic( USES_REGS1 );
STATIC_PROTO(Int p_kill_dynamic, ( USES_REGS1 )); static Int p_kill_dynamic( USES_REGS1 );
STATIC_PROTO(Int p_compile_mode, ( USES_REGS1 )); static Int p_compile_mode( USES_REGS1 );
STATIC_PROTO(Int p_is_profiled, ( USES_REGS1 )); static Int p_is_profiled( USES_REGS1 );
STATIC_PROTO(Int p_profile_info, ( USES_REGS1 )); static Int p_profile_info( USES_REGS1 );
STATIC_PROTO(Int p_profile_reset, ( USES_REGS1 )); static Int p_profile_reset( USES_REGS1 );
STATIC_PROTO(Int p_is_call_counted, ( USES_REGS1 )); static Int p_is_call_counted( USES_REGS1 );
STATIC_PROTO(Int p_call_count_info, ( USES_REGS1 )); static Int p_call_count_info( USES_REGS1 );
STATIC_PROTO(Int p_call_count_set, ( USES_REGS1 )); static Int p_call_count_set( USES_REGS1 );
STATIC_PROTO(Int p_call_count_reset, ( USES_REGS1 )); static Int p_call_count_reset( USES_REGS1 );
STATIC_PROTO(Int p_toggle_static_predicates_in_use, ( USES_REGS1 )); static Int p_toggle_static_predicates_in_use( USES_REGS1 );
STATIC_PROTO(Atom YapConsultingFile, ( USES_REGS1 )); static Atom YapConsultingFile( USES_REGS1 );
STATIC_PROTO(Int PredForCode,(yamop *, Atom *, UInt *, Term *)); static Int PredForCode(yamop *, Atom *, UInt *, Term *);
STATIC_PROTO(void kill_first_log_iblock,(LogUpdIndex *, LogUpdIndex *, PredEntry *)); static void kill_first_log_iblock(LogUpdIndex *, LogUpdIndex *, PredEntry *);
STATIC_PROTO(LogUpdIndex *find_owner_log_index,(LogUpdIndex *, yamop *)); static LogUpdIndex *find_owner_log_index(LogUpdIndex *, yamop *);
STATIC_PROTO(StaticIndex *find_owner_static_index,(StaticIndex *, yamop *)); static StaticIndex *find_owner_static_index(StaticIndex *, yamop *);
#define PredArity(p) (p->ArityOfPE) #define PredArity(p) (p->ArityOfPE)
#define TRYCODE(G,F,N) ( (N)<5 ? (op_numbers)((int)F+(N)*3) : G) #define TRYCODE(G,F,N) ( (N)<5 ? (op_numbers)((int)F+(N)*3) : G)

28
C/cmppreds.c
View File

@ -27,20 +27,20 @@ static char SccsId[] = "%W% %G%";
#endif #endif
#include <wchar.h> #include <wchar.h>
STATIC_PROTO(Int compare, (Term, Term)); static Int compare(Term, Term);
STATIC_PROTO(Int p_compare, ( USES_REGS1 )); static Int p_compare( USES_REGS1 );
STATIC_PROTO(Int p_acomp, ( USES_REGS1 )); static Int p_acomp( USES_REGS1 );
STATIC_PROTO(Int a_eq, (Term,Term)); static Int a_eq(Term,Term);
STATIC_PROTO(Int a_dif, (Term,Term)); static Int a_dif(Term,Term);
STATIC_PROTO(Int a_gt, (Term, Term)); static Int a_gt(Term, Term);
STATIC_PROTO(Int a_ge, (Term,Term)); static Int a_ge(Term,Term);
STATIC_PROTO(Int a_lt, (Term,Term)); static Int a_lt(Term,Term);
STATIC_PROTO(Int a_le, (Term,Term)); static Int a_le(Term,Term);
STATIC_PROTO(Int a_noteq, (Term,Term)); static Int a_noteq(Term,Term);
STATIC_PROTO(Int a_gen_lt, (Term,Term)); static Int a_gen_lt(Term,Term);
STATIC_PROTO(Int a_gen_le, (Term,Term)); static Int a_gen_le(Term,Term);
STATIC_PROTO(Int a_gen_gt, (Term,Term)); static Int a_gen_gt(Term,Term);
STATIC_PROTO(Int a_gen_ge, (Term,Term)); static Int a_gen_ge(Term,Term);
#define rfloat(X) ( X > 0.0 ? 1 : ( X == 0.0 ? 0 : -1)) #define rfloat(X) ( X > 0.0 ? 1 : ( X == 0.0 ? 0 : -1))

50
C/compiler.c
View File

@ -224,35 +224,35 @@ typedef struct compiler_struct_struct {
CIntermediates cint; CIntermediates cint;
} compiler_struct; } compiler_struct;
STATIC_PROTO(int active_branch, (int, int)); static int active_branch(int, int);
STATIC_PROTO(void c_var, (Term, Int, unsigned int, unsigned int, compiler_struct *)); static void c_var(Term, Int, unsigned int, unsigned int, compiler_struct *);
STATIC_PROTO(void reset_vars, (Ventry *)); static void reset_vars(Ventry *);
STATIC_PROTO(Term optimize_ce, (Term, unsigned int, unsigned int, compiler_struct *)); static Term optimize_ce(Term, unsigned int, unsigned int, compiler_struct *);
STATIC_PROTO(void c_arg, (Int, Term, unsigned int, unsigned int, compiler_struct *)); static void c_arg(Int, Term, unsigned int, unsigned int, compiler_struct *);
STATIC_PROTO(void c_args, (Term, unsigned int, compiler_struct *)); static void c_args(Term, unsigned int, compiler_struct *);
STATIC_PROTO(void c_eq, (Term, Term, compiler_struct *)); static void c_eq(Term, Term, compiler_struct *);
STATIC_PROTO(void c_test, (Int, Term, compiler_struct *)); static void c_test(Int, Term, compiler_struct *);
STATIC_PROTO(void c_bifun, (basic_preds, Term, Term, Term, Term, Term, compiler_struct *)); static void c_bifun(basic_preds, Term, Term, Term, Term, Term, compiler_struct *);
STATIC_PROTO(void c_goal, (Term, Term, compiler_struct *)); static void c_goal(Term, Term, compiler_struct *);
STATIC_PROTO(void c_body, (Term, Term, compiler_struct *)); static void c_body(Term, Term, compiler_struct *);
STATIC_PROTO(void c_head, (Term, compiler_struct *)); static void c_head(Term, compiler_struct *);
STATIC_PROTO(int usesvar, (compiler_vm_op)); static int usesvar(compiler_vm_op);
STATIC_PROTO(CELL *init_bvarray, (int, compiler_struct *)); static CELL *init_bvarray(int, compiler_struct *);
#ifdef DEBUG #ifdef DEBUG
STATIC_PROTO(void clear_bvarray, (int, CELL *, compiler_struct *)); static void clear_bvarray(int, CELL *, compiler_struct *);
#else #else
STATIC_PROTO(void clear_bvarray, (int, CELL *)); static void clear_bvarray(int, CELL *);
#endif #endif
STATIC_PROTO(void add_bvarray_op, (PInstr *,CELL *, int, compiler_struct *)); static void add_bvarray_op(PInstr *,CELL *, int, compiler_struct *);
STATIC_PROTO(void AssignPerm, (PInstr *, compiler_struct *)); static void AssignPerm(PInstr *, compiler_struct *);
STATIC_PROTO(void CheckUnsafe, (PInstr *, compiler_struct *)); static void CheckUnsafe(PInstr *, compiler_struct *);
STATIC_PROTO(void CheckVoids, (compiler_struct *)); static void CheckVoids(compiler_struct *);
STATIC_PROTO( int checktemp, (Int, Int, compiler_vm_op, compiler_struct *)); static int checktemp(Int, Int, compiler_vm_op, compiler_struct *);
STATIC_PROTO( Int checkreg, (Int, Int, compiler_vm_op, int, compiler_struct *)); static Int checkreg(Int, Int, compiler_vm_op, int, compiler_struct *);
STATIC_PROTO(void c_layout, (compiler_struct *)); static void c_layout(compiler_struct *);
STATIC_PROTO(void c_optimize, (PInstr *)); static void c_optimize(PInstr *);
#ifdef SFUNC #ifdef SFUNC
STATIC_PROTO(void compile_sf_term, (Term, int)); static void compile_sf_term(Term, int);
#endif #endif
static void static void

2
C/computils.c
View File

@ -67,7 +67,7 @@ static char SccsId[] = "%W% %G%";
#endif #endif
#ifdef DEBUG #ifdef DEBUG
STATIC_PROTO (void ShowOp, (char *, struct PSEUDO *)); static void ShowOp(char *, struct PSEUDO *);
#endif /* DEBUG */ #endif /* DEBUG */
/* /*

118
C/dbase.c
View File

@ -174,70 +174,70 @@ typedef table {
} hash_db_table; } hash_db_table;
#endif #endif
STATIC_PROTO(CELL *cpcells,(CELL *,CELL*,Int)); static CELL *cpcells(CELL *,CELL*,Int);
STATIC_PROTO(void linkblk,(link_entry *,CELL *,CELL)); static void linkblk(link_entry *,CELL *,CELL);
STATIC_PROTO(Int cmpclls,(CELL *,CELL *,Int)); static Int cmpclls(CELL *,CELL *,Int);
STATIC_PROTO(Prop FindDBProp,(AtomEntry *, int, unsigned int, Term)); static Prop FindDBProp(AtomEntry *, int, unsigned int, Term);
STATIC_PROTO(CELL CalcKey, (Term)); static CELL CalcKey(Term);
#ifdef COROUTINING #ifdef COROUTINING
STATIC_PROTO(CELL *MkDBTerm, (CELL *, CELL *, CELL *, CELL *, CELL *, CELL *,int *, struct db_globs *)); static CELL *MkDBTerm(CELL *, CELL *, CELL *, CELL *, CELL *, CELL *,int *, struct db_globs *);
#else #else
STATIC_PROTO(CELL *MkDBTerm, (CELL *, CELL *, CELL *, CELL *, CELL *, int *, struct db_globs *)); static CELL *MkDBTerm(CELL *, CELL *, CELL *, CELL *, CELL *, int *, struct db_globs *);
#endif #endif
STATIC_PROTO(DBRef CreateDBStruct, (Term, DBProp, int, int *, UInt, struct db_globs *)); static DBRef CreateDBStruct(Term, DBProp, int, int *, UInt, struct db_globs *);
STATIC_PROTO(DBRef record, (int, Term, Term, Term CACHE_TYPE)); static DBRef record(int, Term, Term, Term CACHE_TYPE);
STATIC_PROTO(DBRef check_if_cons, (DBRef, Term)); static DBRef check_if_cons(DBRef, Term);
STATIC_PROTO(DBRef check_if_var, (DBRef)); static DBRef check_if_var(DBRef);
STATIC_PROTO(DBRef check_if_wvars, (DBRef, unsigned int, CELL *)); static DBRef check_if_wvars(DBRef, unsigned int, CELL *);
STATIC_PROTO(int scheckcells, (int, CELL *, CELL *, link_entry *, CELL)); static int scheckcells(int, CELL *, CELL *, link_entry *, CELL);
STATIC_PROTO(DBRef check_if_nvars, (DBRef, unsigned int, CELL *, struct db_globs *)); static DBRef check_if_nvars(DBRef, unsigned int, CELL *, struct db_globs *);
STATIC_PROTO(Int p_rcda, ( USES_REGS1 )); static Int p_rcda( USES_REGS1 );
STATIC_PROTO(Int p_rcdap, ( USES_REGS1 )); static Int p_rcdap( USES_REGS1 );
STATIC_PROTO(Int p_rcdz, ( USES_REGS1 )); static Int p_rcdz( USES_REGS1 );
STATIC_PROTO(Int p_rcdzp, ( USES_REGS1 )); static Int p_rcdzp( USES_REGS1 );
STATIC_PROTO(Int p_drcdap, ( USES_REGS1 )); static Int p_drcdap( USES_REGS1 );
STATIC_PROTO(Int p_drcdzp, ( USES_REGS1 )); static Int p_drcdzp( USES_REGS1 );
STATIC_PROTO(Term GetDBTerm, (DBTerm * CACHE_TYPE)); static Term GetDBTerm(DBTerm * CACHE_TYPE);
STATIC_PROTO(DBProp FetchDBPropFromKey, (Term, int, int, char *)); static DBProp FetchDBPropFromKey(Term, int, int, char *);
STATIC_PROTO(Int i_recorded, (DBProp,Term CACHE_TYPE)); static Int i_recorded(DBProp,Term CACHE_TYPE);
STATIC_PROTO(Int c_recorded, (int CACHE_TYPE)); static Int c_recorded(int CACHE_TYPE);
STATIC_PROTO(Int co_rded, ( USES_REGS1 )); static Int co_rded( USES_REGS1 );
STATIC_PROTO(Int in_rdedp, ( USES_REGS1 )); static Int in_rdedp( USES_REGS1 );
STATIC_PROTO(Int co_rdedp, ( USES_REGS1 )); static Int co_rdedp( USES_REGS1 );
STATIC_PROTO(Int p_first_instance, ( USES_REGS1 )); static Int p_first_instance( USES_REGS1 );
STATIC_PROTO(void ErasePendingRefs, (DBTerm * CACHE_TYPE)); static void ErasePendingRefs(DBTerm * CACHE_TYPE);
STATIC_PROTO(void RemoveDBEntry, (DBRef CACHE_TYPE)); static void RemoveDBEntry(DBRef CACHE_TYPE);
STATIC_PROTO(void EraseLogUpdCl, (LogUpdClause *)); static void EraseLogUpdCl(LogUpdClause *);
STATIC_PROTO(void MyEraseClause, (DynamicClause * CACHE_TYPE)); static void MyEraseClause(DynamicClause * CACHE_TYPE);
STATIC_PROTO(void PrepareToEraseClause, (DynamicClause *, DBRef)); static void PrepareToEraseClause(DynamicClause *, DBRef);
STATIC_PROTO(void EraseEntry, (DBRef)); static void EraseEntry(DBRef);
STATIC_PROTO(Int p_erase, ( USES_REGS1 )); static Int p_erase( USES_REGS1 );
STATIC_PROTO(Int p_eraseall, ( USES_REGS1 )); static Int p_eraseall( USES_REGS1 );
STATIC_PROTO(Int p_erased, ( USES_REGS1 )); static Int p_erased( USES_REGS1 );
STATIC_PROTO(Int p_instance, ( USES_REGS1 )); static Int p_instance( USES_REGS1 );
STATIC_PROTO(int NotActiveDB, (DBRef)); static int NotActiveDB(DBRef);
STATIC_PROTO(DBEntry *NextDBProp, (PropEntry *)); static DBEntry *NextDBProp(PropEntry *);
STATIC_PROTO(Int init_current_key, ( USES_REGS1 )); static Int init_current_key( USES_REGS1 );
STATIC_PROTO(Int cont_current_key, ( USES_REGS1 )); static Int cont_current_key( USES_REGS1 );
STATIC_PROTO(Int cont_current_key_integer, ( USES_REGS1 )); static Int cont_current_key_integer( USES_REGS1 );
STATIC_PROTO(Int p_rcdstatp, ( USES_REGS1 )); static Int p_rcdstatp( USES_REGS1 );
STATIC_PROTO(Int p_somercdedp, ( USES_REGS1 )); static Int p_somercdedp( USES_REGS1 );
STATIC_PROTO(yamop * find_next_clause, (DBRef USES_REGS)); static yamop * find_next_clause(DBRef USES_REGS);
STATIC_PROTO(Int p_jump_to_next_dynamic_clause, ( USES_REGS1 )); static Int p_jump_to_next_dynamic_clause( USES_REGS1 );
#ifdef SFUNC #ifdef SFUNC
STATIC_PROTO(void SFVarIn, (Term)); static void SFVarIn(Term);
STATIC_PROTO(void sf_include, (SFKeep *)); static void sf_include(SFKeep *);
#endif #endif
STATIC_PROTO(Int p_init_queue, ( USES_REGS1 )); static Int p_init_queue( USES_REGS1 );
STATIC_PROTO(Int p_enqueue, ( USES_REGS1 )); static Int p_enqueue( USES_REGS1 );
STATIC_PROTO(void keepdbrefs, (DBTerm * CACHE_TYPE)); static void keepdbrefs(DBTerm * CACHE_TYPE);
STATIC_PROTO(Int p_dequeue, ( USES_REGS1 )); static Int p_dequeue( USES_REGS1 );
STATIC_PROTO(void ErDBE, (DBRef CACHE_TYPE)); static void ErDBE(DBRef CACHE_TYPE);
STATIC_PROTO(void ReleaseTermFromDB, (DBTerm * CACHE_TYPE)); static void ReleaseTermFromDB(DBTerm * CACHE_TYPE);
STATIC_PROTO(PredEntry *new_lu_entry, (Term)); static PredEntry *new_lu_entry(Term);
STATIC_PROTO(PredEntry *new_lu_int_key, (Int)); static PredEntry *new_lu_int_key(Int);
STATIC_PROTO(PredEntry *find_lu_entry, (Term)); static PredEntry *find_lu_entry(Term);
STATIC_PROTO(DBProp find_int_key, (Int)); static DBProp find_int_key(Int);
#define db_check_trail(x) { \ #define db_check_trail(x) { \
if (Unsigned(dbg->tofref) == Unsigned(x)) { \ if (Unsigned(dbg->tofref) == Unsigned(x)) { \

4
C/depth_bound.c
View File

@ -29,8 +29,8 @@ static char SccsId[] = "%W% %G%";
#include "Yatom.h" #include "Yatom.h"
STD_PROTO(static Int p_get_depth_limit, ( USES_REGS1 )); static Int p_get_depth_limit( USES_REGS1 );
STD_PROTO(static Int p_set_depth_limit, ( USES_REGS1 )); static Int p_set_depth_limit( USES_REGS1 );
static Int p_get_depth_limit( USES_REGS1 ) static Int p_get_depth_limit( USES_REGS1 )
{ {

8
C/errors.c
View File

@ -41,10 +41,10 @@ Yap_RestartYap ( int flag )
} }
#ifdef DEBUG #ifdef DEBUG
STATIC_PROTO (int hidden, (Atom)); static int hidden(Atom);
STATIC_PROTO (int legal_env, (CELL * CACHE_TYPE)); static int legal_env(CELL * CACHE_TYPE);
void STD_PROTO (DumpActiveGoals, ( CACHE_TYPE1 )); void DumpActiveGoals( CACHE_TYPE1 );
STATIC_PROTO (void detect_bug_location, (yamop *,find_pred_type,char *, int)); static void detect_bug_location(yamop *,find_pred_type,char *, int);
#define ONHEAP(ptr) (CellPtr(ptr) >= CellPtr(Yap_HeapBase) && CellPtr(ptr) < CellPtr(HeapTop)) #define ONHEAP(ptr) (CellPtr(ptr) >= CellPtr(Yap_HeapBase) && CellPtr(ptr) < CellPtr(HeapTop))

10
C/exec.c
View File

@ -28,11 +28,11 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
#include "myddas.h" #include "myddas.h"
#endif #endif
STATIC_PROTO(Int CallPredicate, (PredEntry *, choiceptr, yamop * CACHE_TYPE)); static Int CallPredicate(PredEntry *, choiceptr, yamop * CACHE_TYPE);
STATIC_PROTO(Int EnterCreepMode, (Term, Term CACHE_TYPE)); static Int EnterCreepMode(Term, Term CACHE_TYPE);
STATIC_PROTO(Int p_save_cp, ( USES_REGS1 )); static Int p_save_cp( USES_REGS1 );
STATIC_PROTO(Int p_execute, ( USES_REGS1 )); static Int p_execute( USES_REGS1 );
STATIC_PROTO(Int p_execute0, ( USES_REGS1 )); static Int p_execute0( USES_REGS1 );
static int execute_pred(PredEntry *ppe, CELL *pt USES_REGS); static int execute_pred(PredEntry *ppe, CELL *pt USES_REGS);
static Term static Term

44
C/grow.c
View File

@ -44,30 +44,30 @@ typedef enum {
STATIC_PROTO(Int p_growheap, ( USES_REGS1 )); static Int p_growheap( USES_REGS1 );
STATIC_PROTO(Int p_growstack, ( USES_REGS1 )); static Int p_growstack( USES_REGS1 );
STATIC_PROTO(Int p_inform_trail_overflows, ( USES_REGS1 )); static Int p_inform_trail_overflows( USES_REGS1 );
STATIC_PROTO(Int p_inform_heap_overflows, ( USES_REGS1 )); static Int p_inform_heap_overflows( USES_REGS1 );
STATIC_PROTO(Int p_inform_stack_overflows, ( USES_REGS1 )); static Int p_inform_stack_overflows( USES_REGS1 );
/* #define undf7 */ /* #define undf7 */
/* #define undf5 */ /* #define undf5 */
STATIC_PROTO(int growstack, (long CACHE_TYPE)); static int growstack(size_t CACHE_TYPE);
STATIC_PROTO(void MoveGlobal, ( CACHE_TYPE1 )); static void MoveGlobal( CACHE_TYPE1 );
STATIC_PROTO(void MoveLocalAndTrail, ( CACHE_TYPE1 )); static void MoveLocalAndTrail( CACHE_TYPE1 );
STATIC_PROTO(void SetHeapRegs, (int CACHE_TYPE)); static void SetHeapRegs(int CACHE_TYPE);
STATIC_PROTO(void AdjustTrail, (int, int CACHE_TYPE)); static void AdjustTrail(int, int CACHE_TYPE);
STATIC_PROTO(void AdjustLocal, (int CACHE_TYPE)); static void AdjustLocal(int CACHE_TYPE);
STATIC_PROTO(void AdjustGlobal, (long, int CACHE_TYPE)); static void AdjustGlobal(long, int CACHE_TYPE);
STATIC_PROTO(void AdjustGrowStack, ( CACHE_TYPE1 )); static void AdjustGrowStack( CACHE_TYPE1 );
STATIC_PROTO(int static_growheap, (long,int,struct intermediates *,tr_fr_ptr *, TokEntry **, VarEntry ** CACHE_TYPE)); static int static_growheap(long,int,struct intermediates *,tr_fr_ptr *, TokEntry **, VarEntry ** CACHE_TYPE);
STATIC_PROTO(void cpcellsd, (CELL *, CELL *, CELL)); static void cpcellsd(CELL *, CELL *, CELL);
STATIC_PROTO(CELL AdjustAppl, (CELL CACHE_TYPE)); static CELL AdjustAppl(CELL CACHE_TYPE);
STATIC_PROTO(CELL AdjustPair, (CELL CACHE_TYPE)); static CELL AdjustPair(CELL CACHE_TYPE);
STATIC_PROTO(void AdjustStacksAndTrail, (long, int CACHE_TYPE)); static void AdjustStacksAndTrail(long, int CACHE_TYPE);
STATIC_PROTO(void AdjustRegs, (int CACHE_TYPE)); static void AdjustRegs(int CACHE_TYPE);
STATIC_PROTO(Term AdjustGlobTerm, (Term CACHE_TYPE)); static Term AdjustGlobTerm(Term CACHE_TYPE);
static void static void
LeaveGrowMode(prolog_exec_mode grow_mode) LeaveGrowMode(prolog_exec_mode grow_mode)
@ -1500,7 +1500,7 @@ Yap_InsertInGlobal(CELL *where, UInt howmuch)
int int
Yap_growstack(long size) Yap_growstack(size_t size)
{ {
CACHE_REGS CACHE_REGS
int res; int res;
@ -1616,7 +1616,7 @@ execute_growstack(long size0, int from_trail, int in_parser, tr_fr_ptr *old_trp,
/* Used by do_goal() when we're short of stack space */ /* Used by do_goal() when we're short of stack space */
static int static int
growstack(long size USES_REGS) growstack(size_t size USES_REGS)
{ {
UInt start_growth_time, growth_time; UInt start_growth_time, growth_time;
int gc_verbose; int gc_verbose;

44
C/heapgc.c
View File

@ -35,28 +35,28 @@ static char SccsId[] = "%W% %G%";
/* global variables for garbage collection */ /* global variables for garbage collection */
STATIC_PROTO(Int p_inform_gc, ( CACHE_TYPE1 )); static Int p_inform_gc( CACHE_TYPE1 );
STATIC_PROTO(Int p_gc, ( CACHE_TYPE1 )); static Int p_gc( CACHE_TYPE1 );
STATIC_PROTO(void marking_phase, (tr_fr_ptr, CELL *, yamop * CACHE_TYPE)); static void marking_phase(tr_fr_ptr, CELL *, yamop * CACHE_TYPE);
STATIC_PROTO(void compaction_phase, (tr_fr_ptr, CELL *, yamop * CACHE_TYPE)); static void compaction_phase(tr_fr_ptr, CELL *, yamop * CACHE_TYPE);
STATIC_PROTO(void init_dbtable, (tr_fr_ptr CACHE_TYPE)); static void init_dbtable(tr_fr_ptr CACHE_TYPE);
STATIC_PROTO(void mark_external_reference, (CELL * CACHE_TYPE)); static void mark_external_reference(CELL * CACHE_TYPE);
STATIC_PROTO(void mark_db_fixed, (CELL * CACHE_TYPE)); static void mark_db_fixed(CELL * CACHE_TYPE);
STATIC_PROTO(void mark_regs, (tr_fr_ptr CACHE_TYPE)); static void mark_regs(tr_fr_ptr CACHE_TYPE);
STATIC_PROTO(void mark_trail, (tr_fr_ptr, tr_fr_ptr, CELL *, choiceptr CACHE_TYPE)); static void mark_trail(tr_fr_ptr, tr_fr_ptr, CELL *, choiceptr CACHE_TYPE);
STATIC_PROTO(void mark_environments, (CELL *, OPREG, CELL * CACHE_TYPE)); static void mark_environments(CELL *, OPREG, CELL * CACHE_TYPE);
STATIC_PROTO(void mark_choicepoints, (choiceptr, tr_fr_ptr, int CACHE_TYPE)); static void mark_choicepoints(choiceptr, tr_fr_ptr, int CACHE_TYPE);
STATIC_PROTO(void into_relocation_chain, (CELL *, CELL * CACHE_TYPE)); static void into_relocation_chain(CELL *, CELL * CACHE_TYPE);
STATIC_PROTO(void sweep_trail, (choiceptr, tr_fr_ptr CACHE_TYPE)); static void sweep_trail(choiceptr, tr_fr_ptr CACHE_TYPE);
STATIC_PROTO(void sweep_environments, (CELL *, OPREG, CELL * CACHE_TYPE)); static void sweep_environments(CELL *, OPREG, CELL * CACHE_TYPE);
STATIC_PROTO(void sweep_choicepoints, (choiceptr CACHE_TYPE)); static void sweep_choicepoints(choiceptr CACHE_TYPE);
STATIC_PROTO(void compact_heap, ( CACHE_TYPE1 )); static void compact_heap( CACHE_TYPE1 );
STATIC_PROTO(void update_relocation_chain, (CELL *, CELL * CACHE_TYPE)); static void update_relocation_chain(CELL *, CELL * CACHE_TYPE);
STATIC_PROTO(int is_gc_verbose, (void)); static int is_gc_verbose(void);
STATIC_PROTO(int is_gc_very_verbose, (void)); static int is_gc_very_verbose(void);
STATIC_PROTO(void LeaveGCMode, ( CACHE_TYPE1 )); static void LeaveGCMode( CACHE_TYPE1 );
#ifdef EASY_SHUNTING #ifdef EASY_SHUNTING
STATIC_PROTO(void set_conditionals, (tr_fr_ptr CACHE_TYPE)); static void set_conditionals(tr_fr_ptr CACHE_TYPE);
#endif /* EASY_SHUNTING */ #endif /* EASY_SHUNTING */
#include "heapgc.h" #include "heapgc.h"
@ -1064,7 +1064,7 @@ inc_var(CELL *current, CELL *next)
} }
#endif /* INSTRUMENT_GC */ #endif /* INSTRUMENT_GC */
int STD_PROTO(vsc_stop,(void)); int vsc_stop(void);
int int
vsc_stop(void) { vsc_stop(void) {

8
C/index.c
View File

@ -502,10 +502,10 @@ static char SccsId[] = "%W% %G%";
#define SET_JLBL(X) #define SET_JLBL(X)
#endif #endif
UInt STATIC_PROTO(do_index, (ClauseDef *,ClauseDef *,struct intermediates *,UInt,UInt,int,int,CELL *)); static UInt do_index(ClauseDef *,ClauseDef *,struct intermediates *,UInt,UInt,int,int,CELL *);
UInt STATIC_PROTO(do_compound_index, (ClauseDef *,ClauseDef *,Term *t,struct intermediates *,UInt,UInt,UInt,UInt,int,int,int,CELL *,int)); static UInt do_compound_index(ClauseDef *,ClauseDef *,Term *t,struct intermediates *,UInt,UInt,UInt,UInt,int,int,int,CELL *,int);
UInt STATIC_PROTO(do_dbref_index, (ClauseDef *,ClauseDef *,Term,struct intermediates *,UInt,UInt,int,int,CELL *)); static UInt do_dbref_index(ClauseDef *,ClauseDef *,Term,struct intermediates *,UInt,UInt,int,int,CELL *);
UInt STATIC_PROTO(do_blob_index, (ClauseDef *,ClauseDef *,Term,struct intermediates *,UInt,UInt,int,int,CELL *,int)); static UInt do_blob_index(ClauseDef *,ClauseDef *,Term,struct intermediates *,UInt,UInt,int,int,CELL *,int);
static UInt static UInt
cleanup_sw_on_clauses(CELL larg, UInt sz, OPCODE ecls) cleanup_sw_on_clauses(CELL larg, UInt sz, OPCODE ecls)

22
C/init.c
View File

@ -62,22 +62,22 @@ static char SccsId[] = "%W% %G%";
int Yap_output_msg = FALSE; int Yap_output_msg = FALSE;
#ifdef MACC #ifdef MACC
STATIC_PROTO(void InTTYLine, (char *)); static void InTTYLine(char *);
#endif #endif
#endif #endif
STATIC_PROTO(void SetOp, (int, int, char *, Term)); static void SetOp(int, int, char *, Term);
STATIC_PROTO(void InitOps, (void)); static void InitOps(void);
STATIC_PROTO(void InitDebug, (void)); static void InitDebug(void);
#ifdef CUT_C #ifdef CUT_C
STATIC_PROTO(void CleanBack, (PredEntry *, CPredicate, CPredicate, CPredicate)); static void CleanBack(PredEntry *, CPredicate, CPredicate, CPredicate);
#else #else
STATIC_PROTO(void CleanBack, (PredEntry *, CPredicate, CPredicate)); static void CleanBack(PredEntry *, CPredicate, CPredicate);
#endif #endif
STATIC_PROTO(void InitStdPreds,(void)); static void InitStdPreds(void);
STATIC_PROTO(void InitFlags, (void)); static void InitFlags(void);
STATIC_PROTO(void InitCodes, (void)); static void InitCodes(void);
STATIC_PROTO(void InitVersion, (void)); static void InitVersion(void);
STD_PROTO(void exit, (int)); void exit(int);
static void InitWorker(int wid); static void InitWorker(int wid);

30
C/inlines.c
View File

@ -23,21 +23,21 @@
#include "cut_c.h" #include "cut_c.h"
#endif #endif
STATIC_PROTO(Int p_atom, ( USES_REGS1 )); static Int p_atom( USES_REGS1 );
STATIC_PROTO(Int p_atomic, ( USES_REGS1 )); static Int p_atomic( USES_REGS1 );
STATIC_PROTO(Int p_integer, ( USES_REGS1 )); static Int p_integer( USES_REGS1 );
STATIC_PROTO(Int p_nonvar, ( USES_REGS1 )); static Int p_nonvar( USES_REGS1 );
STATIC_PROTO(Int p_number, ( USES_REGS1 )); static Int p_number( USES_REGS1 );
STATIC_PROTO(Int p_var, ( USES_REGS1 )); static Int p_var( USES_REGS1 );
STATIC_PROTO(Int p_db_ref, ( USES_REGS1 )); static Int p_db_ref( USES_REGS1 );
STATIC_PROTO(Int p_primitive, ( USES_REGS1 )); static Int p_primitive( USES_REGS1 );
STATIC_PROTO(Int p_compound, ( USES_REGS1 )); static Int p_compound( USES_REGS1 );
STATIC_PROTO(Int p_float, ( USES_REGS1 )); static Int p_float( USES_REGS1 );
STATIC_PROTO(Int p_equal, ( USES_REGS1 )); static Int p_equal( USES_REGS1 );
STATIC_PROTO(Int p_dif, ( USES_REGS1 )); static Int p_dif( USES_REGS1 );
STATIC_PROTO(Int p_eq, ( USES_REGS1 )); static Int p_eq( USES_REGS1 );
STATIC_PROTO(Int p_arg, ( USES_REGS1 )); static Int p_arg( USES_REGS1 );
STATIC_PROTO(Int p_functor, ( USES_REGS1 )); static Int p_functor( USES_REGS1 );
static Int static Int

12
C/iopreds.c
View File

@ -84,12 +84,12 @@ static char SccsId[] = "%W% %G%";
#endif #endif
#include "iopreds.h" #include "iopreds.h"
STATIC_PROTO (Int p_set_read_error_handler, ( USES_REGS1 )); static Int p_set_read_error_handler( USES_REGS1 );
STATIC_PROTO (Int p_get_read_error_handler, ( USES_REGS1 )); static Int p_get_read_error_handler( USES_REGS1 );
STATIC_PROTO (Int p_read, ( USES_REGS1 )); static Int p_read( USES_REGS1 );
STATIC_PROTO (Int p_startline, ( USES_REGS1 )); static Int p_startline( USES_REGS1 );
STATIC_PROTO (Int p_change_type_of_char, ( USES_REGS1 )); static Int p_change_type_of_char( USES_REGS1 );
STATIC_PROTO (Int p_type_of_char, ( USES_REGS1 )); static Int p_type_of_char( USES_REGS1 );
extern Atom Yap_FileName(IOSTREAM *s); extern Atom Yap_FileName(IOSTREAM *s);

2
C/load_foreign.c
View File

@ -34,7 +34,7 @@ static char SccsId[] = "%W% %G%.2";
#endif #endif
#endif #endif
STD_PROTO(Int p_load_foreign, ( USES_REGS1 )); Int p_load_foreign( USES_REGS1 );
Int Int
p_load_foreign( USES_REGS1 ) p_load_foreign( USES_REGS1 )

2
C/load_shl.c
View File

@ -167,7 +167,7 @@ Yap_ReLoadForeign(StringList ofiles, StringList libs,
/* /*
dunno what this one is supposed to do, no load_* defines it dunno what this one is supposed to do, no load_* defines it
void STD_PROTO(ReOpenLoadForeign,(void)); void ReOpenLoadForeign(void);
*/ */
#endif #endif

10
C/mavar.c
View File

@ -23,11 +23,11 @@
#include "YapHeap.h" #include "YapHeap.h"
#include "eval.h" #include "eval.h"
STD_PROTO(static Int p_setarg, ( USES_REGS1 )); static Int p_setarg( USES_REGS1 );
STD_PROTO(static Int p_create_mutable, ( USES_REGS1 )); static Int p_create_mutable( USES_REGS1 );
STD_PROTO(static Int p_get_mutable, ( USES_REGS1 )); static Int p_get_mutable( USES_REGS1 );
STD_PROTO(static Int p_update_mutable, ( USES_REGS1 )); static Int p_update_mutable( USES_REGS1 );
STD_PROTO(static Int p_is_mutable, ( USES_REGS1 )); static Int p_is_mutable( USES_REGS1 );
static Int static Int
p_setarg( USES_REGS1 ) p_setarg( USES_REGS1 )

4
C/modules.c
View File

@ -22,8 +22,8 @@ static char SccsId[] = "%W% %G%";
#include "Yatom.h" #include "Yatom.h"
#include "YapHeap.h" #include "YapHeap.h"
STATIC_PROTO(Int p_current_module, ( USES_REGS1 )); static Int p_current_module( USES_REGS1 );
STATIC_PROTO(Int p_current_module1, ( USES_REGS1 )); static Int p_current_module1( USES_REGS1 );
inline static ModEntry * inline static ModEntry *

10
C/parser.c
View File

@ -68,11 +68,11 @@ typedef struct jmp_buff_struct {
sigjmp_buf JmpBuff; sigjmp_buf JmpBuff;
} JMPBUFF; } JMPBUFF;
STATIC_PROTO(void GNextToken, ( CACHE_TYPE1 )); static void GNextToken( CACHE_TYPE1 );
STATIC_PROTO(void checkfor, (Term, JMPBUFF * CACHE_TYPE)); static void checkfor(Term, JMPBUFF * CACHE_TYPE);
STATIC_PROTO(Term ParseArgs, (Atom, JMPBUFF * CACHE_TYPE)); static Term ParseArgs(Atom, JMPBUFF * CACHE_TYPE);
STATIC_PROTO(Term ParseList, (JMPBUFF * CACHE_TYPE)); static Term ParseList(JMPBUFF * CACHE_TYPE);
STATIC_PROTO(Term ParseTerm, (int, JMPBUFF * CACHE_TYPE)); static Term ParseTerm(int, JMPBUFF * CACHE_TYPE);
#define TRY(S,P) \ #define TRY(S,P) \

2
C/pl-yap.c
View File

@ -1212,7 +1212,7 @@ Yap_StreamPosition(IOSTREAM *st)
return StreamPosition(st); return StreamPosition(st);
} }
IOSTREAM *STD_PROTO(Yap_Scurin, (void)); IOSTREAM *Yap_Scurin(void);
IOSTREAM * IOSTREAM *
Yap_Scurin(void) Yap_Scurin(void)

4
C/qlyr.c
View File

@ -29,8 +29,8 @@
#include "qly.h" #include "qly.h"
STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS)); static void RestoreEntries(PropEntry *, int USES_REGS);
STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS)); static void CleanCode(PredEntry * USES_REGS);
typedef enum { typedef enum {
OUT_OF_TEMP_SPACE = 0, OUT_OF_TEMP_SPACE = 0,

4
C/qlyw.c
View File

@ -29,8 +29,8 @@
#include "qly.h" #include "qly.h"
STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS)); static void RestoreEntries(PropEntry *, int USES_REGS);
STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS)); static void CleanCode(PredEntry * USES_REGS);
static void static void
GrowAtomTable(void) { GrowAtomTable(void) {

88
C/save.c
View File

@ -85,55 +85,55 @@ void initIO(void);
#endif #endif
STATIC_PROTO(int myread, (int, char *, Int)); static int myread(int, char *, Int);
STATIC_PROTO(Int mywrite, (int, char *, Int)); static Int mywrite(int, char *, Int);
STATIC_PROTO(int open_file, (char *, int)); static int open_file(char *, int);
STATIC_PROTO(int close_file, (void)); static int close_file(void);
STATIC_PROTO(Int putout, (CELL)); static Int putout(CELL);
STATIC_PROTO(Int putcellptr, (CELL *)); static Int putcellptr(CELL *);
STATIC_PROTO(CELL get_cell, (void)); static CELL get_cell(void);
STATIC_PROTO(CELL *get_cellptr, ( /* CELL * */ void)); static CELL *get_cellptr( /* CELL * */ void);
STATIC_PROTO(int put_info, (int, int CACHE_TYPE)); static int put_info(int, int CACHE_TYPE);
STATIC_PROTO(int save_regs, (int CACHE_TYPE)); static int save_regs(int CACHE_TYPE);
STATIC_PROTO(int save_code_info, (void)); static int save_code_info(void);
STATIC_PROTO(int save_heap, (void)); static int save_heap(void);
STATIC_PROTO(int save_stacks, (int CACHE_TYPE)); static int save_stacks(int CACHE_TYPE);
STATIC_PROTO(int save_crc, (void)); static int save_crc(void);
STATIC_PROTO(Int do_save, (int CACHE_TYPE)); static Int do_save(int CACHE_TYPE);
STATIC_PROTO(Int p_save2, ( CACHE_TYPE1 )); static Int p_save2( CACHE_TYPE1 );
STATIC_PROTO(Int p_save_program, ( CACHE_TYPE1 )); static Int p_save_program( CACHE_TYPE1 );
STATIC_PROTO(int check_header, (CELL *, CELL *, CELL *, CELL * CACHE_TYPE)); static int check_header(CELL *, CELL *, CELL *, CELL * CACHE_TYPE);
STATIC_PROTO(int get_heap_info, (CACHE_TYPE1)); static int get_heap_info(CACHE_TYPE1);
STATIC_PROTO(int get_regs, (int CACHE_TYPE)); static int get_regs(int CACHE_TYPE);
STATIC_PROTO(int get_insts, (OPCODE [])); static int get_insts(OPCODE []);
STATIC_PROTO(int get_hash, (void)); static int get_hash(void);
STATIC_PROTO(int CopyCode, ( CACHE_TYPE1 )); static int CopyCode( CACHE_TYPE1 );
STATIC_PROTO(int CopyStacks, ( CACHE_TYPE1 )); static int CopyStacks( CACHE_TYPE1 );
STATIC_PROTO(int get_coded, (int, OPCODE [] CACHE_TYPE)); static int get_coded(int, OPCODE [] CACHE_TYPE);
STATIC_PROTO(void restore_codes, (void)); static void restore_codes(void);
STATIC_PROTO(void RestoreDB, (DBEntry * CACHE_TYPE)); static void RestoreDB(DBEntry * CACHE_TYPE);
STATIC_PROTO(void RestoreDBTerm, (DBTerm *, int CACHE_TYPE)); static void RestoreDBTerm(DBTerm *, int CACHE_TYPE);
STATIC_PROTO(void CleanClauses, (yamop *, yamop *,PredEntry * CACHE_TYPE)); static void CleanClauses(yamop *, yamop *,PredEntry * CACHE_TYPE);
STATIC_PROTO(void rehash, (CELL *, int, int CACHE_TYPE)); static void rehash(CELL *, int, int CACHE_TYPE);
STATIC_PROTO(void CleanCode, (PredEntry * CACHE_TYPE)); static void CleanCode(PredEntry * CACHE_TYPE);
STATIC_PROTO(void RestoreEntries, (PropEntry *, int CACHE_TYPE)); static void RestoreEntries(PropEntry *, int CACHE_TYPE);
STATIC_PROTO(void RestoreFreeSpace, ( CACHE_TYPE1 )); static void RestoreFreeSpace( CACHE_TYPE1 );
STATIC_PROTO(void restore_heap, (void)); static void restore_heap(void);
#ifdef DEBUG_RESTORE3 #ifdef DEBUG_RESTORE3
STATIC_PROTO(void ShowAtoms, (void)); static void ShowAtoms(void);
STATIC_PROTO(void ShowEntries, (PropEntry *)); static void ShowEntries(PropEntry *);
#endif #endif
STATIC_PROTO(int OpenRestore, (char *, char *, CELL *, CELL *, CELL *, CELL *, IOSTREAM **)); static int OpenRestore(char *, char *, CELL *, CELL *, CELL *, CELL *, IOSTREAM **);
STATIC_PROTO(void CloseRestore, (void)); static void CloseRestore(void);
#ifndef _WIN32 #ifndef _WIN32
STATIC_PROTO(int check_opcodes, (OPCODE [])); static int check_opcodes(OPCODE []);
#endif #endif
STATIC_PROTO(void RestoreHeap, (OPCODE [] CACHE_TYPE)); static void RestoreHeap(OPCODE [] CACHE_TYPE);
STATIC_PROTO(Int p_restore, ( CACHE_TYPE1 )); static Int p_restore( CACHE_TYPE1 );
STATIC_PROTO(void restore_heap_regs, ( CACHE_TYPE1 )); static void restore_heap_regs( CACHE_TYPE1 );
STATIC_PROTO(void restore_regs, (int CACHE_TYPE)); static void restore_regs(int CACHE_TYPE);
#ifdef MACYAP #ifdef MACYAP
STATIC_PROTO(void NewFileInfo, (long, long)); static void NewFileInfo(long, long);
extern int DefVol; extern int DefVol;
#endif #endif

4
C/scanner.c
View File

@ -59,8 +59,8 @@
#define my_isupper(C) ( C >= 'A' && C <= 'Z' ) #define my_isupper(C) ( C >= 'A' && C <= 'Z' )
#define my_islower(C) ( C >= 'a' && C <= 'z' ) #define my_islower(C) ( C >= 'a' && C <= 'z' )
STATIC_PROTO(Term float_send, (char *, int)); static Term float_send(char *, int);
STATIC_PROTO(Term get_num, (int *, int *, IOSTREAM *,char *,UInt,int)); static Term get_num(int *, int *, IOSTREAM *,char *,UInt,int);
/* token table with some help from Richard O'Keefe's PD scanner */ /* token table with some help from Richard O'Keefe's PD scanner */
static char chtype0[NUMBER_OF_CHARS+1] = static char chtype0[NUMBER_OF_CHARS+1] =

16
C/sort.c
View File

@ -28,14 +28,14 @@
#define M_EVEN 0 #define M_EVEN 0
#define M_ODD 1 #define M_ODD 1
STATIC_PROTO(Int build_new_list, (CELL *, Term CACHE_TYPE)); static Int build_new_list(CELL *, Term CACHE_TYPE);
STATIC_PROTO(void simple_mergesort, (CELL *, Int, int)); static void simple_mergesort(CELL *, Int, int);
STATIC_PROTO(Int compact_mergesort, (CELL *, Int, int)); static Int compact_mergesort(CELL *, Int, int);
STATIC_PROTO(int key_mergesort, (CELL *, Int, int, Functor)); static int key_mergesort(CELL *, Int, int, Functor);
STATIC_PROTO(void adjust_vector, (CELL *, Int)); static void adjust_vector(CELL *, Int);
STATIC_PROTO(Int p_sort, ( USES_REGS1 )); static Int p_sort( USES_REGS1 );
STATIC_PROTO(Int p_msort, ( USES_REGS1 )); static Int p_msort( USES_REGS1 );
STATIC_PROTO(Int p_ksort, ( USES_REGS1 )); static Int p_ksort( USES_REGS1 );
/* copy to a new list of terms */ /* copy to a new list of terms */
static Int static Int

121
C/stdpreds.c
View File

@ -285,75 +285,72 @@ static char SccsId[] = "%W% %G%";
#endif #endif
#include <wchar.h> #include <wchar.h>
STD_PROTO(static Int p_setval, ( USES_REGS1 )); static Int p_setval( USES_REGS1 );
STD_PROTO(static Int p_value, ( USES_REGS1 )); static Int p_value( USES_REGS1 );
STD_PROTO(static Int p_values, ( USES_REGS1 )); static Int p_values( USES_REGS1 );
#ifdef undefined #ifdef undefined
STD_PROTO(static CODEADDR *FindAtom, (CODEADDR, int *)); static CODEADDR *FindAtom(CODEADDR, int *);
#endif /* undefined */ #endif /* undefined */
STD_PROTO(static Int p_opdec, ( USES_REGS1 )); static Int p_opdec( USES_REGS1 );
STD_PROTO(static Term get_num, (char * USES_REGS)); static Term get_num(char * USES_REGS);
STD_PROTO(static Int p_name, ( USES_REGS1 )); static Int p_name( USES_REGS1 );
STD_PROTO(static Int p_atom_chars, ( USES_REGS1 )); static Int p_atom_chars( USES_REGS1 );
STD_PROTO(static Int p_atom_codes, ( USES_REGS1 )); static Int p_atom_codes( USES_REGS1 );
STD_PROTO(static Int p_atom_length, ( USES_REGS1 )); static Int p_atom_length( USES_REGS1 );
STD_PROTO(static Int p_atom_split, ( USES_REGS1 )); static Int p_atom_split( USES_REGS1 );
STD_PROTO(static Int p_number_chars, ( USES_REGS1 )); static Int p_number_chars( USES_REGS1 );
STD_PROTO(static Int p_number_codes, ( USES_REGS1 )); static Int p_number_codes( USES_REGS1 );
STD_PROTO(static Int p_univ, ( USES_REGS1 )); static Int p_univ( USES_REGS1 );
STD_PROTO(static Int p_abort, ( USES_REGS1 )); static Int p_abort( USES_REGS1 );
#ifdef BEAM #ifdef BEAM
STD_PROTO(Int p_halt, ( USES_REGS1 )); Int p_halt( USES_REGS1 );
#else #else
STD_PROTO(static Int p_halt, ( USES_REGS1 )); static Int p_halt( USES_REGS1 );
#endif #endif
STD_PROTO(static Int init_current_atom, ( USES_REGS1 )); static Int init_current_atom( USES_REGS1 );
STD_PROTO(static Int cont_current_atom, ( USES_REGS1 )); static Int cont_current_atom( USES_REGS1 );
STD_PROTO(static Int init_current_predicate, ( USES_REGS1 )); static Int init_current_predicate( USES_REGS1 );
STD_PROTO(static Int cont_current_predicate, ( USES_REGS1 )); static Int cont_current_predicate( USES_REGS1 );
STD_PROTO(static Int init_current_predicate_for_atom, ( USES_REGS1 )); static Int init_current_predicate_for_atom( USES_REGS1 );
STD_PROTO(static Int cont_current_predicate_for_atom, ( USES_REGS1 )); static Int cont_current_predicate_for_atom( USES_REGS1 );
STD_PROTO(static OpEntry *NextOp, (OpEntry * CACHE_TYPE)); static OpEntry *NextOp(OpEntry * CACHE_TYPE);
STD_PROTO(static Int init_current_op, ( USES_REGS1 )); static Int init_current_op( USES_REGS1 );
STD_PROTO(static Int cont_current_op, ( USES_REGS1 )); static Int cont_current_op( USES_REGS1 );
STD_PROTO(static Int init_current_atom_op, ( USES_REGS1 )); static Int init_current_atom_op( USES_REGS1 );
STD_PROTO(static Int cont_current_atom_op, ( USES_REGS1 )); static Int cont_current_atom_op( USES_REGS1 );
#ifdef DEBUG static Int p_flags( USES_REGS1 );
STD_PROTO(static Int p_debug, ( USES_REGS1 )); static int AlreadyHidden(char *);
#endif static Int p_hide( USES_REGS1 );
STD_PROTO(static Int p_flags, ( USES_REGS1 )); static Int p_hidden( USES_REGS1 );
STD_PROTO(static int AlreadyHidden, (char *)); static Int p_unhide( USES_REGS1 );
STD_PROTO(static Int p_hide, ( USES_REGS1 )); static Int TrailMax(void);
STD_PROTO(static Int p_hidden, ( USES_REGS1 )); static Int GlobalMax(void);
STD_PROTO(static Int p_unhide, ( USES_REGS1 )); static Int LocalMax(void);
STD_PROTO(static Int TrailMax, (void)); static Int p_statistics_heap_max( USES_REGS1 );
STD_PROTO(static Int GlobalMax, (void)); static Int p_statistics_global_max( USES_REGS1 );
STD_PROTO(static Int LocalMax, (void)); static Int p_statistics_local_max( USES_REGS1 );
STD_PROTO(static Int p_statistics_heap_max, ( USES_REGS1 )); static Int p_statistics_heap_info( USES_REGS1 );
STD_PROTO(static Int p_statistics_global_max, ( USES_REGS1 )); static Int p_statistics_stacks_info( USES_REGS1 );
STD_PROTO(static Int p_statistics_local_max, ( USES_REGS1 )); static Int p_statistics_trail_info( USES_REGS1 );
STD_PROTO(static Int p_statistics_heap_info, ( USES_REGS1 )); static Term mk_argc_list( USES_REGS1 );
STD_PROTO(static Int p_statistics_stacks_info, ( USES_REGS1 )); static Int p_argv( USES_REGS1 );
STD_PROTO(static Int p_statistics_trail_info, ( USES_REGS1 )); static Int p_cputime( USES_REGS1 );
STD_PROTO(static Term mk_argc_list, ( USES_REGS1 )); static Int p_systime( USES_REGS1 );
STD_PROTO(static Int p_argv, ( USES_REGS1 )); static Int p_runtime( USES_REGS1 );
STD_PROTO(static Int p_cputime, ( USES_REGS1 )); static Int p_walltime( USES_REGS1 );
STD_PROTO(static Int p_systime, ( USES_REGS1 )); static Int p_access_yap_flags( USES_REGS1 );
STD_PROTO(static Int p_runtime, ( USES_REGS1 )); static Int p_set_yap_flags( USES_REGS1 );
STD_PROTO(static Int p_walltime, ( USES_REGS1 ));
STD_PROTO(static Int p_access_yap_flags, ( USES_REGS1 ));
STD_PROTO(static Int p_set_yap_flags, ( USES_REGS1 ));
#ifdef BEAM #ifdef BEAM
STD_PROTO(Int use_eam, ( USES_REGS1 )); Int use_eam( USES_REGS1 );
STD_PROTO(Int eager_split, ( USES_REGS1 )); Int eager_split( USES_REGS1 );
STD_PROTO(Int force_wait, ( USES_REGS1 )); Int force_wait( USES_REGS1 );
STD_PROTO(Int commit, ( USES_REGS1 )); Int commit( USES_REGS1 );
STD_PROTO(Int skip_while_var, ( USES_REGS1 )); Int skip_while_var( USES_REGS1 );
STD_PROTO(Int wait_while_var, ( USES_REGS1 )); Int wait_while_var( USES_REGS1 );
STD_PROTO(Int show_time, ( USES_REGS1 )); Int show_time( USES_REGS1 );
STD_PROTO(Int start_eam, ( USES_REGS1 )); Int start_eam( USES_REGS1 );
STD_PROTO(Int cont_eam, ( USES_REGS1 )); Int cont_eam( USES_REGS1 );
extern int EAM; extern int EAM;
extern int eam_am(PredEntry*); extern int eam_am(PredEntry*);

62
C/sysbits.c
View File

@ -90,26 +90,26 @@ static char SccsId[] = "%W% %G%";
#endif #endif
STATIC_PROTO (void InitTime, (int)); static void InitTime(int);
STATIC_PROTO (void InitWTime, (void)); static void InitWTime(void);
STATIC_PROTO (Int p_sh, ( USES_REGS1 )); static Int p_sh( USES_REGS1 );
STATIC_PROTO (Int p_shell, ( USES_REGS1 )); static Int p_shell( USES_REGS1 );
STATIC_PROTO (Int p_system, ( USES_REGS1 )); static Int p_system( USES_REGS1 );
STATIC_PROTO (Int p_mv, ( USES_REGS1 )); static Int p_mv( USES_REGS1 );
STATIC_PROTO (Int p_dir_sp, ( USES_REGS1 )); static Int p_dir_sp( USES_REGS1 );
STATIC_PROTO (void InitRandom, (void)); static void InitRandom(void);
STATIC_PROTO (Int p_srandom, ( USES_REGS1 )); static Int p_srandom( USES_REGS1 );
STATIC_PROTO (Int p_alarm, ( USES_REGS1 )); static Int p_alarm( USES_REGS1 );
STATIC_PROTO (Int p_getenv, ( USES_REGS1 )); static Int p_getenv( USES_REGS1 );
STATIC_PROTO (Int p_putenv, ( USES_REGS1 )); static Int p_putenv( USES_REGS1 );
STATIC_PROTO (void set_fpu_exceptions, (int)); static void set_fpu_exceptions(int);
#ifdef MACYAP #ifdef MACYAP
STATIC_PROTO (int chdir, (char *)); static int chdir(char *);
/* #define signal skel_signal */ /* #define signal skel_signal */
#endif /* MACYAP */ #endif /* MACYAP */
STD_PROTO (void exit, (int)); void exit(int);
#ifdef _WIN32 #ifdef _WIN32
void void
@ -1037,7 +1037,7 @@ InitRandom (void)
#endif #endif
} }
STD_PROTO (extern int rand, (void)); extern int rand(void);
double double
@ -1094,7 +1094,7 @@ p_srandom ( USES_REGS1 )
#endif #endif
STATIC_PROTO (void InitSignals, (void)); static void InitSignals(void);
#define PLSIG_PREPARED 0x01 /* signal is prepared */ #define PLSIG_PREPARED 0x01 /* signal is prepared */
#define PLSIG_THROW 0x02 /* throw signal(num, name) */ #define PLSIG_THROW 0x02 /* throw signal(num, name) */
@ -1239,10 +1239,10 @@ Yap_signal_index(const char *name)
#include <sys/ucontext.h> #include <sys/ucontext.h>
#endif #endif
STATIC_PROTO (void HandleSIGSEGV, (int, siginfo_t *, ucontext_t *)); static void HandleSIGSEGV(int, siginfo_t *, ucontext_t *);
STATIC_PROTO (void HandleMatherr, (int, siginfo_t *, ucontext_t *)); static void HandleMatherr, (int, siginfo_t *, ucontext_t *);
STATIC_PROTO (void my_signal_info, (int, void (*)(int, siginfo_t *, ucontext_t *))); static void my_signal_info(int, void (*)(int, siginfo_t *, ucontext_t *));
STATIC_PROTO (void my_signal, (int, void (*)(int, siginfo_t *, ucontext_t *))); static void my_signal(int, void (*)(int, siginfo_t *, ucontext_t *));
/* This routine believes there is a continuous space starting from the /* This routine believes there is a continuous space starting from the
HeapBase and ending on TrailTop */ HeapBase and ending on TrailTop */
@ -1328,12 +1328,12 @@ my_signal(int sig, void (*handler)(int, siginfo_t *, ucontext_t *))
#elif defined(__linux__) #elif defined(__linux__)
STATIC_PROTO (RETSIGTYPE HandleMatherr, (int)); static RETSIGTYPE HandleMatherr(int);
#if HAVE_SIGSEGV && !defined(THREADS) #if HAVE_SIGSEGV && !defined(THREADS)
STATIC_PROTO (RETSIGTYPE HandleSIGSEGV, (int,siginfo_t *,void *)); static RETSIGTYPE HandleSIGSEGV(int,siginfo_t *,void *);
STATIC_PROTO (void my_signal_info, (int, void (*)(int,siginfo_t *,void *))); static void my_signal_info(int, void (*)(int,siginfo_t *,void *));
#endif #endif
STATIC_PROTO (void my_signal, (int, void (*)(int))); static void my_signal(int, void (*)(int));
/******** Handling floating point errors *******************/ /******** Handling floating point errors *******************/
@ -1457,10 +1457,10 @@ my_signal(int sig, void (*handler)(int))
#else /* if not (defined(__svr4__) || defined(__SVR4)) */ #else /* if not (defined(__svr4__) || defined(__SVR4)) */
STATIC_PROTO (RETSIGTYPE HandleMatherr, (int)); static RETSIGTYPE HandleMatherr(int);
STATIC_PROTO (RETSIGTYPE HandleSIGSEGV, (int)); static RETSIGTYPE HandleSIGSEGV(int);
STATIC_PROTO (void my_signal_info, (int, void (*)(int))); static void my_signal_info(int, void (*)(int));
STATIC_PROTO (void my_signal, (int, void (*)(int))); static void my_signal(int, void (*)(int));
/******** Handling floating point errors *******************/ /******** Handling floating point errors *******************/
@ -3163,7 +3163,7 @@ VaxFixFrame (dummy)
#include <windows.h> #include <windows.h>
int WINAPI STD_PROTO(win_yap, (HANDLE, DWORD, LPVOID)); int WINAPI win_yap(HANDLE, DWORD, LPVOID);
int WINAPI win_yap(HANDLE hinst, DWORD reason, LPVOID reserved) int WINAPI win_yap(HANDLE hinst, DWORD reason, LPVOID reserved)
{ {
@ -3184,7 +3184,7 @@ int WINAPI win_yap(HANDLE hinst, DWORD reason, LPVOID reserved)
#if (defined(YAPOR) || defined(THREADS)) && !defined(USE_PTHREAD_LOCKING) #if (defined(YAPOR) || defined(THREADS)) && !defined(USE_PTHREAD_LOCKING)
#ifdef sparc #ifdef sparc
void STD_PROTO(rw_lock_voodoo,(void)); void rw_lock_voodoo(void);
void void
rw_lock_voodoo(void) { rw_lock_voodoo(void) {

2
C/tracer.c
View File

@ -26,7 +26,7 @@
#include "clause.h" #include "clause.h"
#include "tracer.h" #include "tracer.h"
STATIC_PROTO(void send_tracer_message, (char *, char *, Int, char *, CELL *)); static void send_tracer_message(char *, char *, Int, char *, CELL *);
static void static void
send_tracer_message(char *start, char *name, Int arity, char *mname, CELL *args) send_tracer_message(char *start, char *name, Int arity, char *mname, CELL *args)

12
C/unify.c
View File

@ -20,14 +20,14 @@
#include "absmi.h" #include "absmi.h"
STD_PROTO(int Yap_rational_tree_loop, (CELL *, CELL *, CELL **, CELL **)); int Yap_rational_tree_loop(CELL *, CELL *, CELL **, CELL **);
STATIC_PROTO(int OCUnify_complex, (CELL *, CELL *, CELL *)); static int OCUnify_complex(CELL *, CELL *, CELL *);
STATIC_PROTO(int OCUnify, (register CELL, register CELL)); static int OCUnify(register CELL, register CELL);
STATIC_PROTO(Int p_ocunify, ( USES_REGS1 )); static Int p_ocunify( USES_REGS1 );
#ifdef THREADED_CODE #ifdef THREADED_CODE
STATIC_PROTO(int rtable_hash_op, (OPCODE)); static int rtable_hash_op(OPCODE);
STATIC_PROTO(void InitReverseLookupOpcode, (void)); static void InitReverseLookupOpcode(void);
#endif #endif
/* support for rational trees and unification with occur checking */ /* support for rational trees and unification with occur checking */

28
C/userpreds.c
View File

@ -51,26 +51,26 @@ static char SccsId[] = "%W% %G%";
/* You should include here the prototypes for all static functions */ /* You should include here the prototypes for all static functions */
#ifdef EUROTRA #ifdef EUROTRA
STATIC_PROTO(int p_clean, (void)); static int p_clean(void);
STATIC_PROTO(int p_namelength, (void)); static int p_namelength(void);
STATIC_PROTO(int p_getpid, (void)); static int p_getpid(void);
STATIC_PROTO(int p_exit, (void)); static int p_exit(void);
STATIC_PROTO(int p_incrcounter, (void)); static int p_incrcounter(void);
STATIC_PROTO(int p_setcounter, (void)); static int p_setcounter(void);
STATIC_PROTO(int p_trapsignal, (void)); static int p_trapsignal(void);
STATIC_PROTO(int subsumes, (Term, Term)); static int subsumes(Term, Term);
STATIC_PROTO(int p_subsumes, (void)); static int p_subsumes(void);
STATIC_PROTO(int p_grab_tokens, (void)); static int p_grab_tokens(void);
#endif #endif
#ifdef MACYAP #ifdef MACYAP
STATIC_PROTO(typedef int, (*SignalProc) ()); static typedef int(*SignalProc) ();
STATIC_PROTO(SignalProc skel_signal, (int, SignalProc)); static SignalProc skel_signal(int, SignalProc);
STATIC_PROTO(int chdir, (char *)); static int chdir(char *);
#endif #endif
#ifdef SFUNC #ifdef SFUNC
STATIC_PROTO(int p_softfunctor, (void)); static int p_softfunctor(void);
#endif /* SFUNC */ #endif /* SFUNC */

20
C/utilpreds.c
View File

@ -32,18 +32,18 @@ typedef struct {
} *vcell; } *vcell;
STATIC_PROTO(int copy_complex_term, (CELL *, CELL *, int, int, CELL *, CELL * CACHE_TYPE)); static int copy_complex_term(CELL *, CELL *, int, int, CELL *, CELL * CACHE_TYPE);
STATIC_PROTO(CELL vars_in_complex_term, (CELL *, CELL *, Term CACHE_TYPE)); static CELL vars_in_complex_term(CELL *, CELL *, Term CACHE_TYPE);
STATIC_PROTO(Int p_non_singletons_in_term, ( USES_REGS1)); static Int p_non_singletons_in_term( USES_REGS1);
STATIC_PROTO(CELL non_singletons_in_complex_term, (CELL *, CELL * CACHE_TYPE)); static CELL non_singletons_in_complex_term(CELL *, CELL * CACHE_TYPE);
STATIC_PROTO(Int p_variables_in_term, ( USES_REGS1 )); static Int p_variables_in_term( USES_REGS1 );
STATIC_PROTO(Int ground_complex_term, (CELL *, CELL * CACHE_TYPE)); static Int ground_complex_term(CELL *, CELL * CACHE_TYPE);
STATIC_PROTO(Int p_ground, ( USES_REGS1 )); static Int p_ground( USES_REGS1 );
STATIC_PROTO(Int p_copy_term, ( USES_REGS1 )); static Int p_copy_term( USES_REGS1 );
STATIC_PROTO(Int var_in_complex_term, (CELL *, CELL *, Term CACHE_TYPE)); static Int var_in_complex_term(CELL *, CELL *, Term CACHE_TYPE);
#ifdef DEBUG #ifdef DEBUG
STATIC_PROTO(Int p_force_trail_expansion, ( USES_REGS1 )); static Int p_force_trail_expansion( USES_REGS1 );
#endif /* DEBUG */ #endif /* DEBUG */
static inline void static inline void

18
C/write.c
View File

@ -78,15 +78,15 @@ typedef struct write_globs {
#define lastw wglb->lw #define lastw wglb->lw
#define last_minus wglb->last_atom_minus #define last_minus wglb->last_atom_minus
STATIC_PROTO(void wrputn, (Int, struct write_globs *)); static void wrputn(Int, struct write_globs *);
STATIC_PROTO(void wrputf, (Float, struct write_globs *)); static void wrputf(Float, struct write_globs *);
STATIC_PROTO(void wrputref, (CODEADDR, int, struct write_globs *)); static void wrputref(CODEADDR, int, struct write_globs *);
STATIC_PROTO(int legalAtom, (unsigned char *)); static int legalAtom(unsigned char *);
/*STATIC_PROTO(int LeftOpToProtect, (Atom, int)); /*static int LeftOpToProtect(Atom, int);
STATIC_PROTO(int RightOpToProtect, (Atom, int));*/ static int RightOpToProtect(Atom, int);*/
STATIC_PROTO(wtype AtomIsSymbols, (unsigned char *)); static wtype AtomIsSymbols(unsigned char *);
STATIC_PROTO(void putAtom, (Atom, int, struct write_globs *)); static void putAtom(Atom, int, struct write_globs *);
STATIC_PROTO(void writeTerm, (Term, int, int, int, struct write_globs *, struct rewind_term *)); static void writeTerm(Term, int, int, int, struct write_globs *, struct rewind_term *);
#define wrputc(X,WF) Sputcode(X,WF) /* writes a character */ #define wrputc(X,WF) Sputcode(X,WF) /* writes a character */

19
H/Foreign.h
View File

@ -100,18 +100,13 @@ typedef struct ForeignLoadItem {
typedef void (*YapInitProc)(void); typedef void (*YapInitProc)(void);
void *Yap_LoadForeignFile(char *, int);
#ifndef STD_PROTO int Yap_CallForeignFile(void *, char *);
#define STD_PROTO(F,A) F A int Yap_CloseForeignFile(void *);
#endif Int Yap_LoadForeign(StringList, StringList, char *, YapInitProc *);
Int Yap_ReLoadForeign(StringList, StringList, char *, YapInitProc *);
void *STD_PROTO(Yap_LoadForeignFile,(char *, int)); void Yap_ReOpenLoadForeign(void);
int STD_PROTO(Yap_CallForeignFile,(void *, char *)); void Yap_ShutdownLoadForeign(void);
int STD_PROTO(Yap_CloseForeignFile,(void *));
Int STD_PROTO(Yap_LoadForeign,(StringList, StringList, char *, YapInitProc *));
Int STD_PROTO(Yap_ReLoadForeign,(StringList, StringList, char *, YapInitProc *));
void STD_PROTO(Yap_ReOpenLoadForeign,(void));
void STD_PROTO(Yap_ShutdownLoadForeign,(void));
#define EAGER_LOADING 1 #define EAGER_LOADING 1
#define GLOBAL_LOADING 2 #define GLOBAL_LOADING 2

14
H/TermExt.h
View File

@ -371,11 +371,11 @@ IsBigIntTerm (Term t)
#ifdef USE_GMP #ifdef USE_GMP
Term STD_PROTO (Yap_MkBigIntTerm, (MP_INT *)); Term Yap_MkBigIntTerm(MP_INT *);
MP_INT *STD_PROTO (Yap_BigIntOfTerm, (Term)); MP_INT *Yap_BigIntOfTerm(Term);
Term STD_PROTO (Yap_MkBigRatTerm, (MP_RAT *)); Term Yap_MkBigRatTerm(MP_RAT *);
MP_RAT *STD_PROTO (Yap_BigRatOfTerm, (Term)); MP_RAT *Yap_BigRatOfTerm(Term);
INLINE_ONLY inline EXTERN void MPZ_SET (mpz_t, MP_INT *); INLINE_ONLY inline EXTERN void MPZ_SET (mpz_t, MP_INT *);
@ -636,11 +636,11 @@ INLINE_ONLY inline EXTERN void *Yap_BlobInfo(Term t)
#ifdef YAP_H #ifdef YAP_H
INLINE_ONLY inline EXTERN int STD_PROTO (unify_extension, (Functor, CELL, CELL *, CELL)); INLINE_ONLY inline EXTERN int unify_extension(Functor, CELL, CELL *, CELL);
EXTERN int STD_PROTO (unify_extension, (Functor, CELL, CELL *, CELL)); EXTERN int unify_extension(Functor, CELL, CELL *, CELL);
int STD_PROTO(Yap_gmp_tcmp_big_big,(Term, Term)); int Yap_gmp_tcmp_big_big(Term, Term);
INLINE_ONLY inline EXTERN int INLINE_ONLY inline EXTERN int
unify_extension (Functor f, CELL d0, CELL * pt0, CELL d1) unify_extension (Functor f, CELL d0, CELL * pt0, CELL d1)

8
H/YapHeap.h
View File

@ -90,7 +90,7 @@ typedef struct halt_hook {
struct halt_hook *next; struct halt_hook *next;
} halt_hook_entry; } halt_hook_entry;
int STD_PROTO(Yap_HaltRegisterHook,(HaltHookFunc, void *)); int Yap_HaltRegisterHook(HaltHookFunc, void *);
typedef struct atom_hash_entry { typedef struct atom_hash_entry {
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
@ -215,12 +215,12 @@ extern struct various_codes *Yap_heap_regs;
#if (defined(USE_SYSTEM_MALLOC) && HAVE_MALLINFO)||USE_DL_MALLOC #if (defined(USE_SYSTEM_MALLOC) && HAVE_MALLINFO)||USE_DL_MALLOC
UInt STD_PROTO(Yap_givemallinfo, (void)); UInt Yap_givemallinfo(void);
#endif #endif
ADDR STD_PROTO(Yap_ExpandPreAllocCodeSpace, (UInt, void *, int)); ADDR Yap_ExpandPreAllocCodeSpace(UInt, void *, int);
#define Yap_ReleasePreAllocCodeSpace(x) #define Yap_ReleasePreAllocCodeSpace(x)
ADDR STD_PROTO(Yap_InitPreAllocCodeSpace, (int)); ADDR Yap_InitPreAllocCodeSpace(int);
#include "inline-only.h" #include "inline-only.h"
INLINE_ONLY EXTERN inline ADDR INLINE_ONLY EXTERN inline ADDR

580
H/Yapproto.h
View File

@ -15,259 +15,255 @@
/* prototype file for Yap */ /* prototype file for Yap */
#define STD_PROTO(F,A) F A
#define STATIC_PROTO(F,A) static F A
/* absmi.c */ /* absmi.c */
Int STD_PROTO(Yap_absmi,(int)); Int Yap_absmi(int);
int STD_PROTO(Yap_absmiEND,(void)); int Yap_absmiEND(void);
/* adtdefs.c */ /* adtdefs.c */
Term STD_PROTO(Yap_ArrayToList,(Term *,int)); Term Yap_ArrayToList(Term *,int);
int STD_PROTO(Yap_GetName,(char *,UInt,Term)); int Yap_GetName(char *,UInt,Term);
Term STD_PROTO(Yap_GetValue,(Atom)); Term Yap_GetValue(Atom);
int STD_PROTO(Yap_HasOp,(Atom)); int Yap_HasOp(Atom);
struct operator_entry *STD_PROTO(Yap_GetOpPropForAModuleHavingALock,(AtomEntry *, Term)); struct operator_entry *Yap_GetOpPropForAModuleHavingALock(AtomEntry *, Term);
Atom STD_PROTO(Yap_LookupAtom,(char *)); Atom Yap_LookupAtom(char *);
Atom STD_PROTO(Yap_LookupMaybeWideAtom,(wchar_t *)); Atom Yap_LookupMaybeWideAtom(wchar_t *);
Atom STD_PROTO(Yap_LookupMaybeWideAtomWithLength,(wchar_t *, size_t)); Atom Yap_LookupMaybeWideAtomWithLength(wchar_t *, size_t);
Atom STD_PROTO(Yap_FullLookupAtom,(char *)); Atom Yap_FullLookupAtom(char *);
void STD_PROTO(Yap_LookupAtomWithAddress,(char *,AtomEntry *)); void Yap_LookupAtomWithAddress(char *,AtomEntry *);
Prop STD_PROTO(Yap_NewPredPropByFunctor,(struct FunctorEntryStruct *, Term)); Prop Yap_NewPredPropByFunctor(struct FunctorEntryStruct *, Term);
Prop STD_PROTO(Yap_NewPredPropByAtom,(struct AtomEntryStruct *, Term)); Prop Yap_NewPredPropByAtom(struct AtomEntryStruct *, Term);
Prop STD_PROTO(Yap_PredPropByFunctorNonThreadLocal,(struct FunctorEntryStruct *, Term)); Prop Yap_PredPropByFunctorNonThreadLocal(struct FunctorEntryStruct *, Term);
Prop STD_PROTO(Yap_PredPropByAtomNonThreadLocal,(struct AtomEntryStruct *, Term)); Prop Yap_PredPropByAtomNonThreadLocal(struct AtomEntryStruct *, Term);
Functor STD_PROTO(Yap_UnlockedMkFunctor,(AtomEntry *,unsigned int)); Functor Yap_UnlockedMkFunctor(AtomEntry *,unsigned int);
Functor STD_PROTO(Yap_MkFunctor,(Atom,unsigned int)); Functor Yap_MkFunctor(Atom,unsigned int);
void STD_PROTO(Yap_MkFunctorWithAddress,(Atom,unsigned int,FunctorEntry *)); void Yap_MkFunctorWithAddress(Atom,unsigned int,FunctorEntry *);
void STD_PROTO(Yap_PutValue,(Atom,Term)); void Yap_PutValue(Atom,Term);
void STD_PROTO(Yap_ReleaseAtom,(Atom)); void Yap_ReleaseAtom(Atom);
Term STD_PROTO(Yap_StringToList,(char *)); Term Yap_StringToList(char *);
Term STD_PROTO(Yap_NStringToList,(char *, size_t)); Term Yap_NStringToList(char *, size_t);
Term STD_PROTO(Yap_WideStringToList,(wchar_t *)); Term Yap_WideStringToList(wchar_t *);
Term STD_PROTO(Yap_NWideStringToList,(wchar_t *, size_t)); Term Yap_NWideStringToList(wchar_t *, size_t);
Term STD_PROTO(Yap_StringToDiffList,(char *,Term CACHE_TYPE)); Term Yap_StringToDiffList(char *,Term CACHE_TYPE);
Term STD_PROTO(Yap_NStringToDiffList,(char *,Term, size_t)); Term Yap_NStringToDiffList(char *,Term, size_t);
Term STD_PROTO(Yap_WideStringToDiffList,(wchar_t *,Term)); Term Yap_WideStringToDiffList(wchar_t *,Term);
Term STD_PROTO(Yap_NWideStringToDiffList,(wchar_t *,Term, size_t)); Term Yap_NWideStringToDiffList(wchar_t *,Term, size_t);
Term STD_PROTO(Yap_StringToListOfAtoms,(char *)); Term Yap_StringToListOfAtoms(char *);
Term STD_PROTO(Yap_NStringToListOfAtoms,(char *, size_t)); Term Yap_NStringToListOfAtoms(char *, size_t);
Term STD_PROTO(Yap_WideStringToListOfAtoms,(wchar_t *)); Term Yap_WideStringToListOfAtoms(wchar_t *);
Term STD_PROTO(Yap_NWideStringToListOfAtoms,(wchar_t *, size_t)); Term Yap_NWideStringToListOfAtoms(wchar_t *, size_t);
Term STD_PROTO(Yap_NWideStringToDiffListOfAtoms,(wchar_t *, Term, size_t)); Term Yap_NWideStringToDiffListOfAtoms(wchar_t *, Term, size_t);
int STD_PROTO(Yap_AtomIncreaseHold,(Atom)); int Yap_AtomIncreaseHold(Atom);
int STD_PROTO(Yap_AtomDecreaseHold,(Atom)); int Yap_AtomDecreaseHold(Atom);
struct operator_entry *STD_PROTO(Yap_OpPropForModule,(Atom, Term)); struct operator_entry *Yap_OpPropForModule(Atom, Term);
Int STD_PROTO(Yap_InitSlot,(Term CACHE_TYPE)); Int Yap_InitSlot(Term CACHE_TYPE);
Int STD_PROTO(Yap_NewSlots,(int CACHE_TYPE)); Int Yap_NewSlots(int CACHE_TYPE);
int STD_PROTO(Yap_RecoverSlots,(int CACHE_TYPE)); int Yap_RecoverSlots(int CACHE_TYPE);
#ifdef SFUNC #ifdef SFUNC
Term STD_PROTO(MkSFTerm,(Functor,int,Term *,Term)); Term MkSFTerm(Functor,int,Term *,Term);
CELL STD_PROTO(*ArgsOfSFTerm,(Term)); CELL *ArgsOfSFTerm(Term);
#endif #endif
Prop STD_PROTO(Yap_GetPredPropByAtom,(Atom, Term)); Prop Yap_GetPredPropByAtom(Atom, Term);
Prop STD_PROTO(Yap_GetPredPropByFunc,(Functor, Term)); Prop Yap_GetPredPropByFunc(Functor, Term);
Prop STD_PROTO(Yap_GetPredPropByAtomInThisModule,(Atom, Term)); Prop Yap_GetPredPropByAtomInThisModule(Atom, Term);
Prop STD_PROTO(Yap_GetPredPropByFuncInThisModule,(Functor, Term)); Prop Yap_GetPredPropByFuncInThisModule(Functor, Term);
Prop STD_PROTO(Yap_GetPredPropHavingLock,(Atom,unsigned int, Term)); Prop Yap_GetPredPropHavingLock(Atom,unsigned int, Term);
Prop STD_PROTO(Yap_GetExpProp,(Atom,unsigned int)); Prop Yap_GetExpProp(Atom,unsigned int);
Prop STD_PROTO(Yap_GetExpPropHavingLock,(AtomEntry *,unsigned int)); Prop Yap_GetExpPropHavingLock(AtomEntry *,unsigned int);
/* agc.c */ /* agc.c */
void STD_PROTO(Yap_atom_gc, (CACHE_TYPE1)); void Yap_atom_gc( CACHE_TYPE1 );
void STD_PROTO(Yap_init_agc, (void)); void Yap_init_agc( void );
/* alloc.c */ /* alloc.c */
void STD_PROTO(Yap_FreeCodeSpace,(char *)); void Yap_FreeCodeSpace(char *);
char *STD_PROTO(Yap_AllocAtomSpace,(size_t)); char *Yap_AllocAtomSpace(size_t);
char *STD_PROTO(Yap_AllocCodeSpace,(size_t)); char *Yap_AllocCodeSpace(size_t);
char *STD_PROTO(Yap_ReallocCodeSpace,(char *,size_t)); char *Yap_ReallocCodeSpace(char *,size_t);
ADDR STD_PROTO(Yap_AllocFromForeignArea,(Int)); ADDR Yap_AllocFromForeignArea(Int);
int STD_PROTO(Yap_ExtendWorkSpace,(Int)); int Yap_ExtendWorkSpace(Int);
void STD_PROTO(Yap_FreeAtomSpace,(char *)); void Yap_FreeAtomSpace(char *);
int STD_PROTO(Yap_FreeWorkSpace, (void)); int Yap_FreeWorkSpace(void);
void STD_PROTO(Yap_InitMemory,(UInt,UInt,UInt)); void Yap_InitMemory(UInt,UInt,UInt);
void STD_PROTO(Yap_InitExStacks,(int,int,int)); void Yap_InitExStacks(int,int,int);
/* amasm.c */ /* amasm.c */
OPCODE STD_PROTO(Yap_opcode,(op_numbers)); OPCODE Yap_opcode(op_numbers);
/* analyst.c */ /* analyst.c */
#ifdef ANALYST #ifdef ANALYST
void STD_PROTO(Yap_InitAnalystPreds,(void)); void Yap_InitAnalystPreds(void);
#endif /* ANALYST */ #endif /* ANALYST */
/* arrays.c */ /* arrays.c */
void STD_PROTO(Yap_InitArrayPreds,(void)); void Yap_InitArrayPreds(void);
/* attvar.c */ /* attvar.c */
void STD_PROTO(Yap_InitAttVarPreds,(void)); void Yap_InitAttVarPreds(void);
/* bb.c */ /* bb.c */
void STD_PROTO(Yap_InitBBPreds,(void)); void Yap_InitBBPreds(void);
/* bignum.c */ /* bignum.c */
Term STD_PROTO(Yap_MkULLIntTerm, (YAP_ULONG_LONG)); Term Yap_MkULLIntTerm(YAP_ULONG_LONG);
int STD_PROTO(Yap_IsStringTerm, (Term)); int Yap_IsStringTerm(Term);
int STD_PROTO(Yap_IsWideStringTerm, (Term)); int Yap_IsWideStringTerm(Term);
Term STD_PROTO(Yap_RatTermToApplTerm, (Term)); Term Yap_RatTermToApplTerm(Term);
void STD_PROTO(Yap_InitBigNums, (void)); void Yap_InitBigNums(void);
Term STD_PROTO(Yap_AllocExternalDataInStack, (CELL, size_t)); Term Yap_AllocExternalDataInStack(CELL, size_t);
int STD_PROTO(Yap_CleanOpaqueVariable, (CELL *)); int Yap_CleanOpaqueVariable(CELL *);
/* c_interface.c */ /* c_interface.c */
Int STD_PROTO(YAP_Execute,(struct pred_entry *, CPredicate)); Int YAP_Execute(struct pred_entry *, CPredicate);
Int STD_PROTO(YAP_ExecuteFirst,(struct pred_entry *, CPredicate)); Int YAP_ExecuteFirst(struct pred_entry *, CPredicate);
Int STD_PROTO(YAP_ExecuteNext,(struct pred_entry *, CPredicate)); Int YAP_ExecuteNext(struct pred_entry *, CPredicate);
Int STD_PROTO(YAP_ExecuteOnCut,(struct pred_entry *, CPredicate, struct cut_c_str *)); Int YAP_ExecuteOnCut(struct pred_entry *, CPredicate, struct cut_c_str *);
/* cdmgr.c */ /* cdmgr.c */
Term STD_PROTO(Yap_all_calls,(void)); Term Yap_all_calls(void);
Atom STD_PROTO(Yap_ConsultingFile,(void)); Atom Yap_ConsultingFile(void);
struct pred_entry *STD_PROTO(Yap_PredForChoicePt,(choiceptr)); struct pred_entry *Yap_PredForChoicePt(choiceptr);
void STD_PROTO(Yap_InitCdMgr,(void)); void Yap_InitCdMgr(void);
void STD_PROTO(Yap_init_consult,(int, char *)); void Yap_init_consult(int, char *);
void STD_PROTO(Yap_end_consult,(void)); void Yap_end_consult(void);
void STD_PROTO(Yap_Abolish,(struct pred_entry *)); void Yap_Abolish(struct pred_entry *);
void STD_PROTO(Yap_BuildMegaClause,(struct pred_entry *)); void Yap_BuildMegaClause(struct pred_entry *);
void STD_PROTO(Yap_EraseMegaClause,(yamop *,struct pred_entry *)); void Yap_EraseMegaClause(yamop *,struct pred_entry *);
void STD_PROTO(Yap_ResetConsultStack,(void)); void Yap_ResetConsultStack(void);
void STD_PROTO(Yap_AssertzClause,(struct pred_entry *, yamop *)); void Yap_AssertzClause(struct pred_entry *, yamop *);
void Yap_HidePred(struct pred_entry *pe); void Yap_HidePred(struct pred_entry *pe);
/* cmppreds.c */ /* cmppreds.c */
Int STD_PROTO(Yap_compare_terms,(Term,Term)); Int Yap_compare_terms(Term,Term);
void STD_PROTO(Yap_InitCmpPreds,(void)); void Yap_InitCmpPreds(void);
/* compiler.c */ /* compiler.c */
yamop *STD_PROTO(Yap_cclause,(Term, Int, Term, Term)); yamop *Yap_cclause(Term, Int, Term, Term);
/* computils.c */ /* computils.c */
/* corout.c */ /* corout.c */
void STD_PROTO(Yap_InitCoroutPreds,(void)); void Yap_InitCoroutPreds(void);
#ifdef COROUTINING #ifdef COROUTINING
Term STD_PROTO(Yap_ListOfWokenGoals,(void)); Term Yap_ListOfWokenGoals(void);
void STD_PROTO(Yap_WakeUp,(CELL *)); void Yap_WakeUp(CELL *);
#endif #endif
/* dbase.c */ /* dbase.c */
struct pred_entry *STD_PROTO(Yap_FindLUIntKey,(Int)); struct pred_entry *Yap_FindLUIntKey(Int);
int STD_PROTO(Yap_DBTrailOverflow,(void)); int Yap_DBTrailOverflow(void);
CELL STD_PROTO(Yap_EvalMasks,(Term,CELL *)); CELL Yap_EvalMasks(Term,CELL *);
void STD_PROTO(Yap_InitBackDB,(void)); void Yap_InitBackDB(void);
void STD_PROTO(Yap_InitDBPreds,(void)); void Yap_InitDBPreds(void);
/* errors.c */ /* errors.c */
void STD_PROTO(Yap_RestartYap,(int)); void Yap_RestartYap(int);
void STD_PROTO(Yap_exit,(int)); void Yap_exit(int);
yamop *STD_PROTO(Yap_Error,(yap_error_number,Term,char *msg, ...)); yamop *Yap_Error(yap_error_number,Term,char *msg, ...);
yamop *STD_PROTO(Yap_NilError,(yap_error_number,char *msg, ...)); yamop *Yap_NilError(yap_error_number,char *msg, ...);
/* eval.c */ /* eval.c */
void STD_PROTO(Yap_InitEval,(void)); void Yap_InitEval(void);
/* exec.c */ /* exec.c */
Term STD_PROTO(Yap_ExecuteCallMetaCall,(Term)); Term Yap_ExecuteCallMetaCall(Term);
void STD_PROTO(Yap_InitExecFs,(void)); void Yap_InitExecFs(void);
Int STD_PROTO(Yap_JumpToEnv,(Term)); Int Yap_JumpToEnv(Term);
Term STD_PROTO(Yap_RunTopGoal,(Term)); Term Yap_RunTopGoal(Term);
void STD_PROTO(Yap_ResetExceptionTerm,(int)); void Yap_ResetExceptionTerm(int);
Int STD_PROTO(Yap_execute_goal,(Term, int, Term)); Int Yap_execute_goal(Term, int, Term);
Int STD_PROTO(Yap_exec_absmi,(int)); Int Yap_exec_absmi(int);
void STD_PROTO(Yap_trust_last,(void)); void Yap_trust_last(void);
Term STD_PROTO(Yap_GetException,(void)); Term Yap_GetException(void);
void STD_PROTO(Yap_PrepGoal,(UInt, CELL *, choiceptr USES_REGS)); void Yap_PrepGoal(UInt, CELL *, choiceptr USES_REGS);
/* exo.c */ /* exo.c */
void STD_PROTO(Yap_InitExoPreds,(void)); void Yap_InitExoPreds(void);
void Yap_udi_Interval_init(void); void Yap_udi_Interval_init(void);
/* foreign.c */ /* foreign.c */
char *STD_PROTO(Yap_FindExecutable,(void)); char *Yap_FindExecutable(void);
/* gprof.c */ /* gprof.c */
void STD_PROTO(Yap_InitLowProf,(void)); void Yap_InitLowProf(void);
#if LOW_PROF #if LOW_PROF
void STD_PROTO(Yap_inform_profiler_of_clause__,(void *,void *,struct pred_entry *, gprof_info)); void Yap_inform_profiler_of_clause__(void *,void *,struct pred_entry *, gprof_info);
#define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE) {if (GLOBAL_FPreds) Yap_inform_profiler_of_clause__(CODE0,CODEF,AP,MODE);} #define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE) {if (GLOBAL_FPreds) Yap_inform_profiler_of_clause__(CODE0,CODEF,AP,MODE);}
#else #else
#define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE) #define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE)
#endif #endif
void STD_PROTO(Yap_tell_gprof,(yamop *)); void Yap_tell_gprof(yamop *);
/* globals.c */ /* globals.c */
Term STD_PROTO(Yap_NewArena,(UInt,CELL *)); Term Yap_NewArena(UInt,CELL *);
CELL *STD_PROTO(Yap_GetFromArena,(Term *,UInt,UInt)); CELL *Yap_GetFromArena(Term *,UInt,UInt);
void STD_PROTO(Yap_InitGlobals,(void)); void Yap_InitGlobals(void);
Term STD_PROTO(Yap_SaveTerm, (Term)); Term Yap_SaveTerm(Term);
Term STD_PROTO(Yap_SetGlobalVal, (Atom, Term)); Term Yap_SetGlobalVal(Atom, Term);
Int STD_PROTO(Yap_DeleteGlobal, (Atom)); Int Yap_DeleteGlobal(Atom);
void STD_PROTO(Yap_AllocateDefaultArena, (Int, Int, int)); void Yap_AllocateDefaultArena(Int, Int, int);
/* grow.c */ /* grow.c */
Int STD_PROTO(Yap_total_stack_shift_time,(void)); Int Yap_total_stack_shift_time(void);
void STD_PROTO(Yap_InitGrowPreds, (void)); void Yap_InitGrowPreds(void);
UInt STD_PROTO(Yap_InsertInGlobal, (CELL *, UInt)); UInt Yap_InsertInGlobal(CELL *, UInt);
int STD_PROTO(Yap_growheap, (int, size_t, void *)); int Yap_growheap(int, size_t, void *);
int STD_PROTO(Yap_growstack, (long)); int Yap_growstack( size_t );
int STD_PROTO(Yap_growtrail, (long, int)); int Yap_growtrail(long, int);
int STD_PROTO(Yap_growglobal, (CELL **)); int Yap_growglobal(CELL **);
CELL **STD_PROTO(Yap_shift_visit, (CELL **, CELL ***, CELL ***)); CELL **Yap_shift_visit(CELL **, CELL ***, CELL ***);
#ifdef THREADS #ifdef THREADS
void STD_PROTO(Yap_CopyThreadStacks, (int, int, int)); void Yap_CopyThreadStacks(int, int, int);
#endif #endif
/* heapgc.c */ /* heapgc.c */
Int STD_PROTO(Yap_total_gc_time,(void)); Int Yap_total_gc_time(void);
void STD_PROTO(Yap_init_gc,(void)); void Yap_init_gc(void);
int STD_PROTO(Yap_is_gc_verbose, (void)); int Yap_is_gc_verbose(void);
int STD_PROTO(Yap_gc, (Int, CELL *, yamop *)); int Yap_gc(Int, CELL *, yamop *);
int STD_PROTO(Yap_gcl, (UInt, Int, CELL *, yamop *)); int Yap_gcl(UInt, Int, CELL *, yamop *);
/* init.c */ /* init.c */
#ifdef DEBUG #ifdef DEBUG
int STD_PROTO(Yap_DebugPutc,(int,wchar_t)); int Yap_DebugPutc(int,wchar_t);
void STD_PROTO(Yap_DebugSetIFile,(char *)); void Yap_DebugSetIFile(char *);
void STD_PROTO(Yap_DebugEndline,(void)); void Yap_DebugEndline(void);
int STD_PROTO(Yap_DebugGetc,(void)); int Yap_DebugGetc(void);
#endif #endif
int STD_PROTO(Yap_IsOpType,(char *)); int Yap_IsOpType(char *);
void STD_PROTO(Yap_InitCPred,(char *, unsigned long int, CPredicate, UInt)); void Yap_InitCPred(char *, unsigned long int, CPredicate, UInt);
void STD_PROTO(Yap_InitAsmPred,(char *, unsigned long int, int, CPredicate, UInt)); void Yap_InitAsmPred(char *, unsigned long int, int, CPredicate, UInt);
void STD_PROTO(Yap_InitCmpPred,(char *, unsigned long int, CmpPredicate, UInt)); void Yap_InitCmpPred(char *, unsigned long int, CmpPredicate, UInt);
void STD_PROTO(Yap_InitCPredBack,(char *, unsigned long int, unsigned int, CPredicate,CPredicate,UInt)); void Yap_InitCPredBack(char *, unsigned long int, unsigned int, CPredicate,CPredicate,UInt);
void STD_PROTO(Yap_InitCPredBackCut,(char *, unsigned long int, unsigned int, CPredicate,CPredicate,CPredicate,UInt)); void Yap_InitCPredBackCut(char *, unsigned long int, unsigned int, CPredicate,CPredicate,CPredicate,UInt);
#ifdef CUT_C #ifdef CUT_C
void STD_PROTO(Yap_InitCPredBack_,(char *, unsigned long int, unsigned int, CPredicate,CPredicate,CPredicate,UInt)); void Yap_InitCPredBack_(char *, unsigned long int, unsigned int, CPredicate,CPredicate,CPredicate,UInt);
#endif #endif
void STD_PROTO(Yap_InitWorkspace,(UInt,UInt,UInt,UInt,UInt,int,int,int)); void Yap_InitWorkspace(UInt,UInt,UInt,UInt,UInt,int,int,int);
#ifdef YAPOR #ifdef YAPOR
void STD_PROTO(Yap_init_yapor_workers, (void)); void Yap_init_yapor_workers(void);
#endif /* YAPOR */ #endif /* YAPOR */
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
void STD_PROTO(Yap_KillStacks,(int)); void Yap_KillStacks(int);
#else #else
void STD_PROTO(Yap_KillStacks,(int)); void Yap_KillStacks(int);
#endif #endif
void STD_PROTO(Yap_InitYaamRegs,(int)); void Yap_InitYaamRegs(int);
void STD_PROTO(Yap_ReInitWallTime, (void)); void Yap_ReInitWallTime(void);
int STD_PROTO(Yap_OpDec,(int,char *,Atom,Term)); int Yap_OpDec(int,char *,Atom,Term);
void STD_PROTO(Yap_CloseScratchPad,(void)); void Yap_CloseScratchPad(void);
/* inlines.c */ /* inlines.c */
void STD_PROTO(Yap_InitInlines,(void)); void Yap_InitInlines(void);
int STD_PROTO(Yap_eq,(Term, Term)); int Yap_eq(Term, Term);
/* iopreds.c */ /* iopreds.c */
void STD_PROTO(Yap_InitBackIO,(void)); void Yap_InitBackIO(void);
void STD_PROTO(Yap_InitIOPreds,(void)); void Yap_InitIOPreds(void);
void *Yap_GetStreamHandle(Atom at); void *Yap_GetStreamHandle(Atom at);
void *Yap_GetInputStream(Atom at); void *Yap_GetInputStream(Atom at);
void *Yap_GetOutputStream(Atom at); void *Yap_GetOutputStream(Atom at);
@ -275,159 +271,159 @@ void *Yap_GetOutputStream(Atom at);
extern void Yap_DebugPlWrite (Term t); extern void Yap_DebugPlWrite (Term t);
extern void Yap_DebugErrorPutc (int n); extern void Yap_DebugErrorPutc (int n);
#endif #endif
int STD_PROTO(Yap_readTerm, (void *, Term *, Term *, Term *, Term *)); int Yap_readTerm(void *, Term *, Term *, Term *, Term *);
void STD_PROTO(Yap_PlWriteToStream, (Term, int, int)); void Yap_PlWriteToStream(Term, int, int);
/* depth_lim.c */ /* depth_lim.c */
void STD_PROTO(Yap_InitItDeepenPreds,(void)); void Yap_InitItDeepenPreds(void);
/* load_foreign.c */ /* load_foreign.c */
void STD_PROTO(Yap_InitLoadForeign,(void)); void Yap_InitLoadForeign(void);
/* mavar.c */ /* mavar.c */
void STD_PROTO(Yap_InitMaVarCPreds,(void)); void Yap_InitMaVarCPreds(void);
Term STD_PROTO(Yap_NewTimedVar,(Term)); Term Yap_NewTimedVar(Term);
Term STD_PROTO(Yap_NewEmptyTimedVar,(void)); Term Yap_NewEmptyTimedVar(void);
Term STD_PROTO(Yap_ReadTimedVar,(Term)); Term Yap_ReadTimedVar(Term);
Term STD_PROTO(Yap_UpdateTimedVar,(Term, Term)); Term Yap_UpdateTimedVar(Term, Term);
/* modules.c */ /* modules.c */
Term STD_PROTO(Yap_Module, (Term)); Term Yap_Module(Term);
Term STD_PROTO(Yap_Module_Name, (struct pred_entry *)); Term Yap_Module_Name(struct pred_entry *);
struct pred_entry *STD_PROTO(Yap_ModulePred, (Term)); struct pred_entry *Yap_ModulePred(Term);
void STD_PROTO(Yap_NewModulePred, (Term, struct pred_entry *)); void Yap_NewModulePred(Term, struct pred_entry *);
Term STD_PROTO(Yap_StripModule, (Term, Term *)); Term Yap_StripModule(Term, Term *);
void STD_PROTO(Yap_InitModules, (void)); void Yap_InitModules(void);
void STD_PROTO(Yap_InitModulesC, (void)); void Yap_InitModulesC(void);
#if HAVE_MPI #if HAVE_MPI
/* mpi.c */ /* mpi.c */
void STD_PROTO(Yap_InitMPI,(void)); void Yap_InitMPI(void);
#endif #endif
#if HAVE_MPE #if HAVE_MPE
/* mpe.c */ /* mpe.c */
void STD_PROTO(Yap_InitMPE,(void)); void Yap_InitMPE(void);
#endif #endif
/* other.c */ /* other.c */
Term STD_PROTO(Yap_MkApplTerm,(Functor,unsigned int,Term *)); Term Yap_MkApplTerm(Functor,unsigned int,Term *);
Term STD_PROTO(Yap_MkNewApplTerm,(Functor,unsigned int)); Term Yap_MkNewApplTerm(Functor,unsigned int);
Term STD_PROTO(Yap_MkNewPairTerm,(void)); Term Yap_MkNewPairTerm(void);
Term STD_PROTO(Yap_Globalise,(Term)); Term Yap_Globalise(Term);
/* parser.c */ /* parser.c */
Term STD_PROTO(Yap_Parse,(void)); Term Yap_Parse(void);
/* readutil.c */ /* readutil.c */
void STD_PROTO(Yap_InitReadUtil,(void)); void Yap_InitReadUtil(void);
/* qly.c */ /* qly.c */
void STD_PROTO(Yap_InitQLY,(void)); void Yap_InitQLY(void);
int STD_PROTO(Yap_Restore,(char *, char *)); int Yap_Restore(char *, char *);
void STD_PROTO(Yap_InitQLYR,(void)); void Yap_InitQLYR(void);
/* range.c */ /* range.c */
void Yap_InitRange(void); void Yap_InitRange(void);
/* save.c */ /* save.c */
int STD_PROTO(Yap_SavedInfo,(char *,char *,CELL *,CELL *,CELL *)); int Yap_SavedInfo(char *,char *,CELL *,CELL *,CELL *);
int STD_PROTO(Yap_SavedStateRestore,(char *, char *)); int Yap_SavedStateRestore(char *, char *);
struct io_stream *STD_PROTO(Yap_OpenRestore,(char *, char *)); struct io_stream *Yap_OpenRestore(char *, char *);
void STD_PROTO(Yap_InitSavePreds,(void)); void Yap_InitSavePreds(void);
/* scanner.c */ /* scanner.c */
/* signals.c */ /* signals.c */
void STD_PROTO(Yap_signal,(yap_signals)); void Yap_signal(yap_signals);
void STD_PROTO(Yap_undo_signal,(yap_signals)); void Yap_undo_signal(yap_signals);
void STD_PROTO(Yap_InitSignalCPreds,(void)); void Yap_InitSignalCPreds(void);
/* sort.c */ /* sort.c */
void STD_PROTO(Yap_InitSortPreds,(void)); void Yap_InitSortPreds(void);
/* stdpreds.c */ /* stdpreds.c */
void STD_PROTO(Yap_InitBackCPreds,(void)); void Yap_InitBackCPreds(void);
void STD_PROTO(Yap_InitCPreds,(void)); void Yap_InitCPreds(void);
void STD_PROTO(Yap_show_statistics,(void)); void Yap_show_statistics(void);
int STD_PROTO(Yap_IsOpMaxPrio,(Atom)); int Yap_IsOpMaxPrio(Atom);
/* sysbits.c */ /* sysbits.c */
void STD_PROTO(Yap_InitPageSize, (void)); void Yap_InitPageSize(void);
void STD_PROTO(Yap_set_fpu_exceptions,(int)); void Yap_set_fpu_exceptions(int);
UInt STD_PROTO(Yap_cputime,(void)); UInt Yap_cputime(void);
Int STD_PROTO(Yap_walltime,(void)); Int Yap_walltime(void);
int STD_PROTO(Yap_dir_separator,(int)); int Yap_dir_separator(int);
int STD_PROTO(Yap_volume_header,(char *)); int Yap_volume_header(char *);
void STD_PROTO(Yap_InitSysPath,(void)); void Yap_InitSysPath(void);
int STD_PROTO(Yap_signal_index,(const char *)); int Yap_signal_index(const char *);
#ifdef MAC #ifdef MAC
void STD_PROTO(Yap_SetTextFile,(char *)); void Yap_SetTextFile(char *);
#endif #endif
int STD_PROTO(Yap_getcwd,(const char *, int)); int Yap_getcwd(const char *, int);
void STD_PROTO(Yap_cputime_interval,(Int *,Int *)); void Yap_cputime_interval(Int *,Int *);
void STD_PROTO(Yap_systime_interval,(Int *,Int *)); void Yap_systime_interval(Int *,Int *);
void STD_PROTO(Yap_walltime_interval,(Int *,Int *)); void Yap_walltime_interval(Int *,Int *);
void STD_PROTO(Yap_InitSysbits,(void)); void Yap_InitSysbits(void);
void STD_PROTO(Yap_InitSysPreds,(void)); void Yap_InitSysPreds(void);
void STD_PROTO(Yap_InitTime,(int)); void Yap_InitTime(int);
int STD_PROTO(Yap_TrueFileName, (char *, char *, int)); int Yap_TrueFileName(char *, char *, int);
double STD_PROTO(Yap_random, (void)); double Yap_random(void);
#ifdef _WIN32 #ifdef _WIN32
char *STD_PROTO(Yap_RegistryGetString,(char *)); char *Yap_RegistryGetString(char *);
void STD_PROTO(Yap_WinError,(char *)); void Yap_WinError(char *);
#endif #endif
/* threads.c */ /* threads.c */
void STD_PROTO(Yap_InitThreadPreds,(void)); void Yap_InitThreadPreds(void);
#if THREADS #if THREADS
int STD_PROTO(Yap_InitThread,(int)); int Yap_InitThread(int);
#endif #endif
/* tracer.c */ /* tracer.c */
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
void STD_PROTO(Yap_InitLowLevelTrace,(void)); void Yap_InitLowLevelTrace(void);
#endif #endif
/* udi.c */ /* udi.c */
void STD_PROTO(Yap_udi_init,(void)); void Yap_udi_init(void);
void STD_PROTO(Yap_udi_abolish,(struct pred_entry *)); void Yap_udi_abolish(struct pred_entry *);
/* unify.c */ /* unify.c */
int STD_PROTO(Yap_rational_tree_loop, (CELL *, CELL *, CELL **, CELL **)); int Yap_rational_tree_loop(CELL *, CELL *, CELL **, CELL **);
void STD_PROTO(Yap_InitAbsmi,(void)); void Yap_InitAbsmi(void);
void STD_PROTO(Yap_InitUnify,(void)); void Yap_InitUnify(void);
void STD_PROTO(Yap_TrimTrail,(void)); void Yap_TrimTrail(void);
int STD_PROTO(Yap_Unifiable,(Term d0, Term d1)); int Yap_Unifiable(Term d0, Term d1);
int STD_PROTO(Yap_IUnify,(register CELL d0,register CELL d1)); int Yap_IUnify(register CELL d0,register CELL d1);
/* userpreds.c */ /* userpreds.c */
void STD_PROTO(Yap_InitUserCPreds,(void)); void Yap_InitUserCPreds(void);
void STD_PROTO(Yap_InitUserBacks,(void)); void Yap_InitUserBacks(void);
/* utilpreds.c */ /* utilpreds.c */
Term STD_PROTO(Yap_CopyTerm,(Term)); Term Yap_CopyTerm(Term);
int STD_PROTO(Yap_Variant,(Term, Term)); int Yap_Variant(Term, Term);
size_t STD_PROTO(Yap_ExportTerm,(Term, char *, size_t, UInt)); size_t Yap_ExportTerm(Term, char *, size_t, UInt);
size_t STD_PROTO(Yap_SizeOfExportedTerm,(char *)); size_t Yap_SizeOfExportedTerm(char *);
Term STD_PROTO(Yap_ImportTerm,(char *)); Term Yap_ImportTerm(char *);
int STD_PROTO(Yap_IsListTerm,(Term)); int Yap_IsListTerm(Term);
int STD_PROTO(Yap_IsListOrPartialListTerm,(Term)); int Yap_IsListOrPartialListTerm(Term);
Term STD_PROTO(Yap_CopyTermNoShare,(Term)); Term Yap_CopyTermNoShare(Term);
int STD_PROTO(Yap_SizeGroundTerm,(Term, int)); int Yap_SizeGroundTerm(Term, int);
int STD_PROTO(Yap_IsGroundTerm,(Term)); int Yap_IsGroundTerm(Term);
int STD_PROTO(Yap_IsAcyclicTerm,(Term)); int Yap_IsAcyclicTerm(Term);
void STD_PROTO(Yap_InitUtilCPreds,(void)); void Yap_InitUtilCPreds(void);
Int STD_PROTO(Yap_TermHash,(Term, Int, Int, int)); Int Yap_TermHash(Term, Int, Int, int);
Int STD_PROTO(Yap_NumberVars,(Term, Int, int)); Int Yap_NumberVars(Term, Int, int);
Term STD_PROTO(Yap_UnNumberTerm,(Term, int)); Term Yap_UnNumberTerm(Term, int);
Int STD_PROTO(Yap_SkipList,(Term *, Term **)); Int Yap_SkipList(Term *, Term **);
/* yap.c */ /* yap.c */
/* write.c */ /* write.c */
void STD_PROTO(Yap_plwrite,(Term, void *, int, int, int)); void Yap_plwrite(Term, void *, int, int, int);
/* MYDDAS */ /* MYDDAS */
@ -435,44 +431,44 @@ void STD_PROTO(Yap_plwrite,(Term, void *, int, int, int));
#if defined MYDDAS_MYSQL || defined MYDDAS_ODBC #if defined MYDDAS_MYSQL || defined MYDDAS_ODBC
/* myddas_initialization.c */ /* myddas_initialization.c */
MYDDAS_GLOBAL STD_PROTO(myddas_init_initialize_myddas,(void)); MYDDAS_GLOBAL myddas_init_initialize_myddas(void);
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_init_initialize_connection,(void *,void *,MYDDAS_UTIL_CONNECTION)); MYDDAS_UTIL_CONNECTION myddas_init_initialize_connection(void *,void *,MYDDAS_UTIL_CONNECTION);
MYDDAS_UTIL_PREDICATE STD_PROTO(myddas_init_initialize_predicate,(char *, int, char *,MYDDAS_UTIL_PREDICATE)); MYDDAS_UTIL_PREDICATE myddas_init_initialize_predicate(char *, int, char *,MYDDAS_UTIL_PREDICATE);
#ifdef MYDDAS_STATS #ifdef MYDDAS_STATS
/* myddas_statistics.c */ /* myddas_statistics.c */
MYDDAS_GLOBAL STD_PROTO(myddas_stats_initialize_global_stats,(MYDDAS_GLOBAL)); MYDDAS_GLOBAL myddas_stats_initialize_global_stats(MYDDAS_GLOBAL);
MYDDAS_STATS_STRUCT STD_PROTO(myddas_stats_initialize_connection_stats,(void)); MYDDAS_STATS_STRUCT myddas_stats_initialize_connection_stats(void);
void STD_PROTO(myddas_stats_delete_stats_list,(MYDDAS_STATS_STRUCT)); void myddas_stats_delete_stats_list(MYDDAS_STATS_STRUCT);
#endif /* MYDDAS_STATS */ #endif /* MYDDAS_STATS */
#ifdef MYDDAS_MYSQL #ifdef MYDDAS_MYSQL
/* myddas_util.c */ /* myddas_util.c */
void STD_PROTO(myddas_util_table_write,(MYSQL_RES *)); void myddas_util_table_write(MYSQL_RES *);
#endif #endif
Short STD_PROTO(myddas_util_connection_type,(void *)); Short myddas_util_connection_type(void *);
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_add_connection,(void *,void *)); MYDDAS_UTIL_CONNECTION myddas_util_add_connection(void *,void *);
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_search_connection,(void *)); MYDDAS_UTIL_CONNECTION myddas_util_search_connection(void *);
void STD_PROTO(myddas_util_delete_connection,(void *)); void myddas_util_delete_connection(void *);
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_add_predicate,(char * ,Int , char *,void *)); MYDDAS_UTIL_CONNECTION myddas_util_add_predicate(char * ,Int , char *,void *);
MYDDAS_UTIL_PREDICATE STD_PROTO(myddas_util_search_predicate,(char * ,Int , char *)); MYDDAS_UTIL_PREDICATE myddas_util_search_predicate(char * ,Int , char *);
void STD_PROTO(myddas_util_delete_predicate,(MYDDAS_UTIL_PREDICATE)); void myddas_util_delete_predicate(MYDDAS_UTIL_PREDICATE);
/* Get's the number of queries to save */ /* Get's the number of queries to save */
UInt STD_PROTO(myddas_util_get_total_multi_queries_number,(MYDDAS_UTIL_CONNECTION)); UInt myddas_util_get_total_multi_queries_number(MYDDAS_UTIL_CONNECTION);
void STD_PROTO(myddas_util_set_total_multi_queries_number,(MYDDAS_UTIL_CONNECTION,UInt)); void myddas_util_set_total_multi_queries_number(MYDDAS_UTIL_CONNECTION,UInt);
#ifdef MYDDAS_ODBC #ifdef MYDDAS_ODBC
/* Return enviromment identifier*/ /* Return enviromment identifier*/
SQLHENV STD_PROTO(myddas_util_get_odbc_enviromment,(SQLHDBC)); SQLHENV myddas_util_get_odbc_enviromment(SQLHDBC);
#endif #endif
void * STD_PROTO(myddas_util_get_list_pred,(MYDDAS_UTIL_CONNECTION)); void * myddas_util_get_list_pred(MYDDAS_UTIL_CONNECTION);
void * STD_PROTO(myddas_util_get_pred_next,(void *)); void * myddas_util_get_pred_next(void *);
char * STD_PROTO(myddas_util_get_pred_module,(void *)); char * myddas_util_get_pred_module(void *);
char * STD_PROTO(myddas_util_get_pred_name,(void *)); char * myddas_util_get_pred_name(void *);
MyddasInt STD_PROTO(myddas_util_get_pred_arity,(void *)); MyddasInt myddas_util_get_pred_arity(void *);
//DELETE THIS WHEN DB_STATS IS COMPLETED //DELETE THIS WHEN DB_STATS IS COMPLETED
MyddasInt STD_PROTO(get_myddas_top,(void)); MyddasInt get_myddas_top(void);
#ifdef DEBUG #ifdef DEBUG
void check_int(void); void check_int(void);
@ -482,36 +478,36 @@ void check_int(void);
/* myddas_mysql.c */ /* myddas_mysql.c */
#if defined MYDDAS_MYSQL #if defined MYDDAS_MYSQL
void STD_PROTO(Yap_InitMYDDAS_MySQLPreds,(void)); void Yap_InitMYDDAS_MySQLPreds(void);
void STD_PROTO(Yap_InitBackMYDDAS_MySQLPreds,(void)); void Yap_InitBackMYDDAS_MySQLPreds(void);
#endif #endif
/* myddas_odbc.c */ /* myddas_odbc.c */
#if defined MYDDAS_ODBC #if defined MYDDAS_ODBC
void STD_PROTO(Yap_InitMYDDAS_ODBCPreds,(void)); void Yap_InitMYDDAS_ODBCPreds(void);
void STD_PROTO(Yap_InitBackMYDDAS_ODBCPreds,(void)); void Yap_InitBackMYDDAS_ODBCPreds(void);
#endif #endif
/* myddas_shared.c */ /* myddas_shared.c */
#if defined MYDDAS_ODBC || defined MYDDAS_MYSQL #if defined MYDDAS_ODBC || defined MYDDAS_MYSQL
void STD_PROTO(Yap_MYDDAS_delete_all_myddas_structs,(void)); void Yap_MYDDAS_delete_all_myddas_structs(void);
void STD_PROTO(Yap_InitMYDDAS_SharedPreds,(void)); void Yap_InitMYDDAS_SharedPreds(void);
void STD_PROTO(Yap_InitBackMYDDAS_SharedPreds,(void)); void Yap_InitBackMYDDAS_SharedPreds(void);
#endif #endif
/* myddas_top_level.c */ /* myddas_top_level.c */
#if defined MYDDAS_TOP_LEVEL && defined MYDDAS_MYSQL //&& defined HAVE_LIBREADLINE #if defined MYDDAS_TOP_LEVEL && defined MYDDAS_MYSQL //&& defined HAVE_LIBREADLINE
void STD_PROTO(Yap_InitMYDDAS_TopLevelPreds,(void)); void Yap_InitMYDDAS_TopLevelPreds(void);
#endif #endif
/* yap2swi.c */ /* yap2swi.c */
void STD_PROTO(Yap_swi_install,(void)); void Yap_swi_install(void);
void STD_PROTO(Yap_InitSWIHash,(void)); void Yap_InitSWIHash(void);
int STD_PROTO(Yap_get_stream_handle,(Term, int, int, void *)); int Yap_get_stream_handle(Term, int, int, void *);
Term STD_PROTO(Yap_get_stream_position,(void *)); Term Yap_get_stream_position(void *);
/* opt.preds.c */ /* opt.preds.c */
void STD_PROTO(Yap_init_optyap_preds,(void)); void Yap_init_optyap_preds(void);
/* pl-file.c */ /* pl-file.c */
struct PL_local_data *Yap_InitThreadIO(int wid); struct PL_local_data *Yap_InitThreadIO(int wid);

52
H/Yatom.h
View File

@ -37,7 +37,7 @@ INLINE_ONLY inline EXTERN AtomEntry *RepAtom (Atom a);
INLINE_ONLY inline EXTERN AtomEntry * INLINE_ONLY inline EXTERN AtomEntry *
RepAtom (Atom a) RepAtom (Atom a)
{ {
return (AtomEntry *) (AtomBase + Unsigned (a)); return (AtomEntry *) (AtomBase + Unsigned (a);
} }
@ -487,12 +487,12 @@ typedef enum
} op_type; } op_type;
OpEntry *STD_PROTO(Yap_GetOpProp,(Atom, op_type CACHE_TYPE)); OpEntry *Yap_GetOpProp(Atom, op_type CACHE_TYPE);
int STD_PROTO(Yap_IsPrefixOp,(Atom,int *,int *)); int Yap_IsPrefixOp(Atom,int *,int *);
int STD_PROTO(Yap_IsOp,(Atom)); int Yap_IsOp(Atom);
int STD_PROTO(Yap_IsInfixOp,(Atom,int *,int *,int *)); int Yap_IsInfixOp(Atom,int *,int *,int *);
int STD_PROTO(Yap_IsPosfixOp,(Atom,int *,int *)); int Yap_IsPosfixOp(Atom,int *,int *);
/* defines related to operator specifications */ /* defines related to operator specifications */
#define MaskPrio 0x0fff #define MaskPrio 0x0fff
@ -1440,23 +1440,23 @@ IsBlob (Atom at)
/* Proto types */ /* Proto types */
/* cdmgr.c */ /* cdmgr.c */
int STD_PROTO (Yap_RemoveIndexation, (PredEntry *)); int Yap_RemoveIndexation(PredEntry *);
void STD_PROTO (Yap_UpdateTimestamps, (PredEntry *)); void Yap_UpdateTimestamps(PredEntry *);
/* dbase.c */ /* dbase.c */
void STD_PROTO (Yap_ErDBE, (DBRef)); void Yap_ErDBE(DBRef);
DBTerm *STD_PROTO (Yap_StoreTermInDB, (Term, int)); DBTerm *Yap_StoreTermInDB(Term, int);
DBTerm *STD_PROTO (Yap_StoreTermInDBPlusExtraSpace, (Term, UInt, UInt *)); DBTerm *Yap_StoreTermInDBPlusExtraSpace(Term, UInt, UInt *);
Term STD_PROTO (Yap_FetchTermFromDB, (DBTerm *)); Term Yap_FetchTermFromDB(DBTerm *);
Term STD_PROTO (Yap_PopTermFromDB, (DBTerm *)); Term Yap_PopTermFromDB(DBTerm *);
void STD_PROTO (Yap_ReleaseTermFromDB, (DBTerm *)); void Yap_ReleaseTermFromDB(DBTerm *);
/* init.c */ /* init.c */
Atom STD_PROTO (Yap_GetOp, (OpEntry *, int *, int)); Atom Yap_GetOp(OpEntry *, int *, int);
/* vsc: redefined to GetAProp to avoid conflicts with Windows header files */ /* vsc: redefined to GetAProp to avoid conflicts with Windows header files */
Prop STD_PROTO (Yap_GetAProp, (Atom, PropFlags)); Prop Yap_GetAProp(Atom, PropFlags);
Prop STD_PROTO (Yap_GetAPropHavingLock, (AtomEntry *, PropFlags)); Prop Yap_GetAPropHavingLock(AtomEntry *, PropFlags);
typedef enum typedef enum
{ {
@ -1473,7 +1473,7 @@ typedef enum
#define PredHashInitialSize ((UInt)1039) #define PredHashInitialSize ((UInt)1039)
#define PredHashIncrement ((UInt)7919) #define PredHashIncrement ((UInt)7919)
INLINE_ONLY EXTERN inline UInt STD_PROTO(PRED_HASH, (FunctorEntry *, Term, UInt)); INLINE_ONLY EXTERN inline UInt PRED_HASH(FunctorEntry *, Term, UInt);
INLINE_ONLY EXTERN inline UInt INLINE_ONLY EXTERN inline UInt
PRED_HASH(FunctorEntry *fe, Term cur_mod, UInt size) PRED_HASH(FunctorEntry *fe, Term cur_mod, UInt size)
@ -1481,16 +1481,16 @@ PRED_HASH(FunctorEntry *fe, Term cur_mod, UInt size)
return (((CELL)fe+cur_mod)>>2) % size; return (((CELL)fe+cur_mod)>>2) % size;
} }
INLINE_ONLY EXTERN inline Prop STD_PROTO(GetPredPropByFuncAndModHavingLock, (FunctorEntry *, Term)); INLINE_ONLY EXTERN inline Prop GetPredPropByFuncAndModHavingLock(FunctorEntry *, Term);
INLINE_ONLY EXTERN inline Prop STD_PROTO(PredPropByFuncAndMod, (FunctorEntry *, Term)); INLINE_ONLY EXTERN inline Prop PredPropByFuncAndMod(FunctorEntry *, Term);
INLINE_ONLY EXTERN inline Prop STD_PROTO(PredPropByAtomAndMod, (Atom, Term)); INLINE_ONLY EXTERN inline Prop PredPropByAtomAndMod(Atom, Term);
INLINE_ONLY EXTERN inline Prop STD_PROTO(GetPredPropByFuncHavingLock, (FunctorEntry *, Term)); INLINE_ONLY EXTERN inline Prop GetPredPropByFuncHavingLock(FunctorEntry *, Term);
#ifdef THREADS #ifdef THREADS
Prop STD_PROTO(Yap_NewThreadPred, (struct pred_entry * CACHE_TYPE)); Prop Yap_NewThreadPred(struct pred_entry * CACHE_TYPE);
Prop STD_PROTO(Yap_NewPredPropByFunctor, (Functor, Term)); Prop Yap_NewPredPropByFunctor(Functor, Term);
INLINE_ONLY EXTERN inline struct pred_entry *STD_PROTO(Yap_GetThreadPred, (struct pred_entry * CACHE_TYPE)); INLINE_ONLY EXTERN inline struct pred_entry *Yap_GetThreadPred(struct pred_entry * CACHE_TYPE);
INLINE_ONLY EXTERN inline struct pred_entry * INLINE_ONLY EXTERN inline struct pred_entry *
Yap_GetThreadPred(struct pred_entry *ap USES_REGS) Yap_GetThreadPred(struct pred_entry *ap USES_REGS)
@ -1698,7 +1698,7 @@ PredPropByAtomAndMod (Atom at, Term cur_mod)
#define UNLOCKPE(I,Z) UNLOCK((Z)->PELock) #define UNLOCKPE(I,Z) UNLOCK((Z)->PELock)
#endif #endif
INLINE_ONLY EXTERN inline void STD_PROTO(AddPropToAtom, (AtomEntry *, PropEntry *p)); INLINE_ONLY EXTERN inline void AddPropToAtom(AtomEntry *, PropEntry *p);
INLINE_ONLY EXTERN inline void INLINE_ONLY EXTERN inline void
AddPropToAtom(AtomEntry *ae, PropEntry *p) AddPropToAtom(AtomEntry *ae, PropEntry *p)

6
H/alloc.h
View File

@ -96,9 +96,9 @@ typedef struct FREEB {
/* Operating system and architecture dependent page size */ /* Operating system and architecture dependent page size */
extern int Yap_page_size; extern int Yap_page_size;
void STD_PROTO(Yap_InitHeap, (void *)); void Yap_InitHeap(void *);
UInt STD_PROTO(Yap_ExtendWorkSpaceThroughHole, (UInt)); UInt Yap_ExtendWorkSpaceThroughHole(UInt);
void STD_PROTO(Yap_AllocHole, (UInt, UInt)); void Yap_AllocHole(UInt, UInt);
#if USE_MMAP && ! defined(__CYGWIN__) #if USE_MMAP && ! defined(__CYGWIN__)

4
H/amiops.h
View File

@ -285,7 +285,7 @@ Unification Routines
*************************************************************/ *************************************************************/
INLINE_ONLY inline EXTERN void STD_PROTO(reset_trail,(tr_fr_ptr)); INLINE_ONLY inline EXTERN void reset_trail(tr_fr_ptr TR0);
INLINE_ONLY inline EXTERN void INLINE_ONLY inline EXTERN void
reset_trail(tr_fr_ptr TR0) { reset_trail(tr_fr_ptr TR0) {
@ -371,7 +371,7 @@ Int Yap_unify(Term t0, Term t1)
} }
} }
EXTERN Int STD_PROTO(Yap_unify_constant,(Term,Term)); EXTERN Int Yap_unify_constant(Term a, Term cons);
EXTERN inline Int EXTERN inline Int
Yap_unify_constant(register Term a, register Term cons) Yap_unify_constant(register Term a, register Term cons)

66
H/clause.h
View File

@ -256,36 +256,36 @@ typedef struct dbterm_list {
#endif #endif
/* amasm.c */ /* amasm.c */
wamreg STD_PROTO(Yap_emit_x,(CELL)); wamreg Yap_emit_x(CELL);
COUNT STD_PROTO(Yap_compile_cmp_flags,(PredEntry *)); COUNT Yap_compile_cmp_flags(PredEntry *);
void STD_PROTO(Yap_InitComma,(void)); void Yap_InitComma(void);
/* cdmgr.c */ /* cdmgr.c */
void STD_PROTO(Yap_IPred,(PredEntry *, UInt, yamop *)); void Yap_IPred(PredEntry *, UInt, yamop *);
int STD_PROTO(Yap_addclause,(Term,yamop *,int,Term,Term*)); int Yap_addclause(Term,yamop *,int,Term,Term*);
void STD_PROTO(Yap_add_logupd_clause,(PredEntry *,LogUpdClause *,int)); void Yap_add_logupd_clause(PredEntry *,LogUpdClause *,int);
void STD_PROTO(Yap_kill_iblock,(ClauseUnion *,ClauseUnion *,PredEntry *)); void Yap_kill_iblock(ClauseUnion *,ClauseUnion *,PredEntry *);
void STD_PROTO(Yap_EraseStaticClause,(StaticClause *, Term)); void Yap_EraseStaticClause(StaticClause *, Term);
ClauseUnion *STD_PROTO(Yap_find_owner_index,(yamop *, PredEntry *)); ClauseUnion *Yap_find_owner_index(yamop *, PredEntry *);
/* dbase.c */ /* dbase.c */
void STD_PROTO(Yap_ErCl,(DynamicClause *)); void Yap_ErCl(DynamicClause *);
void STD_PROTO(Yap_ErLogUpdCl,(LogUpdClause *)); void Yap_ErLogUpdCl(LogUpdClause *);
void STD_PROTO(Yap_ErLogUpdIndex,(LogUpdIndex *)); void Yap_ErLogUpdIndex(LogUpdIndex *);
Int STD_PROTO(Yap_Recordz,(Atom, Term)); Int Yap_Recordz(Atom, Term);
/* exec.c */ /* exec.c */
Term STD_PROTO(Yap_cp_as_integer,(choiceptr)); Term Yap_cp_as_integer(choiceptr);
/* index.c */ /* index.c */
yamop *STD_PROTO(Yap_PredIsIndexable,(PredEntry *, UInt, yamop *)); yamop *Yap_PredIsIndexable(PredEntry *, UInt, yamop *);
yamop *STD_PROTO(Yap_ExpandIndex,(PredEntry *, UInt)); yamop *Yap_ExpandIndex(PredEntry *, UInt);
void STD_PROTO(Yap_CleanUpIndex,(struct logic_upd_index *)); void Yap_CleanUpIndex(struct logic_upd_index *);
void STD_PROTO(Yap_CleanKids,(struct logic_upd_index *)); void Yap_CleanKids(struct logic_upd_index *);
void STD_PROTO(Yap_AddClauseToIndex,(PredEntry *,yamop *,int)); void Yap_AddClauseToIndex(PredEntry *,yamop *,int);
void STD_PROTO(Yap_RemoveClauseFromIndex,(PredEntry *,yamop *)); void Yap_RemoveClauseFromIndex(PredEntry *,yamop *);
LogUpdClause *STD_PROTO(Yap_NthClause,(PredEntry *,Int)); LogUpdClause *Yap_NthClause(PredEntry *,Int);
LogUpdClause *STD_PROTO(Yap_FollowIndexingCode,(PredEntry *,yamop *, Term *, yamop *,yamop *)); LogUpdClause *Yap_FollowIndexingCode(PredEntry *,yamop *, Term *, yamop *,yamop *);
/* exo.c */ /* exo.c */
yamop *Yap_ExoLookup(PredEntry *ap USES_REGS); yamop *Yap_ExoLookup(PredEntry *ap USES_REGS);
@ -392,24 +392,24 @@ typedef enum {
FIND_PRED_FROM_ENV FIND_PRED_FROM_ENV
} find_pred_type; } find_pred_type;
Int STD_PROTO(Yap_PredForCode,(yamop *, find_pred_type, Atom *, UInt *, Term *)); Int Yap_PredForCode(yamop *, find_pred_type, Atom *, UInt *, Term *);
PredEntry *STD_PROTO(Yap_PredEntryForCode,(yamop *, find_pred_type, CODEADDR *, CODEADDR *)); PredEntry *Yap_PredEntryForCode(yamop *, find_pred_type, CODEADDR *, CODEADDR *);
LogUpdClause *STD_PROTO(Yap_new_ludbe,(Term, PredEntry *, UInt)); LogUpdClause *Yap_new_ludbe(Term, PredEntry *, UInt);
Term STD_PROTO(Yap_LUInstance,(LogUpdClause *, UInt)); Term Yap_LUInstance(LogUpdClause *, UInt);
/* udi.c */ /* udi.c */
void STD_PROTO(Yap_udi_init,(void)); void Yap_udi_init(void);
int STD_PROTO(Yap_new_udi_clause,(PredEntry *, yamop *, Term)); int Yap_new_udi_clause(PredEntry *, yamop *, Term);
yamop *STD_PROTO(Yap_udi_search,(PredEntry *)); yamop *Yap_udi_search(PredEntry *);
void STD_PROTO(Yap_udi_abolish,(PredEntry *p)); void Yap_udi_abolish(PredEntry *p);
#ifdef DEBUG #ifdef DEBUG
void STD_PROTO(Yap_bug_location,(yamop *)); void Yap_bug_location(yamop *);
#endif #endif
#if LOW_PROF #if LOW_PROF
void STD_PROTO(Yap_InformOfRemoval,(void *)); void Yap_InformOfRemoval(void *);
void STD_PROTO(Yap_dump_code_area_for_profiler,(void)); void Yap_dump_code_area_for_profiler(void);
#else #else
#define Yap_InformOfRemoval(X) #define Yap_InformOfRemoval(X)
#endif #endif

20
H/compile.h
View File

@ -325,17 +325,17 @@ typedef enum special_label_op_enum {
#define Two 2 #define Two 2
yamop *STD_PROTO(Yap_assemble,(int,Term,struct pred_entry *,int, struct intermediates *, UInt)); yamop *Yap_assemble(int,Term,struct pred_entry *,int, struct intermediates *, UInt);
void STD_PROTO(Yap_emit,(compiler_vm_op,Int,CELL, struct intermediates *)); void Yap_emit(compiler_vm_op,Int,CELL, struct intermediates *);
void STD_PROTO(Yap_emit_3ops,(compiler_vm_op,CELL,CELL,CELL, struct intermediates *)); void Yap_emit_3ops(compiler_vm_op,CELL,CELL,CELL, struct intermediates *);
void STD_PROTO(Yap_emit_4ops,(compiler_vm_op,CELL,CELL,CELL,CELL, struct intermediates *)); void Yap_emit_4ops(compiler_vm_op,CELL,CELL,CELL,CELL, struct intermediates *);
CELL *STD_PROTO(Yap_emit_extra_size,(compiler_vm_op,CELL,int, struct intermediates *)); CELL *Yap_emit_extra_size(compiler_vm_op,CELL,int, struct intermediates *);
char *STD_PROTO(Yap_AllocCMem,(UInt, struct intermediates *)); char *Yap_AllocCMem(UInt, struct intermediates *);
void STD_PROTO(Yap_ReleaseCMem, (struct intermediates *)); void Yap_ReleaseCMem(struct intermediates *);
int STD_PROTO(Yap_is_a_test_pred,(Term, Term)); int Yap_is_a_test_pred(Term, Term);
void STD_PROTO(Yap_bip_name,(Int, char *)); void Yap_bip_name(Int, char *);
#ifdef DEBUG #ifdef DEBUG
void STD_PROTO(Yap_ShowCode,(struct intermediates *)); void Yap_ShowCode(struct intermediates *);
#endif /* DEBUG */ #endif /* DEBUG */

4
H/dlmalloc.h
View File

@ -7,8 +7,8 @@
/* YAP only stuff */ /* YAP only stuff */
void STD_PROTO(Yap_initdlmalloc,(void)); void Yap_initdlmalloc(void);
void STD_PROTO(Yap_RestoreDLMalloc,(void)); void Yap_RestoreDLMalloc(void);
/* Synopsis of compile-time options: /* Synopsis of compile-time options:

178
H/eval.h
View File

@ -128,7 +128,7 @@ typedef enum {
op_rdiv op_rdiv
} arith2_op; } arith2_op;
Functor STD_PROTO(EvalArg,(Term)); Functor EvalArg(Term);
/* Needed to handle numbers: /* Needed to handle numbers:
these two macros are fundamental in the integer/float conversions */ these two macros are fundamental in the integer/float conversions */
@ -161,20 +161,20 @@ Functor STD_PROTO(EvalArg,(Term));
#define FL(X) ((double)(X)) #define FL(X) ((double)(X))
#endif #endif
void STD_PROTO(Yap_InitConstExps,(void)); void Yap_InitConstExps(void);
void STD_PROTO(Yap_InitUnaryExps,(void)); void Yap_InitUnaryExps(void);
void STD_PROTO(Yap_InitBinaryExps,(void)); void Yap_InitBinaryExps(void);
int STD_PROTO(Yap_ReInitConstExps,(void)); int Yap_ReInitConstExps(void);
int STD_PROTO(Yap_ReInitUnaryExps,(void)); int Yap_ReInitUnaryExps(void);
int STD_PROTO(Yap_ReInitBinaryExps,(void)); int Yap_ReInitBinaryExps(void);
Term STD_PROTO(Yap_eval_atom,(Int)); Term Yap_eval_atom(Int);
Term STD_PROTO(Yap_eval_unary,(Int,Term)); Term Yap_eval_unary(Int,Term);
Term STD_PROTO(Yap_eval_binary,(Int,Term,Term)); Term Yap_eval_binary(Int,Term,Term);
Term STD_PROTO(Yap_InnerEval,(Term)); Term Yap_InnerEval(Term);
Int STD_PROTO(Yap_ArithError,(yap_error_number,Term,char *msg, ...)); Int Yap_ArithError(yap_error_number,Term,char *msg, ...);
#include "inline-only.h" #include "inline-only.h"
INLINE_ONLY inline EXTERN Term INLINE_ONLY inline EXTERN Term
@ -225,95 +225,95 @@ ETypeOfTerm(Term t)
} }
#if USE_GMP #if USE_GMP
Term STD_PROTO(Yap_gmq_rdiv_int_int,(Int, Int)); Term Yap_gmq_rdiv_int_int(Int, Int);
Term STD_PROTO(Yap_gmq_rdiv_int_big,(Int, Term)); Term Yap_gmq_rdiv_int_big(Int, Term);
Term STD_PROTO(Yap_gmq_rdiv_big_int,(Term, Int)); Term Yap_gmq_rdiv_big_int(Term, Int);
Term STD_PROTO(Yap_gmq_rdiv_big_big,(Term, Term)); Term Yap_gmq_rdiv_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_add_ints,(Int, Int)); Term Yap_gmp_add_ints(Int, Int);
Term STD_PROTO(Yap_gmp_sub_ints,(Int, Int)); Term Yap_gmp_sub_ints(Int, Int);
Term STD_PROTO(Yap_gmp_mul_ints,(Int, Int)); Term Yap_gmp_mul_ints(Int, Int);
Term STD_PROTO(Yap_gmp_sll_ints,(Int, Int)); Term Yap_gmp_sll_ints(Int, Int);
Term STD_PROTO(Yap_gmp_add_int_big,(Int, Term)); Term Yap_gmp_add_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_sub_int_big,(Int, Term)); Term Yap_gmp_sub_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_sub_big_int,(Term, Int)); Term Yap_gmp_sub_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_mul_int_big,(Int, Term)); Term Yap_gmp_mul_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_div_int_big,(Int, Term)); Term Yap_gmp_div_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_div_big_int,(Term, Int)); Term Yap_gmp_div_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_div2_big_int,(Term, Int)); Term Yap_gmp_div2_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_fdiv_int_big,(Int, Term)); Term Yap_gmp_fdiv_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_fdiv_big_int,(Term, Int)); Term Yap_gmp_fdiv_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_and_int_big,(Int, Term)); Term Yap_gmp_and_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_ior_int_big,(Int, Term)); Term Yap_gmp_ior_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_xor_int_big,(Int, Term)); Term Yap_gmp_xor_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_sll_big_int,(Term, Int)); Term Yap_gmp_sll_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_add_big_big,(Term, Term)); Term Yap_gmp_add_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_sub_big_big,(Term, Term)); Term Yap_gmp_sub_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_mul_big_big,(Term, Term)); Term Yap_gmp_mul_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_div_big_big,(Term, Term)); Term Yap_gmp_div_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_div2_big_big,(Term, Term)); Term Yap_gmp_div2_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_fdiv_big_big,(Term, Term)); Term Yap_gmp_fdiv_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_and_big_big,(Term, Term)); Term Yap_gmp_and_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_ior_big_big,(Term, Term)); Term Yap_gmp_ior_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_xor_big_big,(Term, Term)); Term Yap_gmp_xor_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_mod_big_big,(Term, Term)); Term Yap_gmp_mod_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_mod_big_int,(Term, Int)); Term Yap_gmp_mod_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_mod_int_big,(Int, Term)); Term Yap_gmp_mod_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_rem_big_big,(Term, Term)); Term Yap_gmp_rem_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_rem_big_int,(Term, Int)); Term Yap_gmp_rem_big_int(Term, Int);
Term STD_PROTO(Yap_gmp_rem_int_big,(Int, Term)); Term Yap_gmp_rem_int_big(Int, Term);
Term STD_PROTO(Yap_gmp_exp_int_int,(Int,Int)); Term Yap_gmp_exp_int_int(Int,Int);
Term STD_PROTO(Yap_gmp_exp_int_big,(Int,Term)); Term Yap_gmp_exp_int_big(Int,Term);
Term STD_PROTO(Yap_gmp_exp_big_int,(Term,Int)); Term Yap_gmp_exp_big_int(Term,Int);
Term STD_PROTO(Yap_gmp_exp_big_big,(Term,Term)); Term Yap_gmp_exp_big_big(Term,Term);
Term STD_PROTO(Yap_gmp_gcd_int_big,(Int,Term)); Term Yap_gmp_gcd_int_big(Int,Term);
Term STD_PROTO(Yap_gmp_gcd_big_big,(Term,Term)); Term Yap_gmp_gcd_big_big(Term,Term);
Term STD_PROTO(Yap_gmp_big_from_64bits,(YAP_LONG_LONG)); Term Yap_gmp_big_from_64bits(YAP_LONG_LONG);
Term STD_PROTO(Yap_gmp_float_to_big,(Float)); Term Yap_gmp_float_to_big(Float);
Term STD_PROTO(Yap_gmp_float_to_rational,(Float)); Term Yap_gmp_float_to_rational(Float);
Term STD_PROTO(Yap_gmp_float_rationalize,(Float)); Term Yap_gmp_float_rationalize(Float);
Float STD_PROTO(Yap_gmp_to_float,(Term)); Float Yap_gmp_to_float(Term);
Term STD_PROTO(Yap_gmp_add_float_big,(Float, Term)); Term Yap_gmp_add_float_big(Float, Term);
Term STD_PROTO(Yap_gmp_sub_float_big,(Float, Term)); Term Yap_gmp_sub_float_big(Float, Term);
Term STD_PROTO(Yap_gmp_sub_big_float,(Term, Float)); Term Yap_gmp_sub_big_float(Term, Float);
Term STD_PROTO(Yap_gmp_mul_float_big,(Float, Term)); Term Yap_gmp_mul_float_big(Float, Term);
Term STD_PROTO(Yap_gmp_fdiv_float_big,(Float, Term)); Term Yap_gmp_fdiv_float_big(Float, Term);
Term STD_PROTO(Yap_gmp_fdiv_big_float,(Term, Float)); Term Yap_gmp_fdiv_big_float(Term, Float);
int STD_PROTO(Yap_gmp_cmp_big_int,(Term, Int)); int Yap_gmp_cmp_big_int(Term, Int);
#define Yap_gmp_cmp_int_big(I, T) (-Yap_gmp_cmp_big_int(T, I)) #define Yap_gmp_cmp_int_big(I, T) (-Yap_gmp_cmp_big_int(T, I))
int STD_PROTO(Yap_gmp_cmp_big_float,(Term, Float)); int Yap_gmp_cmp_big_float(Term, Float);
#define Yap_gmp_cmp_float_big(D, T) (-Yap_gmp_cmp_big_float(T, D)) #define Yap_gmp_cmp_float_big(D, T) (-Yap_gmp_cmp_big_float(T, D))
int STD_PROTO(Yap_gmp_cmp_big_big,(Term, Term)); int Yap_gmp_cmp_big_big(Term, Term);
int STD_PROTO(Yap_gmp_tcmp_big_int,(Term, Int)); int Yap_gmp_tcmp_big_int(Term, Int);
#define Yap_gmp_tcmp_int_big(I, T) (-Yap_gmp_tcmp_big_int(T, I)) #define Yap_gmp_tcmp_int_big(I, T) (-Yap_gmp_tcmp_big_int(T, I))
int STD_PROTO(Yap_gmp_tcmp_big_float,(Term, Float)); int Yap_gmp_tcmp_big_float(Term, Float);
#define Yap_gmp_tcmp_float_big(D, T) (-Yap_gmp_tcmp_big_float(T, D)) #define Yap_gmp_tcmp_float_big(D, T) (-Yap_gmp_tcmp_big_float(T, D))
int STD_PROTO(Yap_gmp_tcmp_big_big,(Term, Term)); int Yap_gmp_tcmp_big_big(Term, Term);
Term STD_PROTO(Yap_gmp_neg_int,(Int)); Term Yap_gmp_neg_int(Int);
Term STD_PROTO(Yap_gmp_abs_big,(Term)); Term Yap_gmp_abs_big(Term);
Term STD_PROTO(Yap_gmp_neg_big,(Term)); Term Yap_gmp_neg_big(Term);
Term STD_PROTO(Yap_gmp_unot_big,(Term)); Term Yap_gmp_unot_big(Term);
Term STD_PROTO(Yap_gmp_floor,(Term)); Term Yap_gmp_floor(Term);
Term STD_PROTO(Yap_gmp_ceiling,(Term)); Term Yap_gmp_ceiling(Term);
Term STD_PROTO(Yap_gmp_round,(Term)); Term Yap_gmp_round(Term);
Term STD_PROTO(Yap_gmp_trunc,(Term)); Term Yap_gmp_trunc(Term);
Term STD_PROTO(Yap_gmp_float_fractional_part,(Term)); Term Yap_gmp_float_fractional_part(Term);
Term STD_PROTO(Yap_gmp_float_integer_part,(Term)); Term Yap_gmp_float_integer_part(Term);
Term STD_PROTO(Yap_gmp_sign,(Term)); Term Yap_gmp_sign(Term);
Term STD_PROTO(Yap_gmp_lsb,(Term)); Term Yap_gmp_lsb(Term);
Term STD_PROTO(Yap_gmp_msb,(Term)); Term Yap_gmp_msb(Term);
Term STD_PROTO(Yap_gmp_popcount,(Term)); Term Yap_gmp_popcount(Term);
char * STD_PROTO(Yap_gmp_to_string,(Term, char *, size_t, int)); char * Yap_gmp_to_string(Term, char *, size_t, int);
size_t STD_PROTO(Yap_gmp_to_size,(Term, int)); size_t Yap_gmp_to_size(Term, int);
int STD_PROTO(Yap_term_to_existing_big,(Term, MP_INT *)); int Yap_term_to_existing_big(Term, MP_INT *);
int STD_PROTO(Yap_term_to_existing_rat,(Term, MP_RAT *)); int Yap_term_to_existing_rat(Term, MP_RAT *);
void Yap_gmp_set_bit(Int i, Term t); void Yap_gmp_set_bit(Int i, Term t);
#endif #endif

6
H/heapgc.h
View File

@ -166,9 +166,9 @@ typedef CELL *CELL_PTR;
#define ENVSIZE(E) EnvSize(((CELL *)E)[E_CP]) #define ENVSIZE(E) EnvSize(((CELL *)E)[E_CP])
void STD_PROTO(Yap_mark_variable, (CELL *)); void Yap_mark_variable(CELL *);
void STD_PROTO(Yap_mark_external_reference, (CELL *)); void Yap_mark_external_reference(CELL *);
void STD_PROTO(Yap_inc_mark_variable, (void)); void Yap_inc_mark_variable(void);

6
H/iopreds.h
View File

@ -112,7 +112,7 @@ StreamDesc;
#define ALIASES_BLOCK_SIZE 8 #define ALIASES_BLOCK_SIZE 8
void STD_PROTO (Yap_InitStdStreams, (void)); void Yap_InitStdStreams(void);
Term STD_PROTO (Yap_StreamPosition, (struct io_stream *)); Term Yap_StreamPosition(struct io_stream *);
void STD_PROTO (Yap_InitPlIO, (void)); void Yap_InitPlIO(void);

6
H/rheap.h
View File

@ -412,9 +412,9 @@ AdjustSwitchTable__(op_numbers op, yamop *table, COUNT i USES_REGS)
} }
} }
STATIC_PROTO(void RestoreAtomList, (Atom CACHE_TYPE)); static void RestoreAtomList(Atom CACHE_TYPE);
STATIC_PROTO(void RestoreAtom, (AtomEntry * CACHE_TYPE)); static void RestoreAtom(AtomEntry * CACHE_TYPE);
STATIC_PROTO(void RestoreHashPreds, ( CACHE_TYPE1 )); static void RestoreHashPreds( CACHE_TYPE1 );
static void static void
RestoreAtoms__( USES_REGS1 ) RestoreAtoms__( USES_REGS1 )

4
H/sshift.h
View File

@ -1120,6 +1120,6 @@ IsGlobal__ (CELL reg USES_REGS)
} }
void STD_PROTO (Yap_AdjustStacksAndTrail, (void)); void Yap_AdjustStacksAndTrail(void);
void STD_PROTO (Yap_AdjustRegs, (int)); void Yap_AdjustRegs(int);

14
H/threads.h
View File

@ -13,13 +13,13 @@ typedef struct thread_attr_struct {
#ifdef THREADS #ifdef THREADS
Int STD_PROTO(Yap_thread_self,(void)); Int Yap_thread_self(void);
int STD_PROTO(Yap_get_thread_ref_count,(int)); int Yap_get_thread_ref_count(int);
void STD_PROTO(Yap_set_thread_ref_count,(int,int)); void Yap_set_thread_ref_count(int,int);
CELL STD_PROTO(Yap_thread_create_engine,(thread_attr *)); CELL Yap_thread_create_engine(thread_attr *);
Int STD_PROTO(Yap_thread_attach_engine,(int)); Int Yap_thread_attach_engine(int);
Int STD_PROTO(Yap_thread_detach_engine,(int)); Int Yap_thread_detach_engine(int);
Int STD_PROTO(Yap_thread_destroy_engine,(int)); Int Yap_thread_destroy_engine(int);
#endif #endif

6
H/tracer.h
View File

@ -27,9 +27,9 @@ typedef enum {
retry_table_loader retry_table_loader
} yap_low_level_port; } yap_low_level_port;
void STD_PROTO(low_level_trace,(yap_low_level_port, PredEntry *, CELL *)); void low_level_trace(yap_low_level_port, PredEntry *, CELL *);
void STD_PROTO(Yap_InitLowLevelTrace,(void)); void Yap_InitLowLevelTrace(void);
void STD_PROTO(toggle_low_level_trace,(void)); void toggle_low_level_trace(void);
#endif #endif

66
H/yapio.h
View File

@ -66,7 +66,7 @@
#define YP_FILE FILE #define YP_FILE FILE
int STD_PROTO(YP_putc,(int, int)); int YP_putc(int, int);
#else #else
@ -231,8 +231,8 @@ typedef struct AliasDescS {
extern char *Yap_chtype; extern char *Yap_chtype;
#include "inline-only.h" #include "inline-only.h"
INLINE_ONLY EXTERN inline int STD_PROTO(chtype,(Int)); INLINE_ONLY EXTERN inline int chtype(Int);
int STD_PROTO(Yap_wide_chtype,(Int)); int Yap_wide_chtype(Int);
INLINE_ONLY EXTERN inline int INLINE_ONLY EXTERN inline int
chtype(Int ch) chtype(Int ch)
@ -247,44 +247,44 @@ chtype(Int ch)
#define ParserAuxSp LOCAL_ScannerStack #define ParserAuxSp LOCAL_ScannerStack
/* routines in parser.c */ /* routines in parser.c */
VarEntry STD_PROTO(*Yap_LookupVar,(char *)); VarEntry *Yap_LookupVar(char *);
Term STD_PROTO(Yap_VarNames,(VarEntry *,Term)); Term Yap_VarNames(VarEntry *,Term);
/* routines in scanner.c */ /* routines in scanner.c */
TokEntry STD_PROTO(*Yap_tokenizer,(struct io_stream *, int, Term *)); TokEntry *Yap_tokenizer(struct io_stream *, int, Term *);
void STD_PROTO(Yap_clean_tokenizer,(TokEntry *, VarEntry *, VarEntry *,Term)); void Yap_clean_tokenizer(TokEntry *, VarEntry *, VarEntry *,Term);
Term STD_PROTO(Yap_scan_num,(struct io_stream *)); Term Yap_scan_num(struct io_stream *);
char STD_PROTO(*Yap_AllocScannerMemory,(unsigned int)); char *Yap_AllocScannerMemory(unsigned int);
/* routines in iopreds.c */ /* routines in iopreds.c */
FILE *STD_PROTO(Yap_FileDescriptorFromStream,(Term)); FILE *Yap_FileDescriptorFromStream(Term);
Int STD_PROTO(Yap_FirstLineInParse,(void)); Int Yap_FirstLineInParse(void);
int STD_PROTO(Yap_CheckIOStream,(Term, char *)); int Yap_CheckIOStream(Term, char *);
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
void STD_PROTO(Yap_LockStream,(struct io_stream *)); void Yap_LockStream(struct io_stream *);
void STD_PROTO(Yap_UnLockStream,(struct io_stream *)); void Yap_UnLockStream(struct io_stream *);
#else #else
#define Yap_LockStream(X) #define Yap_LockStream(X)
#define Yap_UnLockStream(X) #define Yap_UnLockStream(X)
#endif #endif
Int STD_PROTO(Yap_GetStreamFd,(int)); Int Yap_GetStreamFd(int);
void STD_PROTO(Yap_CloseStreams,(int)); void Yap_CloseStreams(int);
void STD_PROTO(Yap_FlushStreams,(void)); void Yap_FlushStreams(void);
void STD_PROTO(Yap_CloseStream,(int)); void Yap_CloseStream(int);
int STD_PROTO(Yap_PlGetchar,(void)); int Yap_PlGetchar(void);
int STD_PROTO(Yap_PlGetWchar,(void)); int Yap_PlGetWchar(void);
int STD_PROTO(Yap_PlFGetchar,(void)); int Yap_PlFGetchar(void);
int STD_PROTO(Yap_GetCharForSIGINT,(void)); int Yap_GetCharForSIGINT(void);
Int STD_PROTO(Yap_StreamToFileNo,(Term)); Int Yap_StreamToFileNo(Term);
Term STD_PROTO(Yap_OpenStream,(FILE *,char *,Term,int)); Term Yap_OpenStream(FILE *,char *,Term,int);
Term STD_PROTO(Yap_StringToTerm,(char *,Term *)); Term Yap_StringToTerm(char *,Term *);
char *Yap_TermToString(Term t, char *s, size_t sz, size_t *length, int *encoding, int flags); char *Yap_TermToString(Term t, char *s, size_t sz, size_t *length, int *encoding, int flags);
int Yap_GetFreeStreamD(void); int Yap_GetFreeStreamD(void);
int Yap_GetFreeStreamDForReading(void); int Yap_GetFreeStreamDForReading(void);
Term Yap_WStringToList(wchar_t *); Term Yap_WStringToList(wchar_t *);
Term STD_PROTO(Yap_WStringToListOfAtoms,(wchar_t *)); Term Yap_WStringToListOfAtoms(wchar_t *);
Atom STD_PROTO(Yap_LookupWideAtom,(wchar_t *)); Atom Yap_LookupWideAtom( wchar_t * );
#define YAP_INPUT_STREAM 0x01 #define YAP_INPUT_STREAM 0x01
#define YAP_OUTPUT_STREAM 0x02 #define YAP_OUTPUT_STREAM 0x02
@ -312,9 +312,9 @@ Atom STD_PROTO(Yap_LookupWideAtom,(wchar_t *));
/* grow.c */ /* grow.c */
int STD_PROTO(Yap_growheap_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); int Yap_growheap_in_parser(tr_fr_ptr *, TokEntry **, VarEntry **);
int STD_PROTO(Yap_growstack_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); int Yap_growstack_in_parser(tr_fr_ptr *, TokEntry **, VarEntry **);
int STD_PROTO(Yap_growtrail_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); int Yap_growtrail_in_parser(tr_fr_ptr *, TokEntry **, VarEntry **);
@ -324,8 +324,8 @@ int STD_PROTO(Yap_growtrail_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)
extern int errno; extern int errno;
#endif #endif
INLINE_ONLY EXTERN inline UInt STD_PROTO(HashFunction, (unsigned char *)); INLINE_ONLY EXTERN UInt inline HashFunction(unsigned char *);
INLINE_ONLY EXTERN inline UInt STD_PROTO(WideHashFunction, (wchar_t *)); INLINE_ONLY EXTERN UInt inline WideHashFunction(wchar_t *);
INLINE_ONLY EXTERN inline UInt INLINE_ONLY EXTERN inline UInt
HashFunction(unsigned char *CHP) HashFunction(unsigned char *CHP)
@ -346,7 +346,7 @@ HashFunction(unsigned char *CHP)
*/ */
} }
INLINE_ONLY EXTERN inline UInt INLINE_ONLY EXTERN UInt inline
WideHashFunction(wchar_t *CHP) WideHashFunction(wchar_t *CHP)
{ {
UInt hash = 5381; UInt hash = 5381;

24
MYDDAS/myddas_mysql.c
View File

@ -45,18 +45,18 @@
static Int null_id = 0; static Int null_id = 0;
STATIC_PROTO(Int c_db_my_connect,( USES_REGS1 )); static Int c_db_my_connect( USES_REGS1 );
STATIC_PROTO(Int c_db_my_disconnect,( USES_REGS1 )); static Int c_db_my_disconnect( USES_REGS1 );
STATIC_PROTO(Int c_db_my_number_of_fields,( USES_REGS1 )); static Int c_db_my_number_of_fields( USES_REGS1 );
STATIC_PROTO(Int c_db_my_get_attributes_types,( USES_REGS1 )); static Int c_db_my_get_attributes_types( USES_REGS1 );
STATIC_PROTO(Int c_db_my_query,( USES_REGS1 )); static Int c_db_my_query( USES_REGS1 );
STATIC_PROTO(Int c_db_my_table_write,( USES_REGS1 )); static Int c_db_my_table_write( USES_REGS1 );
STATIC_PROTO(Int c_db_my_row,( USES_REGS1 )); static Int c_db_my_row( USES_REGS1 );
STATIC_PROTO(Int c_db_my_row_cut,( USES_REGS1 )); static Int c_db_my_row_cut( USES_REGS1 );
STATIC_PROTO(Int c_db_my_get_fields_properties,( USES_REGS1 )); static Int c_db_my_get_fields_properties( USES_REGS1 );
STATIC_PROTO(Int c_db_my_get_next_result_set,( USES_REGS1 )); static Int c_db_my_get_next_result_set( USES_REGS1 );
STATIC_PROTO(Int c_db_my_get_database,( USES_REGS1 )); static Int c_db_my_get_database( USES_REGS1 );
STATIC_PROTO(Int c_db_my_change_database,( USES_REGS1 )); static Int c_db_my_change_database( USES_REGS1 );
void Yap_InitMYDDAS_MySQLPreds(void) void Yap_InitMYDDAS_MySQLPreds(void)
{ {

18
MYDDAS/myddas_odbc.c
View File

@ -29,15 +29,15 @@
static Int null_id = 0; static Int null_id = 0;
STATIC_PROTO(Int c_db_odbc_connect,( USES_REGS1 )); static Int c_db_odbc_connect( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_disconnect,( USES_REGS1 )); static Int c_db_odbc_disconnect( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_number_of_fields,( USES_REGS1 )); static Int c_db_odbc_number_of_fields( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_get_attributes_types,( USES_REGS1 )); static Int c_db_odbc_get_attributes_types( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_query,( USES_REGS1 )); static Int c_db_odbc_query( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_row,( USES_REGS1 )); static Int c_db_odbc_row( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_row_cut,( USES_REGS1 )); static Int c_db_odbc_row_cut( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_get_fields_properties,( USES_REGS1 )); static Int c_db_odbc_get_fields_properties( USES_REGS1 );
STATIC_PROTO(Int c_db_odbc_number_of_fields_in_query,( USES_REGS1 )); static Int c_db_odbc_number_of_fields_in_query( USES_REGS1 );
static int static int
odbc_error(SQLSMALLINT type, SQLHANDLE hdbc, char *msg, char *print) odbc_error(SQLSMALLINT type, SQLHANDLE hdbc, char *msg, char *print)

30
MYDDAS/myddas_shared.c
View File

@ -27,24 +27,24 @@
#include "myddas_statistics.h" #include "myddas_statistics.h"
#endif #endif
STATIC_PROTO(Int c_db_initialize_myddas,( USES_REGS1 )); static Int c_db_initialize_myddas( USES_REGS1 );
STATIC_PROTO(Int c_db_connection_type,( USES_REGS1 )); static Int c_db_connection_type( USES_REGS1 );
STATIC_PROTO(Int c_db_add_preds,( USES_REGS1 )); static Int c_db_add_preds( USES_REGS1 );
STATIC_PROTO(Int c_db_preds_conn_start ,( USES_REGS1 )); static Int c_db_preds_conn_start ( USES_REGS1 );
STATIC_PROTO(Int c_db_preds_conn_continue ,( USES_REGS1 )); static Int c_db_preds_conn_continue ( USES_REGS1 );
STATIC_PROTO(Int c_db_connection_start ,( USES_REGS1 )); static Int c_db_connection_start ( USES_REGS1 );
STATIC_PROTO(Int c_db_connection_continue ,( USES_REGS1 )); static Int c_db_connection_continue ( USES_REGS1 );
STATIC_PROTO(Int c_db_check_if_exists_pred,( USES_REGS1 )); static Int c_db_check_if_exists_pred( USES_REGS1 );
STATIC_PROTO(Int c_db_delete_predicate,( USES_REGS1 )); static Int c_db_delete_predicate( USES_REGS1 );
STATIC_PROTO(Int c_db_multi_queries_number,( USES_REGS1 )); static Int c_db_multi_queries_number( USES_REGS1 );
#ifdef MYDDAS_STATS #ifdef MYDDAS_STATS
STATIC_PROTO(Int c_db_stats,( USES_REGS1 )); static Int c_db_stats( USES_REGS1 );
STATIC_PROTO(Int c_db_stats_walltime,( USES_REGS1 )); static Int c_db_stats_walltime( USES_REGS1 );
STATIC_PROTO(Int c_db_stats_translate,( USES_REGS1 )); static Int c_db_stats_translate( USES_REGS1 );
STATIC_PROTO(Int c_db_stats_time,( USES_REGS1 )); static Int c_db_stats_time( USES_REGS1 );
#endif #endif
#ifdef DEBUG #ifdef DEBUG
STATIC_PROTO(Int c_db_check,( USES_REGS1 )); static Int c_db_check( USES_REGS1 );
#endif #endif
void Yap_InitMYDDAS_SharedPreds(void) void Yap_InitMYDDAS_SharedPreds(void)

2
MYDDAS/myddas_top_level.c
View File

@ -34,7 +34,7 @@
#include <sys/times.h> #include <sys/times.h>
STATIC_PROTO(Int c_db_tl_readline,(void)); static Int c_db_tl_readline(void);
void Yap_InitMYDDAS_TopLevelPreds(void) void Yap_InitMYDDAS_TopLevelPreds(void)

2
OPTYap/or.cow_engine.c
View File

@ -39,7 +39,7 @@ static void share_private_nodes(int worker_q);
** Local inlines ** ** Local inlines **
** ----------------------- */ ** ----------------------- */
STD_PROTO(static inline void PUT_BUSY, (int)); static inline void PUT_BUSY(int);
static inline static inline
void PUT_BUSY(int worker_num) { void PUT_BUSY(int worker_num) {

44
OPTYap/or.macros.h
View File

@ -18,36 +18,36 @@
/* get a def for NULL */ /* get a def for NULL */
#include <stdlib.h> #include <stdlib.h>
STD_PROTO(static inline void PUT_IN_EXECUTING, (int)); static inline void PUT_IN_EXECUTING(int);
STD_PROTO(static inline void PUT_OUT_EXECUTING, (int)); static inline void PUT_OUT_EXECUTING(int);
STD_PROTO(static inline void PUT_IN_FINISHED, (int)); static inline void PUT_IN_FINISHED(int);
#ifdef TABLING_INNER_CUTS #ifdef TABLING_INNER_CUTS
STD_PROTO(static inline void PUT_IN_PRUNING, (int)); static inline void PUT_IN_PRUNING(int);
STD_PROTO(static inline void PUT_OUT_PRUNING, (int)); static inline void PUT_OUT_PRUNING(int);
#endif /* TABLING_INNER_CUTS */ #endif /* TABLING_INNER_CUTS */
STD_PROTO(static inline void PUT_IN_REQUESTABLE, (int)); static inline void PUT_IN_REQUESTABLE(int);
STD_PROTO(static inline void PUT_OUT_REQUESTABLE, (int)); static inline void PUT_OUT_REQUESTABLE(int);
STD_PROTO(static inline void SCH_update_local_or_tops, (void)); static inline void SCH_update_local_or_tops(void);
STD_PROTO(static inline void SCH_refuse_share_request_if_any, (void)); static inline void SCH_refuse_share_request_if_any(void);
STD_PROTO(static inline void SCH_set_load, (choiceptr)); static inline void SCH_set_load(choiceptr);
STD_PROTO(static inline void SCH_new_alternative, (yamop *,yamop *)); static inline void SCH_new_alternative(yamop *,yamop *);
STD_PROTO(static inline void CUT_send_prune_request, (int, choiceptr)); static inline void CUT_send_prune_request(int, choiceptr);
STD_PROTO(static inline void CUT_reset_prune_request, (void)); static inline void CUT_reset_prune_request(void);
STD_PROTO(static inline int CUT_last_worker_left_pending_prune, (or_fr_ptr)); static inline int CUT_last_worker_left_pending_prune(or_fr_ptr);
STD_PROTO(static inline or_fr_ptr CUT_leftmost_or_frame, (void)); static inline or_fr_ptr CUT_leftmost_or_frame(void);
#ifdef TABLING_INNER_CUTS #ifdef TABLING_INNER_CUTS
STD_PROTO(static inline or_fr_ptr CUT_leftmost_until, (or_fr_ptr, int)); static inline or_fr_ptr CUT_leftmost_until(or_fr_ptr, int);
#endif /* TABLING_INNER_CUTS */ #endif /* TABLING_INNER_CUTS */
STD_PROTO(static inline void CUT_store_answer, (or_fr_ptr, qg_ans_fr_ptr)); static inline void CUT_store_answer(or_fr_ptr, qg_ans_fr_ptr);
STD_PROTO(static inline void CUT_store_answers, (or_fr_ptr, qg_sol_fr_ptr)); static inline void CUT_store_answers(or_fr_ptr, qg_sol_fr_ptr);
STD_PROTO(static inline void CUT_join_answers_in_an_unique_frame, (qg_sol_fr_ptr)); static inline void CUT_join_answers_in_an_unique_frame(qg_sol_fr_ptr);
STD_PROTO(static inline void CUT_free_solution_frame, (qg_sol_fr_ptr)); static inline void CUT_free_solution_frame(qg_sol_fr_ptr);
STD_PROTO(static inline void CUT_free_solution_frames, (qg_sol_fr_ptr)); static inline void CUT_free_solution_frames(qg_sol_fr_ptr);
STD_PROTO(static inline qg_sol_fr_ptr CUT_prune_solution_frames, (qg_sol_fr_ptr, int)); static inline qg_sol_fr_ptr CUT_prune_solution_frames(qg_sol_fr_ptr, int);

12
OPTYap/or.scheduler.c
View File

@ -42,12 +42,12 @@ static int search_for_hidden_shared_work(bitmap stable_busy);
** Local inlines ** ** Local inlines **
** ----------------------- */ ** ----------------------- */
STD_PROTO(static inline void PUT_NO_WORK_IN_UPPER_NODES, (void)); static inline void PUT_NO_WORK_IN_UPPER_NODES(void);
STD_PROTO(static inline void PUT_IDLE, (int)); static inline void PUT_IDLE(int);
STD_PROTO(static inline void PUT_BUSY, (int)); static inline void PUT_BUSY(int);
STD_PROTO(static inline void PUT_IN_ROOT_NODE, (int)); static inline void PUT_IN_ROOT_NODE(int);
STD_PROTO(static inline void PUT_OUT_ROOT_NODE, (int)); static inline void PUT_OUT_ROOT_NODE(int);
STD_PROTO(static inline void move_up_to_prune_request, (void)); static inline void move_up_to_prune_request(void);
static inline static inline