diff --git a/H/Tags_24bits.h b/H/Tags_24bits.h index 4b6aa805b..73c536bd7 100644 --- a/H/Tags_24bits.h +++ b/H/Tags_24bits.h @@ -67,22 +67,22 @@ #include "inline-only.h" -INLINE_ONLY int IsVarTerm (Term); +INLINE_ONLY bool IsVarTerm (Term); -INLINE_ONLY int +INLINE_ONLY bool IsVarTerm (Term t) { - return (int) (Signed (t) >= 0); + return Signed (t) >= 0; } -INLINE_ONLY int IsNonVarTerm (Term); +INLINE_ONLY bool IsNonVarTerm (Term); -INLINE_ONLY int +INLINE_ONLY bool IsNonVarTerm (Term t) { - return (int) (Signed (t) < 0); + return Signed (t) < 0; } @@ -107,12 +107,12 @@ AbsPair (Term * p) -INLINE_ONLY Int IsPairTerm (Term); +INLINE_ONLY bool IsPairTerm (Term); -INLINE_ONLY Int +INLINE_ONLY bool IsPairTerm (Term t) { - return (Int) (BitOn (PairBit, (t))); + return BitOn (PairBit, (t)); } @@ -137,22 +137,22 @@ AbsAppl (Term * p) -INLINE_ONLY Int IsApplTerm (Term); +INLINE_ONLY bool IsApplTerm (Term); -INLINE_ONLY Int +INLINE_ONLY bool IsApplTerm (Term t) { - return (Int) (BitOn (ApplBit, (t))); + return BitOn (ApplBit, (t)); } -INLINE_ONLY Int IsAtomOrIntTerm (Term); +INLINE_ONLY bool IsAtomOrIntTerm (Term); -INLINE_ONLY Int +INLINE_ONLY bool IsAtomOrIntTerm (Term t) { - return (Int) (!(Unsigned (t) & CompBits)); + return !(Unsigned (t) & CompBits); } diff --git a/H/TermExt.h b/H/TermExt.h index bc4dd8177..30cd73f9c 100755 --- a/H/TermExt.h +++ b/H/TermExt.h @@ -243,9 +243,9 @@ OOPS #include #endif -INLINE_ONLY inline EXTERN int IsFloatTerm(Term); +INLINE_ONLY inline EXTERN bool IsFloatTerm(Term); -INLINE_ONLY inline EXTERN int IsFloatTerm(Term t) { +INLINE_ONLY inline EXTERN bool IsFloatTerm(Term t) { return (int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorDouble); } @@ -269,10 +269,11 @@ INLINE_ONLY inline EXTERN Int LongIntOfTerm(Term t) { return (Int)(RepAppl(t)[1]); } -INLINE_ONLY inline EXTERN int IsLongIntTerm(Term); +INLINE_ONLY inline EXTERN bool IsLongIntTerm(Term); -INLINE_ONLY inline EXTERN int IsLongIntTerm(Term t) { - return (int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorLongInt); +INLINE_ONLY inline EXTERN bool IsLongIntTerm(Term t) { + return IsApplTerm(t) && + FunctorOfTerm(t) == FunctorLongInt; } /****************************************************/ @@ -325,10 +326,11 @@ INLINE_ONLY inline EXTERN const char *StringOfTerm(Term t) { return (const char *)(RepAppl(t) + 2); } -INLINE_ONLY inline EXTERN int IsStringTerm(Term); +INLINE_ONLY inline EXTERN bool IsStringTerm(Term); -INLINE_ONLY inline EXTERN int IsStringTerm(Term t) { - return (int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorString); +INLINE_ONLY inline EXTERN bool IsStringTerm(Term t) { + return IsApplTerm(t) && + FunctorOfTerm(t) == FunctorString; } /****************************************************/ @@ -357,10 +359,11 @@ typedef struct { #endif -INLINE_ONLY inline EXTERN int IsBigIntTerm(Term); +INLINE_ONLY inline EXTERN bool IsBigIntTerm(Term); -INLINE_ONLY inline EXTERN int IsBigIntTerm(Term t) { - return (int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorBigInt); +INLINE_ONLY inline EXTERN bool IsBigIntTerm(Term t) { + return IsApplTerm(t) && + FunctorOfTerm(t) == FunctorBigInt; } #ifdef USE_GMP @@ -379,11 +382,12 @@ INLINE_ONLY inline EXTERN void MPZ_SET(mpz_t dest, MP_INT *src) { dest->_mp_d = src->_mp_d; } -INLINE_ONLY inline EXTERN int IsLargeIntTerm(Term); +INLINE_ONLY inline EXTERN bool IsLargeIntTerm(Term); -INLINE_ONLY inline EXTERN int IsLargeIntTerm(Term t) { - return (int)(IsApplTerm(t) && ((FunctorOfTerm(t) <= FunctorBigInt) && - (FunctorOfTerm(t) >= FunctorLongInt))); +INLINE_ONLY inline EXTERN bool IsLargeIntTerm(Term t) { + return IsApplTerm(t) && + ((FunctorOfTerm(t) <= FunctorBigInt) && + (FunctorOfTerm(t) >= FunctorLongInt)); } INLINE_ONLY inline EXTERN UInt Yap_SizeOfBigInt(Term); @@ -407,18 +411,20 @@ INLINE_ONLY inline EXTERN int IsLargeIntTerm(Term t) { /* extern Functor FunctorLongInt; */ -INLINE_ONLY inline EXTERN int IsLargeNumTerm(Term); +INLINE_ONLY inline EXTERN bool IsLargeNumTerm(Term); -INLINE_ONLY inline EXTERN int IsLargeNumTerm(Term t) { - return (int)(IsApplTerm(t) && ((FunctorOfTerm(t) <= FunctorBigInt) && - (FunctorOfTerm(t) >= FunctorDouble))); +INLINE_ONLY inline EXTERN bool IsLargeNumTerm(Term t) { + return IsApplTerm(t) && + ((FunctorOfTerm(t) <= FunctorBigInt) && + (FunctorOfTerm(t) >= FunctorDouble)); } -INLINE_ONLY inline EXTERN int IsExternalBlobTerm(Term, CELL); +INLINE_ONLY inline EXTERN bool IsExternalBlobTerm(Term, CELL); -INLINE_ONLY inline EXTERN int IsExternalBlobTerm(Term t, CELL tag) { - return (int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorBigInt && - RepAppl(t)[1] == tag); +INLINE_ONLY inline EXTERN bool IsExternalBlobTerm(Term t, CELL tag) { + return IsApplTerm(t) && + FunctorOfTerm(t) == FunctorBigInt && + RepAppl(t)[1] == tag; } INLINE_ONLY inline EXTERN void *ExternalBlobFromTerm(Term); @@ -428,63 +434,69 @@ INLINE_ONLY inline EXTERN void *ExternalBlobFromTerm(Term t) { return (void *)(base + 1); } -INLINE_ONLY inline EXTERN int IsNumTerm(Term); +INLINE_ONLY inline EXTERN bool IsNumTerm(Term); -INLINE_ONLY inline EXTERN int IsNumTerm(Term t) { - return (int)((IsIntTerm(t) || IsLargeNumTerm(t))); +INLINE_ONLY inline EXTERN bool IsNumTerm(Term t) { + return (IsIntTerm(t) || IsLargeNumTerm(t)); } -INLINE_ONLY inline EXTERN Int IsAtomicTerm(Term); +INLINE_ONLY inline EXTERN bool IsAtomicTerm(Term); -INLINE_ONLY inline EXTERN Int IsAtomicTerm(Term t) { - return (Int)(IsAtomOrIntTerm(t) || IsLargeNumTerm(t) || IsStringTerm(t)); +INLINE_ONLY inline EXTERN bool IsAtomicTerm(Term t) { + return IsAtomOrIntTerm(t) || + IsLargeNumTerm(t) || + IsStringTerm(t); } -INLINE_ONLY inline EXTERN Int IsExtensionFunctor(Functor); +INLINE_ONLY inline EXTERN bool IsExtensionFunctor(Functor); -INLINE_ONLY inline EXTERN Int IsExtensionFunctor(Functor f) { - return (Int)(f <= FunctorString); +INLINE_ONLY inline EXTERN bool IsExtensionFunctor(Functor f) { + return f <= FunctorString; } -INLINE_ONLY inline EXTERN Int IsBlobFunctor(Functor); +INLINE_ONLY inline EXTERN bool IsBlobFunctor(Functor); -INLINE_ONLY inline EXTERN Int IsBlobFunctor(Functor f) { - return (Int)((f <= FunctorString && f >= FunctorDBRef)); +INLINE_ONLY inline EXTERN bool IsBlobFunctor(Functor f) { + return (f <= FunctorString && + f >= FunctorDBRef); } -INLINE_ONLY inline EXTERN Int IsPrimitiveTerm(Term); +INLINE_ONLY inline EXTERN bool IsPrimitiveTerm(Term); -INLINE_ONLY inline EXTERN Int IsPrimitiveTerm(Term t) { - return (Int)((IsAtomOrIntTerm(t) || - (IsApplTerm(t) && IsBlobFunctor(FunctorOfTerm(t))))); +INLINE_ONLY inline EXTERN bool IsPrimitiveTerm(Term t) { + return (IsAtomOrIntTerm(t) || + (IsApplTerm(t) && + IsBlobFunctor(FunctorOfTerm(t)))); } #ifdef TERM_EXTENSIONS -INLINE_ONLY inline EXTERN Int IsAttachFunc(Functor); +INLINE_ONLY inline EXTERN bool IsAttachFunc(Functor); -INLINE_ONLY inline EXTERN Int IsAttachFunc(Functor f) { return (Int)(FALSE); } +INLINE_ONLY inline EXTERN bool IsAttachFunc(Functor f) { return (Int)(FALSE); } #define IsAttachedTerm(t) __IsAttachedTerm(t PASS_REGS) -INLINE_ONLY inline EXTERN Int __IsAttachedTerm(Term USES_REGS); +INLINE_ONLY inline EXTERN bool __IsAttachedTerm(Term USES_REGS); -INLINE_ONLY inline EXTERN Int __IsAttachedTerm(Term t USES_REGS) { - return (Int)((IsVarTerm(t) && IsAttVar(VarOfTerm(t)))); +INLINE_ONLY inline EXTERN bool __IsAttachedTerm(Term t USES_REGS) { + return (IsVarTerm(t) && + IsAttVar(VarOfTerm(t))); } -INLINE_ONLY inline EXTERN Int GlobalIsAttachedTerm(Term); +INLINE_ONLY inline EXTERN bool GlobalIsAttachedTerm(Term); -INLINE_ONLY inline EXTERN Int GlobalIsAttachedTerm(Term t) { - return (Int)((IsVarTerm(t) && GlobalIsAttVar(VarOfTerm(t)))); +INLINE_ONLY inline EXTERN bool GlobalIsAttachedTerm(Term t) { + return (IsVarTerm(t) && + GlobalIsAttVar(VarOfTerm(t))); } #define SafeIsAttachedTerm(t) __SafeIsAttachedTerm((t)PASS_REGS) -INLINE_ONLY inline EXTERN Int __SafeIsAttachedTerm(Term USES_REGS); +INLINE_ONLY inline EXTERN bool __SafeIsAttachedTerm(Term USES_REGS); -INLINE_ONLY inline EXTERN Int __SafeIsAttachedTerm(Term t USES_REGS) { - return (Int)(IsVarTerm(t) && IsAttVar(VarOfTerm(t))); +INLINE_ONLY inline EXTERN bool __SafeIsAttachedTerm(Term t USES_REGS) { + return IsVarTerm(t) && IsAttVar(VarOfTerm(t)); } INLINE_ONLY inline EXTERN exts ExtFromCell(CELL *); @@ -523,13 +535,13 @@ INLINE_ONLY inline EXTERN void *Yap_BlobInfo(Term t) { #ifdef YAP_H -INLINE_ONLY inline EXTERN int unify_extension(Functor, CELL, CELL *, CELL); +INLINE_ONLY inline EXTERN bool unify_extension(Functor, CELL, CELL *, CELL); -EXTERN int unify_extension(Functor, CELL, CELL *, CELL); +EXTERN bool unify_extension(Functor, CELL, CELL *, CELL); int Yap_gmp_tcmp_big_big(Term, Term); -INLINE_ONLY inline EXTERN int unify_extension(Functor f, CELL d0, CELL *pt0, +INLINE_ONLY inline EXTERN bool unify_extension(Functor f, CELL d0, CELL *pt0, CELL d1) { switch (BlobOfFunctor(f)) { case db_ref_e: @@ -555,7 +567,7 @@ INLINE_ONLY inline EXTERN int unify_extension(Functor f, CELL d0, CELL *pt0, ); } } - return (FALSE); + return false; } static inline CELL Yap_IntP_key(CELL *pt) { diff --git a/H/Yap.h b/H/Yap.h index 1c6190f3d..f603243c3 100755 --- a/H/Yap.h +++ b/H/Yap.h @@ -17,6 +17,9 @@ #define YAP_H 1 +#define USE_MYDDAS 1 +#define USE_MYDDAS_SQLITE3 1 + #if defined(YAPOR) // #error Do not explicitly define YAPOR #endif /* YAPOR */ @@ -256,6 +259,11 @@ INLINE_ONLY inline EXTERN size_t strnlen(const char *s, size_t maxlen) { /* #define RANDOMIZE_START_ADDRESS 1 */ + + +extern size_t Yap_page_size; + + #ifdef USE_SYSTEM_MALLOC #define HEAP_INIT_BASE 0L #define AtomBase NULL @@ -480,6 +488,11 @@ extern bool Yap_AccessAsset(const char *name, int mode); extern bool Yap_AssetIsFile(const char *name); extern bool Yap_AssetIsDir(const char *name); extern int64_t Yap_AssetSize(const char *name); + +#else + +#define __android_log_print(...) + #endif /************************************************************************************************* diff --git a/H/YapGFlagInfo.h b/H/YapGFlagInfo.h index 73f5f9f43..d6c342b7a 100644 --- a/H/YapGFlagInfo.h +++ b/H/YapGFlagInfo.h @@ -33,7 +33,7 @@ Set or read system properties for _Param_: YAP_FLAG(ADDRESS_BITS_FLAG, "address_bits", false, nat, BITNESS, NULL), /** `address_bits` Number of address bits in the machine, either 64 or 32 bits */ - YAP_FLAG(AGC_MARGIN_FLAG, "agc_margin", true, nat, "10000", + YAP_FLAG(AGC_MARGIN_FLAG, "agc_margin", true, nat, "10000", agc_threshold), /**`agc_margin ` An integer: if this amount of atoms has been created since the last @@ -234,7 +234,7 @@ source mode is disabled. YAP_FLAG(HOME_FLAG, "home", false, isatom, YAP_ROOTDIR, NULL), /**< home ` the root of the YAP installation, by default `/usr/local` in Unix or -`c:\Yap` in Windows system. Can only be set at configure tien +`c:\Yap` in Windows system. Can only be set at configure time */ YAP_FLAG(HOST_TYPE_FLAG, "host_type", false, isatom, HOST_ALIAS, NULL), /**< host_type ` @@ -337,7 +337,8 @@ only if the query contains variables. The alternative, default in SWI-Prolog is goal succeeded while leaving choicepoints. */ YAP_FLAG(QUASI_QUOTATIONS_FLAG, "quasi_quotations", true, booleanFlag, "true", NULL), - YAP_FLAG(READLINE_FLAG, "readline", true, booleanFlag, "false", Yap_InitReadline), /**< `readline(boolean, changeable)` + YAP_FLAG(READLINE_FLAG, "readline", true, booleanFlag, "false" , Yap_InitReadline), /**< `readline(boolean, changeable)` + } enable the use of the readline library for console interactions, true by default if readline was found. */ YAP_FLAG(REPORT_ERROR_FLAG, "report_error", true, booleanFlag, "true", NULL), diff --git a/H/YapHeap.h b/H/YapHeap.h index 143867121..59daba9d4 100755 --- a/H/YapHeap.h +++ b/H/YapHeap.h @@ -61,7 +61,7 @@ typedef struct memory_hole { ADDR start; ADDR end; } memory_hole_type; -#endif +#endif // USE_DL_MALLOC typedef struct swi_reverse_hash { ADDR key; @@ -154,7 +154,15 @@ typedef struct thandle { /******************* this is the data base: everything here should be possible to restore ********************/ +#if __INIT_C__ +#define EXTERNAL +#else +#define EXTERNAL extern +#endif + + #if YAPOR + typedef struct various_codes { /* memory allocation and management */ special_functors funcs; @@ -172,15 +180,11 @@ typedef struct various_codes { /* memory allocation and management */ special_functors funcs; - #include "tatoms.h" } all_heap_codes; -#if __INIT_C__ -#define EXTERNAL -#else -#define EXTERNAL extern -#endif +#include "tatoms.h" + #include "h0struct.h" diff --git a/H/YapTags.h b/H/YapTags.h index 5c666c707..d2b446755 100644 --- a/H/YapTags.h +++ b/H/YapTags.h @@ -170,9 +170,10 @@ INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1) { return (Term)((*HR = 0, HR++)); } -INLINE_ONLY inline EXTERN int IsUnboundVar(Term *); +INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *); -INLINE_ONLY inline EXTERN int IsUnboundVar(Term *t) { return (int)(*(t) == 0); } +INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) == +0); } #else @@ -184,10 +185,10 @@ INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1) { return (Term)((*HR = (CELL)HR, HR++)); } -INLINE_ONLY inline EXTERN int IsUnboundVar(Term *); +INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *); -INLINE_ONLY inline EXTERN int IsUnboundVar(Term *t) { - return (int)(*(t) == (Term)(t)); +INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { + return *(t) == (Term)(t); } #endif @@ -234,10 +235,10 @@ INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) { #endif -INLINE_ONLY inline EXTERN int IsAtomTerm(Term); +INLINE_ONLY inline EXTERN bool IsAtomTerm(Term); -INLINE_ONLY inline EXTERN int IsAtomTerm(Term t) { - return (int)(CHKTAG((t), AtomTag)); +INLINE_ONLY inline EXTERN bool IsAtomTerm(Term t) { + return CHKTAG((t), AtomTag); } INLINE_ONLY inline EXTERN Term MkIntTerm(Int); @@ -257,10 +258,10 @@ INLINE_ONLY inline EXTERN Term MkIntConstant(Int n) { return (Term)(NONTAGGED(NumberTag, (n))); } -INLINE_ONLY inline EXTERN int IsIntTerm(Term); +INLINE_ONLY inline EXTERN bool IsIntTerm(Term); -INLINE_ONLY inline EXTERN int IsIntTerm(Term t) { - return (int)(CHKTAG((t), NumberTag)); +INLINE_ONLY inline EXTERN bool IsIntTerm(Term t) { + return CHKTAG((t), NumberTag); } INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS); @@ -312,9 +313,9 @@ INLINE_ONLY inline EXTERN Term __MkIntegerTerm(Int n USES_REGS) { } #endif -INLINE_ONLY inline EXTERN int IsIntegerTerm(Term); +INLINE_ONLY inline EXTERN bool IsIntegerTerm(Term); -INLINE_ONLY inline EXTERN int IsIntegerTerm(Term t) { +INLINE_ONLY inline EXTERN bool IsIntegerTerm(Term t) { return (int)(IsIntTerm(t) || IsLongIntTerm(t)); } diff --git a/H/YapTerm.h b/H/YapTerm.h index ad306edd8..a3767309d 100644 --- a/H/YapTerm.h +++ b/H/YapTerm.h @@ -17,6 +17,11 @@ #include "YapTermConfig.h" #include "config.h" +typedef void *Functor; +typedef void *Atom; + +#endif + #if HAVE_STDINT_H #include #endif @@ -24,11 +29,6 @@ #include #endif -typedef void *Functor; -typedef void *Atom; - -#endif - #define ALIGN_BY_TYPE(X, TYPE) \ (((CELL)(X) + (sizeof(TYPE) - 1)) & ~(sizeof(TYPE) - 1)) @@ -43,85 +43,61 @@ typedef void *Atom; /* defines integer types Int and UInt (unsigned) with the same size as a ptr ** and integer types Short and UShort with half the size of a ptr */ -#if HAVE_INTTYPES_H -#include +#if defined(PRIdPTR) #define Int_FORMAT "%" PRIdPTR -#define UInt_ANYFORMAT "%" PRIuPTR +#define Int_ANYFORMAT "%" PRIuPTR #define UInt_FORMAT "%" PRIuPTR +#define Int_F PRIdPTR +#define Int_ANYF PRIuPTR +#define UInt_F PRIuPTR typedef intptr_t Int; typedef uintptr_t UInt; -#elif SIZEOF_INT_P == 4 +#elif defined(_WIN64) -#if SIZEOF_LONGINT == 4 +typedef int64_t Int; +typedef uint64_t UInt; +#define Int_FORMAT "%I64d" +#define UInt_FORMAT "%I64u" +#define Int_F "I64d" +#define UInt_F "I64u" +#elif defined(_WIN32) + +typedef int32_t Int; +typedef uint32_t UInt; +#define Int_FORMAT "%I32d" +#define UInt_FORMAT "%I32u" +#define Int_F "I32d" +#define UInt_F "I32u" + +#elif SIZEOF_LONGINT == SIZEOF_INT_P + +typedef long int Int; +typedef unsigned long int UInt; +#define Int_FORMAT "%ld" +#define UInt_FORMAT "%uld" +#define Int_F "ld" +#define UInt_F "uld" + +#elif SIZEOF_INT == SIZEOF_INT_P + +typedef int Int; +typedef unsigned int UInt; #define Int_FORMAT "%l" #define UInt_FORMAT "%ul" +#define Int_F "l" +#define UInt_F "ul" -#elif SIZEOF_LONG_INT == 4 -/* typedef long int Int;*/ -/* typedef unsigned long int UInt; */ - -#if _WIN32 || __ANDROID__ -#define Int_FORMAT "%d" -#define UInt_FORMAT "%u" -#else -#define Int_FORMAT "%ld" -#define UInt_FORMAT "%lu" -#endif #else #error Yap require integer types of the same size as a pointer #endif -#if SIZEOF_SHORT_INT == 2 /* */ typedef short int Short; /* */ typedef unsigned short int UShort; -#else -#error Yap requires integer types half the size of a pointer -#endif - -#elif SIZEOF_INT_P == 8 - -#if SIZEOF_INT == 8 - -#define Int_FORMAT "%d" -#define UInt_FORMAT "%u" - -#elif SIZEOF_LONG_INT == 8 - -#define Int_FORMAT "%ld" -#define UInt_FORMAT "%lu" - -#elif SIZEOF_LONG_LONG_INT == 8 - -#define Int_FORMAT "%I64d" -#define UInt_FORMAT "%I64u" - -#else -#error Yap requires integer types of the same size as a pointer -#endif - -#if SIZEOF_SHORT_INT == 4 -/* */ typedef short int Short; -/* */ typedef unsigned short int UShort; - -#elif SIZEOF_INT == 4 -/* */ typedef int Short; -/* */ typedef unsigned int UShort; - -#else -#error Yap requires integer types half the size of a pointer -#endif - -#else - -#error Yap requires pointers of size 4 or 8 - -#endif - -typedef uintptr_t CELL; +typedef UInt CELL; typedef uint16_t BITS16; typedef int16_t SBITS16; @@ -135,9 +111,9 @@ typedef uint32_t BITS32; type casting macros *************************************************************************************************/ -typedef uintptr_t Term; +typedef UInt Term; -typedef intptr_t yhandle_t; +typedef Int yhandle_t; typedef double Float; diff --git a/H/YapText.h b/H/YapText.h index eb31a9b07..fbd204286 100644 --- a/H/YapText.h +++ b/H/YapText.h @@ -28,8 +28,8 @@ * mirroring */ -#include "Yap.h" #include "../utf8proc/utf8proc.h" +#include "Yap.h" /* Character types for tokenizer and write.c */ @@ -141,7 +141,7 @@ INLINE_ONLY EXTERN inline char_kind_t chtype(Int ch) { #define __android_log_print(...) #endif -inline static utf8proc_ssize_t get_utf8(utf8proc_uint8_t *ptr, size_t n, +inline static utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, size_t n, utf8proc_int32_t *valp) { return utf8proc_iterate(ptr, n, valp); } @@ -151,8 +151,8 @@ inline static utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr, return utf8proc_encode_char(val, ptr); } -inline static utf8proc_uint8_t *skip_utf8(utf8proc_uint8_t *pt, - utf8proc_ssize_t n) { +inline static const utf8proc_uint8_t *skip_utf8(const utf8proc_uint8_t *pt, + utf8proc_ssize_t n) { utf8proc_ssize_t i; utf8proc_int32_t b; for (i = 0; i < n; i++) { @@ -164,11 +164,10 @@ inline static utf8proc_uint8_t *skip_utf8(utf8proc_uint8_t *pt, return pt; } -inline static utf8proc_ssize_t utf8_nof( utf8proc_int32_t val) { +inline static utf8proc_ssize_t utf8_nof(utf8proc_int32_t val) { return utf8proc_charwidth(val); } - inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) { utf8proc_ssize_t rc = 0; utf8proc_int32_t b; @@ -267,7 +266,8 @@ inline static int cmpn_utf8(const utf8proc_uint8_t *pt1, // UTF16 #define LEAD_OFFSET ((uint32_t)0xD800 - (uint32_t)(0x10000 >> 10)) -#define SURROGATE_OFFSET ( (uint32_t)0x10000 - (uint32_t)(0xD800 << 10) - (uint32_t)0xDC00 ) +#define SURROGATE_OFFSET \ + ((uint32_t)0x10000 - (uint32_t)(0xD800 << 10) - (uint32_t)0xDC00) const char *Yap_tokRep(TokEntry *tokptr, encoding_t enc); @@ -297,8 +297,8 @@ typedef enum { YAP_STRING_WC = 0x20000, // output with write_canonical YAP_STRING_WITH_BUFFER = 0x40000, // output on existing buffer YAP_STRING_MALLOC = 0x80000, // output on malloced buffer - YAP_STRING_UPCASE = 0x100000, // output on malloced buffer - YAP_STRING_DOWNCASE = 0x200000 // output on malloced buffer + YAP_STRING_UPCASE = 0x100000, // output on malloced buffer + YAP_STRING_DOWNCASE = 0x200000 // output on malloced buffer } enum_seq_type_t; typedef UInt seq_type_t; @@ -313,6 +313,7 @@ typedef union { const wchar_t *w0; char *c; unsigned char *uc; + const unsigned char *uc0; wchar_t *w; Atom a; size_t l; @@ -387,7 +388,7 @@ static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) { extern void *Yap_readText(void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *lengp USES_REGS); extern bool write_Text(void *inp, seq_tv_t *out, encoding_t enc, int minimal, - size_t leng USES_REGS); + size_t leng USES_REGS); extern int Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS); extern void *Yap_Concat_Text(int n, seq_tv_t inp[], seq_tv_t *out USES_REGS); extern void *Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, @@ -401,7 +402,7 @@ static inline Atom Yap_AtomicToLowAtom(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOM|YAP_STRING_DOWNCASE; + out.type = YAP_STRING_ATOM | YAP_STRING_DOWNCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.a; @@ -413,7 +414,7 @@ static inline Atom Yap_AtomicToUpAtom(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOM|YAP_STRING_UPCASE; + out.type = YAP_STRING_ATOM | YAP_STRING_UPCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.a; @@ -425,7 +426,7 @@ static inline Term Yap_AtomicToLowString(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_STRING|YAP_STRING_DOWNCASE; + out.type = YAP_STRING_STRING | YAP_STRING_DOWNCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; @@ -437,7 +438,7 @@ static inline Term Yap_AtomicToUpString(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_STRING|YAP_STRING_UPCASE; + out.type = YAP_STRING_STRING | YAP_STRING_UPCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; @@ -449,7 +450,7 @@ static inline Term Yap_AtomicToLowListOfCodes(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_CODES|YAP_STRING_DOWNCASE; + out.type = YAP_STRING_CODES | YAP_STRING_DOWNCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; @@ -461,7 +462,7 @@ static inline Term Yap_AtomicToUpListOfCodes(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_CODES|YAP_STRING_UPCASE; + out.type = YAP_STRING_CODES | YAP_STRING_UPCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; @@ -473,7 +474,7 @@ static inline Term Yap_AtomicToLowListOfAtoms(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOMS|YAP_STRING_DOWNCASE; + out.type = YAP_STRING_ATOMS | YAP_STRING_DOWNCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; @@ -485,14 +486,12 @@ static inline Term Yap_AtomicToUpListOfAtoms(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOMS|YAP_STRING_UPCASE; + out.type = YAP_STRING_ATOMS | YAP_STRING_UPCASE; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return out.val.t; } - - static inline size_t Yap_AtomicToLength(Term t0 USES_REGS) { seq_tv_t inp, out; inp.val.t = t0; @@ -729,6 +728,20 @@ static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) { return out.val.t; } +static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) { + seq_tv_t inp, out; + + inp.val.uc0 = s; + inp.sz = 0; + inp.type = YAP_STRING_CHARS; + inp.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_ATOM; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + + static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail, encoding_t enc USES_REGS) { seq_tv_t inp, out; @@ -773,6 +786,7 @@ static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s, out.dif = tail; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; + return out.val.t; } @@ -1320,6 +1334,49 @@ static inline Term Yap_StringToNumber(Term t0 USES_REGS) { return out.val.t; } +static inline Atom Yap_TextToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | + YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_ATOM; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_TextToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | + YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | + YAP_STRING_ATOMS_CODES | YAP_STRING_MALLOC; + out.val.uc = NULL; + out.type = YAP_STRING_CHARS; + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.uc0; +} + static inline Term Yap_UTF8ToString(const char *s USES_REGS) { return MkStringTerm(s); } diff --git a/H/Yapproto.h b/H/Yapproto.h index 3b19651d0..59ed9e29d 100755 --- a/H/Yapproto.h +++ b/H/Yapproto.h @@ -22,205 +22,205 @@ /* prototype file for Yap */ /* absmi.c */ -Int Yap_absmi(int); -int Yap_absmiEND(void); +extern Int Yap_absmi(int); +extern int Yap_absmiEND(void); /* adtdefs.c */ -Term Yap_ArrayToList(Term *, size_t); -int Yap_GetName(char *, UInt, Term); -Term Yap_GetValue(Atom); -int Yap_HasOp(Atom); -struct operator_entry * -Yap_GetOpPropForAModuleHavingALock(struct AtomEntryStruct *, Term); -Atom Yap_LookupAtom(const char *); -Atom Yap_ULookupAtom(const unsigned char *); -Atom Yap_LookupAtomWithLength(const char *, size_t); -Atom Yap_LookupUTF8Atom(const unsigned char *); -Atom Yap_LookupMaybeWideAtom(const wchar_t *); -Atom Yap_LookupMaybeWideAtomWithLength(const wchar_t *, size_t); -Atom Yap_FullLookupAtom(const char *); -void Yap_LookupAtomWithAddress(const char *, struct AtomEntryStruct *); -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(struct AtomEntryStruct *, arity_t); -Functor Yap_MkFunctor(Atom, arity_t); -void Yap_MkFunctorWithAddress(Atom, unsigned int, FunctorEntry *); -void Yap_PutValue(Atom, Term); -void Yap_ReleaseAtom(Atom); -int Yap_AtomIncreaseHold(Atom); -int Yap_AtomDecreaseHold(Atom); -struct operator_entry *Yap_OpPropForModule(Atom, Term); +extern Term Yap_ArrayToList(Term *, size_t); +extern int Yap_GetName(char *, UInt, Term); +extern Term Yap_GetValue(Atom); +extern int Yap_HasOp(Atom); +extern struct operator_entry * + Yap_GetOpPropForAModuleHavingALock(struct AtomEntryStruct *, Term); +extern Atom Yap_LookupAtom(const char *); +extern Atom Yap_ULookupAtom(const unsigned char *); +extern Atom Yap_LookupAtomWithLength(const char *, size_t); +extern Atom Yap_LookupUTF8Atom(const unsigned char *); +extern Atom Yap_LookupMaybeWideAtom(const wchar_t *); +extern Atom Yap_LookupMaybeWideAtomWithLength(const wchar_t *, size_t); +extern Atom Yap_FullLookupAtom(const char *); +extern void Yap_LookupAtomWithAddress(const char *, struct AtomEntryStruct *); +extern Prop Yap_NewPredPropByFunctor(struct FunctorEntryStruct *, Term); +extern Prop Yap_NewPredPropByAtom(struct AtomEntryStruct *, Term); +extern Prop Yap_PredPropByFunctorNonThreadLocal(struct FunctorEntryStruct *, Term); +extern Prop Yap_PredPropByAtomNonThreadLocal(struct AtomEntryStruct *, Term); +extern Functor Yap_UnlockedMkFunctor(struct AtomEntryStruct *, arity_t); +extern Functor Yap_MkFunctor(Atom, arity_t); +extern void Yap_MkFunctorWithAddress(Atom, unsigned int, FunctorEntry *); +extern void Yap_PutValue(Atom, Term); +extern void Yap_ReleaseAtom(Atom); +extern int Yap_AtomIncreaseHold(Atom); +extern int Yap_AtomDecreaseHold(Atom); +extern struct operator_entry *Yap_OpPropForModule(Atom, Term); #ifdef SFUNC -Term MkSFTerm(Functor, int, Term *, Term); -CELL *ArgsOfSFTerm(Term); +extern Term MkSFTerm(Functor, int, Term *, Term); +extern CELL *ArgsOfSFTerm(Term); #endif -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(struct AtomEntryStruct *, unsigned int); +extern Prop Yap_GetPredPropByAtom(Atom, Term); +extern Prop Yap_GetPredPropByFunc(Functor, Term); +extern Prop Yap_GetPredPropByAtomInThisModule(Atom, Term); +extern Prop Yap_GetPredPropByFuncInThisModule(Functor, Term); +extern Prop Yap_GetPredPropHavingLock(Atom, unsigned int, Term); +extern Prop Yap_GetExpProp(Atom, unsigned int); +extern Prop Yap_GetExpPropHavingLock(struct AtomEntryStruct *, unsigned int); /* agc.c */ -void Yap_atom_gc(CACHE_TYPE1); -void Yap_init_agc(void); +extern void Yap_atom_gc(CACHE_TYPE1); +extern void Yap_init_agc(void); /* alloc.c */ -void Yap_FreeCodeSpace(void *); -void *Yap_AllocAtomSpace(size_t); -void *Yap_AllocCodeSpace(size_t); -void *Yap_ReallocCodeSpace(void *, size_t); -ADDR Yap_AllocFromForeignArea(Int); -int Yap_ExtendWorkSpace(Int); -void Yap_FreeAtomSpace(void *); -int Yap_FreeWorkSpace(void); -void Yap_InitMemory(UInt, UInt, UInt); -void Yap_InitExStacks(int, int, int); +extern void Yap_FreeCodeSpace(void *); +extern void *Yap_AllocAtomSpace(size_t); +extern void *Yap_AllocCodeSpace(size_t); +extern void *Yap_ReallocCodeSpace(void *, size_t); +extern ADDR Yap_AllocFromForeignArea(Int); +extern int Yap_ExtendWorkSpace(Int); +extern void Yap_FreeAtomSpace(void *); +extern int Yap_FreeWorkSpace(void); +extern void Yap_InitMemory(UInt, UInt, UInt); +extern void Yap_InitExStacks(int, int, int); /* amasm.c */ -OPCODE Yap_opcode(op_numbers); +extern OPCODE Yap_opcode(op_numbers); /* analyst.c */ #ifdef ANALYST -void Yap_InitAnalystPreds(void); +extern void Yap_InitAnalystPreds(void); #endif /* ANALYST */ /* arrays.c */ -void Yap_InitArrayPreds(void); +extern void Yap_InitArrayPreds(void); /* atoms.c */ -void Yap_InitBackAtoms(void); -void Yap_InitAtomPreds(void); +extern void Yap_InitBackAtoms(void); +extern void Yap_InitAtomPreds(void); /* attvar.c */ -void Yap_InitAttVarPreds(void); -void Yap_MkEmptyWakeUp(Atom mod); +extern void Yap_InitAttVarPreds(void); +extern void Yap_MkEmptyWakeUp(Atom mod); /* bb.c */ -void Yap_InitBBPreds(void); +extern void Yap_InitBBPreds(void); /* bignum.c */ -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 *); -CELL *Yap_HeapStoreOpaqueTerm(Term t); -size_t Yap_OpaqueTermToString(Term t, char *str, size_t max); +extern Term Yap_MkULLIntTerm(YAP_ULONG_LONG); +extern int Yap_IsStringTerm(Term); +extern int Yap_IsWideStringTerm(Term); +extern Term Yap_RatTermToApplTerm(Term); +extern void Yap_InitBigNums(void); +extern Term Yap_AllocExternalDataInStack(CELL, size_t); +extern int Yap_CleanOpaqueVariable(CELL *); +extern CELL *Yap_HeapStoreOpaqueTerm(Term t); +extern size_t Yap_OpaqueTermToString(Term t, char *str, size_t max); /* c_interface.c */ #ifndef YAP_CPP_INTERFACE -X_API Int YAP_Execute(struct pred_entry *, CPredicate); -X_API Int YAP_ExecuteFirst(struct pred_entry *, CPredicate); -X_API Int YAP_ExecuteNext(struct pred_entry *, CPredicate); -X_API Int YAP_ExecuteOnCut(struct pred_entry *, CPredicate, struct cut_c_str *); -X_API Int YAP_RunGoalOnce(Term); +extern X_API Int YAP_Execute(struct pred_entry *, CPredicate); +extern X_API Int YAP_ExecuteFirst(struct pred_entry *, CPredicate); +extern X_API Int YAP_ExecuteNext(struct pred_entry *, CPredicate); +extern X_API Int YAP_ExecuteOnCut(struct pred_entry *, CPredicate, struct cut_c_str *); +extern X_API Int YAP_RunGoalOnce(Term); #endif /* cdmgr.c */ -Term Yap_all_calls(void); -Atom Yap_ConsultingFile(USES_REGS1); -struct pred_entry *Yap_PredForChoicePt(choiceptr bptr, op_numbers *op); -void Yap_InitCdMgr(void); -struct pred_entry *Yap_PredFromClause(Term t USES_REGS); -bool Yap_discontiguous(struct pred_entry *ap, Term mode USES_REGS); -bool Yap_multiple(struct pred_entry *ap, Term mode USES_REGS); -void Yap_init_consult(int, const 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); -int Yap_SetNoTrace(char *name, UInt arity, Term tmod); -bool Yap_unknown(Term tflagvalue); -struct pred_entry *Yap_MkLogPred(struct pred_entry *pe); +extern Term Yap_all_calls(void); +extern Atom Yap_ConsultingFile(USES_REGS1); +extern struct pred_entry *Yap_PredForChoicePt(choiceptr bptr, op_numbers *op); +extern void Yap_InitCdMgr(void); +extern struct pred_entry *Yap_PredFromClause(Term t USES_REGS); +extern bool Yap_discontiguous(struct pred_entry *ap, Term mode USES_REGS); +extern bool Yap_multiple(struct pred_entry *ap, Term mode USES_REGS); +extern void Yap_init_consult(int, const char *); +extern void Yap_end_consult(void); +extern void Yap_Abolish(struct pred_entry *); +extern void Yap_BuildMegaClause(struct pred_entry *); +extern void Yap_EraseMegaClause(yamop *, struct pred_entry *); +extern void Yap_ResetConsultStack(void); +extern void Yap_AssertzClause(struct pred_entry *, yamop *); +extern void Yap_HidePred(struct pred_entry *pe); +extern int Yap_SetNoTrace(char *name, UInt arity, Term tmod); +extern bool Yap_unknown(Term tflagvalue); +extern struct pred_entry *Yap_MkLogPred(struct pred_entry *pe); /* cmppreds.c */ -Int Yap_compare_terms(Term, Term); -Int Yap_acmp(Term, Term USES_REGS); -void Yap_InitCmpPreds(void); +extern Int Yap_compare_terms(Term, Term); +extern Int Yap_acmp(Term, Term USES_REGS); +extern void Yap_InitCmpPreds(void); /* compiler.c */ -yamop *Yap_cclause(Term, Int, Term, Term); +extern yamop *Yap_cclause(Term, Int, Term, Term); /* computils.c */ -int Yap_DebugPutc(FILE *, wchar_t); -int Yap_DebugPuts(FILE *, const char *); -void Yap_DebugSetIFile(char *); -void Yap_DebugEndline(void); -void Yap_DebugPlWrite(Term t); -void Yap_DebugPlWriteln(Term t); +extern int Yap_DebugPutc(FILE *, wchar_t); +extern int Yap_DebugPuts(FILE *, const char *); +extern void Yap_DebugSetIFile(char *); +extern void Yap_DebugEndline(void); +extern void Yap_DebugPlWrite(Term t); +extern void Yap_DebugPlWriteln(Term t); /* corout.c */ -void Yap_InitCoroutPreds(void); +extern void Yap_InitCoroutPreds(void); #ifdef COROUTINING -Term Yap_ListOfWokenGoals(void); -void Yap_WakeUp(CELL *); +extern Term Yap_ListOfWokenGoals(void); +extern void Yap_WakeUp(CELL *); #endif /* dbase.c */ -struct pred_entry *Yap_FindLUIntKey(Int); -int Yap_DBTrailOverflow(void); -CELL Yap_EvalMasks(Term, CELL *); -void Yap_InitBackDB(void); -void Yap_InitDBPreds(void); +extern struct pred_entry *Yap_FindLUIntKey(Int); +extern int Yap_DBTrailOverflow(void); +extern CELL Yap_EvalMasks(Term, CELL *); +extern void Yap_InitBackDB(void); +extern void Yap_InitDBPreds(void); /* errors.c */ #if DEBUG -void Yap_PrintPredName(struct pred_entry *ap); +extern const char *Yap_PrintPredName(struct pred_entry *ap); #endif -void Yap_RestartYap(int); -void Yap_exit(int); -bool Yap_Warning(const char *s, ...); -bool Yap_PrintWarning(Term t); -bool Yap_HandleError__(const char *file, const char *function, int lineno, +extern void Yap_RestartYap(int); +extern void Yap_exit(int); +extern bool Yap_Warning(const char *s, ...); +extern bool Yap_PrintWarning(Term t); +extern bool Yap_HandleError__(const char *file, const char *function, int lineno, const char *s, ...); #define Yap_HandleError(...) \ Yap_HandleError__(__FILE__, __FUNCTION__, __LINE__, __VA_ARGS__) -int Yap_SWIHandleError(const char *, ...); -void Yap_InitErrorPreds(void); +extern int Yap_SWIHandleError(const char *, ...); +extern void Yap_InitErrorPreds(void); /* eval.c */ -void Yap_InitEval(void); +extern void Yap_InitEval(void); /* exec.c */ -void Yap_fail_all(choiceptr bb USES_REGS); -Term Yap_ExecuteCallMetaCall(Term); -void Yap_InitExecFs(void); -bool Yap_JumpToEnv(Term); -Term Yap_RunTopGoal(Term, bool); -bool Yap_execute_goal(Term, int, Term, bool); -bool Yap_exec_absmi(bool, yap_reset_t); -void Yap_trust_last(void); +extern void Yap_fail_all(choiceptr bb USES_REGS); +extern Term Yap_ExecuteCallMetaCall(Term); +extern void Yap_InitExecFs(void); +extern bool Yap_JumpToEnv(Term); +extern Term Yap_RunTopGoal(Term, bool); +extern bool Yap_execute_goal(Term, int, Term, bool); +extern bool Yap_exec_absmi(bool, yap_reset_t); +extern void Yap_trust_last(void); -void Yap_PrepGoal(UInt, CELL *, choiceptr USES_REGS); -bool Yap_execute_pred(struct pred_entry *ppe, CELL *pt, +extern void Yap_PrepGoal(UInt, CELL *, choiceptr USES_REGS); +extern bool Yap_execute_pred(struct pred_entry *ppe, CELL *pt, bool pass_exception USES_REGS); -int Yap_dogc(int extra_args, Term *tp USES_REGS); -Term Yap_PredicateIndicator(Term t, Term mod); -bool Yap_Execute(Term t USES_REGS); +extern int Yap_dogc(int extra_args, Term *tp USES_REGS); +extern Term Yap_PredicateIndicator(Term t, Term mod); +extern bool Yap_Execute(Term t USES_REGS); /* exo.c */ -void Yap_InitExoPreds(void); -void Yap_udi_Interval_init(void); -bool Yap_Reset(yap_reset_t mode); +extern void Yap_InitExoPreds(void); +extern void Yap_udi_Interval_init(void); +extern bool Yap_Reset(yap_reset_t mode); /* foreign.c */ -char *Yap_FindExecutable(void); +extern char *Yap_FindExecutable(void); /* gprof.c */ -void Yap_InitLowProf(void); +extern void Yap_InitLowProf(void); #if LOW_PROF -void Yap_inform_profiler_of_clause__(void *, void *, struct pred_entry *, +extern void Yap_inform_profiler_of_clause__(void *, void *, struct pred_entry *, gprof_info); #define Yap_inform_profiler_of_clause(CODE0, CODEF, AP, MODE) \ { \ @@ -230,181 +230,182 @@ void Yap_inform_profiler_of_clause__(void *, void *, struct pred_entry *, #else #define Yap_inform_profiler_of_clause(CODE0, CODEF, AP, MODE) #endif -void Yap_tell_gprof(yamop *); +extern void Yap_tell_gprof(yamop *); /* globals.c */ -Term Yap_NewArena(UInt, CELL *); -CELL *Yap_GetFromArena(Term *, UInt, UInt); -void Yap_InitGlobals(void); -Term Yap_SaveTerm(Term); -Term Yap_SetGlobalVal(Atom, Term); -Term Yap_GetGlobal(Atom); -Int Yap_DeleteGlobal(Atom); -void Yap_AllocateDefaultArena(Int, Int, int); +extern Term Yap_NewArena(UInt, CELL *); +extern CELL *Yap_GetFromArena(Term *, UInt, UInt); +extern void Yap_InitGlobals(void); +extern Term Yap_SaveTerm(Term); +extern Term Yap_SetGlobalVal(Atom, Term); +extern Term Yap_GetGlobal(Atom); +extern Int Yap_DeleteGlobal(Atom); +extern void Yap_AllocateDefaultArena(Int, Int, int); /* grow.c */ -Int Yap_total_stack_shift_time(void); -void Yap_InitGrowPreds(void); -UInt Yap_InsertInGlobal(CELL *, UInt); -int Yap_growheap(bool, size_t, void *); -int Yap_growstack(size_t); -int Yap_growtrail(size_t, bool); -int Yap_growglobal(CELL **); -int Yap_locked_growheap(bool, size_t, void *); -int Yap_locked_growstack(size_t); -int Yap_locked_growtrail(size_t, bool); -int Yap_locked_growglobal(CELL **); -CELL **Yap_shift_visit(CELL **, CELL ***, CELL ***); +extern Int Yap_total_stack_shift_time(void); +extern void Yap_InitGrowPreds(void); +extern UInt Yap_InsertInGlobal(CELL *, UInt); +extern int Yap_growheap(bool, size_t, void *); +extern int Yap_growstack(size_t); +extern int Yap_growtrail(size_t, bool); +extern int Yap_growglobal(CELL **); +extern int Yap_locked_growheap(bool, size_t, void *); +extern int Yap_locked_growstack(size_t); +extern int Yap_locked_growtrail(size_t, bool); +extern int Yap_locked_growglobal(CELL **); +extern CELL **Yap_shift_visit(CELL **, CELL ***, CELL ***); #ifdef THREADS -void Yap_CopyThreadStacks(int, int, int); +extern void Yap_CopyThreadStacks(int, int, int); #endif /* heapgc.c */ -Int Yap_total_gc_time(void); -void Yap_init_gc(void); -bool Yap_is_gc_verbose(void); -int Yap_gc(Int, CELL *, yamop *); -int Yap_locked_gc(Int, CELL *, yamop *); -int Yap_gcl(UInt, Int, CELL *, yamop *); -int Yap_locked_gcl(UInt, Int, CELL *, yamop *); +extern Int Yap_total_gc_time(void); +extern void Yap_init_gc(void); +extern bool Yap_is_gc_verbose(void); +extern int Yap_gc(Int, CELL *, yamop *); +extern int Yap_locked_gc(Int, CELL *, yamop *); +extern int Yap_gcl(UInt, Int, CELL *, yamop *); +extern int Yap_locked_gcl(UInt, Int, CELL *, yamop *); /* init.c */ -int Yap_IsOpType(char *); -void Yap_InitWorkspace(UInt, UInt, UInt, UInt, UInt, int, int, int); -bool Yap_AddCallToFli(struct pred_entry *pe, CPredicate call); -bool Yap_AddRetryToFli(struct pred_entry *pe, CPredicate re); -bool Yap_AddCutToFli(struct pred_entry *pe, CPredicate cut); -const char *Yap_version(void); +extern int Yap_IsOpType(char *); +extern void Yap_InitWorkspace(UInt, UInt, UInt, UInt, UInt, int, int, int); +extern bool Yap_AddCallToFli(struct pred_entry *pe, CPredicate call); +extern bool Yap_AddRetryToFli(struct pred_entry *pe, CPredicate re); +extern bool Yap_AddCutToFli(struct pred_entry *pe, CPredicate cut); +extern const char *Yap_version(void); #ifdef YAPOR -void Yap_init_yapor_workers(void); +extern void Yap_init_yapor_workers(void); #endif /* YAPOR */ #if defined(YAPOR) || defined(THREADS) -void Yap_KillStacks(int); +extern void Yap_KillStacks(int); #else -void Yap_KillStacks(int); +extern void Yap_KillStacks(int); #endif -void Yap_InitYaamRegs(int); -void Yap_ReInitWTime(void); -int Yap_OpDec(int, char *, Atom, Term); -void Yap_CloseScratchPad(void); +extern void Yap_InitYaamRegs(int); +extern void Yap_ReInitWTime(void); +extern int Yap_OpDec(int, char *, Atom, Term); +extern void Yap_CloseScratchPad(void); /* inlines.c */ -void Yap_InitInlines(void); -int Yap_eq(Term, Term); +extern void Yap_InitInlines(void); +extern int Yap_eq(Term, Term); /* iopreds.c */ -void Yap_InitPlIO(void); -void Yap_InitBackIO(void); -void Yap_InitIOPreds(void); +extern void Yap_InitPlIO(void); +extern void Yap_InitBackIO(void); +extern void Yap_InitIOPreds(void); extern void Yap_DebugPlWrite(Term t); extern void Yap_DebugPlWriteln(Term t); extern void Yap_DebugErrorPutc(int n); extern void Yap_DebugErrorPuts(const char *s); extern void Yap_DebugWriteIndicator(struct pred_entry *ap); -void Yap_PlWriteToStream(Term, int, int); -void Yap_CloseReadline(void); +extern void Yap_PlWriteToStream(Term, int, int); +extern void Yap_CloseReadline(void); /* depth_lim.c */ -bool Yap_InitReadline(Term t); -void Yap_InitItDeepenPreds(void); -struct AliasDescS *Yap_InitStandardAliases(void); +extern bool Yap_InitReadline(Term t); +extern void Yap_InitItDeepenPreds(void); +extern struct AliasDescS *Yap_InitStandardAliases(void); +extern struct vfs *Yap_InitAssetManager(void); /* load_foreign.c */ -void Yap_InitLoadForeign(void); +extern void Yap_InitLoadForeign(void); /* mavar.c */ -void Yap_InitMaVarCPreds(void); -Term Yap_NewTimedVar(Term); -Term Yap_NewEmptyTimedVar(void); -Term Yap_ReadTimedVar(Term); -Term Yap_UpdateTimedVar(Term, Term); +extern void Yap_InitMaVarCPreds(void); +extern Term Yap_NewTimedVar(Term); +extern Term Yap_NewEmptyTimedVar(void); +extern Term Yap_ReadTimedVar(Term); +extern Term Yap_UpdateTimedVar(Term, Term); /* modules.c */ -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 *); -Term Yap_YapStripModule(Term, Term *); -void Yap_InitModules(void); -void Yap_InitModulesC(void); -struct mod_entry *Yap_GetModuleEntry(Term tmod); -Term Yap_GetModuleFromEntry(struct mod_entry *me); -bool Yap_CharacterEscapes(Term mt); -bool Yap_constPred(struct pred_entry *pt); -bool Yap_isSystemModule(Term mod); +extern Term Yap_Module(Term); +extern Term Yap_Module_Name(struct pred_entry *); +extern struct pred_entry *Yap_ModulePred(Term); +extern void Yap_NewModulePred(Term, struct pred_entry *); +extern Term Yap_StripModule(Term, Term *); +extern Term Yap_YapStripModule(Term, Term *); +extern void Yap_InitModules(void); +extern void Yap_InitModulesC(void); +extern struct mod_entry *Yap_GetModuleEntry(Term tmod); +extern Term Yap_GetModuleFromEntry(struct mod_entry *me); +extern bool Yap_CharacterEscapes(Term mt); +extern bool Yap_constPred(struct pred_entry *pt); +extern bool Yap_isSystemModule(Term mod); #if HAVE_MPI /* mpi.c */ -void Yap_InitMPI(void); +extern void Yap_InitMPI(void); #endif #if HAVE_MPE /* mpe.c */ -void Yap_InitMPE(void); +extern void Yap_InitMPE(void); #endif /* other.c */ -Term Yap_MkApplTerm(Functor, arity_t, const Term *); -Term Yap_MkNewApplTerm(Functor, arity_t); -Term Yap_MkNewPairTerm(void); -Term Yap_Globalise(Term); +extern Term Yap_MkApplTerm(Functor, arity_t, const Term *); +extern Term Yap_MkNewApplTerm(Functor, arity_t); +extern Term Yap_MkNewPairTerm(void); +extern Term Yap_Globalise(Term); /* readutil.c */ -void Yap_InitReadUtil(void); +extern void Yap_InitReadUtil(void); /* qly.c */ -void Yap_InitQLY(void); -int Yap_Restore(const char *, const char *); -void Yap_InitQLYR(void); +extern void Yap_InitQLY(void); +extern YAP_file_type_t Yap_Restore(const char *, const char *); +extern void Yap_InitQLYR(void); /* range.c */ -void Yap_InitRange(void); +extern void Yap_InitRange(void); /* save.c */ -int Yap_SavedInfo(const char *, const char *, CELL *, CELL *, CELL *); -int Yap_SavedStateRestore(char *, char *); -FILE *Yap_OpenRestore(const char *, const char *); -void Yap_InitSavePreds(void); +extern int Yap_SavedInfo(const char *, const char *, CELL *, CELL *, CELL *); +extern int Yap_SavedStateRestore(char *, char *); +extern FILE *Yap_OpenRestore(const char *, const char *); +extern void Yap_InitSavePreds(void); /* scanner.c */ /* signals.c */ -void Yap_InitSignalCPreds(void); -void *Yap_InitSignals(int wid); -bool Yap_DisableInterrupts(int wid); -bool Yap_EnableInterrupts(int wid); +extern void Yap_InitSignalCPreds(void); +extern void *Yap_InitSignals(int wid); +extern bool Yap_DisableInterrupts(int wid); +extern bool Yap_EnableInterrupts(int wid); -void Yap_InitSockets(void); +extern void Yap_InitSockets(void); /* sort.c */ -void Yap_InitSortPreds(void); +extern void Yap_InitSortPreds(void); /* stack.c */ -void Yap_InitStInfo(void); -void Yap_dump_stack(void); -void Yap_detect_bug_location(yamop *yap_pc, int where_from, int psize); +extern void Yap_InitStInfo(void); +extern void Yap_dump_stack(void); +extern void Yap_detect_bug_location(yamop *yap_pc, int where_from, int psize); #if !defined(YAPOR) && !defined(THREADS) -bool Yap_search_for_static_predicate_in_use(struct pred_entry *, bool); +extern bool Yap_search_for_static_predicate_in_use(struct pred_entry *, bool); #endif /* stdpreds.c */ -void Yap_InitBackCPreds(void); -void Yap_InitCPreds(void); -void Yap_show_statistics(void); -int Yap_IsOpMaxPrio(Atom); +extern void Yap_InitBackCPreds(void); +extern void Yap_InitCPreds(void); +extern void Yap_show_statistics(void); +extern int Yap_IsOpMaxPrio(Atom); /* sysbits.c */ -size_t Yap_InitPageSize(void); -bool Yap_set_fpu_exceptions(Term); -UInt Yap_cputime(void); -uint64_t Yap_walltime(void); -int Yap_dir_separator(int); -int Yap_volume_header(char *); -int Yap_signal_index(const char *); +extern size_t Yap_InitPageSize(void); +extern bool Yap_set_fpu_exceptions(Term); +extern UInt Yap_cputime(void); +extern uint64_t Yap_walltime(void); +extern int Yap_dir_separator(int); +extern int Yap_volume_header(char *); +extern int Yap_signal_index(const char *); #ifdef MAC -void Yap_SetTextFile(char *); +extern void Yap_SetTextFile(char *); #endif #if __ANDROID__ #include @@ -413,99 +414,103 @@ extern AAssetManager *Yap_assetManager; extern void *Yap_openAssetFile(const char *path); extern bool Yap_isAsset(const char *path); #endif -const char *Yap_getcwd(const char *, size_t); -void Yap_cputime_interval(Int *, Int *); -void Yap_systime_interval(Int *, Int *); -void Yap_InitSysbits(int wid); -void Yap_InitSysPreds(void); -void Yap_InitcTime(int); -void Yap_InitTime(int); -double Yap_random(void); +extern const char *Yap_getcwd(const char *, size_t); +extern void Yap_cputime_interval(Int *, Int *); +extern void Yap_systime_interval(Int *, Int *); +extern void Yap_InitSysbits(int wid); +extern void Yap_InitSysPreds(void); +extern void Yap_InitcTime(int); +extern void Yap_InitTime(int); +extern double Yap_random(void); #ifdef _WIN32 -char *Yap_RegistryGetString(char *); -void Yap_WinError(char *); +extern char *Yap_RegistryGetString(char *); +extern void Yap_WinError(char *); #endif -const char *Yap_AbsoluteFile(const char *spec, char *obuf, bool ok); -const char *Yap_AbsoluteFileInBuffer(const char *spec, char *outp, size_t sz, +extern const char *Yap_AbsoluteFile(const char *spec, char *obuf, bool ok); +extern const char *Yap_AbsoluteFileInBuffer(const char *spec, char *outp, size_t sz, bool ok); -const char *Yap_findFile(const char *isource, const char *idef, +extern const char *Yap_findFile(const char *isource, const char *idef, const char *root, char *result, bool access, YAP_file_type_t ftype, bool expand_root, bool in_lib); /* threads.c */ -void Yap_InitThreadPreds(void); -void Yap_InitFirstWorkerThreadHandle(void); -int Yap_ThreadID(void); -int Yap_NOfThreads(void); +extern void Yap_InitThreadPreds(void); +extern void Yap_InitFirstWorkerThreadHandle(void); +extern int Yap_ThreadID(void); +extern int Yap_NOfThreads(void); #if THREADS -int Yap_InitThread(int); +extern int Yap_InitThread(int); #endif -intptr_t system_thread_id(void); +extern intptr_t system_thread_id(void); /* tracer.c */ #ifdef LOW_LEVEL_TRACER -void Yap_InitLowLevelTrace(void); +extern void Yap_InitLowLevelTrace(void); #endif /* udi.c */ -void Yap_udi_init(void); -void Yap_udi_abolish(struct pred_entry *); +extern void Yap_udi_init(void); +extern void Yap_udi_abolish(struct pred_entry *); /* unify.c */ -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); +extern int Yap_rational_tree_loop(CELL *, CELL *, CELL **, CELL **); +extern void Yap_InitAbsmi(void); +extern void Yap_InitUnify(void); +extern void Yap_TrimTrail(void); +extern int Yap_Unifiable(Term d0, Term d1); +extern int Yap_IUnify(register CELL d0, register CELL d1); /* userpreds.c */ -void Yap_InitUserCPreds(void); -void Yap_InitUserBacks(void); +extern void Yap_InitUserCPreds(void); +extern void Yap_InitUserBacks(void); /* utilpreds.c */ -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); -bool 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_TermVariables(Term t, UInt arity USES_REGS); -Term Yap_UnNumberTerm(Term, int); -Int Yap_SkipList(Term *, Term **); +extern Term Yap_CopyTerm(Term); +extern bool Yap_Variant(Term, Term); +extern size_t Yap_ExportTerm(Term, char *, size_t, UInt); +extern size_t Yap_SizeOfExportedTerm(char *); +extern Term Yap_ImportTerm(char *); +extern bool Yap_IsListTerm(Term); +extern bool Yap_IsListOrPartialListTerm(Term); +extern Term Yap_CopyTermNoShare(Term); +extern int Yap_SizeGroundTerm(Term, int); +extern bool Yap_IsGroundTerm(Term); +extern bool Yap_IsAcyclicTerm(Term); +extern void Yap_InitUtilCPreds(void); +extern Int Yap_TermHash(Term, Int, Int, int); +extern Int Yap_NumberVars(Term, Int, bool); +extern Term Yap_TermVariables(Term t, UInt arity USES_REGS); +extern Term Yap_UnNumberTerm(Term, int); +extern Int Yap_SkipList(Term *, Term **); /* yap.c */ /* write.c */ /* yap2swi.c */ -void Yap_swi_install(void); -void Yap_InitSWIHash(void); -int Yap_get_stream_handle(Term, int, int, void *); -Term Yap_get_stream_position(void *); -struct AtomEntryStruct *Yap_lookupBlob(void *blob, size_t len, void *type, +extern void Yap_swi_install(void); +extern void Yap_InitSWIHash(void); +extern int Yap_get_stream_handle(Term, int, int, void *); +extern Term Yap_get_stream_position(void *); +extern struct AtomEntryStruct *Yap_lookupBlob(void *blob, size_t len, void *type, int *newp); /* opt.preds.c */ -void Yap_init_optyap_preds(void); +extern void Yap_init_optyap_preds(void); /* pl-file.c */ // struct PL_local_data *Yap_InitThreadIO(int wid); -void Yap_flush(void); +extern void Yap_flush(void); /* pl-yap.c */ -Int Yap_source_line_no(void); -Atom Yap_source_file_name(void); +extern Int Yap_source_line_no(void); +extern Atom Yap_source_file_name(void); -void Yap_install_blobs(void); +extern void Yap_install_blobs(void); -yamop *Yap_gcP(void); +extern yamop *Yap_gcP(void); + +#if USE_MYDDAS +extern void init_myddas(void); + #endif #if !HAVE_STRNCAT #define strncat(X, Y, Z) strcat(X, Y) diff --git a/H/Yatom.h b/H/Yatom.h index a65fd27c3..05aef0d23 100755 --- a/H/Yatom.h +++ b/H/Yatom.h @@ -252,15 +252,16 @@ INLINE_ONLY inline EXTERN bool IsWideAtom(Atom at) { /** Module property: low-level data used to manage modes. - Includes lists of pedicates, operators and other well-defIned properties. + Includes lists of pedicates, operators and other well-defIned + properties. */ typedef struct mod_entry { - Prop NextOfPE; /** chain of atom properties */ - PropFlags KindOfPE; /** kind of property */ - struct pred_entry *PredForME; /** index in module table */ + Prop NextOfPE; /** chain of atom properties */ + PropFlags KindOfPE; /** kind of property */ + struct pred_entry *PredForME; /** index in module table */ struct operator_entry *OpForME; /** index in operator table */ - Atom AtomOfME; /** module's name */ - Atom OwnerFile; /** module's owner file */ + Atom AtomOfME; /** module's name */ + Atom OwnerFile; /** module's owner file */ #if defined(YAPOR) || defined(THREADS) rwlock_t ModRWLock; /** a read-write lock to protect the entry */ #endif @@ -331,7 +332,7 @@ INLINE_ONLY inline EXTERN bool IsModProperty(int flags) { (UNKNOWN_ERROR | UNKNOWN_WARNING | UNKNOWN_FAIL | UNKNOWN_FAST_FAIL | \ UNKNOWN_ABORT | UNKNOWN_HALT) - Term Yap_getUnknownModule(ModEntry *m); +Term Yap_getUnknownModule(ModEntry *m); void Yap_setModuleFlags(ModEntry *n, ModEntry *o); /* operator property entry structure */ @@ -341,11 +342,11 @@ typedef struct operator_entry { #if defined(YAPOR) || defined(THREADS) rwlock_t OpRWLock; /* a read-write lock to protect the entry */ #endif - Atom OpName; /* atom name */ - Term OpModule; /* module of predicate */ - struct operator_entry *OpNext; /* next in list of operators */ + Atom OpName; /* atom name */ + Term OpModule; /* module of predicate */ + struct operator_entry *OpNext; /* next in list of operators */ struct operator_entry *NextForME; /* next in list of module operators */ - BITS16 Prefix, Infix, Posfix; /**o precedences */ + BITS16 Prefix, Infix, Posfix; /**o precedences */ } OpEntry; #if USE_OFFSETS_IN_PROPS @@ -387,10 +388,10 @@ OpEntry *Yap_GetOpProp(Atom, op_type, Term CACHE_TYPE); int Yap_IsPrefixOp(Atom, int *, int *); int Yap_IsOp(Atom); int Yap_IsInfixOp(Atom, int *, int *, int *); - int Yap_IsPosfixOp(Atom, int *, int *); - bool Yap_dup_op(OpEntry *op, ModEntry *she); - - /* defines related to operator specifications */ +int Yap_IsPosfixOp(Atom, int *, int *); +bool Yap_dup_op(OpEntry *op, ModEntry *she); + +/* defines related to operator specifications */ #define MaskPrio 0x0fff #define DcrlpFlag 0x1000 #define DcrrpFlag 0x2000 @@ -678,8 +679,9 @@ INLINE_ONLY inline EXTERN Atom NameOfPred(PredEntry *pe) { } } - profile_data * - Yap_initProfiler(PredEntry *p); +extern const char *IndicatorOfPred(PredEntry *pe); + +profile_data *Yap_initProfiler(PredEntry *p); /* Flags for code or dbase entry */ /* There are several flags for code and data base entries */ diff --git a/H/index.h b/H/index.h index 32badf1e3..0751a8d49 100644 --- a/H/index.h +++ b/H/index.h @@ -17,21 +17,21 @@ /* allowed types for clauses */ typedef enum clause_type_enum { - pair_clause = 0x01, - struct_clause = 0x02, - atom_clause = 0x04, - int_clause = 0x08, - flt_clause = 0x10, - lgint_clause = 0x20, - dbref_clause = 0x40 + pair_clause = 0x01, + struct_clause = 0x02, + atom_clause = 0x04, + int_clause = 0x08, + flt_clause = 0x10, + lgint_clause = 0x20, + dbref_clause = 0x40 } clause_type; /* Four types of Clauses */ -#define MaxOptions 4 +#define MaxOptions 4 /* Minimum number of clauses needed to build an hash table */ /* must be a power of two */ -#define MIN_HASH_ENTRIES 4 +#define MIN_HASH_ENTRIES 4 #define HASH_SHIFT 6 @@ -40,54 +40,52 @@ typedef enum clause_type_enum { /* Used to store all important information about a clause */ typedef struct StructClauseDef { - Term Tag; /* if nonvar or nonlist, first argument */ - yamop *Code; /* start of code for clause */ - yamop *CurrentCode; /* start of code for clause */ + + Term Tag; /* if nonvar or nonlist, first argument */ + yamop *Code; /* start of code for clause */ + yamop *CurrentCode; /* start of code for clause */ union { - yamop *WorkPC; /* start of code for clause */ - Term t_ptr; - CELL *c_sreg; + yamop *WorkPC; /* start of code for clause */ + Term t_ptr; + CELL *c_sreg; } ucd; } ClauseDef; - /* Relevant information for groups */ typedef struct { ClauseDef *FirstClause; ClauseDef *LastClause; - UInt VarClauses; - UInt AtomClauses; - UInt PairClauses; - UInt StructClauses; - UInt TestClauses; + UInt VarClauses; + UInt AtomClauses; + UInt PairClauses; + UInt StructClauses; + UInt TestClauses; } GroupDef; - - /* switch_on_cons */ typedef struct { - Term Tag; + Term Tag; union { - UInt Label; + UInt Label; yamop *labp; } u_a; } AtomSwiEntry; /* switch_on_func */ typedef struct { - Functor Tag; + Functor Tag; union { - UInt Label; + UInt Label; yamop *labp; } u_f; } FuncSwiEntry; /* switch_on_type */ typedef struct { - UInt PairEntry; - UInt ConstEntry; - UInt FuncEntry; - UInt VarEntry; + UInt PairEntry; + UInt ConstEntry; + UInt FuncEntry; + UInt VarEntry; } TypeSwitch; #define MAX_REG_COPIES 32 @@ -95,20 +93,16 @@ typedef struct { typedef struct { Int pos; Term val; - Term extra; + Term extra; } istack_entry; -typedef enum { - pc_entry, - block_entry -} add2index_entries; - +typedef enum { pc_entry, block_entry } add2index_entries; typedef struct { add2index_entries flag; union { struct { - yamop**pi_pc; + yamop **pi_pc; yamop *code, *current_code, *work_pc; Term tag; } pce; @@ -121,8 +115,4 @@ typedef struct { #define MAX_ISTACK_DEPTH 32 -typedef enum { - REFRESH, - RECORDA, - RECORDZ -} expand_values; +typedef enum { REFRESH, RECORDA, RECORDZ } expand_values; diff --git a/H/qly.h b/H/qly.h index 273a757ad..8c545f33a 100644 --- a/H/qly.h +++ b/H/qly.h @@ -1,3 +1,4 @@ + /************************************************************************* * * * YAP Prolog * @@ -16,8 +17,8 @@ * * *************************************************************************/ -#define EXPORT_ATOM_TABLE_SIZE (16*4096) -#define EXPORT_FUNCTOR_TABLE_SIZE (16*4096) +#define EXPORT_ATOM_TABLE_SIZE (16 * 4096) +#define EXPORT_FUNCTOR_TABLE_SIZE (16 * 4096) #define EXPORT_OPCODE_TABLE_SIZE (4096) #define EXPORT_PRED_ENTRY_TABLE_SIZE (128) #define EXPORT_DBREF_TABLE_SIZE (128) @@ -29,7 +30,7 @@ typedef struct export_atom_hash_entry_struct { typedef struct import_atom_hash_entry_struct { Atom oval; Atom val; - struct import_atom_hash_entry_struct *next; + struct import_atom_hash_entry_struct *next; } import_atom_hash_entry_t; typedef struct export_functor_hash_entry_struct { @@ -41,14 +42,14 @@ typedef struct export_functor_hash_entry_struct { typedef struct import_functor_hash_entry_struct { Functor val; Functor oval; - struct import_functor_hash_entry_struct *next; + struct import_functor_hash_entry_struct *next; } import_functor_hash_entry_t; typedef struct import_opcode_hash_entry_struct { OPCODE val; int id; OPCODE oval; - struct import_opcode_hash_entry_struct *next; + struct import_opcode_hash_entry_struct *next; } import_opcode_hash_entry_t; typedef struct export_pred_entry_hash_entry_struct { @@ -64,7 +65,7 @@ typedef struct export_pred_entry_hash_entry_struct { typedef struct import_pred_entry_hash_entry_struct { PredEntry *val; PredEntry *oval; - struct import_pred_entry_hash_entry_struct *next; + struct import_pred_entry_hash_entry_struct *next; } import_pred_entry_hash_entry_t; typedef struct export_dbref_hash_entry_struct { @@ -77,7 +78,7 @@ typedef struct import_dbref_hash_entry_struct { DBRef val; DBRef oval; int count; - struct import_dbref_hash_entry_struct *next; + struct import_dbref_hash_entry_struct *next; } import_dbref_hash_entry_t; typedef enum { @@ -101,15 +102,30 @@ typedef enum { QLY_ATOM_BLOB = 17 } qlf_tag_t; -#define STATIC_PRED_FLAGS (SourcePredFlag|DynamicPredFlag|LogUpdatePredFlag|CompiledPredFlag|MultiFileFlag|TabledPredFlag|MegaClausePredFlag|CountPredFlag|ProfiledPredFlag|ThreadLocalPredFlag|AtomDBPredFlag|ModuleTransparentPredFlag|NumberDBPredFlag|MetaPredFlag|SyncPredFlag|BackCPredFlag) -#define EXTRA_PRED_FLAGS (QuasiQuotationPredFlag|NoTracePredFlag|NoSpyPredFlag) +#define STATIC_PRED_FLAGS \ + (SourcePredFlag | DynamicPredFlag | LogUpdatePredFlag | CompiledPredFlag | \ + MultiFileFlag | TabledPredFlag | MegaClausePredFlag | CountPredFlag | \ + ProfiledPredFlag | ThreadLocalPredFlag | AtomDBPredFlag | \ + ModuleTransparentPredFlag | NumberDBPredFlag | MetaPredFlag | \ + SyncPredFlag | BackCPredFlag) +#define EXTRA_PRED_FLAGS \ + (QuasiQuotationPredFlag | NoTracePredFlag | NoSpyPredFlag) -#define SYSTEM_PRED_FLAGS (BackCPredFlag|UserCPredFlag|CArgsPredFlag|AsmPredFlag|CPredFlag|BinaryPredFlag) +#define SYSTEM_PRED_FLAGS \ + (BackCPredFlag | UserCPredFlag | CArgsPredFlag | AsmPredFlag | CPredFlag | \ + BinaryPredFlag) -#define CHECK(F) { size_t r = (F); if (!r) return r; } -#define RCHECK(F) if(!(F)) { QLYR_ERROR(MISMATCH); return; } +#define CHECK(F) \ + { \ + size_t r = (F); \ + if (!r) \ + return r; \ + } +#define RCHECK(F) \ + if (!(F)) { \ + QLYR_ERROR(MISMATCH); \ + return; \ + } #define AllocTempSpace() (HR) -#define EnoughTempSpace(sz) ((ASP-HR)*sizeof(CELL) > sz) - - +#define EnoughTempSpace(sz) ((ASP - HR) * sizeof(CELL) > sz) diff --git a/include/YapDefs.h b/include/YapDefs.h index a23cb9ae5..de41bbe05 100755 --- a/include/YapDefs.h +++ b/include/YapDefs.h @@ -39,18 +39,21 @@ #endif /* YAP_H */ -/* truth-values */ -/* stdbool defines the booleam type, bool, - and the constants false and true */ #if HAVE_STDINT_H #include #endif +#if HAVE_INTTYPES_H +#include +#endif + +/* truth-values */ +/* stdbool defines the booleam type, bool, + and the constants false and true */ #if HAVE_STDBOOL_H #include #else #ifndef true typedef int _Bool; -v #define bool _Bool; #define false 0 @@ -107,16 +110,25 @@ typedef bool YAP_Bool; #else /* Type definitions */ - -#if _WIN64 - typedef unsigned long long YAP_CELL; +#if defined(PRIdPTR) +typedef uintptr_t YAP_UInt; +typedef intptr_t YAP_Int; +#elif _WIN64 +typedef int64_t YAP_Int; +typedef uint64_t YAP_UInt; +#elif _WIN32 +typedef int32_t YAP_Int; +typedef uint32_t YAP_UInt; #else -typedef uintptr_t YAP_CELL; +typedef long int YAP_Int; +typedef unsigned long int YAP_UInt; #endif +typedef YAP_UInt YAP_CELL; + typedef YAP_CELL YAP_Term; -typedef YAP_CELL YAP_Arity; +typedef size_t YAP_Arity; typedef YAP_Term YAP_Module; @@ -124,17 +136,6 @@ typedef struct FunctorEntry *YAP_Functor; typedef struct AtomEntry *YAP_Atom; -#if _WIN64 -typedef long long int YAP_Int; - -typedef unsigned long long int YAP_UInt; - -#else -typedef long int YAP_Int; - -typedef unsigned long int YAP_UInt; -#endif - typedef double YAP_Float; #ifndef TRUE @@ -172,14 +173,16 @@ typedef struct YAP_thread_attr_struct { #include #endif -typedef enum { YAP_BIN = 0x0001, - YAP_TEXT = 0x0002, - YAP_SAVED_STATE = 0x0004, - YAP_OBJ = 0x0008, - YAP_PL = 0x0010, - YAP_BOOT_PL = 0x0030, - YAP_QLY = 0x0040, - YAP_EXE = 0x0080 +typedef enum { + YAP_BIN = 0x0001, + YAP_TEXT = 0x0002, + YAP_SAVED_STATE = 0x0004, + YAP_OBJ = 0x0008, + YAP_PL = 0x0010, + YAP_BOOT_PL = 0x0030, + YAP_QLY = 0x0040, + YAP_EXE = 0x0080, + YAP_FOUND_BOOT_ERROR = 0x0100 } YAP_file_type_t; #define YAP_ANY_FILE (0x00ff) @@ -197,9 +200,9 @@ typedef enum { YAP_TAG_FLOAT = 0x200, YAP_TAG_OPAQUE = 0x400, YAP_TAG_APPL = 0x800, - YAP_TAG_DBREF = 0x1000, - YAP_TAG_STRING = 0x2000, - YAP_TAG_ARRAY = 0x4000 + YAP_TAG_DBREF = 0x1000, + YAP_TAG_STRING = 0x2000, + YAP_TAG_ARRAY = 0x4000 } YAP_tag_t; #define YAP_BOOT_FROM_SAVED_CODE 1 @@ -223,26 +226,26 @@ typedef enum { typedef struct yap_boot_params { /* boot type as suggested by the user */ - YAP_file_type_t initial_file_type; + YAP_file_type_t boot_file_type; /* if NON-NULL, path where we can find the saved state */ const char *SavedState; /* if NON-0, minimal size for Heap or Code Area */ - unsigned long int HeapSize; + size_t HeapSize; /* if NON-0, maximal size for Heap or Code Area */ - unsigned long int MaxHeapSize; + size_t MaxHeapSize; /* if NON-0, minimal size for Local+Global Stack */ - unsigned long int StackSize; + size_t StackSize; /* if NON-0, maximal size for Local+Global Stack */ - unsigned long int MaxStackSize; - unsigned long int MaxGlobalSize; + size_t MaxStackSize; + size_t MaxGlobalSize; /* if NON-0, minimal size for Trail */ - unsigned long int TrailSize; + size_t TrailSize; /* if NON-0, maximal size for Trail */ - unsigned long int MaxTrailSize; + size_t MaxTrailSize; /* if NON-0, minimal size for AttributeVarStack */ - unsigned long int AttsSize; + size_t AttsSize; /* if NON-0, maximal size for AttributeVarStack */ - unsigned long int MaxAttsSize; + size_t MaxAttsSize; /* if NON-NULL, value for YAPLIBDIR */ const char *YapLibDir; /* if NON-NULL, name for a Prolog file to use when booting */ @@ -263,7 +266,7 @@ typedef struct yap_boot_params { bool FastBoot; /* the next field only interest YAPTAB */ /* if NON-0, maximum size for Table Space */ - unsigned long int MaxTableSpaceSize; + size_t MaxTableSpaceSize; /* the next three fields only interest YAPOR, but we keep them so that users don't need to recompile DLL in order to use YAPOR */ /* if NON-0, number of workers we want to have (default=1) */ @@ -307,7 +310,8 @@ typedef struct yap_boot_params { } YAP_init_args; #ifdef YAP_H -Int Yap_InitDefaults(YAP_init_args *init_args, char saved_state[]); +YAP_file_type_t Yap_InitDefaults(YAP_init_args *init_args, char saved_state[], + int Argc, char *Argv[]); #endif /* this should be opaque to the user */ @@ -414,4 +418,11 @@ typedef enum yap_enum_reset_t { YAP_RESET_FROM_RESTORE = 3 } yap_reset_t; +typedef bool (*YAP_ModInit_t)(void); + +typedef struct { + YAP_ModInit_t f; + const char *s; +} YAP_delaymodule_t; + #endif /* _YAPDEFS_H */ diff --git a/include/YapErrors.h b/include/YapErrors.h index 3c3b261c2..0144ad9a3 100644 --- a/include/YapErrors.h +++ b/include/YapErrors.h @@ -1,5 +1,3 @@ - - /// /// @file YapErrors.h /// @@ -52,6 +50,9 @@ E(DOMAIN_ERROR_ARRAY_TYPE, DOMAIN_ERROR, "array_type") E(DOMAIN_ERROR_CLOSE_OPTION, DOMAIN_ERROR, "close_option") E(DOMAIN_ERROR_FILE_ERRORS, DOMAIN_ERROR, "file_errors") E(DOMAIN_ERROR_FILE_TYPE, DOMAIN_ERROR, "file_type") + E(DOMAIN_ERROR_FORMAT_CONTROL_SEQUENCE, DOMAIN_ERROR, "format argument " + "domain") + E(DOMAIN_ERROR_FORMAT_OUTPUT, DOMAIN_ERROR, "format output") E(DOMAIN_ERROR_GENERIC_ARGUMENT, DOMAIN_ERROR, "generic_argument") E(DOMAIN_ERROR_IO_MODE, DOMAIN_ERROR, "io_mode") E(DOMAIN_ERROR_MUTABLE, DOMAIN_ERROR, "mutable")