From 743c9c69fb036a30a3c24daeba881a72e4067e08 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Thu, 25 Apr 2013 17:15:04 -0500 Subject: [PATCH] get rid of PROTO --- C/adtdefs.c | 5 +- C/agc.c | 4 +- C/alloc.c | 12 +- C/amasm.c | 120 ++++---- C/analyst.c | 6 +- C/arrays.c | 24 +- C/c_interface.c | 376 ++++++++++++------------ C/cdmgr.c | 90 +++--- C/cmppreds.c | 28 +- C/compiler.c | 50 ++-- C/computils.c | 2 +- C/dbase.c | 118 ++++---- C/depth_bound.c | 4 +- C/errors.c | 8 +- C/exec.c | 10 +- C/grow.c | 44 +-- C/heapgc.c | 44 +-- C/index.c | 8 +- C/init.c | 22 +- C/inlines.c | 30 +- C/iopreds.c | 12 +- C/load_foreign.c | 2 +- C/load_shl.c | 2 +- C/mavar.c | 10 +- C/modules.c | 4 +- C/parser.c | 10 +- C/pl-yap.c | 2 +- C/qlyr.c | 4 +- C/qlyw.c | 4 +- C/save.c | 88 +++--- C/scanner.c | 4 +- C/sort.c | 16 +- C/stdpreds.c | 121 ++++---- C/sysbits.c | 62 ++-- C/tracer.c | 2 +- C/unify.c | 12 +- C/userpreds.c | 28 +- C/utilpreds.c | 20 +- C/write.c | 18 +- H/Foreign.h | 19 +- H/TermExt.h | 14 +- H/YapHeap.h | 8 +- H/Yapproto.h | 580 +++++++++++++++++++------------------- H/Yatom.h | 52 ++-- H/alloc.h | 6 +- H/amiops.h | 4 +- H/clause.h | 66 ++--- H/compile.h | 20 +- H/dlmalloc.h | 4 +- H/eval.h | 178 ++++++------ H/heapgc.h | 6 +- H/iopreds.h | 6 +- H/rheap.h | 6 +- H/sshift.h | 4 +- H/threads.h | 14 +- H/tracer.h | 6 +- H/yapio.h | 66 ++--- MYDDAS/myddas_mysql.c | 24 +- MYDDAS/myddas_odbc.c | 18 +- MYDDAS/myddas_shared.c | 30 +- MYDDAS/myddas_top_level.c | 2 +- OPTYap/or.cow_engine.c | 2 +- OPTYap/or.macros.h | 44 +-- OPTYap/or.scheduler.c | 12 +- 64 files changed, 1302 insertions(+), 1315 deletions(-) diff --git a/C/adtdefs.c b/C/adtdefs.c index 5e0167045..f2c391a9b 100755 --- a/C/adtdefs.c +++ b/C/adtdefs.c @@ -26,9 +26,8 @@ static char SccsId[] = "%W% %G%"; #endif #include "Yap.h" -ADDR STD_PROTO(Yap_PreAllocCodeSpace, (void)); -Prop STD_PROTO(PredPropByFunc,(Functor, Term)); -Prop STD_PROTO(PredPropByAtom,(Atom, Term)); +static Prop PredPropByFunc(Functor, Term); +static Prop PredPropByAtom(Atom, Term); #include "Yatom.h" #include "yapio.h" #include diff --git a/C/agc.c b/C/agc.c index d5d35e5b1..1f13e791f 100644 --- a/C/agc.c +++ b/C/agc.c @@ -32,8 +32,8 @@ static char SccsId[] = "@(#)agc.c 1.3 3/15/90"; #define errout GLOBAL_stderr #endif -STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS)); -STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS)); +static void RestoreEntries(PropEntry *, int USES_REGS); +static void CleanCode(PredEntry * USES_REGS); #define AtomMarkedBit 1 diff --git a/C/alloc.c b/C/alloc.c index 5b4221a3e..a49c91ee0 100644 --- a/C/alloc.c +++ b/C/alloc.c @@ -482,11 +482,11 @@ Yap_givemallinfo(void) #if !USE_DL_MALLOC -STATIC_PROTO(void FreeBlock, (BlockHeader *)); -STATIC_PROTO(BlockHeader *GetBlock, (unsigned long int)); -STATIC_PROTO(char *AllocHeap, (unsigned long int)); -STATIC_PROTO(void RemoveFromFreeList, (BlockHeader *)); -STATIC_PROTO(void AddToFreeList, (BlockHeader *)); +static void FreeBlock(BlockHeader *); +static BlockHeader *GetBlock(unsigned long int); +static char *AllocHeap(unsigned long int); +static void RemoveFromFreeList(BlockHeader *); +static void AddToFreeList(BlockHeader *); #define MinHGap 256*K @@ -1273,7 +1273,7 @@ Yap_FreeWorkSpace(void) \***********************************************************************/ #ifdef _AIX -char *STD_PROTO(sbrk, (int)); +char *sbrk(int); #endif diff --git a/C/amasm.c b/C/amasm.c index 62223ed11..70ece9840 100755 --- a/C/amasm.c +++ b/C/amasm.c @@ -214,73 +214,73 @@ typedef struct clause_info_struct { struct pred_entry *CurrentPred; } clause_info; -STATIC_PROTO(OPREG Var_Ref, (Ventry *, int)); -STATIC_PROTO(wamreg emit_xreg, (CELL)); -STATIC_PROTO(yslot emit_yreg, (CELL)); -STATIC_PROTO(wamreg emit_x, (CELL)); -STATIC_PROTO(yslot emit_y, (Ventry *)); -STATIC_PROTO(yamop *emit_a, (CELL)); -STATIC_PROTO(CELL *emit_bmlabel, (CELL, struct intermediates *)); -STATIC_PROTO(yamop *emit_ilabel, (CELL, struct intermediates *)); -STATIC_PROTO(Functor emit_f, (CELL)); -STATIC_PROTO(CELL emit_c, (CELL)); -STATIC_PROTO(COUNT emit_count, (CELL)); -STATIC_PROTO(OPCODE emit_op, (op_numbers)); -STATIC_PROTO(yamop *a_cle, (op_numbers, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_e, (op_numbers, yamop *, int)); -STATIC_PROTO(yamop *a_ue, (op_numbers, op_numbers, yamop *, int)); -STATIC_PROTO(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_PROTO(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_PROTO(yamop *a_vv, (op_numbers, op_numbers, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_glist, (int *, yamop *, int, struct intermediates *)); -STATIC_PROTO(void a_pair, (CELL *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_f, (CELL, op_numbers, yamop *, int)); -STATIC_PROTO(yamop *a_c, (CELL, op_numbers, yamop *, int)); -STATIC_PROTO(yamop *a_uc, (CELL, op_numbers, op_numbers, yamop *, int)); -STATIC_PROTO(yamop *a_n, (op_numbers, int, yamop *, int)); -STATIC_PROTO(yamop *a_un, (op_numbers, op_numbers, int, yamop *, int)); -STATIC_PROTO(yamop *a_nc, (CELL, op_numbers, int, yamop *, int)); -STATIC_PROTO(yamop *a_unc, (CELL, op_numbers, op_numbers, int, yamop *, int)); -STATIC_PROTO(yamop *a_r, (CELL, op_numbers, yamop *, int)); -STATIC_PROTO(yamop *a_p, (op_numbers, clause_info *, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_pl, (op_numbers, PredEntry *, yamop *, int)); -STATIC_PROTO(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_PROTO(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 OPREG Var_Ref(Ventry *, int); +static wamreg emit_xreg(CELL); +static yslot emit_yreg(CELL); +static wamreg emit_x(CELL); +static yslot emit_y(Ventry *); +static yamop *emit_a(CELL); +static CELL *emit_bmlabel(CELL, struct intermediates *); +static yamop *emit_ilabel(CELL, struct intermediates *); +static Functor emit_f(CELL); +static CELL emit_c(CELL); +static COUNT emit_count(CELL); +static OPCODE emit_op(op_numbers); +static yamop *a_cle(op_numbers, yamop *, int, struct intermediates *); +static yamop *a_e(op_numbers, yamop *, int); +static yamop *a_ue(op_numbers, op_numbers, yamop *, int); +static yamop *a_v(op_numbers, op_numbers, yamop *, int, struct PSEUDO *); +static yamop *a_uv(Ventry *,op_numbers, op_numbers, op_numbers, op_numbers, yamop *, int); +static yamop *a_vr(op_numbers, op_numbers, yamop *, int, struct intermediates *); +static yamop *a_rv(op_numbers, op_numbers, OPREG, yamop *, int, struct PSEUDO *); +static yamop *a_vv(op_numbers, op_numbers, yamop *, int, struct intermediates *); +static yamop *a_glist(int *, yamop *, int, struct intermediates *); +static void a_pair(CELL *, int, struct intermediates *); +static yamop *a_f(CELL, op_numbers, yamop *, int); +static yamop *a_c(CELL, op_numbers, yamop *, int); +static yamop *a_uc(CELL, op_numbers, op_numbers, yamop *, int); +static yamop *a_n(op_numbers, int, yamop *, int); +static yamop *a_un(op_numbers, op_numbers, int, yamop *, int); +static yamop *a_nc(CELL, op_numbers, int, yamop *, int); +static yamop *a_unc(CELL, op_numbers, op_numbers, int, yamop *, int); +static yamop *a_r(CELL, op_numbers, yamop *, int); +static yamop *a_p(op_numbers, clause_info *, yamop *, int, struct intermediates *); +static yamop *a_pl(op_numbers, PredEntry *, yamop *, int); +static yamop *a_l(CELL, op_numbers, yamop *, int, struct intermediates *); +static yamop *a_hx(op_numbers, union clause_obj *, int, yamop *, int, struct intermediates *); +static yamop *a_if(op_numbers, union clause_obj *, int, yamop *, int, struct intermediates *cip); +static yamop *a_cut(clause_info *,yamop *, int, struct intermediates *); #ifdef YAPOR -STATIC_PROTO(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_try(op_numbers, CELL, CELL, int, int, yamop *, int, struct intermediates *); +static yamop *a_either(op_numbers, CELL, CELL, int, yamop *, int, struct intermediates *); #else -STATIC_PROTO(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_try(op_numbers, CELL, CELL, yamop *, int, struct intermediates *); +static yamop *a_either(op_numbers, CELL, CELL, yamop *, int, struct intermediates *); #endif /* YAPOR */ -STATIC_PROTO(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_PROTO( -COUNT compile_cmp_flags, (char *)); -STATIC_PROTO(yamop *a_igl, (CELL, op_numbers, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_xigl, (op_numbers, yamop *, int, struct PSEUDO *)); -STATIC_PROTO(yamop *a_ucons, (int *, compiler_vm_op, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_uvar, (yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_wvar, (yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *do_pass, (int, yamop **, int, int *, int *,struct intermediates *, UInt CACHE_TYPE)); +static yamop *a_gl(op_numbers, yamop *, int, struct PSEUDO *, struct intermediates * CACHE_TYPE); +static yamop *a_bfunc(CELL, clause_info *, yamop *, int, struct intermediates *); +static +COUNT compile_cmp_flags(char *); +static yamop *a_igl(CELL, op_numbers, yamop *, int, struct intermediates *); +static yamop *a_xigl(op_numbers, yamop *, int, struct PSEUDO *); +static yamop *a_ucons(int *, compiler_vm_op, yamop *, int, struct intermediates *); +static yamop *a_uvar(yamop *, int, struct intermediates *); +static yamop *a_wvar(yamop *, int, struct intermediates *); +static yamop *do_pass(int, yamop **, int, int *, int *,struct intermediates *, UInt CACHE_TYPE); #ifdef DEBUG_OPCODES -STATIC_PROTO(void DumpOpCodes, (void)); +static void DumpOpCodes(void); #endif #ifdef SFUNC -STATIC_PROTO(void a_vsf, (int, yamop *, int, struct PSEUDO *)); -STATIC_PROTO(void a_asf, (int, yamop *, int, struct PSEUDO *)); +static void a_vsf(int, yamop *, int, struct PSEUDO *); +static void a_asf(int, yamop *, int, struct PSEUDO *); #endif -STATIC_PROTO(yamop *check_alloc, (clause_info *, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_deallocate, (clause_info *, yamop *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_bmap, (yamop *, int, struct PSEUDO *)); -STATIC_PROTO(void a_fetch_vv, (cmp_op_info *, int, struct intermediates *)); -STATIC_PROTO(void a_fetch_cv, (cmp_op_info *, int, struct intermediates *)); -STATIC_PROTO(void a_fetch_vc, (cmp_op_info *, int, struct intermediates *)); -STATIC_PROTO(yamop *a_f2, (cmp_op_info *, yamop *, int, struct intermediates *)); +static yamop *check_alloc(clause_info *, yamop *, int, struct intermediates *); +static yamop *a_deallocate(clause_info *, yamop *, int, struct intermediates *); +static yamop *a_bmap(yamop *, int, struct PSEUDO *); +static void a_fetch_vv(cmp_op_info *, int, struct intermediates *); +static void a_fetch_cv(cmp_op_info *, int, struct intermediates *); +static void a_fetch_vc(cmp_op_info *, int, struct intermediates *); +static yamop *a_f2(cmp_op_info *, yamop *, int, struct intermediates *); #define CELLSIZE sizeof(CELL) diff --git a/C/analyst.c b/C/analyst.c index ec6b95985..d268f728f 100644 --- a/C/analyst.c +++ b/C/analyst.c @@ -31,9 +31,9 @@ static char SccsId[] = "%W% %G%"; -STATIC_PROTO(Int p_reset_op_counters, (void)); -STATIC_PROTO(Int p_show_op_counters, (void)); -STATIC_PROTO(Int p_show_ops_by_group, (void)); +static Int p_reset_op_counters(void); +static Int p_show_op_counters(void); +static Int p_show_ops_by_group(void); static Int p_reset_op_counters() diff --git a/C/arrays.c b/C/arrays.c index d87a081cb..90550d778 100644 --- a/C/arrays.c +++ b/C/arrays.c @@ -34,9 +34,9 @@ extern int errno; #endif #endif -STATIC_PROTO(Int p_compile_array_refs, ( USES_REGS1 )); -STATIC_PROTO(Int p_array_refs_compiled, ( USES_REGS1 )); -STATIC_PROTO(Int p_sync_mmapped_arrays, ( USES_REGS1 )); +static Int p_compile_array_refs( USES_REGS1 ); +static Int p_array_refs_compiled( 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_PROTO(Int p_create_mmapped_array, ( USES_REGS1 )); -STATIC_PROTO(Int p_array_references, ( USES_REGS1 )); -STATIC_PROTO(Int p_create_static_array, ( USES_REGS1 )); -STATIC_PROTO(Int p_resize_static_array, ( USES_REGS1 )); -STATIC_PROTO(Int p_close_static_array, ( USES_REGS1 )); -STATIC_PROTO(Int p_access_array, ( USES_REGS1 )); -STATIC_PROTO(Int p_assign_static, ( USES_REGS1 )); -STATIC_PROTO(Int p_assign_dynamic, ( USES_REGS1 )); +static Int p_create_array( USES_REGS1 ); +static Int p_create_mmapped_array( USES_REGS1 ); +static Int p_array_references( USES_REGS1 ); +static Int p_create_static_array( USES_REGS1 ); +static Int p_resize_static_array( USES_REGS1 ); +static Int p_close_static_array( USES_REGS1 ); +static Int p_access_array( USES_REGS1 ); +static Int p_assign_static( USES_REGS1 ); +static Int p_assign_dynamic( USES_REGS1 ); #if HAVE_MMAP diff --git a/C/c_interface.c b/C/c_interface.c index e683eb21b..c9260b55d 100644 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -377,196 +377,196 @@ #define X_API #endif -X_API Term STD_PROTO(YAP_A,(int)); -X_API Term STD_PROTO(YAP_Deref,(Term)); -X_API Term STD_PROTO(YAP_MkVarTerm,(void)); -X_API Bool STD_PROTO(YAP_IsVarTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsNonVarTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsIntTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsLongIntTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsBigNumTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsNumberTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsRationalTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsFloatTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsDbRefTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsAtomTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsPairTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsApplTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsCompoundTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsExternalDataInStackTerm,(Term)); -X_API Bool STD_PROTO(YAP_IsOpaqueObjectTerm,(Term, int)); -X_API Term STD_PROTO(YAP_MkIntTerm,(Int)); -X_API Term STD_PROTO(YAP_MkBigNumTerm,(void *)); -X_API Term STD_PROTO(YAP_MkRationalTerm,(void *)); -X_API Int STD_PROTO(YAP_IntOfTerm,(Term)); -X_API void STD_PROTO(YAP_BigNumOfTerm,(Term, void *)); -X_API void STD_PROTO(YAP_RationalOfTerm,(Term, void *)); -X_API Term STD_PROTO(YAP_MkFloatTerm,(flt)); -X_API flt STD_PROTO(YAP_FloatOfTerm,(Term)); -X_API Term STD_PROTO(YAP_MkAtomTerm,(Atom)); -X_API Atom STD_PROTO(YAP_AtomOfTerm,(Term)); -X_API Atom STD_PROTO(YAP_LookupAtom,(char *)); -X_API Atom STD_PROTO(YAP_LookupWideAtom,(wchar_t *)); -X_API size_t STD_PROTO(YAP_AtomNameLength,(Atom)); -X_API Atom STD_PROTO(YAP_FullLookupAtom,(char *)); -X_API int STD_PROTO(YAP_IsWideAtom,(Atom)); -X_API char *STD_PROTO(YAP_AtomName,(Atom)); -X_API wchar_t *STD_PROTO(YAP_WideAtomName,(Atom)); -X_API Term STD_PROTO(YAP_MkPairTerm,(Term,Term)); -X_API Term STD_PROTO(YAP_MkListFromTerms,(Term *,Int)); -X_API Term STD_PROTO(YAP_MkNewPairTerm,(void)); -X_API Term STD_PROTO(YAP_HeadOfTerm,(Term)); -X_API Term STD_PROTO(YAP_TailOfTerm,(Term)); -X_API Int STD_PROTO(YAP_SkipList,(Term *, Term **)); -X_API Term STD_PROTO(YAP_MkApplTerm,(Functor,UInt,Term *)); -X_API Term STD_PROTO(YAP_MkNewApplTerm,(Functor,UInt)); -X_API Functor STD_PROTO(YAP_FunctorOfTerm,(Term)); -X_API Term STD_PROTO(YAP_ArgOfTerm,(Int,Term)); -X_API Term *STD_PROTO(YAP_ArgsOfTerm,(Term)); -X_API Functor STD_PROTO(YAP_MkFunctor,(Atom,Int)); -X_API Atom STD_PROTO(YAP_NameOfFunctor,(Functor)); -X_API Int STD_PROTO(YAP_ArityOfFunctor,(Functor)); -X_API void *STD_PROTO(YAP_ExtraSpace,(void)); -X_API void STD_PROTO(YAP_cut_up,(void)); -X_API Int STD_PROTO(YAP_Unify,(Term,Term)); -X_API int STD_PROTO(YAP_Unifiable,(Term,Term)); -X_API int STD_PROTO(YAP_Reset,(void)); -X_API Int STD_PROTO(YAP_ListLength,(Term)); -X_API Int STD_PROTO(YAP_Init,(YAP_init_args *)); -X_API Int STD_PROTO(YAP_FastInit,(char *)); -X_API PredEntry *STD_PROTO(YAP_FunctorToPred,(Functor)); -X_API PredEntry *STD_PROTO(YAP_AtomToPred,(Atom)); -X_API PredEntry *STD_PROTO(YAP_FunctorToPredInModule,(Functor, Term)); -X_API PredEntry *STD_PROTO(YAP_AtomToPredInModule,(Atom, Term)); -X_API Int STD_PROTO(YAP_CallProlog,(Term)); -X_API void *STD_PROTO(YAP_AllocSpaceFromYap,(size_t)); -X_API void *STD_PROTO(YAP_ReallocSpaceFromYap,(void*,size_t)); -X_API void STD_PROTO(YAP_FreeSpaceFromYap,(void *)); -X_API int STD_PROTO(YAP_StringToBuffer, (Term, char *, unsigned int)); -X_API Term STD_PROTO(YAP_ReadBuffer, (char *,Term *)); -X_API Term STD_PROTO(YAP_FloatsToList, (double *, size_t)); -X_API Int STD_PROTO(YAP_ListToFloats, (Term, double *, size_t)); -X_API Term STD_PROTO(YAP_IntsToList, (Int *, size_t)); -X_API Int STD_PROTO(YAP_ListToInts, (Term, Int *, size_t)); -X_API Term STD_PROTO(YAP_BufferToString, (char *)); -X_API Term STD_PROTO(YAP_NBufferToString, (char *, size_t)); -X_API Term STD_PROTO(YAP_WideBufferToString, (wchar_t *)); -X_API Term STD_PROTO(YAP_NWideBufferToString, (wchar_t *, size_t)); -X_API Term STD_PROTO(YAP_BufferToAtomList, (char *)); -X_API Term STD_PROTO(YAP_NBufferToAtomList, (char *,size_t)); -X_API Term STD_PROTO(YAP_WideBufferToAtomList, (wchar_t *)); -X_API Term STD_PROTO(YAP_NWideBufferToAtomList, (wchar_t *, size_t)); -X_API Term STD_PROTO(YAP_NWideBufferToAtomDiffList, (wchar_t *, Term, size_t)); -X_API Term STD_PROTO(YAP_BufferToDiffList, (char *, Term)); -X_API Term STD_PROTO(YAP_NBufferToDiffList, (char *, Term, size_t)); -X_API Term STD_PROTO(YAP_WideBufferToDiffList, (wchar_t *, Term)); -X_API Term STD_PROTO(YAP_NWideBufferToDiffList, (wchar_t *, Term, size_t)); -X_API void STD_PROTO(YAP_Error,(int, Term, char *, ...)); -X_API Int STD_PROTO(YAP_RunPredicate,(PredEntry *, Term *)); -X_API Int STD_PROTO(YAP_RunGoal,(Term)); -X_API Int STD_PROTO(YAP_RunGoalOnce,(Term)); -X_API int STD_PROTO(YAP_RestartGoal,(void)); -X_API int STD_PROTO(YAP_ShutdownGoal,(int)); -X_API int STD_PROTO(YAP_EnterGoal,(PredEntry *, Term *, YAP_dogoalinfo *)); -X_API int STD_PROTO(YAP_RetryGoal,(YAP_dogoalinfo *)); -X_API int STD_PROTO(YAP_LeaveGoal,(int, YAP_dogoalinfo *)); -X_API int STD_PROTO(YAP_GoalHasException,(Term *)); -X_API void STD_PROTO(YAP_ClearExceptions,(void)); -X_API int STD_PROTO(YAP_ContinueGoal,(void)); -X_API void STD_PROTO(YAP_PruneGoal,(YAP_dogoalinfo *)); -X_API IOSTREAM *STD_PROTO(YAP_TermToStream,(Term)); -X_API IOSTREAM *STD_PROTO(YAP_InitConsult,(int, char *)); -X_API void STD_PROTO(YAP_EndConsult,(IOSTREAM *)); -X_API Term STD_PROTO(YAP_Read, (IOSTREAM *)); -X_API void STD_PROTO(YAP_Write, (Term, IOSTREAM *, int)); -X_API Term STD_PROTO(YAP_CopyTerm, (Term)); -X_API int STD_PROTO(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 *STD_PROTO(YAP_CompileClause, (Term)); -X_API void STD_PROTO(YAP_PutValue, (Atom,Term)); -X_API Term STD_PROTO(YAP_GetValue, (Atom)); -X_API int STD_PROTO(YAP_CompareTerms, (Term,Term)); -X_API void STD_PROTO(YAP_Exit, (int)); -X_API void STD_PROTO(YAP_InitSocks, (char *, long)); -X_API void STD_PROTO(YAP_SetOutputMessage, (void)); -X_API int STD_PROTO(YAP_StreamToFileNo, (Term)); -X_API void STD_PROTO(YAP_CloseAllOpenStreams,(void)); -X_API void STD_PROTO(YAP_FlushAllStreams,(void)); -X_API Int STD_PROTO(YAP_CurrentSlot,(void)); -X_API Int STD_PROTO(YAP_NewSlots,(int)); -X_API Int STD_PROTO(YAP_InitSlot,(Term)); -X_API Term STD_PROTO(YAP_GetFromSlot,(Int)); -X_API Term *STD_PROTO(YAP_AddressFromSlot,(Int)); -X_API Term *STD_PROTO(YAP_AddressOfTermInSlot,(Int)); -X_API void STD_PROTO(YAP_PutInSlot,(Int, Term)); -X_API int STD_PROTO(YAP_RecoverSlots,(int)); -X_API Int STD_PROTO(YAP_ArgsToSlots,(int)); -X_API void STD_PROTO(YAP_SlotsToArgs,(int, Int)); -X_API void STD_PROTO(YAP_Throw,(Term)); -X_API void STD_PROTO(YAP_AsyncThrow,(Term)); -X_API void STD_PROTO(YAP_Halt,(int)); -X_API Term *STD_PROTO(YAP_TopOfLocalStack,(void)); -X_API void *STD_PROTO(YAP_Predicate,(Atom,UInt,Term)); -X_API void STD_PROTO(YAP_PredicateInfo,(void *,Atom *,UInt *,Term *)); -X_API void STD_PROTO(YAP_UserCPredicate,(char *,CPredicate,UInt)); -X_API void STD_PROTO(YAP_UserBackCPredicate,(char *,CPredicate,CPredicate,UInt,unsigned int)); -X_API void STD_PROTO(YAP_UserCPredicateWithArgs,(char *,CPredicate,UInt,Term)); +X_API Term YAP_A(int); +X_API Term YAP_Deref(Term); +X_API Term YAP_MkVarTerm(void); +X_API Bool YAP_IsVarTerm(Term); +X_API Bool YAP_IsNonVarTerm(Term); +X_API Bool YAP_IsIntTerm(Term); +X_API Bool YAP_IsLongIntTerm(Term); +X_API Bool YAP_IsBigNumTerm(Term); +X_API Bool YAP_IsNumberTerm(Term); +X_API Bool YAP_IsRationalTerm(Term); +X_API Bool YAP_IsFloatTerm(Term); +X_API Bool YAP_IsDbRefTerm(Term); +X_API Bool YAP_IsAtomTerm(Term); +X_API Bool YAP_IsPairTerm(Term); +X_API Bool YAP_IsApplTerm(Term); +X_API Bool YAP_IsCompoundTerm(Term); +X_API Bool YAP_IsExternalDataInStackTerm(Term); +X_API Bool YAP_IsOpaqueObjectTerm(Term, int); +X_API Term YAP_MkIntTerm(Int); +X_API Term YAP_MkBigNumTerm(void *); +X_API Term YAP_MkRationalTerm(void *); +X_API Int YAP_IntOfTerm(Term); +X_API void YAP_BigNumOfTerm(Term, void *); +X_API void YAP_RationalOfTerm(Term, void *); +X_API Term YAP_MkFloatTerm(flt); +X_API flt YAP_FloatOfTerm(Term); +X_API Term YAP_MkAtomTerm(Atom); +X_API Atom YAP_AtomOfTerm(Term); +X_API Atom YAP_LookupAtom(char *); +X_API Atom YAP_LookupWideAtom(wchar_t *); +X_API size_t YAP_AtomNameLength(Atom); +X_API Atom YAP_FullLookupAtom(char *); +X_API int YAP_IsWideAtom(Atom); +X_API char *YAP_AtomName(Atom); +X_API wchar_t *YAP_WideAtomName(Atom); +X_API Term YAP_MkPairTerm(Term,Term); +X_API Term YAP_MkListFromTerms(Term *,Int); +X_API Term YAP_MkNewPairTerm(void); +X_API Term YAP_HeadOfTerm(Term); +X_API Term YAP_TailOfTerm(Term); +X_API Int YAP_SkipList(Term *, Term **); +X_API Term YAP_MkApplTerm(Functor,UInt,Term *); +X_API Term YAP_MkNewApplTerm(Functor,UInt); +X_API Functor YAP_FunctorOfTerm(Term); +X_API Term YAP_ArgOfTerm(Int,Term); +X_API Term *YAP_ArgsOfTerm(Term); +X_API Functor YAP_MkFunctor(Atom,Int); +X_API Atom YAP_NameOfFunctor(Functor); +X_API Int YAP_ArityOfFunctor(Functor); +X_API void *YAP_ExtraSpace(void); +X_API void YAP_cut_up(void); +X_API Int YAP_Unify(Term,Term); +X_API int YAP_Unifiable(Term,Term); +X_API int YAP_Reset(void); +X_API Int YAP_ListLength(Term); +X_API Int YAP_Init(YAP_init_args *); +X_API Int YAP_FastInit(char *); +X_API PredEntry *YAP_FunctorToPred(Functor); +X_API PredEntry *YAP_AtomToPred(Atom); +X_API PredEntry *YAP_FunctorToPredInModule(Functor, Term); +X_API PredEntry *YAP_AtomToPredInModule(Atom, Term); +X_API Int YAP_CallProlog(Term); +X_API void *YAP_AllocSpaceFromYap(size_t); +X_API void *YAP_ReallocSpaceFromYap(void*,size_t); +X_API void YAP_FreeSpaceFromYap(void *); +X_API int YAP_StringToBuffer(Term, char *, unsigned int); +X_API Term YAP_ReadBuffer(char *,Term *); +X_API Term YAP_FloatsToList(double *, size_t); +X_API Int YAP_ListToFloats(Term, double *, size_t); +X_API Term YAP_IntsToList(Int *, size_t); +X_API Int YAP_ListToInts(Term, Int *, size_t); +X_API Term YAP_BufferToString(char *); +X_API Term YAP_NBufferToString(char *, size_t); +X_API Term YAP_WideBufferToString(wchar_t *); +X_API Term YAP_NWideBufferToString(wchar_t *, size_t); +X_API Term YAP_BufferToAtomList(char *); +X_API Term YAP_NBufferToAtomList(char *,size_t); +X_API Term YAP_WideBufferToAtomList(wchar_t *); +X_API Term YAP_NWideBufferToAtomList(wchar_t *, size_t); +X_API Term YAP_NWideBufferToAtomDiffList(wchar_t *, Term, size_t); +X_API Term YAP_BufferToDiffList(char *, Term); +X_API Term YAP_NBufferToDiffList(char *, Term, size_t); +X_API Term YAP_WideBufferToDiffList(wchar_t *, Term); +X_API Term YAP_NWideBufferToDiffList(wchar_t *, Term, size_t); +X_API void YAP_Error(int, Term, char *, ...); +X_API Int YAP_RunPredicate(PredEntry *, Term *); +X_API Int YAP_RunGoal(Term); +X_API Int YAP_RunGoalOnce(Term); +X_API int YAP_RestartGoal(void); +X_API int YAP_ShutdownGoal(int); +X_API int YAP_EnterGoal(PredEntry *, Term *, YAP_dogoalinfo *); +X_API int YAP_RetryGoal(YAP_dogoalinfo *); +X_API int YAP_LeaveGoal(int, YAP_dogoalinfo *); +X_API int YAP_GoalHasException(Term *); +X_API void YAP_ClearExceptions(void); +X_API int YAP_ContinueGoal(void); +X_API void YAP_PruneGoal(YAP_dogoalinfo *); +X_API IOSTREAM *YAP_TermToStream(Term); +X_API IOSTREAM *YAP_InitConsult(int, char *); +X_API void YAP_EndConsult(IOSTREAM *); +X_API Term YAP_Read(IOSTREAM *); +X_API void YAP_Write(Term, IOSTREAM *, int); +X_API Term YAP_CopyTerm(Term); +X_API int YAP_WriteBuffer(Term, char *, size_t, int); +X_API char *YAP_WriteDynamicBuffer(Term, char *, size_t, size_t *, int *, int); +X_API char *YAP_CompileClause(Term); +X_API void YAP_PutValue(Atom,Term); +X_API Term YAP_GetValue(Atom); +X_API int YAP_CompareTerms(Term,Term); +X_API void YAP_Exit(int); +X_API void YAP_InitSocks(char *, long); +X_API void YAP_SetOutputMessage(void); +X_API int YAP_StreamToFileNo(Term); +X_API void YAP_CloseAllOpenStreams(void); +X_API void YAP_FlushAllStreams(void); +X_API Int YAP_CurrentSlot(void); +X_API Int YAP_NewSlots(int); +X_API Int YAP_InitSlot(Term); +X_API Term YAP_GetFromSlot(Int); +X_API Term *YAP_AddressFromSlot(Int); +X_API Term *YAP_AddressOfTermInSlot(Int); +X_API void YAP_PutInSlot(Int, Term); +X_API int YAP_RecoverSlots(int); +X_API Int YAP_ArgsToSlots(int); +X_API void YAP_SlotsToArgs(int, Int); +X_API void YAP_Throw(Term); +X_API void YAP_AsyncThrow(Term); +X_API void YAP_Halt(int); +X_API Term *YAP_TopOfLocalStack(void); +X_API void *YAP_Predicate(Atom,UInt,Term); +X_API void YAP_PredicateInfo(void *,Atom *,UInt *,Term *); +X_API void YAP_UserCPredicate(char *,CPredicate,UInt); +X_API void YAP_UserBackCPredicate(char *,CPredicate,CPredicate,UInt,unsigned int); +X_API void YAP_UserCPredicateWithArgs(char *,CPredicate,UInt,Term); #ifdef CUT_C -X_API void STD_PROTO(YAP_UserBackCutCPredicate,(char *,CPredicate,CPredicate,CPredicate,UInt,unsigned int)); -X_API void *STD_PROTO(YAP_ExtraSpaceCut,(void)); +X_API void YAP_UserBackCutCPredicate(char *,CPredicate,CPredicate,CPredicate,UInt,unsigned int); +X_API void *YAP_ExtraSpaceCut(void); #endif -X_API Term STD_PROTO(YAP_SetCurrentModule,(Term)); -X_API Term STD_PROTO(YAP_CurrentModule,(void)); -X_API Term STD_PROTO(YAP_CreateModule,(Atom)); -X_API Term STD_PROTO(YAP_StripModule,(Term, Term *)); -X_API int STD_PROTO(YAP_ThreadSelf,(void)); -X_API int STD_PROTO(YAP_ThreadCreateEngine,(struct thread_attr_struct *)); -X_API int STD_PROTO(YAP_ThreadAttachEngine,(int)); -X_API int STD_PROTO(YAP_ThreadDetachEngine,(int)); -X_API int STD_PROTO(YAP_ThreadDestroyEngine,(int)); -X_API Term STD_PROTO(YAP_MkBlobTerm,(unsigned int)); -X_API void *STD_PROTO(YAP_BlobOfTerm,(Term)); -X_API Term STD_PROTO(YAP_TermNil,(void)); -X_API int STD_PROTO(YAP_IsTermNil,(Term)); -X_API int STD_PROTO(YAP_AtomGetHold,(Atom)); -X_API int STD_PROTO(YAP_AtomReleaseHold,(Atom)); -X_API Agc_hook STD_PROTO(YAP_AGCRegisterHook,(Agc_hook)); -X_API int STD_PROTO(YAP_HaltRegisterHook,(HaltHookFunc, void *)); -X_API char *STD_PROTO(YAP_cwd,(void)); -X_API Term STD_PROTO(YAP_OpenList,(int)); -X_API Term STD_PROTO(YAP_ExtendList,(Term, Term)); -X_API int STD_PROTO(YAP_CloseList,(Term, Term)); -X_API int STD_PROTO(YAP_IsAttVar,(Term)); -X_API Term STD_PROTO(YAP_AttsOfVar,(Term)); -X_API int STD_PROTO(YAP_FileNoFromStream,(Term)); -X_API void *STD_PROTO(YAP_FileDescriptorFromStream,(Term)); -X_API void *STD_PROTO(YAP_Record,(Term)); -X_API Term STD_PROTO(YAP_Recorded,(void *)); -X_API int STD_PROTO(YAP_Erase,(void *)); -X_API int STD_PROTO(YAP_Variant,(Term, Term)); -X_API Int STD_PROTO(YAP_NumberVars,(Term, Int)); -X_API Term STD_PROTO(YAP_UnNumberVars,(Term)); -X_API int STD_PROTO(YAP_IsNumberedVariable,(Term)); -X_API int STD_PROTO(YAP_ExactlyEqual,(Term, Term)); -X_API Int STD_PROTO(YAP_TermHash,(Term, Int, Int, int)); -X_API void STD_PROTO(YAP_signal,(int)); -X_API int STD_PROTO(YAP_SetYAPFlag,(yap_flag_t, int)); -X_API Int STD_PROTO(YAP_VarSlotToNumber,(Int)); -X_API Term STD_PROTO(YAP_ModuleUser,(void)); -X_API Int STD_PROTO(YAP_NumberOfClausesForPredicate,(PredEntry *)); -X_API int STD_PROTO(YAP_MaxOpPriority,(Atom, Term)); -X_API int STD_PROTO(YAP_OpInfo,(Atom, Term, int, int *, int *)); -X_API Term STD_PROTO(YAP_AllocExternalDataInStack,(size_t)); -X_API void *STD_PROTO(YAP_ExternalDataInStackFromTerm,(Term)); -X_API int STD_PROTO(YAP_NewOpaqueType,(void *)); -X_API Term STD_PROTO(YAP_NewOpaqueObject,(int, size_t)); -X_API void *STD_PROTO(YAP_OpaqueObjectFromTerm,(Term)); -X_API int STD_PROTO(YAP_Argv,(char *** argvp)); -X_API YAP_tag_t STD_PROTO(YAP_TagOfTerm,(Term)); -X_API size_t STD_PROTO(YAP_ExportTerm,(Term, char *, size_t)); -X_API size_t STD_PROTO(YAP_SizeOfExportedTerm,(char *)); -X_API Term STD_PROTO(YAP_ImportTerm,(char *)); -X_API int STD_PROTO(YAP_RequiresExtraStack,(size_t)); +X_API Term YAP_SetCurrentModule(Term); +X_API Term YAP_CurrentModule(void); +X_API Term YAP_CreateModule(Atom); +X_API Term YAP_StripModule(Term, Term *); +X_API int YAP_ThreadSelf(void); +X_API int YAP_ThreadCreateEngine(struct thread_attr_struct *); +X_API int YAP_ThreadAttachEngine(int); +X_API int YAP_ThreadDetachEngine(int); +X_API int YAP_ThreadDestroyEngine(int); +X_API Term YAP_MkBlobTerm(unsigned int); +X_API void *YAP_BlobOfTerm(Term); +X_API Term YAP_TermNil(void); +X_API int YAP_IsTermNil(Term); +X_API int YAP_AtomGetHold(Atom); +X_API int YAP_AtomReleaseHold(Atom); +X_API Agc_hook YAP_AGCRegisterHook(Agc_hook); +X_API int YAP_HaltRegisterHook(HaltHookFunc, void *); +X_API char *YAP_cwd(void); +X_API Term YAP_OpenList(int); +X_API Term YAP_ExtendList(Term, Term); +X_API int YAP_CloseList(Term, Term); +X_API int YAP_IsAttVar(Term); +X_API Term YAP_AttsOfVar(Term); +X_API int YAP_FileNoFromStream(Term); +X_API void *YAP_FileDescriptorFromStream(Term); +X_API void *YAP_Record(Term); +X_API Term YAP_Recorded(void *); +X_API int YAP_Erase(void *); +X_API int YAP_Variant(Term, Term); +X_API Int YAP_NumberVars(Term, Int); +X_API Term YAP_UnNumberVars(Term); +X_API int YAP_IsNumberedVariable(Term); +X_API int YAP_ExactlyEqual(Term, Term); +X_API Int YAP_TermHash(Term, Int, Int, int); +X_API void YAP_signal(int); +X_API int YAP_SetYAPFlag(yap_flag_t, int); +X_API Int YAP_VarSlotToNumber(Int); +X_API Term YAP_ModuleUser(void); +X_API Int YAP_NumberOfClausesForPredicate(PredEntry *); +X_API int YAP_MaxOpPriority(Atom, Term); +X_API int YAP_OpInfo(Atom, Term, int, int *, int *); +X_API Term YAP_AllocExternalDataInStack(size_t); +X_API void *YAP_ExternalDataInStackFromTerm(Term); +X_API int YAP_NewOpaqueType(void *); +X_API Term YAP_NewOpaqueObject(int, size_t); +X_API void *YAP_OpaqueObjectFromTerm(Term); +X_API int YAP_Argv(char *** argvp); +X_API YAP_tag_t YAP_TagOfTerm(Term); +X_API size_t YAP_ExportTerm(Term, char *, size_t); +X_API size_t YAP_SizeOfExportedTerm(char *); +X_API Term YAP_ImportTerm(char *); +X_API int YAP_RequiresExtraStack(size_t); static UInt current_arity(void) diff --git a/C/cdmgr.c b/C/cdmgr.c index cba627968..35828e7cd 100644 --- a/C/cdmgr.c +++ b/C/cdmgr.c @@ -473,53 +473,53 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98"; #endif -STATIC_PROTO(void retract_all, (PredEntry *, int)); -STATIC_PROTO(void add_first_static, (PredEntry *, yamop *, int)); -STATIC_PROTO(void add_first_dynamic, (PredEntry *, yamop *, int)); -STATIC_PROTO(void asserta_stat_clause, (PredEntry *, yamop *, int)); -STATIC_PROTO(void asserta_dynam_clause, (PredEntry *, yamop *)); -STATIC_PROTO(void assertz_stat_clause, (PredEntry *, yamop *, int)); -STATIC_PROTO(void assertz_dynam_clause, (PredEntry *, yamop *)); -STATIC_PROTO(void expand_consult, ( void )); -STATIC_PROTO(int not_was_reconsulted, (PredEntry *, Term, int)); -STATIC_PROTO(int RemoveIndexation, (PredEntry *)); -STATIC_PROTO(int static_in_use, (PredEntry *, int)); +static void retract_all(PredEntry *, int); +static void add_first_static(PredEntry *, yamop *, int); +static void add_first_dynamic(PredEntry *, yamop *, int); +static void asserta_stat_clause(PredEntry *, yamop *, int); +static void asserta_dynam_clause(PredEntry *, yamop *); +static void assertz_stat_clause(PredEntry *, yamop *, int); +static void assertz_dynam_clause(PredEntry *, yamop *); +static void expand_consult( void ); +static int not_was_reconsulted(PredEntry *, Term, int); +static int RemoveIndexation(PredEntry *); +static int static_in_use(PredEntry *, int); #if !defined(YAPOR) && !defined(THREADS) -STATIC_PROTO(Int search_for_static_predicate_in_use, (PredEntry *, int)); -STATIC_PROTO(void mark_pred, (int, PredEntry *)); -STATIC_PROTO(void do_toggle_static_predicates_in_use, (int)); +static Int search_for_static_predicate_in_use(PredEntry *, int); +static void mark_pred(int, PredEntry *); +static void do_toggle_static_predicates_in_use(int); #endif -STATIC_PROTO(Int p_number_of_clauses, ( USES_REGS1 )); -STATIC_PROTO(Int p_compile, ( USES_REGS1 )); -STATIC_PROTO(Int p_compile_dynamic, ( USES_REGS1 )); -STATIC_PROTO(Int p_purge_clauses, ( USES_REGS1 )); -STATIC_PROTO(Int p_setspy, ( USES_REGS1 )); -STATIC_PROTO(Int p_rmspy, ( USES_REGS1 )); -STATIC_PROTO(Int p_startconsult, ( USES_REGS1 )); -STATIC_PROTO(Int p_showconslultlev, ( USES_REGS1 )); -STATIC_PROTO(Int p_endconsult, ( USES_REGS1 )); -STATIC_PROTO(Int p_undefined, ( USES_REGS1 )); -STATIC_PROTO(Int p_in_use, ( USES_REGS1 )); -STATIC_PROTO(Int p_new_multifile, ( USES_REGS1 )); -STATIC_PROTO(Int p_is_multifile, ( USES_REGS1 )); -STATIC_PROTO(Int p_optimizer_on, ( USES_REGS1 )); -STATIC_PROTO(Int p_optimizer_off, ( USES_REGS1 )); -STATIC_PROTO(Int p_is_dynamic, ( USES_REGS1 )); -STATIC_PROTO(Int p_kill_dynamic, ( USES_REGS1 )); -STATIC_PROTO(Int p_compile_mode, ( USES_REGS1 )); -STATIC_PROTO(Int p_is_profiled, ( USES_REGS1 )); -STATIC_PROTO(Int p_profile_info, ( USES_REGS1 )); -STATIC_PROTO(Int p_profile_reset, ( USES_REGS1 )); -STATIC_PROTO(Int p_is_call_counted, ( USES_REGS1 )); -STATIC_PROTO(Int p_call_count_info, ( USES_REGS1 )); -STATIC_PROTO(Int p_call_count_set, ( USES_REGS1 )); -STATIC_PROTO(Int p_call_count_reset, ( USES_REGS1 )); -STATIC_PROTO(Int p_toggle_static_predicates_in_use, ( USES_REGS1 )); -STATIC_PROTO(Atom YapConsultingFile, ( USES_REGS1 )); -STATIC_PROTO(Int PredForCode,(yamop *, Atom *, UInt *, Term *)); -STATIC_PROTO(void kill_first_log_iblock,(LogUpdIndex *, LogUpdIndex *, PredEntry *)); -STATIC_PROTO(LogUpdIndex *find_owner_log_index,(LogUpdIndex *, yamop *)); -STATIC_PROTO(StaticIndex *find_owner_static_index,(StaticIndex *, yamop *)); +static Int p_number_of_clauses( USES_REGS1 ); +static Int p_compile( USES_REGS1 ); +static Int p_compile_dynamic( USES_REGS1 ); +static Int p_purge_clauses( USES_REGS1 ); +static Int p_setspy( USES_REGS1 ); +static Int p_rmspy( USES_REGS1 ); +static Int p_startconsult( USES_REGS1 ); +static Int p_showconslultlev( USES_REGS1 ); +static Int p_endconsult( USES_REGS1 ); +static Int p_undefined( USES_REGS1 ); +static Int p_in_use( USES_REGS1 ); +static Int p_new_multifile( USES_REGS1 ); +static Int p_is_multifile( USES_REGS1 ); +static Int p_optimizer_on( USES_REGS1 ); +static Int p_optimizer_off( USES_REGS1 ); +static Int p_is_dynamic( USES_REGS1 ); +static Int p_kill_dynamic( USES_REGS1 ); +static Int p_compile_mode( USES_REGS1 ); +static Int p_is_profiled( USES_REGS1 ); +static Int p_profile_info( USES_REGS1 ); +static Int p_profile_reset( USES_REGS1 ); +static Int p_is_call_counted( USES_REGS1 ); +static Int p_call_count_info( USES_REGS1 ); +static Int p_call_count_set( USES_REGS1 ); +static Int p_call_count_reset( USES_REGS1 ); +static Int p_toggle_static_predicates_in_use( USES_REGS1 ); +static Atom YapConsultingFile( USES_REGS1 ); +static Int PredForCode(yamop *, Atom *, UInt *, Term *); +static void kill_first_log_iblock(LogUpdIndex *, LogUpdIndex *, PredEntry *); +static LogUpdIndex *find_owner_log_index(LogUpdIndex *, yamop *); +static StaticIndex *find_owner_static_index(StaticIndex *, yamop *); #define PredArity(p) (p->ArityOfPE) #define TRYCODE(G,F,N) ( (N)<5 ? (op_numbers)((int)F+(N)*3) : G) diff --git a/C/cmppreds.c b/C/cmppreds.c index fcdb8fff8..1f13f76ae 100644 --- a/C/cmppreds.c +++ b/C/cmppreds.c @@ -27,20 +27,20 @@ static char SccsId[] = "%W% %G%"; #endif #include -STATIC_PROTO(Int compare, (Term, Term)); -STATIC_PROTO(Int p_compare, ( USES_REGS1 )); -STATIC_PROTO(Int p_acomp, ( USES_REGS1 )); -STATIC_PROTO(Int a_eq, (Term,Term)); -STATIC_PROTO(Int a_dif, (Term,Term)); -STATIC_PROTO(Int a_gt, (Term, Term)); -STATIC_PROTO(Int a_ge, (Term,Term)); -STATIC_PROTO(Int a_lt, (Term,Term)); -STATIC_PROTO(Int a_le, (Term,Term)); -STATIC_PROTO(Int a_noteq, (Term,Term)); -STATIC_PROTO(Int a_gen_lt, (Term,Term)); -STATIC_PROTO(Int a_gen_le, (Term,Term)); -STATIC_PROTO(Int a_gen_gt, (Term,Term)); -STATIC_PROTO(Int a_gen_ge, (Term,Term)); +static Int compare(Term, Term); +static Int p_compare( USES_REGS1 ); +static Int p_acomp( USES_REGS1 ); +static Int a_eq(Term,Term); +static Int a_dif(Term,Term); +static Int a_gt(Term, Term); +static Int a_ge(Term,Term); +static Int a_lt(Term,Term); +static Int a_le(Term,Term); +static Int a_noteq(Term,Term); +static Int a_gen_lt(Term,Term); +static Int a_gen_le(Term,Term); +static Int a_gen_gt(Term,Term); +static Int a_gen_ge(Term,Term); #define rfloat(X) ( X > 0.0 ? 1 : ( X == 0.0 ? 0 : -1)) diff --git a/C/compiler.c b/C/compiler.c index 610ae0e0e..6d3d7df64 100644 --- a/C/compiler.c +++ b/C/compiler.c @@ -224,35 +224,35 @@ typedef struct compiler_struct_struct { CIntermediates cint; } compiler_struct; -STATIC_PROTO(int active_branch, (int, int)); -STATIC_PROTO(void c_var, (Term, Int, unsigned int, unsigned int, compiler_struct *)); -STATIC_PROTO(void reset_vars, (Ventry *)); -STATIC_PROTO(Term optimize_ce, (Term, unsigned int, unsigned int, compiler_struct *)); -STATIC_PROTO(void c_arg, (Int, Term, unsigned int, unsigned int, compiler_struct *)); -STATIC_PROTO(void c_args, (Term, unsigned int, compiler_struct *)); -STATIC_PROTO(void c_eq, (Term, Term, compiler_struct *)); -STATIC_PROTO(void c_test, (Int, Term, compiler_struct *)); -STATIC_PROTO(void c_bifun, (basic_preds, Term, Term, Term, Term, Term, compiler_struct *)); -STATIC_PROTO(void c_goal, (Term, Term, compiler_struct *)); -STATIC_PROTO(void c_body, (Term, Term, compiler_struct *)); -STATIC_PROTO(void c_head, (Term, compiler_struct *)); -STATIC_PROTO(int usesvar, (compiler_vm_op)); -STATIC_PROTO(CELL *init_bvarray, (int, compiler_struct *)); +static int active_branch(int, int); +static void c_var(Term, Int, unsigned int, unsigned int, compiler_struct *); +static void reset_vars(Ventry *); +static Term optimize_ce(Term, unsigned int, unsigned int, compiler_struct *); +static void c_arg(Int, Term, unsigned int, unsigned int, compiler_struct *); +static void c_args(Term, unsigned int, compiler_struct *); +static void c_eq(Term, Term, compiler_struct *); +static void c_test(Int, Term, compiler_struct *); +static void c_bifun(basic_preds, Term, Term, Term, Term, Term, compiler_struct *); +static void c_goal(Term, Term, compiler_struct *); +static void c_body(Term, Term, compiler_struct *); +static void c_head(Term, compiler_struct *); +static int usesvar(compiler_vm_op); +static CELL *init_bvarray(int, compiler_struct *); #ifdef DEBUG -STATIC_PROTO(void clear_bvarray, (int, CELL *, compiler_struct *)); +static void clear_bvarray(int, CELL *, compiler_struct *); #else -STATIC_PROTO(void clear_bvarray, (int, CELL *)); +static void clear_bvarray(int, CELL *); #endif -STATIC_PROTO(void add_bvarray_op, (PInstr *,CELL *, int, compiler_struct *)); -STATIC_PROTO(void AssignPerm, (PInstr *, compiler_struct *)); -STATIC_PROTO(void CheckUnsafe, (PInstr *, compiler_struct *)); -STATIC_PROTO(void CheckVoids, (compiler_struct *)); -STATIC_PROTO( int checktemp, (Int, Int, compiler_vm_op, compiler_struct *)); -STATIC_PROTO( Int checkreg, (Int, Int, compiler_vm_op, int, compiler_struct *)); -STATIC_PROTO(void c_layout, (compiler_struct *)); -STATIC_PROTO(void c_optimize, (PInstr *)); +static void add_bvarray_op(PInstr *,CELL *, int, compiler_struct *); +static void AssignPerm(PInstr *, compiler_struct *); +static void CheckUnsafe(PInstr *, compiler_struct *); +static void CheckVoids(compiler_struct *); +static int checktemp(Int, Int, compiler_vm_op, compiler_struct *); +static Int checkreg(Int, Int, compiler_vm_op, int, compiler_struct *); +static void c_layout(compiler_struct *); +static void c_optimize(PInstr *); #ifdef SFUNC -STATIC_PROTO(void compile_sf_term, (Term, int)); +static void compile_sf_term(Term, int); #endif static void diff --git a/C/computils.c b/C/computils.c index 494997c29..a11d96173 100644 --- a/C/computils.c +++ b/C/computils.c @@ -67,7 +67,7 @@ static char SccsId[] = "%W% %G%"; #endif #ifdef DEBUG -STATIC_PROTO (void ShowOp, (char *, struct PSEUDO *)); +static void ShowOp(char *, struct PSEUDO *); #endif /* DEBUG */ /* diff --git a/C/dbase.c b/C/dbase.c index d85a0d93c..7a509a78f 100755 --- a/C/dbase.c +++ b/C/dbase.c @@ -174,70 +174,70 @@ typedef table { } hash_db_table; #endif -STATIC_PROTO(CELL *cpcells,(CELL *,CELL*,Int)); -STATIC_PROTO(void linkblk,(link_entry *,CELL *,CELL)); -STATIC_PROTO(Int cmpclls,(CELL *,CELL *,Int)); -STATIC_PROTO(Prop FindDBProp,(AtomEntry *, int, unsigned int, Term)); -STATIC_PROTO(CELL CalcKey, (Term)); +static CELL *cpcells(CELL *,CELL*,Int); +static void linkblk(link_entry *,CELL *,CELL); +static Int cmpclls(CELL *,CELL *,Int); +static Prop FindDBProp(AtomEntry *, int, unsigned int, Term); +static CELL CalcKey(Term); #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 -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 -STATIC_PROTO(DBRef CreateDBStruct, (Term, DBProp, int, int *, UInt, struct db_globs *)); -STATIC_PROTO(DBRef record, (int, Term, Term, Term CACHE_TYPE)); -STATIC_PROTO(DBRef check_if_cons, (DBRef, Term)); -STATIC_PROTO(DBRef check_if_var, (DBRef)); -STATIC_PROTO(DBRef check_if_wvars, (DBRef, unsigned int, CELL *)); -STATIC_PROTO(int scheckcells, (int, CELL *, CELL *, link_entry *, CELL)); -STATIC_PROTO(DBRef check_if_nvars, (DBRef, unsigned int, CELL *, struct db_globs *)); -STATIC_PROTO(Int p_rcda, ( USES_REGS1 )); -STATIC_PROTO(Int p_rcdap, ( USES_REGS1 )); -STATIC_PROTO(Int p_rcdz, ( USES_REGS1 )); -STATIC_PROTO(Int p_rcdzp, ( USES_REGS1 )); -STATIC_PROTO(Int p_drcdap, ( USES_REGS1 )); -STATIC_PROTO(Int p_drcdzp, ( USES_REGS1 )); -STATIC_PROTO(Term GetDBTerm, (DBTerm * CACHE_TYPE)); -STATIC_PROTO(DBProp FetchDBPropFromKey, (Term, int, int, char *)); -STATIC_PROTO(Int i_recorded, (DBProp,Term CACHE_TYPE)); -STATIC_PROTO(Int c_recorded, (int CACHE_TYPE)); -STATIC_PROTO(Int co_rded, ( USES_REGS1 )); -STATIC_PROTO(Int in_rdedp, ( USES_REGS1 )); -STATIC_PROTO(Int co_rdedp, ( USES_REGS1 )); -STATIC_PROTO(Int p_first_instance, ( USES_REGS1 )); -STATIC_PROTO(void ErasePendingRefs, (DBTerm * CACHE_TYPE)); -STATIC_PROTO(void RemoveDBEntry, (DBRef CACHE_TYPE)); -STATIC_PROTO(void EraseLogUpdCl, (LogUpdClause *)); -STATIC_PROTO(void MyEraseClause, (DynamicClause * CACHE_TYPE)); -STATIC_PROTO(void PrepareToEraseClause, (DynamicClause *, DBRef)); -STATIC_PROTO(void EraseEntry, (DBRef)); -STATIC_PROTO(Int p_erase, ( USES_REGS1 )); -STATIC_PROTO(Int p_eraseall, ( USES_REGS1 )); -STATIC_PROTO(Int p_erased, ( USES_REGS1 )); -STATIC_PROTO(Int p_instance, ( USES_REGS1 )); -STATIC_PROTO(int NotActiveDB, (DBRef)); -STATIC_PROTO(DBEntry *NextDBProp, (PropEntry *)); -STATIC_PROTO(Int init_current_key, ( USES_REGS1 )); -STATIC_PROTO(Int cont_current_key, ( USES_REGS1 )); -STATIC_PROTO(Int cont_current_key_integer, ( USES_REGS1 )); -STATIC_PROTO(Int p_rcdstatp, ( USES_REGS1 )); -STATIC_PROTO(Int p_somercdedp, ( USES_REGS1 )); -STATIC_PROTO(yamop * find_next_clause, (DBRef USES_REGS)); -STATIC_PROTO(Int p_jump_to_next_dynamic_clause, ( USES_REGS1 )); +static DBRef CreateDBStruct(Term, DBProp, int, int *, UInt, struct db_globs *); +static DBRef record(int, Term, Term, Term CACHE_TYPE); +static DBRef check_if_cons(DBRef, Term); +static DBRef check_if_var(DBRef); +static DBRef check_if_wvars(DBRef, unsigned int, CELL *); +static int scheckcells(int, CELL *, CELL *, link_entry *, CELL); +static DBRef check_if_nvars(DBRef, unsigned int, CELL *, struct db_globs *); +static Int p_rcda( USES_REGS1 ); +static Int p_rcdap( USES_REGS1 ); +static Int p_rcdz( USES_REGS1 ); +static Int p_rcdzp( USES_REGS1 ); +static Int p_drcdap( USES_REGS1 ); +static Int p_drcdzp( USES_REGS1 ); +static Term GetDBTerm(DBTerm * CACHE_TYPE); +static DBProp FetchDBPropFromKey(Term, int, int, char *); +static Int i_recorded(DBProp,Term CACHE_TYPE); +static Int c_recorded(int CACHE_TYPE); +static Int co_rded( USES_REGS1 ); +static Int in_rdedp( USES_REGS1 ); +static Int co_rdedp( USES_REGS1 ); +static Int p_first_instance( USES_REGS1 ); +static void ErasePendingRefs(DBTerm * CACHE_TYPE); +static void RemoveDBEntry(DBRef CACHE_TYPE); +static void EraseLogUpdCl(LogUpdClause *); +static void MyEraseClause(DynamicClause * CACHE_TYPE); +static void PrepareToEraseClause(DynamicClause *, DBRef); +static void EraseEntry(DBRef); +static Int p_erase( USES_REGS1 ); +static Int p_eraseall( USES_REGS1 ); +static Int p_erased( USES_REGS1 ); +static Int p_instance( USES_REGS1 ); +static int NotActiveDB(DBRef); +static DBEntry *NextDBProp(PropEntry *); +static Int init_current_key( USES_REGS1 ); +static Int cont_current_key( USES_REGS1 ); +static Int cont_current_key_integer( USES_REGS1 ); +static Int p_rcdstatp( USES_REGS1 ); +static Int p_somercdedp( USES_REGS1 ); +static yamop * find_next_clause(DBRef USES_REGS); +static Int p_jump_to_next_dynamic_clause( USES_REGS1 ); #ifdef SFUNC -STATIC_PROTO(void SFVarIn, (Term)); -STATIC_PROTO(void sf_include, (SFKeep *)); +static void SFVarIn(Term); +static void sf_include(SFKeep *); #endif -STATIC_PROTO(Int p_init_queue, ( USES_REGS1 )); -STATIC_PROTO(Int p_enqueue, ( USES_REGS1 )); -STATIC_PROTO(void keepdbrefs, (DBTerm * CACHE_TYPE)); -STATIC_PROTO(Int p_dequeue, ( USES_REGS1 )); -STATIC_PROTO(void ErDBE, (DBRef CACHE_TYPE)); -STATIC_PROTO(void ReleaseTermFromDB, (DBTerm * CACHE_TYPE)); -STATIC_PROTO(PredEntry *new_lu_entry, (Term)); -STATIC_PROTO(PredEntry *new_lu_int_key, (Int)); -STATIC_PROTO(PredEntry *find_lu_entry, (Term)); -STATIC_PROTO(DBProp find_int_key, (Int)); +static Int p_init_queue( USES_REGS1 ); +static Int p_enqueue( USES_REGS1 ); +static void keepdbrefs(DBTerm * CACHE_TYPE); +static Int p_dequeue( USES_REGS1 ); +static void ErDBE(DBRef CACHE_TYPE); +static void ReleaseTermFromDB(DBTerm * CACHE_TYPE); +static PredEntry *new_lu_entry(Term); +static PredEntry *new_lu_int_key(Int); +static PredEntry *find_lu_entry(Term); +static DBProp find_int_key(Int); #define db_check_trail(x) { \ if (Unsigned(dbg->tofref) == Unsigned(x)) { \ diff --git a/C/depth_bound.c b/C/depth_bound.c index b29558366..96aee5900 100644 --- a/C/depth_bound.c +++ b/C/depth_bound.c @@ -29,8 +29,8 @@ static char SccsId[] = "%W% %G%"; #include "Yatom.h" -STD_PROTO(static Int p_get_depth_limit, ( USES_REGS1 )); -STD_PROTO(static Int p_set_depth_limit, ( USES_REGS1 )); +static Int p_get_depth_limit( USES_REGS1 ); +static Int p_set_depth_limit( USES_REGS1 ); static Int p_get_depth_limit( USES_REGS1 ) { diff --git a/C/errors.c b/C/errors.c index eedc98ded..a01ed13be 100644 --- a/C/errors.c +++ b/C/errors.c @@ -41,10 +41,10 @@ Yap_RestartYap ( int flag ) } #ifdef DEBUG -STATIC_PROTO (int hidden, (Atom)); -STATIC_PROTO (int legal_env, (CELL * CACHE_TYPE)); -void STD_PROTO (DumpActiveGoals, ( CACHE_TYPE1 )); -STATIC_PROTO (void detect_bug_location, (yamop *,find_pred_type,char *, int)); +static int hidden(Atom); +static int legal_env(CELL * CACHE_TYPE); +void DumpActiveGoals( CACHE_TYPE1 ); +static void detect_bug_location(yamop *,find_pred_type,char *, int); #define ONHEAP(ptr) (CellPtr(ptr) >= CellPtr(Yap_HeapBase) && CellPtr(ptr) < CellPtr(HeapTop)) diff --git a/C/exec.c b/C/exec.c index 28ab87b72..71f75f13a 100644 --- a/C/exec.c +++ b/C/exec.c @@ -28,11 +28,11 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98"; #include "myddas.h" #endif -STATIC_PROTO(Int CallPredicate, (PredEntry *, choiceptr, yamop * CACHE_TYPE)); -STATIC_PROTO(Int EnterCreepMode, (Term, Term CACHE_TYPE)); -STATIC_PROTO(Int p_save_cp, ( USES_REGS1 )); -STATIC_PROTO(Int p_execute, ( USES_REGS1 )); -STATIC_PROTO(Int p_execute0, ( USES_REGS1 )); +static Int CallPredicate(PredEntry *, choiceptr, yamop * CACHE_TYPE); +static Int EnterCreepMode(Term, Term CACHE_TYPE); +static Int p_save_cp( USES_REGS1 ); +static Int p_execute( USES_REGS1 ); +static Int p_execute0( USES_REGS1 ); static int execute_pred(PredEntry *ppe, CELL *pt USES_REGS); static Term diff --git a/C/grow.c b/C/grow.c index 8145b3765..8e5c7a0aa 100644 --- a/C/grow.c +++ b/C/grow.c @@ -44,30 +44,30 @@ typedef enum { -STATIC_PROTO(Int p_growheap, ( USES_REGS1 )); -STATIC_PROTO(Int p_growstack, ( USES_REGS1 )); -STATIC_PROTO(Int p_inform_trail_overflows, ( USES_REGS1 )); -STATIC_PROTO(Int p_inform_heap_overflows, ( USES_REGS1 )); -STATIC_PROTO(Int p_inform_stack_overflows, ( USES_REGS1 )); +static Int p_growheap( USES_REGS1 ); +static Int p_growstack( USES_REGS1 ); +static Int p_inform_trail_overflows( USES_REGS1 ); +static Int p_inform_heap_overflows( USES_REGS1 ); +static Int p_inform_stack_overflows( USES_REGS1 ); /* #define undf7 */ /* #define undf5 */ -STATIC_PROTO(int growstack, (long CACHE_TYPE)); -STATIC_PROTO(void MoveGlobal, ( CACHE_TYPE1 )); -STATIC_PROTO(void MoveLocalAndTrail, ( CACHE_TYPE1 )); -STATIC_PROTO(void SetHeapRegs, (int CACHE_TYPE)); -STATIC_PROTO(void AdjustTrail, (int, int CACHE_TYPE)); -STATIC_PROTO(void AdjustLocal, (int CACHE_TYPE)); -STATIC_PROTO(void AdjustGlobal, (long, int CACHE_TYPE)); -STATIC_PROTO(void AdjustGrowStack, ( CACHE_TYPE1 )); -STATIC_PROTO(int static_growheap, (long,int,struct intermediates *,tr_fr_ptr *, TokEntry **, VarEntry ** CACHE_TYPE)); -STATIC_PROTO(void cpcellsd, (CELL *, CELL *, CELL)); -STATIC_PROTO(CELL AdjustAppl, (CELL CACHE_TYPE)); -STATIC_PROTO(CELL AdjustPair, (CELL CACHE_TYPE)); -STATIC_PROTO(void AdjustStacksAndTrail, (long, int CACHE_TYPE)); -STATIC_PROTO(void AdjustRegs, (int CACHE_TYPE)); -STATIC_PROTO(Term AdjustGlobTerm, (Term CACHE_TYPE)); +static int growstack(size_t CACHE_TYPE); +static void MoveGlobal( CACHE_TYPE1 ); +static void MoveLocalAndTrail( CACHE_TYPE1 ); +static void SetHeapRegs(int CACHE_TYPE); +static void AdjustTrail(int, int CACHE_TYPE); +static void AdjustLocal(int CACHE_TYPE); +static void AdjustGlobal(long, int CACHE_TYPE); +static void AdjustGrowStack( CACHE_TYPE1 ); +static int static_growheap(long,int,struct intermediates *,tr_fr_ptr *, TokEntry **, VarEntry ** CACHE_TYPE); +static void cpcellsd(CELL *, CELL *, CELL); +static CELL AdjustAppl(CELL CACHE_TYPE); +static CELL AdjustPair(CELL CACHE_TYPE); +static void AdjustStacksAndTrail(long, int CACHE_TYPE); +static void AdjustRegs(int CACHE_TYPE); +static Term AdjustGlobTerm(Term CACHE_TYPE); static void LeaveGrowMode(prolog_exec_mode grow_mode) @@ -1500,7 +1500,7 @@ Yap_InsertInGlobal(CELL *where, UInt howmuch) int -Yap_growstack(long size) +Yap_growstack(size_t size) { CACHE_REGS 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 */ static int -growstack(long size USES_REGS) +growstack(size_t size USES_REGS) { UInt start_growth_time, growth_time; int gc_verbose; diff --git a/C/heapgc.c b/C/heapgc.c index 027548e72..a04ba31b0 100644 --- a/C/heapgc.c +++ b/C/heapgc.c @@ -35,28 +35,28 @@ static char SccsId[] = "%W% %G%"; /* global variables for garbage collection */ -STATIC_PROTO(Int p_inform_gc, ( CACHE_TYPE1 )); -STATIC_PROTO(Int p_gc, ( CACHE_TYPE1 )); -STATIC_PROTO(void marking_phase, (tr_fr_ptr, CELL *, yamop * CACHE_TYPE)); -STATIC_PROTO(void compaction_phase, (tr_fr_ptr, CELL *, yamop * CACHE_TYPE)); -STATIC_PROTO(void init_dbtable, (tr_fr_ptr CACHE_TYPE)); -STATIC_PROTO(void mark_external_reference, (CELL * CACHE_TYPE)); -STATIC_PROTO(void mark_db_fixed, (CELL * CACHE_TYPE)); -STATIC_PROTO(void mark_regs, (tr_fr_ptr CACHE_TYPE)); -STATIC_PROTO(void mark_trail, (tr_fr_ptr, tr_fr_ptr, CELL *, choiceptr CACHE_TYPE)); -STATIC_PROTO(void mark_environments, (CELL *, OPREG, CELL * CACHE_TYPE)); -STATIC_PROTO(void mark_choicepoints, (choiceptr, tr_fr_ptr, int CACHE_TYPE)); -STATIC_PROTO(void into_relocation_chain, (CELL *, CELL * CACHE_TYPE)); -STATIC_PROTO(void sweep_trail, (choiceptr, tr_fr_ptr CACHE_TYPE)); -STATIC_PROTO(void sweep_environments, (CELL *, OPREG, CELL * CACHE_TYPE)); -STATIC_PROTO(void sweep_choicepoints, (choiceptr CACHE_TYPE)); -STATIC_PROTO(void compact_heap, ( CACHE_TYPE1 )); -STATIC_PROTO(void update_relocation_chain, (CELL *, CELL * CACHE_TYPE)); -STATIC_PROTO(int is_gc_verbose, (void)); -STATIC_PROTO(int is_gc_very_verbose, (void)); -STATIC_PROTO(void LeaveGCMode, ( CACHE_TYPE1 )); +static Int p_inform_gc( CACHE_TYPE1 ); +static Int p_gc( CACHE_TYPE1 ); +static void marking_phase(tr_fr_ptr, CELL *, yamop * CACHE_TYPE); +static void compaction_phase(tr_fr_ptr, CELL *, yamop * CACHE_TYPE); +static void init_dbtable(tr_fr_ptr CACHE_TYPE); +static void mark_external_reference(CELL * CACHE_TYPE); +static void mark_db_fixed(CELL * CACHE_TYPE); +static void mark_regs(tr_fr_ptr CACHE_TYPE); +static void mark_trail(tr_fr_ptr, tr_fr_ptr, CELL *, choiceptr CACHE_TYPE); +static void mark_environments(CELL *, OPREG, CELL * CACHE_TYPE); +static void mark_choicepoints(choiceptr, tr_fr_ptr, int CACHE_TYPE); +static void into_relocation_chain(CELL *, CELL * CACHE_TYPE); +static void sweep_trail(choiceptr, tr_fr_ptr CACHE_TYPE); +static void sweep_environments(CELL *, OPREG, CELL * CACHE_TYPE); +static void sweep_choicepoints(choiceptr CACHE_TYPE); +static void compact_heap( CACHE_TYPE1 ); +static void update_relocation_chain(CELL *, CELL * CACHE_TYPE); +static int is_gc_verbose(void); +static int is_gc_very_verbose(void); +static void LeaveGCMode( CACHE_TYPE1 ); #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 */ #include "heapgc.h" @@ -1064,7 +1064,7 @@ inc_var(CELL *current, CELL *next) } #endif /* INSTRUMENT_GC */ -int STD_PROTO(vsc_stop,(void)); +int vsc_stop(void); int vsc_stop(void) { diff --git a/C/index.c b/C/index.c index b7b65e7f8..02da73d2e 100755 --- a/C/index.c +++ b/C/index.c @@ -502,10 +502,10 @@ static char SccsId[] = "%W% %G%"; #define SET_JLBL(X) #endif -UInt STATIC_PROTO(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)); -UInt STATIC_PROTO(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_index(ClauseDef *,ClauseDef *,struct intermediates *,UInt,UInt,int,int,CELL *); +static UInt do_compound_index(ClauseDef *,ClauseDef *,Term *t,struct intermediates *,UInt,UInt,UInt,UInt,int,int,int,CELL *,int); +static UInt do_dbref_index(ClauseDef *,ClauseDef *,Term,struct intermediates *,UInt,UInt,int,int,CELL *); +static UInt do_blob_index(ClauseDef *,ClauseDef *,Term,struct intermediates *,UInt,UInt,int,int,CELL *,int); static UInt cleanup_sw_on_clauses(CELL larg, UInt sz, OPCODE ecls) diff --git a/C/init.c b/C/init.c index a704b19de..1ecb37e74 100755 --- a/C/init.c +++ b/C/init.c @@ -62,22 +62,22 @@ static char SccsId[] = "%W% %G%"; int Yap_output_msg = FALSE; #ifdef MACC -STATIC_PROTO(void InTTYLine, (char *)); +static void InTTYLine(char *); #endif #endif -STATIC_PROTO(void SetOp, (int, int, char *, Term)); -STATIC_PROTO(void InitOps, (void)); -STATIC_PROTO(void InitDebug, (void)); +static void SetOp(int, int, char *, Term); +static void InitOps(void); +static void InitDebug(void); #ifdef CUT_C -STATIC_PROTO(void CleanBack, (PredEntry *, CPredicate, CPredicate, CPredicate)); +static void CleanBack(PredEntry *, CPredicate, CPredicate, CPredicate); #else -STATIC_PROTO(void CleanBack, (PredEntry *, CPredicate, CPredicate)); +static void CleanBack(PredEntry *, CPredicate, CPredicate); #endif -STATIC_PROTO(void InitStdPreds,(void)); -STATIC_PROTO(void InitFlags, (void)); -STATIC_PROTO(void InitCodes, (void)); -STATIC_PROTO(void InitVersion, (void)); -STD_PROTO(void exit, (int)); +static void InitStdPreds(void); +static void InitFlags(void); +static void InitCodes(void); +static void InitVersion(void); +void exit(int); static void InitWorker(int wid); diff --git a/C/inlines.c b/C/inlines.c index 356de33a4..a8a79a925 100644 --- a/C/inlines.c +++ b/C/inlines.c @@ -23,21 +23,21 @@ #include "cut_c.h" #endif -STATIC_PROTO(Int p_atom, ( USES_REGS1 )); -STATIC_PROTO(Int p_atomic, ( USES_REGS1 )); -STATIC_PROTO(Int p_integer, ( USES_REGS1 )); -STATIC_PROTO(Int p_nonvar, ( USES_REGS1 )); -STATIC_PROTO(Int p_number, ( USES_REGS1 )); -STATIC_PROTO(Int p_var, ( USES_REGS1 )); -STATIC_PROTO(Int p_db_ref, ( USES_REGS1 )); -STATIC_PROTO(Int p_primitive, ( USES_REGS1 )); -STATIC_PROTO(Int p_compound, ( USES_REGS1 )); -STATIC_PROTO(Int p_float, ( USES_REGS1 )); -STATIC_PROTO(Int p_equal, ( USES_REGS1 )); -STATIC_PROTO(Int p_dif, ( USES_REGS1 )); -STATIC_PROTO(Int p_eq, ( USES_REGS1 )); -STATIC_PROTO(Int p_arg, ( USES_REGS1 )); -STATIC_PROTO(Int p_functor, ( USES_REGS1 )); +static Int p_atom( USES_REGS1 ); +static Int p_atomic( USES_REGS1 ); +static Int p_integer( USES_REGS1 ); +static Int p_nonvar( USES_REGS1 ); +static Int p_number( USES_REGS1 ); +static Int p_var( USES_REGS1 ); +static Int p_db_ref( USES_REGS1 ); +static Int p_primitive( USES_REGS1 ); +static Int p_compound( USES_REGS1 ); +static Int p_float( USES_REGS1 ); +static Int p_equal( USES_REGS1 ); +static Int p_dif( USES_REGS1 ); +static Int p_eq( USES_REGS1 ); +static Int p_arg( USES_REGS1 ); +static Int p_functor( USES_REGS1 ); static Int diff --git a/C/iopreds.c b/C/iopreds.c index 665ff5b50..0bd63a23a 100755 --- a/C/iopreds.c +++ b/C/iopreds.c @@ -84,12 +84,12 @@ static char SccsId[] = "%W% %G%"; #endif #include "iopreds.h" -STATIC_PROTO (Int p_set_read_error_handler, ( USES_REGS1 )); -STATIC_PROTO (Int p_get_read_error_handler, ( USES_REGS1 )); -STATIC_PROTO (Int p_read, ( USES_REGS1 )); -STATIC_PROTO (Int p_startline, ( USES_REGS1 )); -STATIC_PROTO (Int p_change_type_of_char, ( USES_REGS1 )); -STATIC_PROTO (Int p_type_of_char, ( USES_REGS1 )); +static Int p_set_read_error_handler( USES_REGS1 ); +static Int p_get_read_error_handler( USES_REGS1 ); +static Int p_read( USES_REGS1 ); +static Int p_startline( USES_REGS1 ); +static Int p_change_type_of_char( USES_REGS1 ); +static Int p_type_of_char( USES_REGS1 ); extern Atom Yap_FileName(IOSTREAM *s); diff --git a/C/load_foreign.c b/C/load_foreign.c index 2247dfea3..7edbe673f 100644 --- a/C/load_foreign.c +++ b/C/load_foreign.c @@ -34,7 +34,7 @@ static char SccsId[] = "%W% %G%.2"; #endif #endif -STD_PROTO(Int p_load_foreign, ( USES_REGS1 )); +Int p_load_foreign( USES_REGS1 ); Int p_load_foreign( USES_REGS1 ) diff --git a/C/load_shl.c b/C/load_shl.c index 15c412404..85a177516 100644 --- a/C/load_shl.c +++ b/C/load_shl.c @@ -167,7 +167,7 @@ Yap_ReLoadForeign(StringList ofiles, StringList libs, /* dunno what this one is supposed to do, no load_* defines it -void STD_PROTO(ReOpenLoadForeign,(void)); +void ReOpenLoadForeign(void); */ #endif diff --git a/C/mavar.c b/C/mavar.c index 6667d1da3..d9e0a23de 100644 --- a/C/mavar.c +++ b/C/mavar.c @@ -23,11 +23,11 @@ #include "YapHeap.h" #include "eval.h" -STD_PROTO(static Int p_setarg, ( USES_REGS1 )); -STD_PROTO(static Int p_create_mutable, ( USES_REGS1 )); -STD_PROTO(static Int p_get_mutable, ( USES_REGS1 )); -STD_PROTO(static Int p_update_mutable, ( USES_REGS1 )); -STD_PROTO(static Int p_is_mutable, ( USES_REGS1 )); +static Int p_setarg( USES_REGS1 ); +static Int p_create_mutable( USES_REGS1 ); +static Int p_get_mutable( USES_REGS1 ); +static Int p_update_mutable( USES_REGS1 ); +static Int p_is_mutable( USES_REGS1 ); static Int p_setarg( USES_REGS1 ) diff --git a/C/modules.c b/C/modules.c index 72766b755..2f7349959 100644 --- a/C/modules.c +++ b/C/modules.c @@ -22,8 +22,8 @@ static char SccsId[] = "%W% %G%"; #include "Yatom.h" #include "YapHeap.h" -STATIC_PROTO(Int p_current_module, ( USES_REGS1 )); -STATIC_PROTO(Int p_current_module1, ( USES_REGS1 )); +static Int p_current_module( USES_REGS1 ); +static Int p_current_module1( USES_REGS1 ); inline static ModEntry * diff --git a/C/parser.c b/C/parser.c index c0bad6fdb..523efc26a 100644 --- a/C/parser.c +++ b/C/parser.c @@ -68,11 +68,11 @@ typedef struct jmp_buff_struct { sigjmp_buf JmpBuff; } JMPBUFF; -STATIC_PROTO(void GNextToken, ( CACHE_TYPE1 )); -STATIC_PROTO(void checkfor, (Term, JMPBUFF * CACHE_TYPE)); -STATIC_PROTO(Term ParseArgs, (Atom, JMPBUFF * CACHE_TYPE)); -STATIC_PROTO(Term ParseList, (JMPBUFF * CACHE_TYPE)); -STATIC_PROTO(Term ParseTerm, (int, JMPBUFF * CACHE_TYPE)); +static void GNextToken( CACHE_TYPE1 ); +static void checkfor(Term, JMPBUFF * CACHE_TYPE); +static Term ParseArgs(Atom, JMPBUFF * CACHE_TYPE); +static Term ParseList(JMPBUFF * CACHE_TYPE); +static Term ParseTerm(int, JMPBUFF * CACHE_TYPE); #define TRY(S,P) \ diff --git a/C/pl-yap.c b/C/pl-yap.c index daa3fa674..a83ab13d2 100755 --- a/C/pl-yap.c +++ b/C/pl-yap.c @@ -1212,7 +1212,7 @@ Yap_StreamPosition(IOSTREAM *st) return StreamPosition(st); } -IOSTREAM *STD_PROTO(Yap_Scurin, (void)); +IOSTREAM *Yap_Scurin(void); IOSTREAM * Yap_Scurin(void) diff --git a/C/qlyr.c b/C/qlyr.c index 522b6d941..c7497859e 100755 --- a/C/qlyr.c +++ b/C/qlyr.c @@ -29,8 +29,8 @@ #include "qly.h" -STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS)); -STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS)); +static void RestoreEntries(PropEntry *, int USES_REGS); +static void CleanCode(PredEntry * USES_REGS); typedef enum { OUT_OF_TEMP_SPACE = 0, diff --git a/C/qlyw.c b/C/qlyw.c index cb5187921..28347fa62 100755 --- a/C/qlyw.c +++ b/C/qlyw.c @@ -29,8 +29,8 @@ #include "qly.h" -STATIC_PROTO(void RestoreEntries, (PropEntry *, int USES_REGS)); -STATIC_PROTO(void CleanCode, (PredEntry * USES_REGS)); +static void RestoreEntries(PropEntry *, int USES_REGS); +static void CleanCode(PredEntry * USES_REGS); static void GrowAtomTable(void) { diff --git a/C/save.c b/C/save.c index 86e6ea0c4..53049000d 100755 --- a/C/save.c +++ b/C/save.c @@ -85,55 +85,55 @@ void initIO(void); #endif -STATIC_PROTO(int myread, (int, char *, Int)); -STATIC_PROTO(Int mywrite, (int, char *, Int)); -STATIC_PROTO(int open_file, (char *, int)); -STATIC_PROTO(int close_file, (void)); -STATIC_PROTO(Int putout, (CELL)); -STATIC_PROTO(Int putcellptr, (CELL *)); -STATIC_PROTO(CELL get_cell, (void)); -STATIC_PROTO(CELL *get_cellptr, ( /* CELL * */ void)); -STATIC_PROTO(int put_info, (int, int CACHE_TYPE)); -STATIC_PROTO(int save_regs, (int CACHE_TYPE)); -STATIC_PROTO(int save_code_info, (void)); -STATIC_PROTO(int save_heap, (void)); -STATIC_PROTO(int save_stacks, (int CACHE_TYPE)); -STATIC_PROTO(int save_crc, (void)); -STATIC_PROTO(Int do_save, (int CACHE_TYPE)); -STATIC_PROTO(Int p_save2, ( CACHE_TYPE1 )); -STATIC_PROTO(Int p_save_program, ( CACHE_TYPE1 )); -STATIC_PROTO(int check_header, (CELL *, CELL *, CELL *, CELL * CACHE_TYPE)); -STATIC_PROTO(int get_heap_info, (CACHE_TYPE1)); -STATIC_PROTO(int get_regs, (int CACHE_TYPE)); -STATIC_PROTO(int get_insts, (OPCODE [])); -STATIC_PROTO(int get_hash, (void)); -STATIC_PROTO(int CopyCode, ( CACHE_TYPE1 )); -STATIC_PROTO(int CopyStacks, ( CACHE_TYPE1 )); -STATIC_PROTO(int get_coded, (int, OPCODE [] CACHE_TYPE)); -STATIC_PROTO(void restore_codes, (void)); -STATIC_PROTO(void RestoreDB, (DBEntry * CACHE_TYPE)); -STATIC_PROTO(void RestoreDBTerm, (DBTerm *, int CACHE_TYPE)); -STATIC_PROTO(void CleanClauses, (yamop *, yamop *,PredEntry * CACHE_TYPE)); -STATIC_PROTO(void rehash, (CELL *, int, int CACHE_TYPE)); -STATIC_PROTO(void CleanCode, (PredEntry * CACHE_TYPE)); -STATIC_PROTO(void RestoreEntries, (PropEntry *, int CACHE_TYPE)); -STATIC_PROTO(void RestoreFreeSpace, ( CACHE_TYPE1 )); -STATIC_PROTO(void restore_heap, (void)); +static int myread(int, char *, Int); +static Int mywrite(int, char *, Int); +static int open_file(char *, int); +static int close_file(void); +static Int putout(CELL); +static Int putcellptr(CELL *); +static CELL get_cell(void); +static CELL *get_cellptr( /* CELL * */ void); +static int put_info(int, int CACHE_TYPE); +static int save_regs(int CACHE_TYPE); +static int save_code_info(void); +static int save_heap(void); +static int save_stacks(int CACHE_TYPE); +static int save_crc(void); +static Int do_save(int CACHE_TYPE); +static Int p_save2( CACHE_TYPE1 ); +static Int p_save_program( CACHE_TYPE1 ); +static int check_header(CELL *, CELL *, CELL *, CELL * CACHE_TYPE); +static int get_heap_info(CACHE_TYPE1); +static int get_regs(int CACHE_TYPE); +static int get_insts(OPCODE []); +static int get_hash(void); +static int CopyCode( CACHE_TYPE1 ); +static int CopyStacks( CACHE_TYPE1 ); +static int get_coded(int, OPCODE [] CACHE_TYPE); +static void restore_codes(void); +static void RestoreDB(DBEntry * CACHE_TYPE); +static void RestoreDBTerm(DBTerm *, int CACHE_TYPE); +static void CleanClauses(yamop *, yamop *,PredEntry * CACHE_TYPE); +static void rehash(CELL *, int, int CACHE_TYPE); +static void CleanCode(PredEntry * CACHE_TYPE); +static void RestoreEntries(PropEntry *, int CACHE_TYPE); +static void RestoreFreeSpace( CACHE_TYPE1 ); +static void restore_heap(void); #ifdef DEBUG_RESTORE3 -STATIC_PROTO(void ShowAtoms, (void)); -STATIC_PROTO(void ShowEntries, (PropEntry *)); +static void ShowAtoms(void); +static void ShowEntries(PropEntry *); #endif -STATIC_PROTO(int OpenRestore, (char *, char *, CELL *, CELL *, CELL *, CELL *, IOSTREAM **)); -STATIC_PROTO(void CloseRestore, (void)); +static int OpenRestore(char *, char *, CELL *, CELL *, CELL *, CELL *, IOSTREAM **); +static void CloseRestore(void); #ifndef _WIN32 -STATIC_PROTO(int check_opcodes, (OPCODE [])); +static int check_opcodes(OPCODE []); #endif -STATIC_PROTO(void RestoreHeap, (OPCODE [] CACHE_TYPE)); -STATIC_PROTO(Int p_restore, ( CACHE_TYPE1 )); -STATIC_PROTO(void restore_heap_regs, ( CACHE_TYPE1 )); -STATIC_PROTO(void restore_regs, (int CACHE_TYPE)); +static void RestoreHeap(OPCODE [] CACHE_TYPE); +static Int p_restore( CACHE_TYPE1 ); +static void restore_heap_regs( CACHE_TYPE1 ); +static void restore_regs(int CACHE_TYPE); #ifdef MACYAP -STATIC_PROTO(void NewFileInfo, (long, long)); +static void NewFileInfo(long, long); extern int DefVol; #endif diff --git a/C/scanner.c b/C/scanner.c index 9600ed27e..f6d29aa1d 100644 --- a/C/scanner.c +++ b/C/scanner.c @@ -59,8 +59,8 @@ #define my_isupper(C) ( C >= 'A' && C <= 'Z' ) #define my_islower(C) ( C >= 'a' && C <= 'z' ) -STATIC_PROTO(Term float_send, (char *, int)); -STATIC_PROTO(Term get_num, (int *, int *, IOSTREAM *,char *,UInt,int)); +static Term float_send(char *, int); +static Term get_num(int *, int *, IOSTREAM *,char *,UInt,int); /* token table with some help from Richard O'Keefe's PD scanner */ static char chtype0[NUMBER_OF_CHARS+1] = diff --git a/C/sort.c b/C/sort.c index a22f339d2..a5f8ed7b3 100644 --- a/C/sort.c +++ b/C/sort.c @@ -28,14 +28,14 @@ #define M_EVEN 0 #define M_ODD 1 -STATIC_PROTO(Int build_new_list, (CELL *, Term CACHE_TYPE)); -STATIC_PROTO(void simple_mergesort, (CELL *, Int, int)); -STATIC_PROTO(Int compact_mergesort, (CELL *, Int, int)); -STATIC_PROTO(int key_mergesort, (CELL *, Int, int, Functor)); -STATIC_PROTO(void adjust_vector, (CELL *, Int)); -STATIC_PROTO(Int p_sort, ( USES_REGS1 )); -STATIC_PROTO(Int p_msort, ( USES_REGS1 )); -STATIC_PROTO(Int p_ksort, ( USES_REGS1 )); +static Int build_new_list(CELL *, Term CACHE_TYPE); +static void simple_mergesort(CELL *, Int, int); +static Int compact_mergesort(CELL *, Int, int); +static int key_mergesort(CELL *, Int, int, Functor); +static void adjust_vector(CELL *, Int); +static Int p_sort( USES_REGS1 ); +static Int p_msort( USES_REGS1 ); +static Int p_ksort( USES_REGS1 ); /* copy to a new list of terms */ static Int diff --git a/C/stdpreds.c b/C/stdpreds.c index 80bf89274..e56624d71 100644 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -285,75 +285,72 @@ static char SccsId[] = "%W% %G%"; #endif #include -STD_PROTO(static Int p_setval, ( USES_REGS1 )); -STD_PROTO(static Int p_value, ( USES_REGS1 )); -STD_PROTO(static Int p_values, ( USES_REGS1 )); +static Int p_setval( USES_REGS1 ); +static Int p_value( USES_REGS1 ); +static Int p_values( USES_REGS1 ); #ifdef undefined -STD_PROTO(static CODEADDR *FindAtom, (CODEADDR, int *)); +static CODEADDR *FindAtom(CODEADDR, int *); #endif /* undefined */ -STD_PROTO(static Int p_opdec, ( USES_REGS1 )); -STD_PROTO(static Term get_num, (char * USES_REGS)); -STD_PROTO(static Int p_name, ( USES_REGS1 )); -STD_PROTO(static Int p_atom_chars, ( USES_REGS1 )); -STD_PROTO(static Int p_atom_codes, ( USES_REGS1 )); -STD_PROTO(static Int p_atom_length, ( USES_REGS1 )); -STD_PROTO(static Int p_atom_split, ( USES_REGS1 )); -STD_PROTO(static Int p_number_chars, ( USES_REGS1 )); -STD_PROTO(static Int p_number_codes, ( USES_REGS1 )); -STD_PROTO(static Int p_univ, ( USES_REGS1 )); -STD_PROTO(static Int p_abort, ( USES_REGS1 )); +static Int p_opdec( USES_REGS1 ); +static Term get_num(char * USES_REGS); +static Int p_name( USES_REGS1 ); +static Int p_atom_chars( USES_REGS1 ); +static Int p_atom_codes( USES_REGS1 ); +static Int p_atom_length( USES_REGS1 ); +static Int p_atom_split( USES_REGS1 ); +static Int p_number_chars( USES_REGS1 ); +static Int p_number_codes( USES_REGS1 ); +static Int p_univ( USES_REGS1 ); +static Int p_abort( USES_REGS1 ); #ifdef BEAM -STD_PROTO(Int p_halt, ( USES_REGS1 )); +Int p_halt( USES_REGS1 ); #else -STD_PROTO(static Int p_halt, ( USES_REGS1 )); +static Int p_halt( USES_REGS1 ); #endif -STD_PROTO(static Int init_current_atom, ( USES_REGS1 )); -STD_PROTO(static Int cont_current_atom, ( USES_REGS1 )); -STD_PROTO(static Int init_current_predicate, ( USES_REGS1 )); -STD_PROTO(static Int cont_current_predicate, ( USES_REGS1 )); -STD_PROTO(static Int init_current_predicate_for_atom, ( USES_REGS1 )); -STD_PROTO(static Int cont_current_predicate_for_atom, ( USES_REGS1 )); -STD_PROTO(static OpEntry *NextOp, (OpEntry * CACHE_TYPE)); -STD_PROTO(static Int init_current_op, ( USES_REGS1 )); -STD_PROTO(static Int cont_current_op, ( USES_REGS1 )); -STD_PROTO(static Int init_current_atom_op, ( USES_REGS1 )); -STD_PROTO(static Int cont_current_atom_op, ( USES_REGS1 )); -#ifdef DEBUG -STD_PROTO(static Int p_debug, ( USES_REGS1 )); -#endif -STD_PROTO(static Int p_flags, ( USES_REGS1 )); -STD_PROTO(static int AlreadyHidden, (char *)); -STD_PROTO(static Int p_hide, ( USES_REGS1 )); -STD_PROTO(static Int p_hidden, ( USES_REGS1 )); -STD_PROTO(static Int p_unhide, ( USES_REGS1 )); -STD_PROTO(static Int TrailMax, (void)); -STD_PROTO(static Int GlobalMax, (void)); -STD_PROTO(static Int LocalMax, (void)); -STD_PROTO(static Int p_statistics_heap_max, ( USES_REGS1 )); -STD_PROTO(static Int p_statistics_global_max, ( USES_REGS1 )); -STD_PROTO(static Int p_statistics_local_max, ( USES_REGS1 )); -STD_PROTO(static Int p_statistics_heap_info, ( USES_REGS1 )); -STD_PROTO(static Int p_statistics_stacks_info, ( USES_REGS1 )); -STD_PROTO(static Int p_statistics_trail_info, ( USES_REGS1 )); -STD_PROTO(static Term mk_argc_list, ( USES_REGS1 )); -STD_PROTO(static Int p_argv, ( USES_REGS1 )); -STD_PROTO(static Int p_cputime, ( USES_REGS1 )); -STD_PROTO(static Int p_systime, ( USES_REGS1 )); -STD_PROTO(static Int p_runtime, ( 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 )); +static Int init_current_atom( USES_REGS1 ); +static Int cont_current_atom( USES_REGS1 ); +static Int init_current_predicate( USES_REGS1 ); +static Int cont_current_predicate( USES_REGS1 ); +static Int init_current_predicate_for_atom( USES_REGS1 ); +static Int cont_current_predicate_for_atom( USES_REGS1 ); +static OpEntry *NextOp(OpEntry * CACHE_TYPE); +static Int init_current_op( USES_REGS1 ); +static Int cont_current_op( USES_REGS1 ); +static Int init_current_atom_op( USES_REGS1 ); +static Int cont_current_atom_op( USES_REGS1 ); +static Int p_flags( USES_REGS1 ); +static int AlreadyHidden(char *); +static Int p_hide( USES_REGS1 ); +static Int p_hidden( USES_REGS1 ); +static Int p_unhide( USES_REGS1 ); +static Int TrailMax(void); +static Int GlobalMax(void); +static Int LocalMax(void); +static Int p_statistics_heap_max( USES_REGS1 ); +static Int p_statistics_global_max( USES_REGS1 ); +static Int p_statistics_local_max( USES_REGS1 ); +static Int p_statistics_heap_info( USES_REGS1 ); +static Int p_statistics_stacks_info( USES_REGS1 ); +static Int p_statistics_trail_info( USES_REGS1 ); +static Term mk_argc_list( USES_REGS1 ); +static Int p_argv( USES_REGS1 ); +static Int p_cputime( USES_REGS1 ); +static Int p_systime( USES_REGS1 ); +static Int p_runtime( USES_REGS1 ); +static Int p_walltime( USES_REGS1 ); +static Int p_access_yap_flags( USES_REGS1 ); +static Int p_set_yap_flags( USES_REGS1 ); #ifdef BEAM -STD_PROTO(Int use_eam, ( USES_REGS1 )); -STD_PROTO(Int eager_split, ( USES_REGS1 )); -STD_PROTO(Int force_wait, ( USES_REGS1 )); -STD_PROTO(Int commit, ( USES_REGS1 )); -STD_PROTO(Int skip_while_var, ( USES_REGS1 )); -STD_PROTO(Int wait_while_var, ( USES_REGS1 )); -STD_PROTO(Int show_time, ( USES_REGS1 )); -STD_PROTO(Int start_eam, ( USES_REGS1 )); -STD_PROTO(Int cont_eam, ( USES_REGS1 )); +Int use_eam( USES_REGS1 ); +Int eager_split( USES_REGS1 ); +Int force_wait( USES_REGS1 ); +Int commit( USES_REGS1 ); +Int skip_while_var( USES_REGS1 ); +Int wait_while_var( USES_REGS1 ); +Int show_time( USES_REGS1 ); +Int start_eam( USES_REGS1 ); +Int cont_eam( USES_REGS1 ); extern int EAM; extern int eam_am(PredEntry*); diff --git a/C/sysbits.c b/C/sysbits.c index 454023b81..75aecb3e3 100755 --- a/C/sysbits.c +++ b/C/sysbits.c @@ -90,26 +90,26 @@ static char SccsId[] = "%W% %G%"; #endif -STATIC_PROTO (void InitTime, (int)); -STATIC_PROTO (void InitWTime, (void)); -STATIC_PROTO (Int p_sh, ( USES_REGS1 )); -STATIC_PROTO (Int p_shell, ( USES_REGS1 )); -STATIC_PROTO (Int p_system, ( USES_REGS1 )); -STATIC_PROTO (Int p_mv, ( USES_REGS1 )); -STATIC_PROTO (Int p_dir_sp, ( USES_REGS1 )); -STATIC_PROTO (void InitRandom, (void)); -STATIC_PROTO (Int p_srandom, ( USES_REGS1 )); -STATIC_PROTO (Int p_alarm, ( USES_REGS1 )); -STATIC_PROTO (Int p_getenv, ( USES_REGS1 )); -STATIC_PROTO (Int p_putenv, ( USES_REGS1 )); -STATIC_PROTO (void set_fpu_exceptions, (int)); +static void InitTime(int); +static void InitWTime(void); +static Int p_sh( USES_REGS1 ); +static Int p_shell( USES_REGS1 ); +static Int p_system( USES_REGS1 ); +static Int p_mv( USES_REGS1 ); +static Int p_dir_sp( USES_REGS1 ); +static void InitRandom(void); +static Int p_srandom( USES_REGS1 ); +static Int p_alarm( USES_REGS1 ); +static Int p_getenv( USES_REGS1 ); +static Int p_putenv( USES_REGS1 ); +static void set_fpu_exceptions(int); #ifdef MACYAP -STATIC_PROTO (int chdir, (char *)); +static int chdir(char *); /* #define signal skel_signal */ #endif /* MACYAP */ -STD_PROTO (void exit, (int)); +void exit(int); #ifdef _WIN32 void @@ -1037,7 +1037,7 @@ InitRandom (void) #endif } -STD_PROTO (extern int rand, (void)); +extern int rand(void); double @@ -1094,7 +1094,7 @@ p_srandom ( USES_REGS1 ) #endif -STATIC_PROTO (void InitSignals, (void)); +static void InitSignals(void); #define PLSIG_PREPARED 0x01 /* signal is prepared */ #define PLSIG_THROW 0x02 /* throw signal(num, name) */ @@ -1239,10 +1239,10 @@ Yap_signal_index(const char *name) #include #endif -STATIC_PROTO (void HandleSIGSEGV, (int, siginfo_t *, ucontext_t *)); -STATIC_PROTO (void HandleMatherr, (int, siginfo_t *, ucontext_t *)); -STATIC_PROTO (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 HandleSIGSEGV(int, siginfo_t *, ucontext_t *); +static void HandleMatherr, (int, siginfo_t *, ucontext_t *); +static void my_signal_info(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 HeapBase and ending on TrailTop */ @@ -1328,12 +1328,12 @@ my_signal(int sig, void (*handler)(int, siginfo_t *, ucontext_t *)) #elif defined(__linux__) -STATIC_PROTO (RETSIGTYPE HandleMatherr, (int)); +static RETSIGTYPE HandleMatherr(int); #if HAVE_SIGSEGV && !defined(THREADS) -STATIC_PROTO (RETSIGTYPE HandleSIGSEGV, (int,siginfo_t *,void *)); -STATIC_PROTO (void my_signal_info, (int, void (*)(int,siginfo_t *,void *))); +static RETSIGTYPE HandleSIGSEGV(int,siginfo_t *,void *); +static void my_signal_info(int, void (*)(int,siginfo_t *,void *)); #endif -STATIC_PROTO (void my_signal, (int, void (*)(int))); +static void my_signal(int, void (*)(int)); /******** Handling floating point errors *******************/ @@ -1457,10 +1457,10 @@ my_signal(int sig, void (*handler)(int)) #else /* if not (defined(__svr4__) || defined(__SVR4)) */ -STATIC_PROTO (RETSIGTYPE HandleMatherr, (int)); -STATIC_PROTO (RETSIGTYPE HandleSIGSEGV, (int)); -STATIC_PROTO (void my_signal_info, (int, void (*)(int))); -STATIC_PROTO (void my_signal, (int, void (*)(int))); +static RETSIGTYPE HandleMatherr(int); +static RETSIGTYPE HandleSIGSEGV(int); +static void my_signal_info(int, void (*)(int)); +static void my_signal(int, void (*)(int)); /******** Handling floating point errors *******************/ @@ -3163,7 +3163,7 @@ VaxFixFrame (dummy) #include -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) { @@ -3184,7 +3184,7 @@ int WINAPI win_yap(HANDLE hinst, DWORD reason, LPVOID reserved) #if (defined(YAPOR) || defined(THREADS)) && !defined(USE_PTHREAD_LOCKING) #ifdef sparc -void STD_PROTO(rw_lock_voodoo,(void)); +void rw_lock_voodoo(void); void rw_lock_voodoo(void) { diff --git a/C/tracer.c b/C/tracer.c index d8e686db1..6d5389357 100644 --- a/C/tracer.c +++ b/C/tracer.c @@ -26,7 +26,7 @@ #include "clause.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 send_tracer_message(char *start, char *name, Int arity, char *mname, CELL *args) diff --git a/C/unify.c b/C/unify.c index 35641c485..4cd457dbc 100644 --- a/C/unify.c +++ b/C/unify.c @@ -20,14 +20,14 @@ #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_PROTO(int OCUnify, (register CELL, register CELL)); -STATIC_PROTO(Int p_ocunify, ( USES_REGS1 )); +static int OCUnify_complex(CELL *, CELL *, CELL *); +static int OCUnify(register CELL, register CELL); +static Int p_ocunify( USES_REGS1 ); #ifdef THREADED_CODE -STATIC_PROTO(int rtable_hash_op, (OPCODE)); -STATIC_PROTO(void InitReverseLookupOpcode, (void)); +static int rtable_hash_op(OPCODE); +static void InitReverseLookupOpcode(void); #endif /* support for rational trees and unification with occur checking */ diff --git a/C/userpreds.c b/C/userpreds.c index 325693a55..55e5ca01b 100644 --- a/C/userpreds.c +++ b/C/userpreds.c @@ -51,26 +51,26 @@ static char SccsId[] = "%W% %G%"; /* You should include here the prototypes for all static functions */ #ifdef EUROTRA -STATIC_PROTO(int p_clean, (void)); -STATIC_PROTO(int p_namelength, (void)); -STATIC_PROTO(int p_getpid, (void)); -STATIC_PROTO(int p_exit, (void)); -STATIC_PROTO(int p_incrcounter, (void)); -STATIC_PROTO(int p_setcounter, (void)); -STATIC_PROTO(int p_trapsignal, (void)); -STATIC_PROTO(int subsumes, (Term, Term)); -STATIC_PROTO(int p_subsumes, (void)); -STATIC_PROTO(int p_grab_tokens, (void)); +static int p_clean(void); +static int p_namelength(void); +static int p_getpid(void); +static int p_exit(void); +static int p_incrcounter(void); +static int p_setcounter(void); +static int p_trapsignal(void); +static int subsumes(Term, Term); +static int p_subsumes(void); +static int p_grab_tokens(void); #endif #ifdef MACYAP -STATIC_PROTO(typedef int, (*SignalProc) ()); -STATIC_PROTO(SignalProc skel_signal, (int, SignalProc)); -STATIC_PROTO(int chdir, (char *)); +static typedef int(*SignalProc) (); +static SignalProc skel_signal(int, SignalProc); +static int chdir(char *); #endif #ifdef SFUNC -STATIC_PROTO(int p_softfunctor, (void)); +static int p_softfunctor(void); #endif /* SFUNC */ diff --git a/C/utilpreds.c b/C/utilpreds.c index 06f201434..b0f6054b3 100644 --- a/C/utilpreds.c +++ b/C/utilpreds.c @@ -32,18 +32,18 @@ typedef struct { } *vcell; -STATIC_PROTO(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_PROTO(Int p_non_singletons_in_term, ( USES_REGS1)); -STATIC_PROTO(CELL non_singletons_in_complex_term, (CELL *, CELL * CACHE_TYPE)); -STATIC_PROTO(Int p_variables_in_term, ( USES_REGS1 )); -STATIC_PROTO(Int ground_complex_term, (CELL *, CELL * CACHE_TYPE)); -STATIC_PROTO(Int p_ground, ( USES_REGS1 )); -STATIC_PROTO(Int p_copy_term, ( USES_REGS1 )); -STATIC_PROTO(Int var_in_complex_term, (CELL *, CELL *, Term CACHE_TYPE)); +static int copy_complex_term(CELL *, CELL *, int, int, CELL *, CELL * CACHE_TYPE); +static CELL vars_in_complex_term(CELL *, CELL *, Term CACHE_TYPE); +static Int p_non_singletons_in_term( USES_REGS1); +static CELL non_singletons_in_complex_term(CELL *, CELL * CACHE_TYPE); +static Int p_variables_in_term( USES_REGS1 ); +static Int ground_complex_term(CELL *, CELL * CACHE_TYPE); +static Int p_ground( USES_REGS1 ); +static Int p_copy_term( USES_REGS1 ); +static Int var_in_complex_term(CELL *, CELL *, Term CACHE_TYPE); #ifdef DEBUG -STATIC_PROTO(Int p_force_trail_expansion, ( USES_REGS1 )); +static Int p_force_trail_expansion( USES_REGS1 ); #endif /* DEBUG */ static inline void diff --git a/C/write.c b/C/write.c index 409cf467d..f362341b7 100644 --- a/C/write.c +++ b/C/write.c @@ -78,15 +78,15 @@ typedef struct write_globs { #define lastw wglb->lw #define last_minus wglb->last_atom_minus -STATIC_PROTO(void wrputn, (Int, struct write_globs *)); -STATIC_PROTO(void wrputf, (Float, struct write_globs *)); -STATIC_PROTO(void wrputref, (CODEADDR, int, struct write_globs *)); -STATIC_PROTO(int legalAtom, (unsigned char *)); -/*STATIC_PROTO(int LeftOpToProtect, (Atom, int)); - STATIC_PROTO(int RightOpToProtect, (Atom, int));*/ -STATIC_PROTO(wtype AtomIsSymbols, (unsigned char *)); -STATIC_PROTO(void putAtom, (Atom, int, struct write_globs *)); -STATIC_PROTO(void writeTerm, (Term, int, int, int, struct write_globs *, struct rewind_term *)); +static void wrputn(Int, struct write_globs *); +static void wrputf(Float, struct write_globs *); +static void wrputref(CODEADDR, int, struct write_globs *); +static int legalAtom(unsigned char *); +/*static int LeftOpToProtect(Atom, int); + static int RightOpToProtect(Atom, int);*/ +static wtype AtomIsSymbols(unsigned char *); +static void putAtom(Atom, int, struct write_globs *); +static void writeTerm(Term, int, int, int, struct write_globs *, struct rewind_term *); #define wrputc(X,WF) Sputcode(X,WF) /* writes a character */ diff --git a/H/Foreign.h b/H/Foreign.h index 268be3b19..9fa3195d0 100644 --- a/H/Foreign.h +++ b/H/Foreign.h @@ -100,18 +100,13 @@ typedef struct ForeignLoadItem { typedef void (*YapInitProc)(void); - -#ifndef STD_PROTO -#define STD_PROTO(F,A) F A -#endif - -void *STD_PROTO(Yap_LoadForeignFile,(char *, int)); -int STD_PROTO(Yap_CallForeignFile,(void *, char *)); -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)); +void *Yap_LoadForeignFile(char *, int); +int Yap_CallForeignFile(void *, char *); +int Yap_CloseForeignFile(void *); +Int Yap_LoadForeign(StringList, StringList, char *, YapInitProc *); +Int Yap_ReLoadForeign(StringList, StringList, char *, YapInitProc *); +void Yap_ReOpenLoadForeign(void); +void Yap_ShutdownLoadForeign(void); #define EAGER_LOADING 1 #define GLOBAL_LOADING 2 diff --git a/H/TermExt.h b/H/TermExt.h index ddad335f3..94d2c67f0 100755 --- a/H/TermExt.h +++ b/H/TermExt.h @@ -371,11 +371,11 @@ IsBigIntTerm (Term t) #ifdef USE_GMP -Term STD_PROTO (Yap_MkBigIntTerm, (MP_INT *)); -MP_INT *STD_PROTO (Yap_BigIntOfTerm, (Term)); +Term Yap_MkBigIntTerm(MP_INT *); +MP_INT *Yap_BigIntOfTerm(Term); -Term STD_PROTO (Yap_MkBigRatTerm, (MP_RAT *)); -MP_RAT *STD_PROTO (Yap_BigRatOfTerm, (Term)); +Term Yap_MkBigRatTerm(MP_RAT *); +MP_RAT *Yap_BigRatOfTerm(Term); 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 -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 unify_extension (Functor f, CELL d0, CELL * pt0, CELL d1) diff --git a/H/YapHeap.h b/H/YapHeap.h index a6e09076a..612fcca4f 100644 --- a/H/YapHeap.h +++ b/H/YapHeap.h @@ -90,7 +90,7 @@ typedef struct halt_hook { struct halt_hook *next; } halt_hook_entry; -int STD_PROTO(Yap_HaltRegisterHook,(HaltHookFunc, void *)); +int Yap_HaltRegisterHook(HaltHookFunc, void *); typedef struct atom_hash_entry { #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 -UInt STD_PROTO(Yap_givemallinfo, (void)); +UInt Yap_givemallinfo(void); #endif -ADDR STD_PROTO(Yap_ExpandPreAllocCodeSpace, (UInt, void *, int)); +ADDR Yap_ExpandPreAllocCodeSpace(UInt, void *, int); #define Yap_ReleasePreAllocCodeSpace(x) -ADDR STD_PROTO(Yap_InitPreAllocCodeSpace, (int)); +ADDR Yap_InitPreAllocCodeSpace(int); #include "inline-only.h" INLINE_ONLY EXTERN inline ADDR diff --git a/H/Yapproto.h b/H/Yapproto.h index 8d3b2233f..6edde1f83 100644 --- a/H/Yapproto.h +++ b/H/Yapproto.h @@ -15,259 +15,255 @@ /* prototype file for Yap */ -#define STD_PROTO(F,A) F A -#define STATIC_PROTO(F,A) static F A - - /* absmi.c */ -Int STD_PROTO(Yap_absmi,(int)); -int STD_PROTO(Yap_absmiEND,(void)); +Int Yap_absmi(int); +int Yap_absmiEND(void); /* adtdefs.c */ -Term STD_PROTO(Yap_ArrayToList,(Term *,int)); -int STD_PROTO(Yap_GetName,(char *,UInt,Term)); -Term STD_PROTO(Yap_GetValue,(Atom)); -int STD_PROTO(Yap_HasOp,(Atom)); -struct operator_entry *STD_PROTO(Yap_GetOpPropForAModuleHavingALock,(AtomEntry *, Term)); -Atom STD_PROTO(Yap_LookupAtom,(char *)); -Atom STD_PROTO(Yap_LookupMaybeWideAtom,(wchar_t *)); -Atom STD_PROTO(Yap_LookupMaybeWideAtomWithLength,(wchar_t *, size_t)); -Atom STD_PROTO(Yap_FullLookupAtom,(char *)); -void STD_PROTO(Yap_LookupAtomWithAddress,(char *,AtomEntry *)); -Prop STD_PROTO(Yap_NewPredPropByFunctor,(struct FunctorEntryStruct *, Term)); -Prop STD_PROTO(Yap_NewPredPropByAtom,(struct AtomEntryStruct *, Term)); -Prop STD_PROTO(Yap_PredPropByFunctorNonThreadLocal,(struct FunctorEntryStruct *, Term)); -Prop STD_PROTO(Yap_PredPropByAtomNonThreadLocal,(struct AtomEntryStruct *, Term)); -Functor STD_PROTO(Yap_UnlockedMkFunctor,(AtomEntry *,unsigned int)); -Functor STD_PROTO(Yap_MkFunctor,(Atom,unsigned int)); -void STD_PROTO(Yap_MkFunctorWithAddress,(Atom,unsigned int,FunctorEntry *)); -void STD_PROTO(Yap_PutValue,(Atom,Term)); -void STD_PROTO(Yap_ReleaseAtom,(Atom)); -Term STD_PROTO(Yap_StringToList,(char *)); -Term STD_PROTO(Yap_NStringToList,(char *, size_t)); -Term STD_PROTO(Yap_WideStringToList,(wchar_t *)); -Term STD_PROTO(Yap_NWideStringToList,(wchar_t *, size_t)); -Term STD_PROTO(Yap_StringToDiffList,(char *,Term CACHE_TYPE)); -Term STD_PROTO(Yap_NStringToDiffList,(char *,Term, size_t)); -Term STD_PROTO(Yap_WideStringToDiffList,(wchar_t *,Term)); -Term STD_PROTO(Yap_NWideStringToDiffList,(wchar_t *,Term, size_t)); -Term STD_PROTO(Yap_StringToListOfAtoms,(char *)); -Term STD_PROTO(Yap_NStringToListOfAtoms,(char *, size_t)); -Term STD_PROTO(Yap_WideStringToListOfAtoms,(wchar_t *)); -Term STD_PROTO(Yap_NWideStringToListOfAtoms,(wchar_t *, size_t)); -Term STD_PROTO(Yap_NWideStringToDiffListOfAtoms,(wchar_t *, Term, size_t)); -int STD_PROTO(Yap_AtomIncreaseHold,(Atom)); -int STD_PROTO(Yap_AtomDecreaseHold,(Atom)); -struct operator_entry *STD_PROTO(Yap_OpPropForModule,(Atom, Term)); -Int STD_PROTO(Yap_InitSlot,(Term CACHE_TYPE)); -Int STD_PROTO(Yap_NewSlots,(int CACHE_TYPE)); -int STD_PROTO(Yap_RecoverSlots,(int CACHE_TYPE)); +Term Yap_ArrayToList(Term *,int); +int Yap_GetName(char *,UInt,Term); +Term Yap_GetValue(Atom); +int Yap_HasOp(Atom); +struct operator_entry *Yap_GetOpPropForAModuleHavingALock(AtomEntry *, Term); +Atom Yap_LookupAtom(char *); +Atom Yap_LookupMaybeWideAtom(wchar_t *); +Atom Yap_LookupMaybeWideAtomWithLength(wchar_t *, size_t); +Atom Yap_FullLookupAtom(char *); +void Yap_LookupAtomWithAddress(char *,AtomEntry *); +Prop Yap_NewPredPropByFunctor(struct FunctorEntryStruct *, Term); +Prop Yap_NewPredPropByAtom(struct AtomEntryStruct *, Term); +Prop Yap_PredPropByFunctorNonThreadLocal(struct FunctorEntryStruct *, Term); +Prop Yap_PredPropByAtomNonThreadLocal(struct AtomEntryStruct *, Term); +Functor Yap_UnlockedMkFunctor(AtomEntry *,unsigned int); +Functor Yap_MkFunctor(Atom,unsigned int); +void Yap_MkFunctorWithAddress(Atom,unsigned int,FunctorEntry *); +void Yap_PutValue(Atom,Term); +void Yap_ReleaseAtom(Atom); +Term Yap_StringToList(char *); +Term Yap_NStringToList(char *, size_t); +Term Yap_WideStringToList(wchar_t *); +Term Yap_NWideStringToList(wchar_t *, size_t); +Term Yap_StringToDiffList(char *,Term CACHE_TYPE); +Term Yap_NStringToDiffList(char *,Term, size_t); +Term Yap_WideStringToDiffList(wchar_t *,Term); +Term Yap_NWideStringToDiffList(wchar_t *,Term, size_t); +Term Yap_StringToListOfAtoms(char *); +Term Yap_NStringToListOfAtoms(char *, size_t); +Term Yap_WideStringToListOfAtoms(wchar_t *); +Term Yap_NWideStringToListOfAtoms(wchar_t *, size_t); +Term Yap_NWideStringToDiffListOfAtoms(wchar_t *, Term, size_t); +int Yap_AtomIncreaseHold(Atom); +int Yap_AtomDecreaseHold(Atom); +struct operator_entry *Yap_OpPropForModule(Atom, Term); +Int Yap_InitSlot(Term CACHE_TYPE); +Int Yap_NewSlots(int CACHE_TYPE); +int Yap_RecoverSlots(int CACHE_TYPE); #ifdef SFUNC -Term STD_PROTO(MkSFTerm,(Functor,int,Term *,Term)); -CELL STD_PROTO(*ArgsOfSFTerm,(Term)); +Term MkSFTerm(Functor,int,Term *,Term); +CELL *ArgsOfSFTerm(Term); #endif -Prop STD_PROTO(Yap_GetPredPropByAtom,(Atom, Term)); -Prop STD_PROTO(Yap_GetPredPropByFunc,(Functor, Term)); -Prop STD_PROTO(Yap_GetPredPropByAtomInThisModule,(Atom, Term)); -Prop STD_PROTO(Yap_GetPredPropByFuncInThisModule,(Functor, Term)); -Prop STD_PROTO(Yap_GetPredPropHavingLock,(Atom,unsigned int, Term)); -Prop STD_PROTO(Yap_GetExpProp,(Atom,unsigned int)); -Prop STD_PROTO(Yap_GetExpPropHavingLock,(AtomEntry *,unsigned int)); +Prop Yap_GetPredPropByAtom(Atom, Term); +Prop Yap_GetPredPropByFunc(Functor, Term); +Prop Yap_GetPredPropByAtomInThisModule(Atom, Term); +Prop Yap_GetPredPropByFuncInThisModule(Functor, Term); +Prop Yap_GetPredPropHavingLock(Atom,unsigned int, Term); +Prop Yap_GetExpProp(Atom,unsigned int); +Prop Yap_GetExpPropHavingLock(AtomEntry *,unsigned int); /* agc.c */ -void STD_PROTO(Yap_atom_gc, (CACHE_TYPE1)); -void STD_PROTO(Yap_init_agc, (void)); +void Yap_atom_gc( CACHE_TYPE1 ); +void Yap_init_agc( void ); /* alloc.c */ -void STD_PROTO(Yap_FreeCodeSpace,(char *)); -char *STD_PROTO(Yap_AllocAtomSpace,(size_t)); -char *STD_PROTO(Yap_AllocCodeSpace,(size_t)); -char *STD_PROTO(Yap_ReallocCodeSpace,(char *,size_t)); -ADDR STD_PROTO(Yap_AllocFromForeignArea,(Int)); -int STD_PROTO(Yap_ExtendWorkSpace,(Int)); -void STD_PROTO(Yap_FreeAtomSpace,(char *)); -int STD_PROTO(Yap_FreeWorkSpace, (void)); -void STD_PROTO(Yap_InitMemory,(UInt,UInt,UInt)); -void STD_PROTO(Yap_InitExStacks,(int,int,int)); +void Yap_FreeCodeSpace(char *); +char *Yap_AllocAtomSpace(size_t); +char *Yap_AllocCodeSpace(size_t); +char *Yap_ReallocCodeSpace(char *,size_t); +ADDR Yap_AllocFromForeignArea(Int); +int Yap_ExtendWorkSpace(Int); +void Yap_FreeAtomSpace(char *); +int Yap_FreeWorkSpace(void); +void Yap_InitMemory(UInt,UInt,UInt); +void Yap_InitExStacks(int,int,int); /* amasm.c */ -OPCODE STD_PROTO(Yap_opcode,(op_numbers)); +OPCODE Yap_opcode(op_numbers); /* analyst.c */ #ifdef ANALYST -void STD_PROTO(Yap_InitAnalystPreds,(void)); +void Yap_InitAnalystPreds(void); #endif /* ANALYST */ /* arrays.c */ -void STD_PROTO(Yap_InitArrayPreds,(void)); +void Yap_InitArrayPreds(void); /* attvar.c */ -void STD_PROTO(Yap_InitAttVarPreds,(void)); +void Yap_InitAttVarPreds(void); /* bb.c */ -void STD_PROTO(Yap_InitBBPreds,(void)); +void Yap_InitBBPreds(void); /* bignum.c */ -Term STD_PROTO(Yap_MkULLIntTerm, (YAP_ULONG_LONG)); -int STD_PROTO(Yap_IsStringTerm, (Term)); -int STD_PROTO(Yap_IsWideStringTerm, (Term)); -Term STD_PROTO(Yap_RatTermToApplTerm, (Term)); -void STD_PROTO(Yap_InitBigNums, (void)); -Term STD_PROTO(Yap_AllocExternalDataInStack, (CELL, size_t)); -int STD_PROTO(Yap_CleanOpaqueVariable, (CELL *)); +Term Yap_MkULLIntTerm(YAP_ULONG_LONG); +int Yap_IsStringTerm(Term); +int Yap_IsWideStringTerm(Term); +Term Yap_RatTermToApplTerm(Term); +void Yap_InitBigNums(void); +Term Yap_AllocExternalDataInStack(CELL, size_t); +int Yap_CleanOpaqueVariable(CELL *); /* c_interface.c */ -Int STD_PROTO(YAP_Execute,(struct pred_entry *, CPredicate)); -Int STD_PROTO(YAP_ExecuteFirst,(struct pred_entry *, CPredicate)); -Int STD_PROTO(YAP_ExecuteNext,(struct pred_entry *, CPredicate)); -Int STD_PROTO(YAP_ExecuteOnCut,(struct pred_entry *, CPredicate, struct cut_c_str *)); +Int YAP_Execute(struct pred_entry *, CPredicate); +Int YAP_ExecuteFirst(struct pred_entry *, CPredicate); +Int YAP_ExecuteNext(struct pred_entry *, CPredicate); +Int YAP_ExecuteOnCut(struct pred_entry *, CPredicate, struct cut_c_str *); /* cdmgr.c */ -Term STD_PROTO(Yap_all_calls,(void)); -Atom STD_PROTO(Yap_ConsultingFile,(void)); -struct pred_entry *STD_PROTO(Yap_PredForChoicePt,(choiceptr)); -void STD_PROTO(Yap_InitCdMgr,(void)); -void STD_PROTO(Yap_init_consult,(int, char *)); -void STD_PROTO(Yap_end_consult,(void)); -void STD_PROTO(Yap_Abolish,(struct pred_entry *)); -void STD_PROTO(Yap_BuildMegaClause,(struct pred_entry *)); -void STD_PROTO(Yap_EraseMegaClause,(yamop *,struct pred_entry *)); -void STD_PROTO(Yap_ResetConsultStack,(void)); -void STD_PROTO(Yap_AssertzClause,(struct pred_entry *, yamop *)); +Term Yap_all_calls(void); +Atom Yap_ConsultingFile(void); +struct pred_entry *Yap_PredForChoicePt(choiceptr); +void Yap_InitCdMgr(void); +void Yap_init_consult(int, char *); +void Yap_end_consult(void); +void Yap_Abolish(struct pred_entry *); +void Yap_BuildMegaClause(struct pred_entry *); +void Yap_EraseMegaClause(yamop *,struct pred_entry *); +void Yap_ResetConsultStack(void); +void Yap_AssertzClause(struct pred_entry *, yamop *); void Yap_HidePred(struct pred_entry *pe); /* cmppreds.c */ -Int STD_PROTO(Yap_compare_terms,(Term,Term)); -void STD_PROTO(Yap_InitCmpPreds,(void)); +Int Yap_compare_terms(Term,Term); +void Yap_InitCmpPreds(void); /* compiler.c */ -yamop *STD_PROTO(Yap_cclause,(Term, Int, Term, Term)); +yamop *Yap_cclause(Term, Int, Term, Term); /* computils.c */ /* corout.c */ -void STD_PROTO(Yap_InitCoroutPreds,(void)); +void Yap_InitCoroutPreds(void); #ifdef COROUTINING -Term STD_PROTO(Yap_ListOfWokenGoals,(void)); -void STD_PROTO(Yap_WakeUp,(CELL *)); +Term Yap_ListOfWokenGoals(void); +void Yap_WakeUp(CELL *); #endif /* dbase.c */ -struct pred_entry *STD_PROTO(Yap_FindLUIntKey,(Int)); -int STD_PROTO(Yap_DBTrailOverflow,(void)); -CELL STD_PROTO(Yap_EvalMasks,(Term,CELL *)); -void STD_PROTO(Yap_InitBackDB,(void)); -void STD_PROTO(Yap_InitDBPreds,(void)); +struct pred_entry *Yap_FindLUIntKey(Int); +int Yap_DBTrailOverflow(void); +CELL Yap_EvalMasks(Term,CELL *); +void Yap_InitBackDB(void); +void Yap_InitDBPreds(void); /* errors.c */ -void STD_PROTO(Yap_RestartYap,(int)); -void STD_PROTO(Yap_exit,(int)); -yamop *STD_PROTO(Yap_Error,(yap_error_number,Term,char *msg, ...)); -yamop *STD_PROTO(Yap_NilError,(yap_error_number,char *msg, ...)); +void Yap_RestartYap(int); +void Yap_exit(int); +yamop *Yap_Error(yap_error_number,Term,char *msg, ...); +yamop *Yap_NilError(yap_error_number,char *msg, ...); /* eval.c */ -void STD_PROTO(Yap_InitEval,(void)); +void Yap_InitEval(void); /* exec.c */ -Term STD_PROTO(Yap_ExecuteCallMetaCall,(Term)); -void STD_PROTO(Yap_InitExecFs,(void)); -Int STD_PROTO(Yap_JumpToEnv,(Term)); -Term STD_PROTO(Yap_RunTopGoal,(Term)); -void STD_PROTO(Yap_ResetExceptionTerm,(int)); -Int STD_PROTO(Yap_execute_goal,(Term, int, Term)); -Int STD_PROTO(Yap_exec_absmi,(int)); -void STD_PROTO(Yap_trust_last,(void)); -Term STD_PROTO(Yap_GetException,(void)); -void STD_PROTO(Yap_PrepGoal,(UInt, CELL *, choiceptr USES_REGS)); +Term Yap_ExecuteCallMetaCall(Term); +void Yap_InitExecFs(void); +Int Yap_JumpToEnv(Term); +Term Yap_RunTopGoal(Term); +void Yap_ResetExceptionTerm(int); +Int Yap_execute_goal(Term, int, Term); +Int Yap_exec_absmi(int); +void Yap_trust_last(void); +Term Yap_GetException(void); +void Yap_PrepGoal(UInt, CELL *, choiceptr USES_REGS); /* exo.c */ -void STD_PROTO(Yap_InitExoPreds,(void)); +void Yap_InitExoPreds(void); void Yap_udi_Interval_init(void); /* foreign.c */ -char *STD_PROTO(Yap_FindExecutable,(void)); +char *Yap_FindExecutable(void); /* gprof.c */ -void STD_PROTO(Yap_InitLowProf,(void)); +void Yap_InitLowProf(void); #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);} #else #define Yap_inform_profiler_of_clause(CODE0,CODEF,AP,MODE) #endif -void STD_PROTO(Yap_tell_gprof,(yamop *)); +void Yap_tell_gprof(yamop *); /* globals.c */ -Term STD_PROTO(Yap_NewArena,(UInt,CELL *)); -CELL *STD_PROTO(Yap_GetFromArena,(Term *,UInt,UInt)); -void STD_PROTO(Yap_InitGlobals,(void)); -Term STD_PROTO(Yap_SaveTerm, (Term)); -Term STD_PROTO(Yap_SetGlobalVal, (Atom, Term)); -Int STD_PROTO(Yap_DeleteGlobal, (Atom)); -void STD_PROTO(Yap_AllocateDefaultArena, (Int, Int, int)); +Term Yap_NewArena(UInt,CELL *); +CELL *Yap_GetFromArena(Term *,UInt,UInt); +void Yap_InitGlobals(void); +Term Yap_SaveTerm(Term); +Term Yap_SetGlobalVal(Atom, Term); +Int Yap_DeleteGlobal(Atom); +void Yap_AllocateDefaultArena(Int, Int, int); /* grow.c */ -Int STD_PROTO(Yap_total_stack_shift_time,(void)); -void STD_PROTO(Yap_InitGrowPreds, (void)); -UInt STD_PROTO(Yap_InsertInGlobal, (CELL *, UInt)); -int STD_PROTO(Yap_growheap, (int, size_t, void *)); -int STD_PROTO(Yap_growstack, (long)); -int STD_PROTO(Yap_growtrail, (long, int)); -int STD_PROTO(Yap_growglobal, (CELL **)); -CELL **STD_PROTO(Yap_shift_visit, (CELL **, CELL ***, CELL ***)); +Int Yap_total_stack_shift_time(void); +void Yap_InitGrowPreds(void); +UInt Yap_InsertInGlobal(CELL *, UInt); +int Yap_growheap(int, size_t, void *); +int Yap_growstack( size_t ); +int Yap_growtrail(long, int); +int Yap_growglobal(CELL **); +CELL **Yap_shift_visit(CELL **, CELL ***, CELL ***); #ifdef THREADS -void STD_PROTO(Yap_CopyThreadStacks, (int, int, int)); +void Yap_CopyThreadStacks(int, int, int); #endif /* heapgc.c */ -Int STD_PROTO(Yap_total_gc_time,(void)); -void STD_PROTO(Yap_init_gc,(void)); -int STD_PROTO(Yap_is_gc_verbose, (void)); -int STD_PROTO(Yap_gc, (Int, CELL *, yamop *)); -int STD_PROTO(Yap_gcl, (UInt, Int, CELL *, yamop *)); +Int Yap_total_gc_time(void); +void Yap_init_gc(void); +int Yap_is_gc_verbose(void); +int Yap_gc(Int, CELL *, yamop *); +int Yap_gcl(UInt, Int, CELL *, yamop *); /* init.c */ #ifdef DEBUG -int STD_PROTO(Yap_DebugPutc,(int,wchar_t)); -void STD_PROTO(Yap_DebugSetIFile,(char *)); -void STD_PROTO(Yap_DebugEndline,(void)); -int STD_PROTO(Yap_DebugGetc,(void)); +int Yap_DebugPutc(int,wchar_t); +void Yap_DebugSetIFile(char *); +void Yap_DebugEndline(void); +int Yap_DebugGetc(void); #endif -int STD_PROTO(Yap_IsOpType,(char *)); -void STD_PROTO(Yap_InitCPred,(char *, unsigned long int, CPredicate, UInt)); -void STD_PROTO(Yap_InitAsmPred,(char *, unsigned long int, int, CPredicate, UInt)); -void STD_PROTO(Yap_InitCmpPred,(char *, unsigned long int, CmpPredicate, UInt)); -void STD_PROTO(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)); +int Yap_IsOpType(char *); +void Yap_InitCPred(char *, unsigned long int, CPredicate, UInt); +void Yap_InitAsmPred(char *, unsigned long int, int, CPredicate, UInt); +void Yap_InitCmpPred(char *, unsigned long int, CmpPredicate, UInt); +void Yap_InitCPredBack(char *, unsigned long int, unsigned int, CPredicate,CPredicate,UInt); +void Yap_InitCPredBackCut(char *, unsigned long int, unsigned int, CPredicate,CPredicate,CPredicate,UInt); #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 -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 -void STD_PROTO(Yap_init_yapor_workers, (void)); +void Yap_init_yapor_workers(void); #endif /* YAPOR */ #if defined(YAPOR) || defined(THREADS) -void STD_PROTO(Yap_KillStacks,(int)); +void Yap_KillStacks(int); #else -void STD_PROTO(Yap_KillStacks,(int)); +void Yap_KillStacks(int); #endif -void STD_PROTO(Yap_InitYaamRegs,(int)); -void STD_PROTO(Yap_ReInitWallTime, (void)); -int STD_PROTO(Yap_OpDec,(int,char *,Atom,Term)); -void STD_PROTO(Yap_CloseScratchPad,(void)); +void Yap_InitYaamRegs(int); +void Yap_ReInitWallTime(void); +int Yap_OpDec(int,char *,Atom,Term); +void Yap_CloseScratchPad(void); /* inlines.c */ -void STD_PROTO(Yap_InitInlines,(void)); -int STD_PROTO(Yap_eq,(Term, Term)); +void Yap_InitInlines(void); +int Yap_eq(Term, Term); /* iopreds.c */ -void STD_PROTO(Yap_InitBackIO,(void)); -void STD_PROTO(Yap_InitIOPreds,(void)); +void Yap_InitBackIO(void); +void Yap_InitIOPreds(void); void *Yap_GetStreamHandle(Atom at); void *Yap_GetInputStream(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_DebugErrorPutc (int n); #endif -int STD_PROTO(Yap_readTerm, (void *, Term *, Term *, Term *, Term *)); -void STD_PROTO(Yap_PlWriteToStream, (Term, int, int)); +int Yap_readTerm(void *, Term *, Term *, Term *, Term *); +void Yap_PlWriteToStream(Term, int, int); /* depth_lim.c */ -void STD_PROTO(Yap_InitItDeepenPreds,(void)); +void Yap_InitItDeepenPreds(void); /* load_foreign.c */ -void STD_PROTO(Yap_InitLoadForeign,(void)); +void Yap_InitLoadForeign(void); /* mavar.c */ -void STD_PROTO(Yap_InitMaVarCPreds,(void)); -Term STD_PROTO(Yap_NewTimedVar,(Term)); -Term STD_PROTO(Yap_NewEmptyTimedVar,(void)); -Term STD_PROTO(Yap_ReadTimedVar,(Term)); -Term STD_PROTO(Yap_UpdateTimedVar,(Term, Term)); +void Yap_InitMaVarCPreds(void); +Term Yap_NewTimedVar(Term); +Term Yap_NewEmptyTimedVar(void); +Term Yap_ReadTimedVar(Term); +Term Yap_UpdateTimedVar(Term, Term); /* modules.c */ -Term STD_PROTO(Yap_Module, (Term)); -Term STD_PROTO(Yap_Module_Name, (struct pred_entry *)); -struct pred_entry *STD_PROTO(Yap_ModulePred, (Term)); -void STD_PROTO(Yap_NewModulePred, (Term, struct pred_entry *)); -Term STD_PROTO(Yap_StripModule, (Term, Term *)); -void STD_PROTO(Yap_InitModules, (void)); -void STD_PROTO(Yap_InitModulesC, (void)); +Term Yap_Module(Term); +Term Yap_Module_Name(struct pred_entry *); +struct pred_entry *Yap_ModulePred(Term); +void Yap_NewModulePred(Term, struct pred_entry *); +Term Yap_StripModule(Term, Term *); +void Yap_InitModules(void); +void Yap_InitModulesC(void); #if HAVE_MPI /* mpi.c */ -void STD_PROTO(Yap_InitMPI,(void)); +void Yap_InitMPI(void); #endif #if HAVE_MPE /* mpe.c */ -void STD_PROTO(Yap_InitMPE,(void)); +void Yap_InitMPE(void); #endif /* other.c */ -Term STD_PROTO(Yap_MkApplTerm,(Functor,unsigned int,Term *)); -Term STD_PROTO(Yap_MkNewApplTerm,(Functor,unsigned int)); -Term STD_PROTO(Yap_MkNewPairTerm,(void)); -Term STD_PROTO(Yap_Globalise,(Term)); +Term Yap_MkApplTerm(Functor,unsigned int,Term *); +Term Yap_MkNewApplTerm(Functor,unsigned int); +Term Yap_MkNewPairTerm(void); +Term Yap_Globalise(Term); /* parser.c */ -Term STD_PROTO(Yap_Parse,(void)); +Term Yap_Parse(void); /* readutil.c */ -void STD_PROTO(Yap_InitReadUtil,(void)); +void Yap_InitReadUtil(void); /* qly.c */ -void STD_PROTO(Yap_InitQLY,(void)); -int STD_PROTO(Yap_Restore,(char *, char *)); -void STD_PROTO(Yap_InitQLYR,(void)); +void Yap_InitQLY(void); +int Yap_Restore(char *, char *); +void Yap_InitQLYR(void); /* range.c */ void Yap_InitRange(void); /* save.c */ -int STD_PROTO(Yap_SavedInfo,(char *,char *,CELL *,CELL *,CELL *)); -int STD_PROTO(Yap_SavedStateRestore,(char *, char *)); -struct io_stream *STD_PROTO(Yap_OpenRestore,(char *, char *)); -void STD_PROTO(Yap_InitSavePreds,(void)); +int Yap_SavedInfo(char *,char *,CELL *,CELL *,CELL *); +int Yap_SavedStateRestore(char *, char *); +struct io_stream *Yap_OpenRestore(char *, char *); +void Yap_InitSavePreds(void); /* scanner.c */ /* signals.c */ -void STD_PROTO(Yap_signal,(yap_signals)); -void STD_PROTO(Yap_undo_signal,(yap_signals)); -void STD_PROTO(Yap_InitSignalCPreds,(void)); +void Yap_signal(yap_signals); +void Yap_undo_signal(yap_signals); +void Yap_InitSignalCPreds(void); /* sort.c */ -void STD_PROTO(Yap_InitSortPreds,(void)); +void Yap_InitSortPreds(void); /* stdpreds.c */ -void STD_PROTO(Yap_InitBackCPreds,(void)); -void STD_PROTO(Yap_InitCPreds,(void)); -void STD_PROTO(Yap_show_statistics,(void)); -int STD_PROTO(Yap_IsOpMaxPrio,(Atom)); +void Yap_InitBackCPreds(void); +void Yap_InitCPreds(void); +void Yap_show_statistics(void); +int Yap_IsOpMaxPrio(Atom); /* sysbits.c */ -void STD_PROTO(Yap_InitPageSize, (void)); -void STD_PROTO(Yap_set_fpu_exceptions,(int)); -UInt STD_PROTO(Yap_cputime,(void)); -Int STD_PROTO(Yap_walltime,(void)); -int STD_PROTO(Yap_dir_separator,(int)); -int STD_PROTO(Yap_volume_header,(char *)); -void STD_PROTO(Yap_InitSysPath,(void)); -int STD_PROTO(Yap_signal_index,(const char *)); +void Yap_InitPageSize(void); +void Yap_set_fpu_exceptions(int); +UInt Yap_cputime(void); +Int Yap_walltime(void); +int Yap_dir_separator(int); +int Yap_volume_header(char *); +void Yap_InitSysPath(void); +int Yap_signal_index(const char *); #ifdef MAC -void STD_PROTO(Yap_SetTextFile,(char *)); +void Yap_SetTextFile(char *); #endif -int STD_PROTO(Yap_getcwd,(const char *, int)); -void STD_PROTO(Yap_cputime_interval,(Int *,Int *)); -void STD_PROTO(Yap_systime_interval,(Int *,Int *)); -void STD_PROTO(Yap_walltime_interval,(Int *,Int *)); -void STD_PROTO(Yap_InitSysbits,(void)); -void STD_PROTO(Yap_InitSysPreds,(void)); -void STD_PROTO(Yap_InitTime,(int)); -int STD_PROTO(Yap_TrueFileName, (char *, char *, int)); -double STD_PROTO(Yap_random, (void)); +int Yap_getcwd(const char *, int); +void Yap_cputime_interval(Int *,Int *); +void Yap_systime_interval(Int *,Int *); +void Yap_walltime_interval(Int *,Int *); +void Yap_InitSysbits(void); +void Yap_InitSysPreds(void); +void Yap_InitTime(int); +int Yap_TrueFileName(char *, char *, int); +double Yap_random(void); #ifdef _WIN32 -char *STD_PROTO(Yap_RegistryGetString,(char *)); -void STD_PROTO(Yap_WinError,(char *)); +char *Yap_RegistryGetString(char *); +void Yap_WinError(char *); #endif /* threads.c */ -void STD_PROTO(Yap_InitThreadPreds,(void)); +void Yap_InitThreadPreds(void); #if THREADS -int STD_PROTO(Yap_InitThread,(int)); +int Yap_InitThread(int); #endif /* tracer.c */ #ifdef LOW_LEVEL_TRACER -void STD_PROTO(Yap_InitLowLevelTrace,(void)); +void Yap_InitLowLevelTrace(void); #endif /* udi.c */ -void STD_PROTO(Yap_udi_init,(void)); -void STD_PROTO(Yap_udi_abolish,(struct pred_entry *)); +void Yap_udi_init(void); +void Yap_udi_abolish(struct pred_entry *); /* unify.c */ -int STD_PROTO(Yap_rational_tree_loop, (CELL *, CELL *, CELL **, CELL **)); -void STD_PROTO(Yap_InitAbsmi,(void)); -void STD_PROTO(Yap_InitUnify,(void)); -void STD_PROTO(Yap_TrimTrail,(void)); -int STD_PROTO(Yap_Unifiable,(Term d0, Term d1)); -int STD_PROTO(Yap_IUnify,(register CELL d0,register CELL d1)); +int Yap_rational_tree_loop(CELL *, CELL *, CELL **, CELL **); +void Yap_InitAbsmi(void); +void Yap_InitUnify(void); +void Yap_TrimTrail(void); +int Yap_Unifiable(Term d0, Term d1); +int Yap_IUnify(register CELL d0,register CELL d1); /* userpreds.c */ -void STD_PROTO(Yap_InitUserCPreds,(void)); -void STD_PROTO(Yap_InitUserBacks,(void)); +void Yap_InitUserCPreds(void); +void Yap_InitUserBacks(void); /* utilpreds.c */ -Term STD_PROTO(Yap_CopyTerm,(Term)); -int STD_PROTO(Yap_Variant,(Term, Term)); -size_t STD_PROTO(Yap_ExportTerm,(Term, char *, size_t, UInt)); -size_t STD_PROTO(Yap_SizeOfExportedTerm,(char *)); -Term STD_PROTO(Yap_ImportTerm,(char *)); -int STD_PROTO(Yap_IsListTerm,(Term)); -int STD_PROTO(Yap_IsListOrPartialListTerm,(Term)); -Term STD_PROTO(Yap_CopyTermNoShare,(Term)); -int STD_PROTO(Yap_SizeGroundTerm,(Term, int)); -int STD_PROTO(Yap_IsGroundTerm,(Term)); -int STD_PROTO(Yap_IsAcyclicTerm,(Term)); -void STD_PROTO(Yap_InitUtilCPreds,(void)); -Int STD_PROTO(Yap_TermHash,(Term, Int, Int, int)); -Int STD_PROTO(Yap_NumberVars,(Term, Int, int)); -Term STD_PROTO(Yap_UnNumberTerm,(Term, int)); -Int STD_PROTO(Yap_SkipList,(Term *, Term **)); +Term Yap_CopyTerm(Term); +int Yap_Variant(Term, Term); +size_t Yap_ExportTerm(Term, char *, size_t, UInt); +size_t Yap_SizeOfExportedTerm(char *); +Term Yap_ImportTerm(char *); +int Yap_IsListTerm(Term); +int Yap_IsListOrPartialListTerm(Term); +Term Yap_CopyTermNoShare(Term); +int Yap_SizeGroundTerm(Term, int); +int Yap_IsGroundTerm(Term); +int Yap_IsAcyclicTerm(Term); +void Yap_InitUtilCPreds(void); +Int Yap_TermHash(Term, Int, Int, int); +Int Yap_NumberVars(Term, Int, int); +Term Yap_UnNumberTerm(Term, int); +Int Yap_SkipList(Term *, Term **); /* yap.c */ /* write.c */ -void STD_PROTO(Yap_plwrite,(Term, void *, int, int, int)); +void Yap_plwrite(Term, void *, int, int, int); /* MYDDAS */ @@ -435,44 +431,44 @@ void STD_PROTO(Yap_plwrite,(Term, void *, int, int, int)); #if defined MYDDAS_MYSQL || defined MYDDAS_ODBC /* myddas_initialization.c */ -MYDDAS_GLOBAL STD_PROTO(myddas_init_initialize_myddas,(void)); -MYDDAS_UTIL_CONNECTION STD_PROTO(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_GLOBAL myddas_init_initialize_myddas(void); +MYDDAS_UTIL_CONNECTION myddas_init_initialize_connection(void *,void *,MYDDAS_UTIL_CONNECTION); +MYDDAS_UTIL_PREDICATE myddas_init_initialize_predicate(char *, int, char *,MYDDAS_UTIL_PREDICATE); #ifdef MYDDAS_STATS /* myddas_statistics.c */ -MYDDAS_GLOBAL STD_PROTO(myddas_stats_initialize_global_stats,(MYDDAS_GLOBAL)); -MYDDAS_STATS_STRUCT STD_PROTO(myddas_stats_initialize_connection_stats,(void)); -void STD_PROTO(myddas_stats_delete_stats_list,(MYDDAS_STATS_STRUCT)); +MYDDAS_GLOBAL myddas_stats_initialize_global_stats(MYDDAS_GLOBAL); +MYDDAS_STATS_STRUCT myddas_stats_initialize_connection_stats(void); +void myddas_stats_delete_stats_list(MYDDAS_STATS_STRUCT); #endif /* MYDDAS_STATS */ #ifdef MYDDAS_MYSQL /* myddas_util.c */ -void STD_PROTO(myddas_util_table_write,(MYSQL_RES *)); +void myddas_util_table_write(MYSQL_RES *); #endif -Short STD_PROTO(myddas_util_connection_type,(void *)); -MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_add_connection,(void *,void *)); -MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_search_connection,(void *)); -void STD_PROTO(myddas_util_delete_connection,(void *)); -MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_add_predicate,(char * ,Int , char *,void *)); -MYDDAS_UTIL_PREDICATE STD_PROTO(myddas_util_search_predicate,(char * ,Int , char *)); -void STD_PROTO(myddas_util_delete_predicate,(MYDDAS_UTIL_PREDICATE)); +Short myddas_util_connection_type(void *); +MYDDAS_UTIL_CONNECTION myddas_util_add_connection(void *,void *); +MYDDAS_UTIL_CONNECTION myddas_util_search_connection(void *); +void myddas_util_delete_connection(void *); +MYDDAS_UTIL_CONNECTION myddas_util_add_predicate(char * ,Int , char *,void *); +MYDDAS_UTIL_PREDICATE myddas_util_search_predicate(char * ,Int , char *); +void myddas_util_delete_predicate(MYDDAS_UTIL_PREDICATE); /* Get's the number of queries to save */ -UInt STD_PROTO(myddas_util_get_total_multi_queries_number,(MYDDAS_UTIL_CONNECTION)); -void STD_PROTO(myddas_util_set_total_multi_queries_number,(MYDDAS_UTIL_CONNECTION,UInt)); +UInt myddas_util_get_total_multi_queries_number(MYDDAS_UTIL_CONNECTION); +void myddas_util_set_total_multi_queries_number(MYDDAS_UTIL_CONNECTION,UInt); #ifdef MYDDAS_ODBC /* Return enviromment identifier*/ -SQLHENV STD_PROTO(myddas_util_get_odbc_enviromment,(SQLHDBC)); +SQLHENV myddas_util_get_odbc_enviromment(SQLHDBC); #endif -void * STD_PROTO(myddas_util_get_list_pred,(MYDDAS_UTIL_CONNECTION)); -void * STD_PROTO(myddas_util_get_pred_next,(void *)); -char * STD_PROTO(myddas_util_get_pred_module,(void *)); -char * STD_PROTO(myddas_util_get_pred_name,(void *)); -MyddasInt STD_PROTO(myddas_util_get_pred_arity,(void *)); +void * myddas_util_get_list_pred(MYDDAS_UTIL_CONNECTION); +void * myddas_util_get_pred_next(void *); +char * myddas_util_get_pred_module(void *); +char * myddas_util_get_pred_name(void *); +MyddasInt myddas_util_get_pred_arity(void *); //DELETE THIS WHEN DB_STATS IS COMPLETED -MyddasInt STD_PROTO(get_myddas_top,(void)); +MyddasInt get_myddas_top(void); #ifdef DEBUG void check_int(void); @@ -482,36 +478,36 @@ void check_int(void); /* myddas_mysql.c */ #if defined MYDDAS_MYSQL -void STD_PROTO(Yap_InitMYDDAS_MySQLPreds,(void)); -void STD_PROTO(Yap_InitBackMYDDAS_MySQLPreds,(void)); +void Yap_InitMYDDAS_MySQLPreds(void); +void Yap_InitBackMYDDAS_MySQLPreds(void); #endif /* myddas_odbc.c */ #if defined MYDDAS_ODBC -void STD_PROTO(Yap_InitMYDDAS_ODBCPreds,(void)); -void STD_PROTO(Yap_InitBackMYDDAS_ODBCPreds,(void)); +void Yap_InitMYDDAS_ODBCPreds(void); +void Yap_InitBackMYDDAS_ODBCPreds(void); #endif /* myddas_shared.c */ #if defined MYDDAS_ODBC || defined MYDDAS_MYSQL -void STD_PROTO(Yap_MYDDAS_delete_all_myddas_structs,(void)); -void STD_PROTO(Yap_InitMYDDAS_SharedPreds,(void)); -void STD_PROTO(Yap_InitBackMYDDAS_SharedPreds,(void)); +void Yap_MYDDAS_delete_all_myddas_structs(void); +void Yap_InitMYDDAS_SharedPreds(void); +void Yap_InitBackMYDDAS_SharedPreds(void); #endif /* myddas_top_level.c */ #if defined MYDDAS_TOP_LEVEL && defined MYDDAS_MYSQL //&& defined HAVE_LIBREADLINE -void STD_PROTO(Yap_InitMYDDAS_TopLevelPreds,(void)); +void Yap_InitMYDDAS_TopLevelPreds(void); #endif /* yap2swi.c */ -void STD_PROTO(Yap_swi_install,(void)); -void STD_PROTO(Yap_InitSWIHash,(void)); -int STD_PROTO(Yap_get_stream_handle,(Term, int, int, void *)); -Term STD_PROTO(Yap_get_stream_position,(void *)); +void Yap_swi_install(void); +void Yap_InitSWIHash(void); +int Yap_get_stream_handle(Term, int, int, void *); +Term Yap_get_stream_position(void *); /* opt.preds.c */ -void STD_PROTO(Yap_init_optyap_preds,(void)); +void Yap_init_optyap_preds(void); /* pl-file.c */ struct PL_local_data *Yap_InitThreadIO(int wid); diff --git a/H/Yatom.h b/H/Yatom.h index f4546bcad..17ba7366c 100644 --- a/H/Yatom.h +++ b/H/Yatom.h @@ -37,7 +37,7 @@ INLINE_ONLY inline EXTERN AtomEntry *RepAtom (Atom a); INLINE_ONLY inline EXTERN AtomEntry * RepAtom (Atom a) { - return (AtomEntry *) (AtomBase + Unsigned (a)); + return (AtomEntry *) (AtomBase + Unsigned (a); } @@ -487,12 +487,12 @@ typedef enum } 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 STD_PROTO(Yap_IsOp,(Atom)); -int STD_PROTO(Yap_IsInfixOp,(Atom,int *,int *,int *)); -int STD_PROTO(Yap_IsPosfixOp,(Atom,int *,int *)); +int Yap_IsPrefixOp(Atom,int *,int *); +int Yap_IsOp(Atom); +int Yap_IsInfixOp(Atom,int *,int *,int *); +int Yap_IsPosfixOp(Atom,int *,int *); /* defines related to operator specifications */ #define MaskPrio 0x0fff @@ -1440,23 +1440,23 @@ IsBlob (Atom at) /* Proto types */ /* cdmgr.c */ -int STD_PROTO (Yap_RemoveIndexation, (PredEntry *)); -void STD_PROTO (Yap_UpdateTimestamps, (PredEntry *)); +int Yap_RemoveIndexation(PredEntry *); +void Yap_UpdateTimestamps(PredEntry *); /* dbase.c */ -void STD_PROTO (Yap_ErDBE, (DBRef)); -DBTerm *STD_PROTO (Yap_StoreTermInDB, (Term, int)); -DBTerm *STD_PROTO (Yap_StoreTermInDBPlusExtraSpace, (Term, UInt, UInt *)); -Term STD_PROTO (Yap_FetchTermFromDB, (DBTerm *)); -Term STD_PROTO (Yap_PopTermFromDB, (DBTerm *)); -void STD_PROTO (Yap_ReleaseTermFromDB, (DBTerm *)); +void Yap_ErDBE(DBRef); +DBTerm *Yap_StoreTermInDB(Term, int); +DBTerm *Yap_StoreTermInDBPlusExtraSpace(Term, UInt, UInt *); +Term Yap_FetchTermFromDB(DBTerm *); +Term Yap_PopTermFromDB(DBTerm *); +void Yap_ReleaseTermFromDB(DBTerm *); /* 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 */ -Prop STD_PROTO (Yap_GetAProp, (Atom, PropFlags)); -Prop STD_PROTO (Yap_GetAPropHavingLock, (AtomEntry *, PropFlags)); +Prop Yap_GetAProp(Atom, PropFlags); +Prop Yap_GetAPropHavingLock(AtomEntry *, PropFlags); typedef enum { @@ -1473,7 +1473,7 @@ typedef enum #define PredHashInitialSize ((UInt)1039) #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 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; } -INLINE_ONLY EXTERN inline Prop STD_PROTO(GetPredPropByFuncAndModHavingLock, (FunctorEntry *, Term)); -INLINE_ONLY EXTERN inline Prop STD_PROTO(PredPropByFuncAndMod, (FunctorEntry *, Term)); -INLINE_ONLY EXTERN inline Prop STD_PROTO(PredPropByAtomAndMod, (Atom, Term)); -INLINE_ONLY EXTERN inline Prop STD_PROTO(GetPredPropByFuncHavingLock, (FunctorEntry *, Term)); +INLINE_ONLY EXTERN inline Prop GetPredPropByFuncAndModHavingLock(FunctorEntry *, Term); +INLINE_ONLY EXTERN inline Prop PredPropByFuncAndMod(FunctorEntry *, Term); +INLINE_ONLY EXTERN inline Prop PredPropByAtomAndMod(Atom, Term); +INLINE_ONLY EXTERN inline Prop GetPredPropByFuncHavingLock(FunctorEntry *, Term); #ifdef THREADS -Prop STD_PROTO(Yap_NewThreadPred, (struct pred_entry * CACHE_TYPE)); -Prop STD_PROTO(Yap_NewPredPropByFunctor, (Functor, Term)); -INLINE_ONLY EXTERN inline struct pred_entry *STD_PROTO(Yap_GetThreadPred, (struct pred_entry * CACHE_TYPE)); +Prop Yap_NewThreadPred(struct pred_entry * CACHE_TYPE); +Prop Yap_NewPredPropByFunctor(Functor, Term); +INLINE_ONLY EXTERN inline struct pred_entry *Yap_GetThreadPred(struct pred_entry * CACHE_TYPE); INLINE_ONLY EXTERN inline struct pred_entry * 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) #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 AddPropToAtom(AtomEntry *ae, PropEntry *p) diff --git a/H/alloc.h b/H/alloc.h index 56cc32a68..e7f41be86 100644 --- a/H/alloc.h +++ b/H/alloc.h @@ -96,9 +96,9 @@ typedef struct FREEB { /* Operating system and architecture dependent page size */ extern int Yap_page_size; -void STD_PROTO(Yap_InitHeap, (void *)); -UInt STD_PROTO(Yap_ExtendWorkSpaceThroughHole, (UInt)); -void STD_PROTO(Yap_AllocHole, (UInt, UInt)); +void Yap_InitHeap(void *); +UInt Yap_ExtendWorkSpaceThroughHole(UInt); +void Yap_AllocHole(UInt, UInt); #if USE_MMAP && ! defined(__CYGWIN__) diff --git a/H/amiops.h b/H/amiops.h index a88f6cdcf..ee6a99a6a 100644 --- a/H/amiops.h +++ b/H/amiops.h @@ -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 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 Yap_unify_constant(register Term a, register Term cons) diff --git a/H/clause.h b/H/clause.h index d2dd1af4b..eb4fd51d6 100644 --- a/H/clause.h +++ b/H/clause.h @@ -256,36 +256,36 @@ typedef struct dbterm_list { #endif /* amasm.c */ -wamreg STD_PROTO(Yap_emit_x,(CELL)); -COUNT STD_PROTO(Yap_compile_cmp_flags,(PredEntry *)); -void STD_PROTO(Yap_InitComma,(void)); +wamreg Yap_emit_x(CELL); +COUNT Yap_compile_cmp_flags(PredEntry *); +void Yap_InitComma(void); /* cdmgr.c */ -void STD_PROTO(Yap_IPred,(PredEntry *, UInt, yamop *)); -int STD_PROTO(Yap_addclause,(Term,yamop *,int,Term,Term*)); -void STD_PROTO(Yap_add_logupd_clause,(PredEntry *,LogUpdClause *,int)); -void STD_PROTO(Yap_kill_iblock,(ClauseUnion *,ClauseUnion *,PredEntry *)); -void STD_PROTO(Yap_EraseStaticClause,(StaticClause *, Term)); -ClauseUnion *STD_PROTO(Yap_find_owner_index,(yamop *, PredEntry *)); +void Yap_IPred(PredEntry *, UInt, yamop *); +int Yap_addclause(Term,yamop *,int,Term,Term*); +void Yap_add_logupd_clause(PredEntry *,LogUpdClause *,int); +void Yap_kill_iblock(ClauseUnion *,ClauseUnion *,PredEntry *); +void Yap_EraseStaticClause(StaticClause *, Term); +ClauseUnion *Yap_find_owner_index(yamop *, PredEntry *); /* dbase.c */ -void STD_PROTO(Yap_ErCl,(DynamicClause *)); -void STD_PROTO(Yap_ErLogUpdCl,(LogUpdClause *)); -void STD_PROTO(Yap_ErLogUpdIndex,(LogUpdIndex *)); -Int STD_PROTO(Yap_Recordz,(Atom, Term)); +void Yap_ErCl(DynamicClause *); +void Yap_ErLogUpdCl(LogUpdClause *); +void Yap_ErLogUpdIndex(LogUpdIndex *); +Int Yap_Recordz(Atom, Term); /* exec.c */ -Term STD_PROTO(Yap_cp_as_integer,(choiceptr)); +Term Yap_cp_as_integer(choiceptr); /* index.c */ -yamop *STD_PROTO(Yap_PredIsIndexable,(PredEntry *, UInt, yamop *)); -yamop *STD_PROTO(Yap_ExpandIndex,(PredEntry *, UInt)); -void STD_PROTO(Yap_CleanUpIndex,(struct logic_upd_index *)); -void STD_PROTO(Yap_CleanKids,(struct logic_upd_index *)); -void STD_PROTO(Yap_AddClauseToIndex,(PredEntry *,yamop *,int)); -void STD_PROTO(Yap_RemoveClauseFromIndex,(PredEntry *,yamop *)); -LogUpdClause *STD_PROTO(Yap_NthClause,(PredEntry *,Int)); -LogUpdClause *STD_PROTO(Yap_FollowIndexingCode,(PredEntry *,yamop *, Term *, yamop *,yamop *)); +yamop *Yap_PredIsIndexable(PredEntry *, UInt, yamop *); +yamop *Yap_ExpandIndex(PredEntry *, UInt); +void Yap_CleanUpIndex(struct logic_upd_index *); +void Yap_CleanKids(struct logic_upd_index *); +void Yap_AddClauseToIndex(PredEntry *,yamop *,int); +void Yap_RemoveClauseFromIndex(PredEntry *,yamop *); +LogUpdClause *Yap_NthClause(PredEntry *,Int); +LogUpdClause *Yap_FollowIndexingCode(PredEntry *,yamop *, Term *, yamop *,yamop *); /* exo.c */ yamop *Yap_ExoLookup(PredEntry *ap USES_REGS); @@ -392,24 +392,24 @@ typedef enum { FIND_PRED_FROM_ENV } find_pred_type; -Int STD_PROTO(Yap_PredForCode,(yamop *, find_pred_type, Atom *, UInt *, Term *)); -PredEntry *STD_PROTO(Yap_PredEntryForCode,(yamop *, find_pred_type, CODEADDR *, CODEADDR *)); -LogUpdClause *STD_PROTO(Yap_new_ludbe,(Term, PredEntry *, UInt)); -Term STD_PROTO(Yap_LUInstance,(LogUpdClause *, UInt)); +Int Yap_PredForCode(yamop *, find_pred_type, Atom *, UInt *, Term *); +PredEntry *Yap_PredEntryForCode(yamop *, find_pred_type, CODEADDR *, CODEADDR *); +LogUpdClause *Yap_new_ludbe(Term, PredEntry *, UInt); +Term Yap_LUInstance(LogUpdClause *, UInt); /* udi.c */ -void STD_PROTO(Yap_udi_init,(void)); -int STD_PROTO(Yap_new_udi_clause,(PredEntry *, yamop *, Term)); -yamop *STD_PROTO(Yap_udi_search,(PredEntry *)); -void STD_PROTO(Yap_udi_abolish,(PredEntry *p)); +void Yap_udi_init(void); +int Yap_new_udi_clause(PredEntry *, yamop *, Term); +yamop *Yap_udi_search(PredEntry *); +void Yap_udi_abolish(PredEntry *p); #ifdef DEBUG -void STD_PROTO(Yap_bug_location,(yamop *)); +void Yap_bug_location(yamop *); #endif #if LOW_PROF -void STD_PROTO(Yap_InformOfRemoval,(void *)); -void STD_PROTO(Yap_dump_code_area_for_profiler,(void)); +void Yap_InformOfRemoval(void *); +void Yap_dump_code_area_for_profiler(void); #else #define Yap_InformOfRemoval(X) #endif diff --git a/H/compile.h b/H/compile.h index ca11ce88d..665d35321 100644 --- a/H/compile.h +++ b/H/compile.h @@ -325,17 +325,17 @@ typedef enum special_label_op_enum { #define Two 2 -yamop *STD_PROTO(Yap_assemble,(int,Term,struct pred_entry *,int, struct intermediates *, UInt)); -void STD_PROTO(Yap_emit,(compiler_vm_op,Int,CELL, struct intermediates *)); -void STD_PROTO(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 *)); -CELL *STD_PROTO(Yap_emit_extra_size,(compiler_vm_op,CELL,int, struct intermediates *)); -char *STD_PROTO(Yap_AllocCMem,(UInt, struct intermediates *)); -void STD_PROTO(Yap_ReleaseCMem, (struct intermediates *)); -int STD_PROTO(Yap_is_a_test_pred,(Term, Term)); -void STD_PROTO(Yap_bip_name,(Int, char *)); +yamop *Yap_assemble(int,Term,struct pred_entry *,int, struct intermediates *, UInt); +void Yap_emit(compiler_vm_op,Int,CELL, struct intermediates *); +void Yap_emit_3ops(compiler_vm_op,CELL,CELL,CELL, struct intermediates *); +void Yap_emit_4ops(compiler_vm_op,CELL,CELL,CELL,CELL, struct intermediates *); +CELL *Yap_emit_extra_size(compiler_vm_op,CELL,int, struct intermediates *); +char *Yap_AllocCMem(UInt, struct intermediates *); +void Yap_ReleaseCMem(struct intermediates *); +int Yap_is_a_test_pred(Term, Term); +void Yap_bip_name(Int, char *); #ifdef DEBUG -void STD_PROTO(Yap_ShowCode,(struct intermediates *)); +void Yap_ShowCode(struct intermediates *); #endif /* DEBUG */ diff --git a/H/dlmalloc.h b/H/dlmalloc.h index 0c3b6f52d..de84b3df2 100644 --- a/H/dlmalloc.h +++ b/H/dlmalloc.h @@ -7,8 +7,8 @@ /* YAP only stuff */ -void STD_PROTO(Yap_initdlmalloc,(void)); -void STD_PROTO(Yap_RestoreDLMalloc,(void)); +void Yap_initdlmalloc(void); +void Yap_RestoreDLMalloc(void); /* Synopsis of compile-time options: diff --git a/H/eval.h b/H/eval.h index 6d43d51ee..3300ecc35 100644 --- a/H/eval.h +++ b/H/eval.h @@ -128,7 +128,7 @@ typedef enum { op_rdiv } arith2_op; -Functor STD_PROTO(EvalArg,(Term)); +Functor EvalArg(Term); /* Needed to handle numbers: these two macros are fundamental in the integer/float conversions */ @@ -161,20 +161,20 @@ Functor STD_PROTO(EvalArg,(Term)); #define FL(X) ((double)(X)) #endif -void STD_PROTO(Yap_InitConstExps,(void)); -void STD_PROTO(Yap_InitUnaryExps,(void)); -void STD_PROTO(Yap_InitBinaryExps,(void)); +void Yap_InitConstExps(void); +void Yap_InitUnaryExps(void); +void Yap_InitBinaryExps(void); -int STD_PROTO(Yap_ReInitConstExps,(void)); -int STD_PROTO(Yap_ReInitUnaryExps,(void)); -int STD_PROTO(Yap_ReInitBinaryExps,(void)); +int Yap_ReInitConstExps(void); +int Yap_ReInitUnaryExps(void); +int Yap_ReInitBinaryExps(void); -Term STD_PROTO(Yap_eval_atom,(Int)); -Term STD_PROTO(Yap_eval_unary,(Int,Term)); -Term STD_PROTO(Yap_eval_binary,(Int,Term,Term)); +Term Yap_eval_atom(Int); +Term Yap_eval_unary(Int,Term); +Term Yap_eval_binary(Int,Term,Term); -Term STD_PROTO(Yap_InnerEval,(Term)); -Int STD_PROTO(Yap_ArithError,(yap_error_number,Term,char *msg, ...)); +Term Yap_InnerEval(Term); +Int Yap_ArithError(yap_error_number,Term,char *msg, ...); #include "inline-only.h" INLINE_ONLY inline EXTERN Term @@ -225,95 +225,95 @@ ETypeOfTerm(Term t) } #if USE_GMP -Term STD_PROTO(Yap_gmq_rdiv_int_int,(Int, Int)); -Term STD_PROTO(Yap_gmq_rdiv_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmq_rdiv_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmq_rdiv_big_big,(Term, Term)); +Term Yap_gmq_rdiv_int_int(Int, Int); +Term Yap_gmq_rdiv_int_big(Int, Term); +Term Yap_gmq_rdiv_big_int(Term, Int); +Term Yap_gmq_rdiv_big_big(Term, Term); -Term STD_PROTO(Yap_gmp_add_ints,(Int, Int)); -Term STD_PROTO(Yap_gmp_sub_ints,(Int, Int)); -Term STD_PROTO(Yap_gmp_mul_ints,(Int, Int)); -Term STD_PROTO(Yap_gmp_sll_ints,(Int, Int)); -Term STD_PROTO(Yap_gmp_add_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_sub_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_sub_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_mul_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_div_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_div_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_div2_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_fdiv_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_fdiv_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_and_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_ior_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_xor_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_sll_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_add_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_sub_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_mul_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_div_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_div2_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_fdiv_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_and_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_ior_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_xor_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_mod_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_mod_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_mod_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_rem_big_big,(Term, Term)); -Term STD_PROTO(Yap_gmp_rem_big_int,(Term, Int)); -Term STD_PROTO(Yap_gmp_rem_int_big,(Int, Term)); -Term STD_PROTO(Yap_gmp_exp_int_int,(Int,Int)); -Term STD_PROTO(Yap_gmp_exp_int_big,(Int,Term)); -Term STD_PROTO(Yap_gmp_exp_big_int,(Term,Int)); -Term STD_PROTO(Yap_gmp_exp_big_big,(Term,Term)); -Term STD_PROTO(Yap_gmp_gcd_int_big,(Int,Term)); -Term STD_PROTO(Yap_gmp_gcd_big_big,(Term,Term)); +Term Yap_gmp_add_ints(Int, Int); +Term Yap_gmp_sub_ints(Int, Int); +Term Yap_gmp_mul_ints(Int, Int); +Term Yap_gmp_sll_ints(Int, Int); +Term Yap_gmp_add_int_big(Int, Term); +Term Yap_gmp_sub_int_big(Int, Term); +Term Yap_gmp_sub_big_int(Term, Int); +Term Yap_gmp_mul_int_big(Int, Term); +Term Yap_gmp_div_int_big(Int, Term); +Term Yap_gmp_div_big_int(Term, Int); +Term Yap_gmp_div2_big_int(Term, Int); +Term Yap_gmp_fdiv_int_big(Int, Term); +Term Yap_gmp_fdiv_big_int(Term, Int); +Term Yap_gmp_and_int_big(Int, Term); +Term Yap_gmp_ior_int_big(Int, Term); +Term Yap_gmp_xor_int_big(Int, Term); +Term Yap_gmp_sll_big_int(Term, Int); +Term Yap_gmp_add_big_big(Term, Term); +Term Yap_gmp_sub_big_big(Term, Term); +Term Yap_gmp_mul_big_big(Term, Term); +Term Yap_gmp_div_big_big(Term, Term); +Term Yap_gmp_div2_big_big(Term, Term); +Term Yap_gmp_fdiv_big_big(Term, Term); +Term Yap_gmp_and_big_big(Term, Term); +Term Yap_gmp_ior_big_big(Term, Term); +Term Yap_gmp_xor_big_big(Term, Term); +Term Yap_gmp_mod_big_big(Term, Term); +Term Yap_gmp_mod_big_int(Term, Int); +Term Yap_gmp_mod_int_big(Int, Term); +Term Yap_gmp_rem_big_big(Term, Term); +Term Yap_gmp_rem_big_int(Term, Int); +Term Yap_gmp_rem_int_big(Int, Term); +Term Yap_gmp_exp_int_int(Int,Int); +Term Yap_gmp_exp_int_big(Int,Term); +Term Yap_gmp_exp_big_int(Term,Int); +Term Yap_gmp_exp_big_big(Term,Term); +Term Yap_gmp_gcd_int_big(Int,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 STD_PROTO(Yap_gmp_float_to_rational,(Float)); -Term STD_PROTO(Yap_gmp_float_rationalize,(Float)); -Float STD_PROTO(Yap_gmp_to_float,(Term)); -Term STD_PROTO(Yap_gmp_add_float_big,(Float, Term)); -Term STD_PROTO(Yap_gmp_sub_float_big,(Float, Term)); -Term STD_PROTO(Yap_gmp_sub_big_float,(Term, Float)); -Term STD_PROTO(Yap_gmp_mul_float_big,(Float, Term)); -Term STD_PROTO(Yap_gmp_fdiv_float_big,(Float, Term)); -Term STD_PROTO(Yap_gmp_fdiv_big_float,(Term, Float)); +Term Yap_gmp_float_to_big(Float); +Term Yap_gmp_float_to_rational(Float); +Term Yap_gmp_float_rationalize(Float); +Float Yap_gmp_to_float(Term); +Term Yap_gmp_add_float_big(Float, Term); +Term Yap_gmp_sub_float_big(Float, Term); +Term Yap_gmp_sub_big_float(Term, Float); +Term Yap_gmp_mul_float_big(Float, Term); +Term Yap_gmp_fdiv_float_big(Float, Term); +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)) -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)) -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)) -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)) -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 STD_PROTO(Yap_gmp_abs_big,(Term)); -Term STD_PROTO(Yap_gmp_neg_big,(Term)); -Term STD_PROTO(Yap_gmp_unot_big,(Term)); -Term STD_PROTO(Yap_gmp_floor,(Term)); -Term STD_PROTO(Yap_gmp_ceiling,(Term)); -Term STD_PROTO(Yap_gmp_round,(Term)); -Term STD_PROTO(Yap_gmp_trunc,(Term)); -Term STD_PROTO(Yap_gmp_float_fractional_part,(Term)); -Term STD_PROTO(Yap_gmp_float_integer_part,(Term)); -Term STD_PROTO(Yap_gmp_sign,(Term)); -Term STD_PROTO(Yap_gmp_lsb,(Term)); -Term STD_PROTO(Yap_gmp_msb,(Term)); -Term STD_PROTO(Yap_gmp_popcount,(Term)); +Term Yap_gmp_neg_int(Int); +Term Yap_gmp_abs_big(Term); +Term Yap_gmp_neg_big(Term); +Term Yap_gmp_unot_big(Term); +Term Yap_gmp_floor(Term); +Term Yap_gmp_ceiling(Term); +Term Yap_gmp_round(Term); +Term Yap_gmp_trunc(Term); +Term Yap_gmp_float_fractional_part(Term); +Term Yap_gmp_float_integer_part(Term); +Term Yap_gmp_sign(Term); +Term Yap_gmp_lsb(Term); +Term Yap_gmp_msb(Term); +Term Yap_gmp_popcount(Term); -char * STD_PROTO(Yap_gmp_to_string,(Term, char *, size_t, int)); -size_t STD_PROTO(Yap_gmp_to_size,(Term, int)); +char * Yap_gmp_to_string(Term, char *, size_t, int); +size_t Yap_gmp_to_size(Term, int); -int STD_PROTO(Yap_term_to_existing_big,(Term, MP_INT *)); -int STD_PROTO(Yap_term_to_existing_rat,(Term, MP_RAT *)); +int Yap_term_to_existing_big(Term, MP_INT *); +int Yap_term_to_existing_rat(Term, MP_RAT *); void Yap_gmp_set_bit(Int i, Term t); #endif diff --git a/H/heapgc.h b/H/heapgc.h index caada250d..013153b79 100644 --- a/H/heapgc.h +++ b/H/heapgc.h @@ -166,9 +166,9 @@ typedef CELL *CELL_PTR; #define ENVSIZE(E) EnvSize(((CELL *)E)[E_CP]) -void STD_PROTO(Yap_mark_variable, (CELL *)); -void STD_PROTO(Yap_mark_external_reference, (CELL *)); -void STD_PROTO(Yap_inc_mark_variable, (void)); +void Yap_mark_variable(CELL *); +void Yap_mark_external_reference(CELL *); +void Yap_inc_mark_variable(void); diff --git a/H/iopreds.h b/H/iopreds.h index 57801f366..0f03bf4f5 100644 --- a/H/iopreds.h +++ b/H/iopreds.h @@ -112,7 +112,7 @@ StreamDesc; #define ALIASES_BLOCK_SIZE 8 -void STD_PROTO (Yap_InitStdStreams, (void)); -Term STD_PROTO (Yap_StreamPosition, (struct io_stream *)); -void STD_PROTO (Yap_InitPlIO, (void)); +void Yap_InitStdStreams(void); +Term Yap_StreamPosition(struct io_stream *); +void Yap_InitPlIO(void); diff --git a/H/rheap.h b/H/rheap.h index 7208d51f9..b16c11b9b 100644 --- a/H/rheap.h +++ b/H/rheap.h @@ -412,9 +412,9 @@ AdjustSwitchTable__(op_numbers op, yamop *table, COUNT i USES_REGS) } } -STATIC_PROTO(void RestoreAtomList, (Atom CACHE_TYPE)); -STATIC_PROTO(void RestoreAtom, (AtomEntry * CACHE_TYPE)); -STATIC_PROTO(void RestoreHashPreds, ( CACHE_TYPE1 )); +static void RestoreAtomList(Atom CACHE_TYPE); +static void RestoreAtom(AtomEntry * CACHE_TYPE); +static void RestoreHashPreds( CACHE_TYPE1 ); static void RestoreAtoms__( USES_REGS1 ) diff --git a/H/sshift.h b/H/sshift.h index 817a19075..69670624e 100644 --- a/H/sshift.h +++ b/H/sshift.h @@ -1120,6 +1120,6 @@ IsGlobal__ (CELL reg USES_REGS) } -void STD_PROTO (Yap_AdjustStacksAndTrail, (void)); -void STD_PROTO (Yap_AdjustRegs, (int)); +void Yap_AdjustStacksAndTrail(void); +void Yap_AdjustRegs(int); diff --git a/H/threads.h b/H/threads.h index b7f3f12b6..bef71e0a5 100644 --- a/H/threads.h +++ b/H/threads.h @@ -13,13 +13,13 @@ typedef struct thread_attr_struct { #ifdef THREADS -Int STD_PROTO(Yap_thread_self,(void)); -int STD_PROTO(Yap_get_thread_ref_count,(int)); -void STD_PROTO(Yap_set_thread_ref_count,(int,int)); -CELL STD_PROTO(Yap_thread_create_engine,(thread_attr *)); -Int STD_PROTO(Yap_thread_attach_engine,(int)); -Int STD_PROTO(Yap_thread_detach_engine,(int)); -Int STD_PROTO(Yap_thread_destroy_engine,(int)); +Int Yap_thread_self(void); +int Yap_get_thread_ref_count(int); +void Yap_set_thread_ref_count(int,int); +CELL Yap_thread_create_engine(thread_attr *); +Int Yap_thread_attach_engine(int); +Int Yap_thread_detach_engine(int); +Int Yap_thread_destroy_engine(int); #endif diff --git a/H/tracer.h b/H/tracer.h index d2e49b739..710884067 100644 --- a/H/tracer.h +++ b/H/tracer.h @@ -27,9 +27,9 @@ typedef enum { retry_table_loader } yap_low_level_port; -void STD_PROTO(low_level_trace,(yap_low_level_port, PredEntry *, CELL *)); -void STD_PROTO(Yap_InitLowLevelTrace,(void)); -void STD_PROTO(toggle_low_level_trace,(void)); +void low_level_trace(yap_low_level_port, PredEntry *, CELL *); +void Yap_InitLowLevelTrace(void); +void toggle_low_level_trace(void); #endif diff --git a/H/yapio.h b/H/yapio.h index e36e7c642..b306d56ac 100644 --- a/H/yapio.h +++ b/H/yapio.h @@ -66,7 +66,7 @@ #define YP_FILE FILE -int STD_PROTO(YP_putc,(int, int)); +int YP_putc(int, int); #else @@ -231,8 +231,8 @@ typedef struct AliasDescS { extern char *Yap_chtype; #include "inline-only.h" -INLINE_ONLY EXTERN inline int STD_PROTO(chtype,(Int)); -int STD_PROTO(Yap_wide_chtype,(Int)); +INLINE_ONLY EXTERN inline int chtype(Int); +int Yap_wide_chtype(Int); INLINE_ONLY EXTERN inline int chtype(Int ch) @@ -247,44 +247,44 @@ chtype(Int ch) #define ParserAuxSp LOCAL_ScannerStack /* routines in parser.c */ -VarEntry STD_PROTO(*Yap_LookupVar,(char *)); -Term STD_PROTO(Yap_VarNames,(VarEntry *,Term)); +VarEntry *Yap_LookupVar(char *); +Term Yap_VarNames(VarEntry *,Term); /* routines in scanner.c */ -TokEntry STD_PROTO(*Yap_tokenizer,(struct io_stream *, int, Term *)); -void STD_PROTO(Yap_clean_tokenizer,(TokEntry *, VarEntry *, VarEntry *,Term)); -Term STD_PROTO(Yap_scan_num,(struct io_stream *)); -char STD_PROTO(*Yap_AllocScannerMemory,(unsigned int)); +TokEntry *Yap_tokenizer(struct io_stream *, int, Term *); +void Yap_clean_tokenizer(TokEntry *, VarEntry *, VarEntry *,Term); +Term Yap_scan_num(struct io_stream *); +char *Yap_AllocScannerMemory(unsigned int); /* routines in iopreds.c */ -FILE *STD_PROTO(Yap_FileDescriptorFromStream,(Term)); -Int STD_PROTO(Yap_FirstLineInParse,(void)); -int STD_PROTO(Yap_CheckIOStream,(Term, char *)); +FILE *Yap_FileDescriptorFromStream(Term); +Int Yap_FirstLineInParse(void); +int Yap_CheckIOStream(Term, char *); #if defined(YAPOR) || defined(THREADS) -void STD_PROTO(Yap_LockStream,(struct io_stream *)); -void STD_PROTO(Yap_UnLockStream,(struct io_stream *)); +void Yap_LockStream(struct io_stream *); +void Yap_UnLockStream(struct io_stream *); #else #define Yap_LockStream(X) #define Yap_UnLockStream(X) #endif -Int STD_PROTO(Yap_GetStreamFd,(int)); -void STD_PROTO(Yap_CloseStreams,(int)); -void STD_PROTO(Yap_FlushStreams,(void)); -void STD_PROTO(Yap_CloseStream,(int)); -int STD_PROTO(Yap_PlGetchar,(void)); -int STD_PROTO(Yap_PlGetWchar,(void)); -int STD_PROTO(Yap_PlFGetchar,(void)); -int STD_PROTO(Yap_GetCharForSIGINT,(void)); -Int STD_PROTO(Yap_StreamToFileNo,(Term)); -Term STD_PROTO(Yap_OpenStream,(FILE *,char *,Term,int)); -Term STD_PROTO(Yap_StringToTerm,(char *,Term *)); +Int Yap_GetStreamFd(int); +void Yap_CloseStreams(int); +void Yap_FlushStreams(void); +void Yap_CloseStream(int); +int Yap_PlGetchar(void); +int Yap_PlGetWchar(void); +int Yap_PlFGetchar(void); +int Yap_GetCharForSIGINT(void); +Int Yap_StreamToFileNo(Term); +Term Yap_OpenStream(FILE *,char *,Term,int); +Term Yap_StringToTerm(char *,Term *); char *Yap_TermToString(Term t, char *s, size_t sz, size_t *length, int *encoding, int flags); int Yap_GetFreeStreamD(void); int Yap_GetFreeStreamDForReading(void); Term Yap_WStringToList(wchar_t *); -Term STD_PROTO(Yap_WStringToListOfAtoms,(wchar_t *)); -Atom STD_PROTO(Yap_LookupWideAtom,(wchar_t *)); +Term Yap_WStringToListOfAtoms(wchar_t *); +Atom Yap_LookupWideAtom( wchar_t * ); #define YAP_INPUT_STREAM 0x01 #define YAP_OUTPUT_STREAM 0x02 @@ -312,9 +312,9 @@ Atom STD_PROTO(Yap_LookupWideAtom,(wchar_t *)); /* grow.c */ -int STD_PROTO(Yap_growheap_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); -int STD_PROTO(Yap_growstack_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); -int STD_PROTO(Yap_growtrail_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); +int Yap_growheap_in_parser(tr_fr_ptr *, TokEntry **, VarEntry **); +int Yap_growstack_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; #endif -INLINE_ONLY EXTERN inline UInt STD_PROTO(HashFunction, (unsigned char *)); -INLINE_ONLY EXTERN inline UInt STD_PROTO(WideHashFunction, (wchar_t *)); +INLINE_ONLY EXTERN UInt inline HashFunction(unsigned char *); +INLINE_ONLY EXTERN UInt inline WideHashFunction(wchar_t *); INLINE_ONLY EXTERN inline UInt 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) { UInt hash = 5381; diff --git a/MYDDAS/myddas_mysql.c b/MYDDAS/myddas_mysql.c index dc09b0911..50c0fb7c4 100644 --- a/MYDDAS/myddas_mysql.c +++ b/MYDDAS/myddas_mysql.c @@ -45,18 +45,18 @@ static Int null_id = 0; -STATIC_PROTO(Int c_db_my_connect,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_disconnect,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_number_of_fields,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_get_attributes_types,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_query,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_table_write,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_row,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_row_cut,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_get_fields_properties,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_get_next_result_set,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_get_database,( USES_REGS1 )); -STATIC_PROTO(Int c_db_my_change_database,( USES_REGS1 )); +static Int c_db_my_connect( USES_REGS1 ); +static Int c_db_my_disconnect( USES_REGS1 ); +static Int c_db_my_number_of_fields( USES_REGS1 ); +static Int c_db_my_get_attributes_types( USES_REGS1 ); +static Int c_db_my_query( USES_REGS1 ); +static Int c_db_my_table_write( USES_REGS1 ); +static Int c_db_my_row( USES_REGS1 ); +static Int c_db_my_row_cut( USES_REGS1 ); +static Int c_db_my_get_fields_properties( USES_REGS1 ); +static Int c_db_my_get_next_result_set( USES_REGS1 ); +static Int c_db_my_get_database( USES_REGS1 ); +static Int c_db_my_change_database( USES_REGS1 ); void Yap_InitMYDDAS_MySQLPreds(void) { diff --git a/MYDDAS/myddas_odbc.c b/MYDDAS/myddas_odbc.c index 72231f20d..c00eaf536 100644 --- a/MYDDAS/myddas_odbc.c +++ b/MYDDAS/myddas_odbc.c @@ -29,15 +29,15 @@ static Int null_id = 0; -STATIC_PROTO(Int c_db_odbc_connect,( USES_REGS1 )); -STATIC_PROTO(Int c_db_odbc_disconnect,( USES_REGS1 )); -STATIC_PROTO(Int c_db_odbc_number_of_fields,( USES_REGS1 )); -STATIC_PROTO(Int c_db_odbc_get_attributes_types,( USES_REGS1 )); -STATIC_PROTO(Int c_db_odbc_query,( USES_REGS1 )); -STATIC_PROTO(Int c_db_odbc_row,( USES_REGS1 )); -STATIC_PROTO(Int c_db_odbc_row_cut,( USES_REGS1 )); -STATIC_PROTO(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_connect( USES_REGS1 ); +static Int c_db_odbc_disconnect( USES_REGS1 ); +static Int c_db_odbc_number_of_fields( USES_REGS1 ); +static Int c_db_odbc_get_attributes_types( USES_REGS1 ); +static Int c_db_odbc_query( USES_REGS1 ); +static Int c_db_odbc_row( USES_REGS1 ); +static Int c_db_odbc_row_cut( USES_REGS1 ); +static Int c_db_odbc_get_fields_properties( USES_REGS1 ); +static Int c_db_odbc_number_of_fields_in_query( USES_REGS1 ); static int odbc_error(SQLSMALLINT type, SQLHANDLE hdbc, char *msg, char *print) diff --git a/MYDDAS/myddas_shared.c b/MYDDAS/myddas_shared.c index fc0755ba6..a6f641080 100644 --- a/MYDDAS/myddas_shared.c +++ b/MYDDAS/myddas_shared.c @@ -27,24 +27,24 @@ #include "myddas_statistics.h" #endif -STATIC_PROTO(Int c_db_initialize_myddas,( USES_REGS1 )); -STATIC_PROTO(Int c_db_connection_type,( USES_REGS1 )); -STATIC_PROTO(Int c_db_add_preds,( USES_REGS1 )); -STATIC_PROTO(Int c_db_preds_conn_start ,( USES_REGS1 )); -STATIC_PROTO(Int c_db_preds_conn_continue ,( USES_REGS1 )); -STATIC_PROTO(Int c_db_connection_start ,( USES_REGS1 )); -STATIC_PROTO(Int c_db_connection_continue ,( USES_REGS1 )); -STATIC_PROTO(Int c_db_check_if_exists_pred,( USES_REGS1 )); -STATIC_PROTO(Int c_db_delete_predicate,( USES_REGS1 )); -STATIC_PROTO(Int c_db_multi_queries_number,( USES_REGS1 )); +static Int c_db_initialize_myddas( USES_REGS1 ); +static Int c_db_connection_type( USES_REGS1 ); +static Int c_db_add_preds( USES_REGS1 ); +static Int c_db_preds_conn_start ( USES_REGS1 ); +static Int c_db_preds_conn_continue ( USES_REGS1 ); +static Int c_db_connection_start ( USES_REGS1 ); +static Int c_db_connection_continue ( USES_REGS1 ); +static Int c_db_check_if_exists_pred( USES_REGS1 ); +static Int c_db_delete_predicate( USES_REGS1 ); +static Int c_db_multi_queries_number( USES_REGS1 ); #ifdef MYDDAS_STATS -STATIC_PROTO(Int c_db_stats,( USES_REGS1 )); -STATIC_PROTO(Int c_db_stats_walltime,( USES_REGS1 )); -STATIC_PROTO(Int c_db_stats_translate,( USES_REGS1 )); -STATIC_PROTO(Int c_db_stats_time,( USES_REGS1 )); +static Int c_db_stats( USES_REGS1 ); +static Int c_db_stats_walltime( USES_REGS1 ); +static Int c_db_stats_translate( USES_REGS1 ); +static Int c_db_stats_time( USES_REGS1 ); #endif #ifdef DEBUG -STATIC_PROTO(Int c_db_check,( USES_REGS1 )); +static Int c_db_check( USES_REGS1 ); #endif void Yap_InitMYDDAS_SharedPreds(void) diff --git a/MYDDAS/myddas_top_level.c b/MYDDAS/myddas_top_level.c index 898ca2ae6..4fad77ee3 100644 --- a/MYDDAS/myddas_top_level.c +++ b/MYDDAS/myddas_top_level.c @@ -34,7 +34,7 @@ #include -STATIC_PROTO(Int c_db_tl_readline,(void)); +static Int c_db_tl_readline(void); void Yap_InitMYDDAS_TopLevelPreds(void) diff --git a/OPTYap/or.cow_engine.c b/OPTYap/or.cow_engine.c index e88017000..a384581bc 100644 --- a/OPTYap/or.cow_engine.c +++ b/OPTYap/or.cow_engine.c @@ -39,7 +39,7 @@ static void share_private_nodes(int worker_q); ** Local inlines ** ** ----------------------- */ -STD_PROTO(static inline void PUT_BUSY, (int)); +static inline void PUT_BUSY(int); static inline void PUT_BUSY(int worker_num) { diff --git a/OPTYap/or.macros.h b/OPTYap/or.macros.h index 5c5ee93d7..689acab4f 100644 --- a/OPTYap/or.macros.h +++ b/OPTYap/or.macros.h @@ -18,36 +18,36 @@ /* get a def for NULL */ #include -STD_PROTO(static inline void PUT_IN_EXECUTING, (int)); -STD_PROTO(static inline void PUT_OUT_EXECUTING, (int)); -STD_PROTO(static inline void PUT_IN_FINISHED, (int)); +static inline void PUT_IN_EXECUTING(int); +static inline void PUT_OUT_EXECUTING(int); +static inline void PUT_IN_FINISHED(int); #ifdef TABLING_INNER_CUTS -STD_PROTO(static inline void PUT_IN_PRUNING, (int)); -STD_PROTO(static inline void PUT_OUT_PRUNING, (int)); +static inline void PUT_IN_PRUNING(int); +static inline void PUT_OUT_PRUNING(int); #endif /* TABLING_INNER_CUTS */ -STD_PROTO(static inline void PUT_IN_REQUESTABLE, (int)); -STD_PROTO(static inline void PUT_OUT_REQUESTABLE, (int)); -STD_PROTO(static inline void SCH_update_local_or_tops, (void)); -STD_PROTO(static inline void SCH_refuse_share_request_if_any, (void)); -STD_PROTO(static inline void SCH_set_load, (choiceptr)); -STD_PROTO(static inline void SCH_new_alternative, (yamop *,yamop *)); +static inline void PUT_IN_REQUESTABLE(int); +static inline void PUT_OUT_REQUESTABLE(int); +static inline void SCH_update_local_or_tops(void); +static inline void SCH_refuse_share_request_if_any(void); +static inline void SCH_set_load(choiceptr); +static inline void SCH_new_alternative(yamop *,yamop *); -STD_PROTO(static inline void CUT_send_prune_request, (int, choiceptr)); -STD_PROTO(static inline void CUT_reset_prune_request, (void)); +static inline void CUT_send_prune_request(int, choiceptr); +static inline void CUT_reset_prune_request(void); -STD_PROTO(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 int CUT_last_worker_left_pending_prune(or_fr_ptr); +static inline or_fr_ptr CUT_leftmost_or_frame(void); #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 */ -STD_PROTO(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)); -STD_PROTO(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)); -STD_PROTO(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 void CUT_store_answer(or_fr_ptr, qg_ans_fr_ptr); +static inline void CUT_store_answers(or_fr_ptr, qg_sol_fr_ptr); +static inline void CUT_join_answers_in_an_unique_frame(qg_sol_fr_ptr); +static inline void CUT_free_solution_frame(qg_sol_fr_ptr); +static inline void CUT_free_solution_frames(qg_sol_fr_ptr); +static inline qg_sol_fr_ptr CUT_prune_solution_frames(qg_sol_fr_ptr, int); diff --git a/OPTYap/or.scheduler.c b/OPTYap/or.scheduler.c index 0a1bfa56c..023433e1e 100644 --- a/OPTYap/or.scheduler.c +++ b/OPTYap/or.scheduler.c @@ -42,12 +42,12 @@ static int search_for_hidden_shared_work(bitmap stable_busy); ** Local inlines ** ** ----------------------- */ -STD_PROTO(static inline void PUT_NO_WORK_IN_UPPER_NODES, (void)); -STD_PROTO(static inline void PUT_IDLE, (int)); -STD_PROTO(static inline void PUT_BUSY, (int)); -STD_PROTO(static inline void PUT_IN_ROOT_NODE, (int)); -STD_PROTO(static inline void PUT_OUT_ROOT_NODE, (int)); -STD_PROTO(static inline void move_up_to_prune_request, (void)); +static inline void PUT_NO_WORK_IN_UPPER_NODES(void); +static inline void PUT_IDLE(int); +static inline void PUT_BUSY(int); +static inline void PUT_IN_ROOT_NODE(int); +static inline void PUT_OUT_ROOT_NODE(int); +static inline void move_up_to_prune_request(void); static inline