YAP 7.1.0
Yapproto.h
1/*************************************************************************
2* *
3* YAP Prolog %W% %G% *
4* Yap Prolog was developed at NCCUP - Universidade do Porto *
5* *
6* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
7* *
8**************************************************************************
9* *
10* File: Yap.proto *
11* mods: *
12* comments: Function declarations for YAP *
13* version: $Id: Yapproto.h,v 1.90 2008-08-07 20:51:23 vsc Exp $ *
14*************************************************************************/
15
16/* prototype file for Yap */
18
19#ifndef YAP_PROTOS_H
20#define YAP_PROTOS_H 1
21
22#if HAVE_STDNORETURN_H
23#include <stdnoreturn.h>
24define noreturn _Noreturn
25#else
26#define noreturn
27#endif
28
29#include "Yap.h"
30
31/* absmi.c */
32extern Int Yap_absmi(int);
33extern int Yap_absmiEND(void);
34
35/* adtdefs.c */
36extern Term Yap_ArrayToList(Term *, size_t);
37extern int Yap_GetName(char *, UInt, Term);
38extern Term Yap_GetValue(Atom);
39extern int Yap_HasOp(Atom);
40extern struct operator_entry *
41 Yap_GetOpPropForAModuleHavingALock(struct AtomEntryStruct *, Term);
42extern Atom Yap_LookupAtom(const char *);
43extern Atom Yap_ULookupAtom(const unsigned char *);
44extern Atom Yap_LookupAtomWithLength(const char *, size_t);
45extern Atom Yap_FullLookupAtom(const char *);
46extern void Yap_LookupAtomWithAddress(const char *, struct AtomEntryStruct *);
47extern Prop Yap_NewPredPropByFunctor(struct FunctorEntryStruct *, Term);
48extern Prop Yap_NewPredPropByAtom(struct AtomEntryStruct *, Term);
49extern Prop Yap_PredPropByFunctorNonThreadLocal(struct FunctorEntryStruct *, Term);
50extern Prop Yap_PredPropByAtomNonThreadLocal(struct AtomEntryStruct *, Term);
51extern Functor Yap_UnlockedMkFunctor(struct AtomEntryStruct *, arity_t);
52extern Functor Yap_MkFunctor(Atom, arity_t);
53extern void Yap_MkFunctorWithAddress(Atom, unsigned int, FunctorEntry *);
54extern void Yap_PutValue(Atom, Term);
55extern void Yap_ReleaseAtom(Atom);
56extern int Yap_AtomIncreaseHold(Atom);
57extern int Yap_AtomDecreaseHold(Atom);
58extern struct operator_entry *Yap_OpPropForModule(Atom, Term);
59
60#ifdef SFUNC
61extern Term MkSFTerm(Functor, int, Term *, Term);
62extern CELL *ArgsOfSFTerm(Term);
63#endif
64
65extern Prop Yap_GetPredPropByAtom(Atom, Term);
66extern Prop Yap_GetPredPropByFunc(Functor, Term);
67extern Prop Yap_GetPredPropByAtomInThisModule(Atom, Term);
68extern Prop Yap_GetPredPropByFuncInThisModule(Functor, Term);
69extern Prop Yap_GetPredPropHavingLock(Atom, unsigned int, Term);
70extern Prop Yap_GetExpProp(Atom, unsigned int);
71extern Prop Yap_GetExpPropHavingLock(struct AtomEntryStruct *, unsigned int);
72
73/* agc.c */
74extern void Yap_atom_gc(CACHE_TYPE1);
75extern void Yap_init_agc(void);
76
77/* alloc.c */
78extern void Yap_FreeCodeSpace(void *);
79extern void *Yap_AllocAtomSpace(size_t);
80extern void *Yap_AllocCodeSpace(size_t);
81extern void *Yap_ReallocCodeSpace(void *, size_t);
82extern ADDR Yap_AllocFromForeignArea(Int);
83extern int Yap_ExtendWorkSpace(Int);
84extern void Yap_FreeAtomSpace(void *);
85extern int Yap_FreeWorkSpace(void);
86extern void Yap_InitMemory(UInt, UInt, UInt);
87extern void Yap_InitExStacks(int, size_t, size_t);
88
89/* amasm.c */
90extern OPCODE Yap_opcode(op_numbers);
91
92/* analyst.c */
93#ifdef ANALYST
94extern void Yap_InitAnalystPreds(void);
95#endif /* ANALYST */
96
97/* arrays.c */
98extern void Yap_InitArrayPreds(void);
99
100/* atoms.c */
101extern void Yap_InitBackAtoms(void);
102extern void Yap_InitAtomPreds(void);
103
104/* attvar.c */
105extern void Yap_InitAttVarPreds(void);
106extern void Yap_MkEmptyWakeUp(Atom mod);
107extern void Yap_suspend_goal(Term tg USES_REGS);
108extern void AddUnifToQueue(Term t1, Term t2 USES_REGS);
109extern void AddCompareToQueue(Term Cmp, Term t1, Term t2 USES_REGS);
110
111/* bb.c */
112extern void Yap_InitBBPreds(void);
113
114/* bignum.c */
115extern Term Yap_MkULLIntTerm(YAP_ULONG_LONG);
116extern int Yap_IsStringTerm(Term);
117extern int Yap_IsWideStringTerm(Term);
118extern Term Yap_RatTermToApplTerm(Term);
119extern void Yap_InitBigNums(void);
120extern Term Yap_AllocExternalDataInStack(CELL, size_t, CELL **);
121extern int Yap_CleanOpaqueVariable(Term t);
122extern CELL *Yap_HeapStoreOpaqueTerm(Term t);
123extern size_t Yap_OpaqueTermToString(Term t, char *str, size_t max);
124extern Int Yap_blob_tag(Term t);
125
126/* c_interface.c */
127#ifndef YAP_CPP_INTERFACE
128extern X_API Int YAP_Execute(struct pred_entry *, CPredicate);
129extern X_API Int YAP_ExecuteFirst(struct pred_entry *, CPredicate);
130extern X_API Int YAP_ExecuteNext(struct pred_entry *, CPredicate);
131extern X_API Int YAP_ExecuteOnCut(struct pred_entry *, CPredicate, struct cut_c_str *);
132extern X_API Int YAP_RunGoalOnce(Term);
133#endif
134
135/* cdmgr.c */
136extern Term Yap_all_calls(void);
137extern Atom Yap_ConsultingFile(USES_REGS1);
138extern struct pred_entry *Yap_PredForChoicePt(choiceptr bptr, op_numbers *op);
139extern void Yap_InitCdMgr(void);
140extern struct pred_entry *Yap_PredFromClause(Term t USES_REGS);
141extern bool Yap_discontiguous(struct pred_entry *ap, Term mode USES_REGS);
142extern bool Yap_multiple(struct pred_entry *ap, Term mode USES_REGS);
143extern void Yap_init_consult(int, const char *);
144extern void Yap_end_consult(void);
145extern void Yap_Abolish(struct pred_entry *);
146extern void Yap_BuildMegaClause(struct pred_entry *);
147extern void Yap_EraseMegaClause(yamop *, struct pred_entry *);
148extern void Yap_ResetConsultStack(void);
149extern void Yap_AssertzClause(struct pred_entry *, yamop *);
150extern void Yap_HidePred(struct pred_entry *pe);
151extern int Yap_SetNoTrace(char *name, UInt arity, Term tmod);
152extern bool Yap_unknown(Term tflagvalue);
153extern struct pred_entry *Yap_MkLogPred(struct pred_entry *pe);
154
155/* cmppreds.c */
156extern Int Yap_compare_terms(Term, Term);
157extern Int Yap_acmp(Term, Term USES_REGS);
158extern void Yap_InitCmpPreds(void);
159
160/* compiler.c */
161extern yamop *Yap_cclause(Term, Int, Term, Term);
162
163
164
165/* computils.c */
166extern int Yap_DebugPutc(FILE *, wchar_t);
167extern int Yap_DebugPuts(FILE *, const char *);
168extern void Yap_DebugSetIFile(char *);
169extern void Yap_DebugEndline(void);
170extern void Yap_DebugPlWrite(Term t);
171extern void Yap_DebugPlWriteln(Term t);
172
173
174/* copy.c */
175extern void Yap_InitCopyTerm(void);
176extern Term Yap_CopyTerm(Term);
177extern Term CopyTermToArena(Term t,
178 bool share, bool copy_att_vars,yap_error_number *errp,
179 Term *arenap, Term *bindp USES_REGS);
180
181/* corout.c */
182extern void Yap_InitCoroutPreds(void);
183extern Term Yap_ListOfWokenGoals(void);
184extern void Yap_WakeUp(CELL *);
185
186/* dbase.c */
187extern struct pred_entry *Yap_FindLUIntKey(Int);
188extern int Yap_DBTrailOverflow(void);
189extern CELL Yap_EvalMasks(Term, CELL *);
190extern void Yap_InitBackDB(void);
191extern void Yap_InitDBPreds(void);
192
193/* debug.c */
194extern void Yap_InitDebugFs(void);
195
196/* errors.c */
197#if DEBUG
198extern const char *Yap_PrintPredName( struct pred_entry *ap);
199extern Term MkErrorTerm(struct s_yap_error_descriptor *t);
200#endif
201extern noreturn void Yap_RestartYap(int);
202extern noreturn void Yap_exit(int);
203extern bool Yap_Warning(const char *s, ...);
204extern bool Yap_PrintWarning(Term t);
205extern bool Yap_HandleError__(const char *file, const char *function, int lineno,
206 const char *s, ...);
207#define Yap_HandleError(...) \
208 Yap_HandleError__(__FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
209extern int Yap_SWIHandleError(const char *, ...);
210extern void Yap_InitErrorPreds(void);
211extern bool Yap_callable(Term t);
212
213/* eval.c */
214extern void Yap_InitEval(void);
215
216/* exec.c */
217extern void Yap_fail_all(choiceptr bb USES_REGS);
218extern Term Yap_ExecuteCallMetaCall(Term,Term);
219extern void Yap_InitExecFs(void);
220extern bool Yap_JumpToEnv(void);
221extern Term Yap_RunTopGoal(Term, bool);
222extern bool Yap_execute_goal(Term, int, Term, bool);
223extern bool Yap_exec_absmi(bool, yap_reset_t);
224extern void Yap_trust_last(void);
225
226extern void Yap_PrepGoal(UInt, CELL *, choiceptr USES_REGS);
227extern bool Yap_execute_pred(struct pred_entry *ppe, CELL *pt,
228 bool pass_exception USES_REGS);
229extern Term Yap_PredicateIndicator(Term t, Term mod);
230extern bool Yap_Execute(Term t USES_REGS);
231extern bool Yap_restore_regs(Term t USES_REGS);
232/* exo.c */
233extern void Yap_InitExoPreds(void);
234extern void Yap_udi_Interval_init(void);
235extern bool Yap_Reset(yap_reset_t mode, bool hard);
236
237/* foreign.c */
238extern char *Yap_FindExecutable(void);
239
240
241/* globals.c */
242extern Term Yap_MkArena(CELL *, CELL *);
243extern CELL *Yap_GetFromArena(Term *arenap, size_t cells, size_t ncells);
244extern void Yap_InitGlobals(void);
245extern Term Yap_SaveTerm(Term);
246extern Term Yap_SetGlobalVal(Atom, Term);
247extern Term Yap_GetGlobal(Atom);
248extern Int Yap_DeleteGlobal(Atom);
249extern void Yap_AllocateDefaultArena(size_t gsize, int wid, void *cs);
250extern CELL *Yap_ArenaLimit(Term arena);
251extern Term Yap_TermAsForest(Term t1);
252extern UInt Yap_ArenaSz(Term arena);
253
254/* grow.c */
255extern Int Yap_total_stack_shift_time(void);
256extern void Yap_InitGrowPreds(void);
257extern UInt Yap_InsertInGlobal(CELL *, UInt,CELL **);
258extern int Yap_growheap(bool, size_t, void *);
259extern int Yap_growstack(size_t);
260extern int Yap_growtrail(size_t, bool);
261extern int Yap_growglobal(CELL **);
262extern int Yap_locked_growheap(bool, size_t, void *);
263extern int Yap_locked_growstack(size_t);
264extern int Yap_locked_growtrail(size_t, bool);
265extern int Yap_locked_growglobal(CELL **);
266extern CELL **Yap_shift_visit(CELL **, CELL ***, CELL ***);
267#ifdef THREADS
268extern void Yap_CopyThreadStacks(int, int, int);
269#endif
270
271/* heapgc.c */
272extern Int Yap_total_gc_time(void);
273extern void Yap_init_gc(void);
274extern bool Yap_is_gc_verbose(void);
275extern bool Yap_gc(void *);
276extern bool Yap_dogcl(size_t USES_REGS);
277extern bool Yap_dogc(USES_REGS1);
278extern int Yap_stack_overflow(op_numbers op, yamop *pc, struct pred_entry **pt USES_REGS);
279
280
281/* init.c */
282extern int Yap_IsOpType(char *);
283extern void Yap_InitWorkspace(struct yap_boot_params *, UInt, UInt, UInt, UInt, UInt, int, int, int);
284extern bool Yap_AddCallToFli(struct pred_entry *pe, CPredicate call);
285extern bool Yap_AddRetryToFli(struct pred_entry *pe, CPredicate re);
286extern bool Yap_AddCutToFli(struct pred_entry *pe, CPredicate cut);
287extern const char *Yap_version(void);
288
289#ifdef YAPOR
290extern void Yap_init_yapor_workers(void);
291#endif /* YAPOR */
292#if defined(YAPOR) || defined(THREADS)
293extern void Yap_KillStacks(int);
294#else
295extern void Yap_KillStacks(int);
296#endif
297extern void Yap_InitYaamRegs(int, bool full_reset);
298extern void Yap_ReInitWTime(void);
299extern int Yap_OpDec(int, char *, Atom, Term);
300extern void Yap_CloseScratchPad(void);
301extern bool Yap_Embeddeded;
302
303/* inlines.c */
304extern void Yap_InitInlines(void);
305extern int Yap_eq(Term, Term);
306
307/* iopreds.c */
308extern bool Yap_IsAbsolutePath(const char *p, bool);
309extern Atom Yap_TemporaryFile(const char *prefix, int *fd);
310extern void Yap_InitPlIO( struct yap_boot_params *ts );
311extern void Yap_InitBackIO(void);
312extern void Yap_InitIOPreds(void);
313extern void Yap_DebugPlWrite(Term t);
314extern void Yap_DebugPlWriteln(Term t);
315extern void Yap_DebugErrorPutc(int n);
316extern void Yap_DebugErrorPuts(const char *s);
317extern void Yap_DebugWriteIndicator(struct pred_entry *ap);
318extern void Yap_PlWriteToStream(Term, int, int);
319extern void Yap_CloseReadline(void);
320/* depth_lim.c */
321extern bool Yap_InitReadline(Term t);
322extern void Yap_InitItDeepenPreds(void);
323extern struct AliasDescS *Yap_InitStandardAliases(void);
324
325/* load_foreign.c */
326extern void Yap_InitLoadForeign(void);
327extern bool Yap_LateInit(const char s[]);
328
329/* mavar.c */
330extern void Yap_InitMaVarCPreds(void);
331extern Term Yap_NewTimedVar(Term);
332extern Term Yap_NewEmptyTimedVar(void);
333extern Term Yap_NewCompactTimedVar(Term);
334extern Term Yap_ReadTimedVar(Term);
335extern Term Yap_UpdateTimedVar(Term, Term);
336
337/* modules.c */
338extern Term Yap_Module(Term);
339extern Term Yap_Module_Name(struct pred_entry *);
340extern struct pred_entry *Yap_ModulePred(Term);
341extern void Yap_NewModulePred(Term, struct pred_entry *);
342extern Term Yap_StripModule(Term, Term *);
343extern Term Yap_YapStripModule(Term, Term *);
344extern void Yap_InitModules(void);
345extern void Yap_InitModulesC(void);
346extern struct mod_entry *Yap_GetModuleEntry(Term tmod);
347extern Term Yap_GetModuleFromEntry(struct mod_entry *me);
348extern bool Yap_CharacterEscapes(Term mt);
349extern bool Yap_constPred(struct pred_entry *pt);
350extern bool Yap_isSystemModule(Term mod);
351
352#if HAVE_MPI
353/* mpi.c */
354extern void Yap_InitMPI(void);
355#endif
356
357#if HAVE_MPE
358/* mpe.c */
359extern void Yap_InitMPE(void);
360#endif
361
362/* other.c */
363extern Term Yap_MkApplTerm(Functor, arity_t, const Term *);
364extern Term Yap_MkNewApplTerm(Functor, arity_t);
365extern Term Yap_MkNewPairTerm(void);
366extern Term Yap_Globalise(Term);
367
368/* readutil.c */
369extern void Yap_InitReadUtil(void);
370
371/* qly.c */
372extern void Yap_InitQLY(void);
373extern YAP_file_type_t Yap_Restore(const char *);
374extern void Yap_InitQLYR(void);
375
376/* range.c */
377extern void Yap_InitRange(void);
378
379/* save.c */
380extern int Yap_SavedInfo(const char *, CELL *, CELL *, CELL *);
381extern int Yap_SavedStateRestore(char *);
382extern FILE *Yap_OpenRestore(const char *);
383extern void Yap_InitSavePreds(void);
384
385/* scanner.c */
386
387/* signals.c */
388extern Term Yap_next_signal(USES_REGS1);
389extern void Yap_InitSignalCPreds(void);
390extern void *Yap_InitSignals(int wid);
391extern bool Yap_DisableInterrupts(int wid);
392extern bool Yap_EnableInterrupts(int wid);
393
394extern void Yap_InitSockets(void);
395
396/* sort.c */
397extern void Yap_InitSortPreds(void);
398extern Term Yap_MergeSort(Term t USES_REGS);
399extern Term Yap_SortList(Term t USES_REGS);
400
401/* stack.c */
402extern void Yap_InitStInfo(void);
403extern const char *Yap_dump_stack(void);
404extern void Yap_detect_bug_location(yamop *yap_pc, int where_from, int psize);
405extern Term Yap_PredicateToIndicator(struct pred_entry *pe);
406extern Term Yap_TermToIndicator(Term t, Term mod);
407extern bool Yap_EnableInterrupts(int wid);
408
409/* terms.c */
410extern void Yap_InitTermCPreds(void);
411
412#if !defined(YAPOR) && !defined(THREADS)
413 extern bool
414 Yap_search_for_static_predicate_in_use(struct pred_entry *, bool);
415#endif
416
417/* stdpreds.c */
418extern void Yap_InitBackCPreds(void);
419extern void Yap_InitCPreds(void);
420extern void Yap_show_statistics(void);
421extern int Yap_IsOpMaxPrio(Atom);
422
423extern bool Yap_SetInputStream( Term sd );
424extern bool Yap_SetOutputStream( Term sd );
425extern bool Yap_SetErrorStream( Term sd );
426
427/* sysbits.c */
428extern size_t Yap_InitPageSize(void);
429extern bool Yap_set_fpu_exceptions(Term);
430extern UInt Yap_cputime(void);
431extern uint64_t Yap_walltime(void);
432extern int Yap_dir_separator(int);
433extern int Yap_volume_header(char *);
434extern int Yap_signal_index(const char *);
435#ifdef MAC
436extern void Yap_SetTextFile(char *);
437#endif
438extern const char *Yap_AbsoluteFile(const char *spec, bool expand);
439#if __ANDROID__
440#include <android/asset_manager.h>
441
442extern void *Yap_openAssetFile(const char *path);
443extern bool Yap_isAsset(const char *path);
444#endif
445extern const char *Yap_getcwd( char *, size_t);
446extern void Yap_cputime_interval(Int *, Int *);
447extern void Yap_systime_interval(Int *, Int *);
448extern void Yap_InitSysbits(int wid);
449extern void Yap_InitSysPreds(void);
450extern void Yap_InitcTime(int);
451extern void Yap_InitTime(int);
452extern double Yap_random(void);
453#ifdef _WIN32
454extern char *Yap_RegistryGetString(char *);
455extern void Yap_WinError(char *);
456#endif
457
458extern const char *Yap_AbsoluteFileInBuffer(const char *spec, char *outp, size_t sz,
459 bool ok);
460extern bool Yap_ChDir(const char *path);
461bool Yap_isDirectory(const char *FileName);
462extern bool Yap_Exists(const char *f);
463
464/* threads.c */
465extern void Yap_InitThreadPreds(void);
466extern void Yap_InitFirstWorkerThreadHandle(void);
467extern int Yap_ThreadID(void);
468extern int Yap_NOfThreads(void);
469#if THREADS
470extern int Yap_InitThread(int);
471#endif
472extern intptr_t system_thread_id(void);
473/* tracer.c */
474#ifdef LOW_LEVEL_TRACER
475extern void Yap_InitLowLevelTrace(void);
476#endif
477
478extern void *Yap_InitTextAllocator( void );
479
480/* udi.c */
481extern void Yap_udi_init(void);
482extern void Yap_udi_abolish(struct pred_entry *);
483
484/* unify.c */
485extern int Yap_rational_tree_loop(CELL *, CELL *, CELL **, CELL **);
486extern void Yap_InitAbsmi(void);
487extern void Yap_InitUnify(void);
488extern void Yap_TrimTrail(void);
489extern int Yap_Unifiable(Term d0, Term d1);
490extern int Yap_IUnify( CELL d0, CELL d1);
491
492/* userpreds.c */
493extern void Yap_InitUserCPreds(void);
494extern void Yap_InitUserBacks(void);
495
496/* utilpreds.c */
497extern bool Yap_Variant(Term, Term);
498extern size_t Yap_ExportTerm(Term, char *, size_t, UInt);
499extern size_t Yap_SizeOfExportedTerm(char *);
500extern Term Yap_ImportTerm(char *);
501extern bool Yap_IsListTerm(Term);
502extern bool Yap_IsListOrPartialListTerm(Term);
503extern Term Yap_CopyTermNoShare(Term);
504extern int Yap_SizeGroundTerm(Term, int);
505extern bool Yap_IsGroundTerm(Term);
506extern bool Yap_IsAcyclicTerm(Term);
507extern void Yap_InitUtilCPreds(void);
508extern Int Yap_TermHash(Term, Int, Int, int);
509extern int Yap_NumberVars(Term t, int numbv, bool handle_singles USES_REGS);
510extern Term Yap_TermVariables(Term t, UInt arity USES_REGS);
511extern Int Yap_UnNumberTerm(Term, CELL * USES_REGS);
512extern Int Yap_SingletonsAndShared(Term, Term *, Int USES_REGS);
513extern Int Yap_SkipList(Term *, Term **);
514extern bool Yap_IsCyclicTerm(Term t USES_REGS);
515
516/* yap.c */
517
518/* write.c */
519
520/* yap2swi.c */
521extern void Yap_swi_install(void);
522extern void Yap_InitSWIHash(void);
523extern int Yap_get_stream_handle(Term, int, int, void *);
524extern Term Yap_get_stream_position(void *);
525extern struct AtomEntryStruct *Yap_lookupBlob(void *blob, size_t len, void *type,
526 int *newp);
527extern void *Yap_RepStreamFromId(int sno);
528
529/* opt.preds.c */
530extern void Yap_init_optyap_preds(void);
531
532/* pl-file.c */
533// struct PL_local_data *Yap_InitThreadIO(int wid);
534extern void Yap_flush_all(void);
535
536extern X_API YAP_opaque_tag_t
537YAP_NewOpaqueType(struct YAP_opaque_handler_struct *f);
538
539/* pl-yap.c */
540extern Int Yap_source_line_no(void);
541extern Int Yap_source_line_pos(void);
542extern Atom Yap_source_file_name(void);
543
544extern void Yap_install_blobs(void);
545
546extern yamop *Yap_gcP(void);
547
548extern char *Yap_TermToBuffer(Term t, int flags);
549
550#if USE_MYDDAS
551extern void init_myddas(void);
552 #endif
553
554#if !HAVE_STRNCAT
555#define strncat(X, Y, Z) strcat(X, Y)
556#endif
557#if !HAVE_STRNCPY
558#define strncpy(X, Y, Z) strcpy(X, Y)
559#endif
560
561#endif /* YAP_PROTOS_H */
Yap.h
Main definitions.
Yap_AbsoluteFile
const char * Yap_AbsoluteFile(const char *spec, bool ok)
generate absolute path, if ok first expand SICStus Prolog style
Definition: absf.c:145
Yap_InitCPreds
Definition: stdpreds.c:1481
system_thread_id
@ system_thread_id
report the thread running YAP
Definition: YapGFlagInfo.h:648
Yap_TermVariables
Term Yap_TermVariables(Term t, Term t0 USES_REGS)
Extends list with all the variables in a term.
Definition: terms.c:581
Yap_NumberVars
int Yap_NumberVars(Term t, int numbv, bool handle_singles USES_REGS)
numbervariables in term t
Definition: terms.c:770
Yap_PredForChoicePt
PredEntry * Yap_PredForChoicePt(choiceptr cp, op_numbers *op)
Yap_v<<ChoicePt(): find out the predicate who generated a CP.
Definition: stack.c:307
YAP_opaque_handler_struct
opaque variables can interact with the system
Definition: YapDefs.h:229
cut_c_str
Definition: cut_c.h:13
mod_entry
Module property: low-level data used to manage modes.
Definition: Yatom.h:209
operator_entry
Definition: Yatom.h:295
pred_entry
Definition: Yatom.h:544
s_yap_error_descriptor
all we need to know about an error/throw
Definition: YapError.h:205
yami
Definition: amidefs.h:264
yap_boot_params
Definition: YapInit.h:22