diff --git a/docs/builtins.tex b/docs/builtins.tex index b10f9a492..97d0d8066 100644 --- a/docs/builtins.tex +++ b/docs/builtins.tex @@ -206,9 +206,9 @@ Note that @code{(->)/2} does not affect the scope of cuts in its arguments. @item +@var{Condition} *-> +@var{Action} ; +@var{Else} -@findex ->*/2 -@snindex ->*/2 -@cnindex ->*/2 +@findex *->/2 +@snindex *->/2 +@cnindex *->/2 This construct implements the so-called @emph{soft-cut}. The control is defined as follows: If @var{Condition} succeeds at least once, the semantics is the same as (@var{Condition}, @var{Action}). If @@ -3259,8 +3259,8 @@ whereas @var{PROTOCOL} must be an integer. The new socket object is accessible through a descriptor bound to the variable @var{SOCKET}. -The current implementation of YAP only accepts one socket -domain: @code{'AF_INET'}. @c and @code{'AF_UNIX'}. +The current implementation of YAP accepts socket +domains @code{'AF_INET'} and @code{'AF_UNIX'}. Socket types depend on the underlying operating system, but at least the following types are supported: @code{'SOCK_STREAM'} and @code{'SOCK_DGRAM'} (untested in 6.3). @@ -4212,7 +4212,7 @@ clause grammars and an extension of the well known context-free grammars. A grammar rule is of the form: @example -@i{ head --> body } +head --> body @end example @noindent where both @i{head} and @i{body} are sequences of one or more items @@ -4271,8 +4271,7 @@ preprocess all terms read when consulting a file. If it succeeds: If @var{X} is of the form @code{:- G} or @code{?- G}, it is processed as a directive. @item -If @var{X} is of the form @code{'$source_location'(, -):} it is processed as if from @code{File} and line @code{Line}. +If @var{X} is of the form @code{'$source_location'(@var{File},@var{Line}):@var{Clause}} it is processed as if from @code{File} and line @code{Line}. @item If @var{X} is a list, all terms of the list are asserted or processed @@ -4979,9 +4978,9 @@ the @var{CallsAndRetries} counter. Reset call count counters. All timers are also reset. @item call_count(?@var{CallsMax}, ?@var{RetriesMax}, ?@var{CallsAndRetriesMax}) -@findex call_count_data/3 -@snindex call_count_data/3 -@cnindex call_count_data/3 +@findex call_count/3 +@snindex call_count/3 +@cnindex call_count/3 Set call count counter as timers. YAP will generate an exception if one of the instantiated call counters decreases to 0. YAP will ignore unbound arguments: @@ -5581,12 +5580,12 @@ source mode is disabled. for which YAP was compiled and Operating System information. @item index -@findex index (yap_flag/2 option) +@findex index_yap_flag/2 @* If @code{on} allow indexing (default), if @code{off} disable it, if @code{single} allow on first argument only. @item index_sub_term_search_depth -@findex index (yap_flag/2 option) +@findex index_sub_term_yap_flag/2 @* Maximum bound on searching sub-terms for indexing, if @code{0} (default) no bound. @@ -5644,7 +5643,7 @@ and on whether YAP uses the @code{GMP} multi-precision library. If @code{bounded} is false, requests for @code{min_integer} will fail. @item min_tagged_integer -@findex max_tagged_integer (yap_flag/2 option) +@findex min_tagged_integer (yap_flag/2 option) @* Read-only flag telling the minimum integer we can store as a single word. Depends on machine and Operating System @@ -5695,7 +5694,7 @@ SWI-Compatible option, determines prompting for alternatives in the Prolog tople @item redefine_warnings -@findex discontiguous_warnings (yap_flag/2 option) +@findex redefine_warnings (yap_flag/2 option) @* If @var{Value} is unbound, tell whether warnings for procedures defined in several different files are @code{on} or @@ -5908,13 +5907,7 @@ YAP is booted with the @code{-q} or @code{-L} flag. consulting files. If @code{false} disable printing these messages. It is @code{normal} by default except if YAP is booted with the @code{-L} flag. - -@item verbose_load -@findex verbose_load (yap_flag/2 option) -@* If @code{true} allow printing of informational messages when -consulting files. If @code{false} disable printing these messages. It -is @code{normal} by default except if YAP is booted with the @code{-L} -flag. +. @item version @findex version (yap_flag/2 option) @@ -6053,35 +6046,35 @@ following keys are available: @table @code @item directory -@findex directory (prolog_load_context/2 option) +@findex directory_prolog_load_context/2 option @* Full name for the directory where YAP is currently consulting the file. @item file -@findex file (prolog_load_context/2 option) +@findex file_prolog_load_context/2 option @* Full name for the file currently being consulted. Notice that included filed are ignored. @item module -@findex module (prolog_load_context/2 option) +@findex module_prolog_load_context/2 option @* Current source module. @item source (prolog_load_context/2 option) -@findex file (prolog_load_context/2 option) +@findex file_prolog_load_context/2 option @* Full name for the file currently being read in, which may be consulted, reconsulted, or included. @item stream -@findex file (prolog_load_context/2 option) +@findex stream_prolog_load_context/2 option @* Stream currently being read in. @item term_position -@findex file (prolog_load_context/2 option) +@findex term_position_prolog_load_context/2 option @* Stream position at the stream currently being read in. For SWI compatibility, it is a term of the form diff --git a/docs/chr.tex b/docs/chr.tex index b47e4a227..5c368b22a 100644 --- a/docs/chr.tex +++ b/docs/chr.tex @@ -52,7 +52,7 @@ implementation. For a more thorough review of CHR we refer the reader to @c \label{sec:SyntaxAndSemantics} @c ============================= -@subsection Syntax +@subsection CHR Syntax @c ----------------- The syntax of CHR rules in hProlog is the following: diff --git a/docs/conv/texi2doxy b/docs/conv/texi2doxy index 62204ed70..8507886ef 100644 --- a/docs/conv/texi2doxy +++ b/docs/conv/texi2doxy @@ -10,7 +10,7 @@ :- initialization(main). -:- dynamic val/2, item/2. +:- dynamic val/2, item/2, last_node/2. get_arg( Inp, Out ) :- unix( argv( [Inp, Out] ) ), !. @@ -332,7 +332,7 @@ process("@chapter", _Line, Rest, NewLine, _Pos ) :- !, jmp_blanks( Rest, Firs ), run( Title, Firs ), nb_setval( level, 1 ), - from_word(Title, Id, _), + title_from_words(Firs, Id, _Pos), format(string(NewLine), '@page ~s ~s', [Id,Title]). % ( format( string(NewLine), '~s', [Title] ) ; NewLine = "======" ). process("@cindex", _Line, _Rest, no , _Pos) :- !. @@ -365,7 +365,13 @@ process("@itemize", _Line, Rest, NewLine , _Pos) :- !, list( "@itemize", First, NewLine). process("@menu", _Line, _Rest, "" , _Pos) :- !, push(skip, "menu" ). -process("@node", Line, _Rest, NewLine, _Pos ) :- !, +process("@node", Line, Rest, NewLine, Pos ) :- !, + jmp_blanks( Rest, First ), + string_codes( First, S ), + argument(AL, 0', , 0', , S, _), + string_codes(SF, AL), + retractall(last_node(_,_)), + assert( last_node( SF, Pos ) ), gen_blank( Line, NewLine ). process("@page", _Line, _Rest, "", _Pos ) :- !. process("@contents", _Line, _Rest, "" , _Pos) :- !. @@ -375,12 +381,12 @@ process("@saindex", _Line, Rest, NewLine, _Pos ) :- !, get_second( Rest, NewLine ). process("@snindex", _Line, _Rest, "", _Pos ) :- !. process("@syindex", _Line, _Rest, "" , _Pos) :- !. -process("@section", _Line, Rest, NewLine, _Pos ) :- !, +process("@section", _Line, Rest, NewLine, Pos ) :- !, jmp_blanks( Rest, Title ), run( NewTitle, Title ), nb_setval( level, 2 ), % format(string(NewLine), '# ~s #', [NewTitle]). - from_word(NewTitle, Id, _), + title_from_words(NewTitle, Id, Pos), format(string(NewLine), '@section ~s ~s', [Id,NewTitle]). % format(string(NewLine), '# ~s #', [NewTitle]). process("@appendix", _Line, Rest, NewLine, _Pos ) :- !, @@ -391,7 +397,7 @@ process("@subsection", _Line, Rest, NewLine, _Pos ) :- !, jmp_blanks( Rest, Title ), run( NewTitle, Title ), nb_setval( level, 3 ), - from_word(NewTitle, Id, _), + title_from_words(NewTitle, Id, _Pos), format(string(NewLine), '@subsection ~s ~s', [Id,NewTitle]). % format(string(NewLine), '## ~s ##', [NewTitle]). process("@unnumberedsubsubsec", _Line, Rest, NewLine, _Pos ) :- !, @@ -401,7 +407,7 @@ process("@subsubsection", _Line, Rest, NewLine, _Pos ) :- !, nb_setval( level, 4 ), jmp_blanks( Rest, Title ), run( NewTitle, Title ), - from_word(NewTitle, Id, _), + title_from_words(NewTitle, Id, _Pos), format(string(NewLine), '@subsubsection ~s ~s', [Id,NewTitle]). % format(string(NewLine), '### ~s ###', [NewTitle]). process("@set", _Line, Rest, NewLine , _Pos) :- !, @@ -426,7 +432,13 @@ process("@setfilename", Line, _Rest, NewLine, _Pos ) :- !, process("@settitle", _Line, Rest, NewLine , _Pos) :- !, jmp_blanks( Rest, Title ), ( format(string(NewLine), '~s {#mainpage}', [Title]) ; NewLine = "=================="; NewLine = "" ; - NewLine = "[TOC]" ). + NewLine = ""; + NewLine = "[TOC]"; + NewLine = ""; +NewLine = "@secreflist" ; + NewLine = ""; +NewLine = "@endsecreflist" +). process("@subtitle", _Line, _Rest, "", _Pos ) :- !. process("@include", _Line, _Rest, "", _Pos ) :- !. process("@table", _Line, Rest, NewLine , _Pos) :- !, @@ -510,7 +522,15 @@ jmp_blanks(SpacesNewFile, NewString) :- NonBlank is NonBlank1 - 1, sub_string(SpacesNewFile, NonBlank, _, 0, NewString), !. -from_word( Line, Id, _) :- +title_from_words(_Title, Id, F:Pos) :- + last_node( Lab, F:Pos1), + Pos1 < Pos, + Pos < Pos1+3, !, + from_word( Lab, Id ). +title_from_words(Title, Id, _Pos) :- + from_word( Title, Id ). + +from_word( Line, Id ) :- jmp_blanks( Line, Line2 ), string_codes( Line2, C0 ), simplify( C1, C0, []), @@ -540,7 +560,9 @@ simplify( [0'd,0'O|L]) --> ".", !, simplify(L). simplify( [0'd,0'Q|L]) --> "\"", !, simplify(L). -simplify( [0'e,0'E|L]) --> "!", !, +simplify( [0'e,0'E|L]) --> "&", !, + simplify(L). +simplify( [0'e,0'X|L]) --> "!", !, simplify(L). simplify( [0'g,0'G|L]) --> ">", !, simplify(L). @@ -550,7 +572,9 @@ simplify( [0'm,0'M|L]) --> ";", !, simplify(L). simplify( [0'q,0'Q|L]) --> "=", !, simplify(L). -simplify( [0's,0'L|L]) --> "/", !, +simplify( [0'q,0'U|L]) --> "?", !, + simplify(L). +simplify( [0'_|L]) --> "/", !, simplify(L). simplify( [0's,0'S|L]) --> "<", !, simplify(L). @@ -570,7 +594,7 @@ simplify( [C|L]) --> [C], { C >= "0", C =< "9"}, !, simplify(L). simplify( [C|L]) --> [C], { C >= "a", C =< "z"}, !, simplify(L). -simplify( [CN|L]) --> [C], { C >= "A", C =< "Z"}, !, {CN is C+"a"-"A"}, +simplify( [C|L]) --> [C], { C >= "A", C =< "Z"}, !, % {CN is C+"a"-"A"}, simplify(L). simplify( L) --> [_], !, simplify(L). @@ -678,6 +702,11 @@ run( L) --> "@env{", !, %' { run(AL1, AL), format(codes(L, R), '`~s`' , [AL1] ) }, %' run(R). +run( L) --> "@key{", !, %' + argument(AL, 0'{, 0'}), + { run(AL1, AL), + format(codes(L, R), '`~s`' , [AL1] ) }, %' + run(R). run( L) --> "@command{", !, %' argument(AL, 0'{, 0'}), { run(AL1, AL), @@ -692,7 +721,7 @@ run( L) --> "@value{", !, run(R). run( L) --> "@pxref{", !, argument(AL, 0'{, 0'}), - { format(codes(L, R), '`~s`', [AL] ) }, %' + { format(codes(L, R), '`see ~s`', [AL] ) }, %' run(R). run( L) --> "@ref{", !, argument(AL, 0'{, 0'}), @@ -786,14 +815,15 @@ argument(L, _C0, _C, L, []) :- format(user_error, 'Line ~w :-~n argument ~c~s~c does not close in same line.~n', [Line, _C0, L, _C]). argument0([], 0, _, C ) --> [C], !. -argument0([C0|L], I0, C0, C ) --> [C0], !, - { I is I0+1 }, - argument0( L, I, C0, C). %:- start_low_level_trace. argument0([C|L], I0, C0, C ) --> [C], !, { I0 > 0, I is I0-1 }, argument0( L, I, C0, C). %:- stop_low_level_trace. +argument0([C0|L], I0, C0, C ) --> [C0], !, + { I is I0+1 }, + argument0( L, I, C0, C). + % follow escaped characters. argument0([0'@,Escaped|L], I, C0, C) --> [0'@], @@ -820,7 +850,7 @@ md_escaped(0'>). %' md_escaped(0'*). %' cvt_slash( F0, Key ) :- - from_word( F0, Key, _ ). + from_word( F0, Key ). :- dynamic i/1. @@ -837,3 +867,5 @@ title(3, subsection). title(4, subsubsection). title(5, paragraph). title(6, paragraph). + +%:- spy title_from_words. diff --git a/docs/load.tex b/docs/load.tex index 52794609c..f0d09d94f 100644 --- a/docs/load.tex +++ b/docs/load.tex @@ -668,7 +668,7 @@ Default initialization file for the new executable. See -f. Restores a previously saved state of YAP from file @var{F}. YAP always tries to find saved states from the current directory -first. If it cannot it will use the environment variable YAPLIBDIR, if +first. If it cannot it will use the environment variable @code{YAPLIBDIR}, if defined, or search the default library directory. @end table diff --git a/docs/swi.tex b/docs/swi.tex index 4268dc238..90a4a7a55 100644 --- a/docs/swi.tex +++ b/docs/swi.tex @@ -310,7 +310,7 @@ enumeration is undefined. Delete the named global variable. @end table -@subsubsection Compatibility of Global Variables +@subsection Compatibility of Global Variables Global variables have been introduced by various Prolog implementations recently. YAP follows their implementation in SWI-Prolog, itself diff --git a/docs/syntax.tex b/docs/syntax.tex index 4dcee0096..f84b8a431 100644 --- a/docs/syntax.tex +++ b/docs/syntax.tex @@ -467,16 +467,17 @@ Prolog escape sequences while other streams generate an I/O exception. @cindex BOM @cindex Byte Order Mark -From @ref{Stream Encoding}, you may have got the impression text-files are -complicated. This section deals with a related topic, making live often -easier for the user, but providing another worry to the programmer. -@strong{BOM} or @emph{Byte Order Marker} is a technique for -identifying Unicode text-files as well as the encoding they use. Such -files start with the Unicode character @code{0xFEFF}, a non-breaking, -zero-width space character. This is a pretty unique sequence that is not -likely to be the start of a non-Unicode file and uniquely distinguishes -the various Unicode file formats. As it is a zero-width blank, it even -doesn't produce any output. This solves all problems, or ... +From @ref{Stream Encoding}, you may have got the impression that +text-files are complicated. This section deals with a related topic, +making live often easier for the user, but providing another worry to +the programmer. @strong{BOM} or @emph{Byte Order Marker} is a technique +for identifying Unicode text-files as well as the encoding they +use. Such files start with the Unicode character @code{0xFEFF}, a +non-breaking, zero-width space character. This is a pretty unique +sequence that is not likely to be the start of a non-Unicode file and +uniquely distinguishes the various Unicode file formats. As it is a +zero-width blank, it even doesn't produce any output. This solves all +problems, or ... Some formats start of as US-ASCII and may contain some encoding mark to switch to UTF-8, such as the @code{encoding="UTF-8"} in an XML header. diff --git a/docs/yap.tex b/docs/yap.tex index 5d5f35ca8..d84dec3e5 100644 --- a/docs/yap.tex +++ b/docs/yap.tex @@ -1321,7 +1321,7 @@ First Argument is the least element of a list. @item max(@var{X}, @var{Vs}) First Argument is the greatest element of a list. -@item lex_order(@var{Vs)}) +@item lex_order(@var{Vs}) All elements must be ordered. @end table @@ -2348,9 +2348,9 @@ natural exponentiation of a number, matrix or list @end table @item foreach(@var{Sequence}, @var{Goal}) -@findex foreach/2 -@snindex foreach/2 -@cnindex foreach/2 +@findex foreach_matrix/2 +@snindex foreach_matrix/2 +@cnindex foreach_matrix/2 Deterministic iterator. The ranges are given by @var{Sequence} that is either @code{@var{I} in @var{M}..@var{N}}, or of the form @code{[@var{I},@var{J}] ins @var{M}..@var{N}}, or a list of the above conditions. @@ -2600,9 +2600,9 @@ Matrix elements with same first index. and @var{Matrix2}. Currently, only addition (@code{+}) is supported. @item matrix_op_to_all(+@var{Matrix1},+@var{Op},+@var{Operand},-@var{Result}) -@findex matrix_op/4 -@snindex matrix_op/4 -@cnindex matrix_op/4 +@findex matrix_op_to_all/4 +@snindex matrix_op_to_all/4 +@cnindex matrix_op_to_all/4 @var{Result} is the result of applying @var{Op} to all elements of @var{Matrix1}, with @var{Operand} as the second argument. Currently, @@ -3842,7 +3842,8 @@ The file mylib.pl can be loaded as a normal Prolog file and provides the predica @findex use_foreign_library/2 @snindex use_foreign_library/2 @cnindex use_foreign_library/2 - Load and install a foreign library as load_foreign_library/1,2 and + Load and install a foreign library as @code{load_foreign_library/1} + and @code{load_foreign_library/2} and register the installation using @code{initialization/2} with the option now. This is similar to using: @@ -5993,14 +5994,7 @@ Subnodes of SWI-Prolog @node Extensions,Debugging,SWI-Prolog Global Variables,Top @chapter Extensions to Prolog -YAP includes several extensions that are not enabled by -default, but that can be used to extend the functionality of the -system. These options can be set at compilation time by enabling the -related compilation flag, as explained in the @code{Makefile} - @menu -Extensions to Traditional Prolog - * Rational Trees:: Working with Rational Trees * Co-routining:: Changing the Execution of Goals * Attributed Variables:: Using attributed Variables @@ -6014,6 +6008,9 @@ Extensions to Traditional Prolog * Low Level Tracing:: Tracing at Abstract Machine Level @end menu +YAP includes a number of extensions over the original Prolog +language. Next, we discuss support to the most important ones. + @node Rational Trees, Co-routining, , Extensions @section Rational Trees @@ -6468,7 +6465,7 @@ name. Attribute names are defined with the following declaration: @findex attribute/1 (declaration) @example -:- attribute @var{AttributeSpec}, ..., @var{AttributeSpec}. +:- attribute AttributeSpec, ..., AttributeSpec. @end example @noindent @@ -8827,16 +8824,14 @@ loop(Env) :- @end itemize -@section Deterministic Programs +@c @section Deterministic Programs -@section Non-Deterministic Programs +@c @section Non-Deterministic Programs -@section Data-Base Operations +@c @section Data-Base Operations @section Indexing -@section Profiling - The indexation mechanism restricts the set of clauses to be tried in a procedure by using information about the status of the instantiated arguments of the goal. These arguments are then used as a key, @@ -8991,7 +8986,7 @@ C-code described below. @example @cartouche -#include "YAP/YAPInterface.h" +#include "YAP/YapInterface.h" static int my_process_id(void) @{ @@ -9089,7 +9084,7 @@ The role of the procedure @code{init_my_predicates} is to make known to YAP, by calling @code{YAP_UserCPredicate}, the predicates being defined in the file. This is in fact why, in the example above, @code{init_my_predicates} was passed as the third argument to -@code{load_foreign_files}. +@code{load_foreign_files/3}. The rest of this appendix describes exhaustively how to interface C to YAP. @@ -9139,26 +9134,35 @@ follows @findex YAP_IsVarTerm (C-Interface function) The primitive -@example - YAP_Bool YAP_IsVarTerm(YAP_Term @var{t}) -@end example +@table @code +@item YAP_Bool YAP_IsVarTerm(YAP_Term @var{t}) @noindent @findex YAP_IsNonVarTerm (C-Interface function) returns true iff its argument is an uninstantiated variable. Conversely the primitive -@example - YAP_Bool YAP_NonVarTerm(YAP_Term @var{t}) -@end example -@noindent + @item YAP_Bool YAP_NonVarTerm(YAP_Term @var{t}) returns true iff its argument is not a variable. +@end table +@noindent The user can create a new uninstantiated variable using the primitive -@example - YAP_Term YAP_MkVarTerm() -@end example +@table @code + @item YAP_Term YAP_MkVarTerm() +@end table +The following primitives can be used to discriminate among the different types +of non-variable terms: +@table @code +@item YAP_Bool YAP_IsIntTerm(YAP_Term @var{t}) +@item YAP_Bool YAP_IsFloatTerm(YAP_Term @var{t}) +@item YAP_Bool YAP_IsDbRefTerm(YAP_Term @var{t}) +@item YAP_Bool YAP_IsAtomTerm(YAP_Term @var{t}) +@item YAP_Bool YAP_IsPairTerm(YAP_Term @var{t}) +@item YAP_Bool YAP_IsApplTerm(YAP_Term @var{t}) +@item YAP_Bool YAP_IsCompoundTerm(YAP_Term @var{t}) +@end table @findex YAP_IsIntTerm (C-Interface function) @findex YAP_IsFloatTerm (C-Interface function) @findex YAP_IsDBRefTerm (C-Interface function) @@ -9166,22 +9170,11 @@ The user can create a new uninstantiated variable using the primitive @findex YAP_IsPairTerm (C-Interface function) @findex YAP_IsApplTerm (C-Interface function) @findex YAP_IsCompoundTerm (C-Interface function) -The following primitives can be used to discriminate among the different types -of non-variable terms: -@example - YAP_Bool YAP_IsIntTerm(YAP_Term @var{t}) - YAP_Bool YAP_IsFloatTerm(YAP_Term @var{t}) - YAP_Bool YAP_IsDbRefTerm(YAP_Term @var{t}) - YAP_Bool YAP_IsAtomTerm(YAP_Term @var{t}) - YAP_Bool YAP_IsPairTerm(YAP_Term @var{t}) - YAP_Bool YAP_IsApplTerm(YAP_Term @var{t}) - YAP_Bool YAP_IsCompoundTerm(YAP_Term @var{t}) -@end example The next primitive gives the type of a Prolog term: -@example - YAP_tag_t YAP_TagOfTerm(YAP_Term @var{t}) -@end example +@table @code +@item YAP_tag_t YAP_TagOfTerm(YAP_Term @var{t}) +@end table The set of possible values is an enumerated type, with the following values: @table @i @item @code{YAP_TAG_ATT}: an attributed variable @@ -9207,10 +9200,10 @@ terms. All the above primitives ensure that their result is @findex YAP_IntOfTerm (C-Interface function) The following primitives are provided for creating an integer term from an integer and to access the value of an integer term. -@example - YAP_Term YAP_MkIntTerm(YAP_Int @var{i}) - YAP_Int YAP_IntOfTerm(YAP_Term @var{t}) -@end example +@table @code +@item YAP_Term YAP_MkIntTerm(YAP_Int @var{i}) + @item YAP_Int YAP_IntOfTerm(YAP_Term @var{t}) +@end table @noindent where @code{YAP_Int} is a typedef for the C integer type appropriate for the machine or compiler in question (normally a long integer). The size @@ -9221,10 +9214,10 @@ on 64 bit machines. @findex YAP_MkFloatTerm (C-Interface function) @findex YAP_FloatOfTerm (C-Interface function) The two following primitives play a similar role for floating-point terms -@example - YAP_Term YAP_MkFloatTerm(YAP_flt @var{double}) - YAP_flt YAP_FloatOfTerm(YAP_Term @var{t}) -@end example +@table @code +@item YAP_Term YAP_MkFloatTerm(YAP_flt @var{double}) + @item YAP_flt YAP_FloatOfTerm(YAP_Term @var{t}) +@end table @noindent where @code{flt} is a typedef for the appropriate C floating point type, nowadays a @code{double} @@ -9235,11 +9228,11 @@ nowadays a @code{double} The following primitives are provided for verifying whether a term is a big int, creating a term from a big integer and to access the value of a big int from a term. -@example - YAP_Bool YAP_IsBigNumTerm(YAP_Term @var{t}) - YAP_Term YAP_MkBigNumTerm(void *@var{b}) - void *YAP_BigNumOfTerm(YAP_Term @var{t}, void *@var{b}) -@end example +@table @code +@item YAP_Bool YAP_IsBigNumTerm(YAP_Term @var{t}) +@item YAP_Term YAP_MkBigNumTerm(void *@var{b}) +@item void *YAP_BigNumOfTerm(YAP_Term @var{t}, void *@var{b}) +@end table @noindent YAP must support bignum for the configuration you are using (check the YAP configuration and setup). For now, YAP only supports the GNU GMP @@ -9272,21 +9265,21 @@ references. A special typedef @code{YAP_Atom} is provided to describe Prolog @i{atoms} (symbolic constants). The two following primitives can be used to manipulate atom terms -@example - YAP_Term YAP_MkAtomTerm(YAP_Atom at) - YAP_Atom YAP_AtomOfTerm(YAP_Term @var{t}) -@end example +@table @code + @item YAP_Term YAP_MkAtomTerm(YAP_Atom at) + @item YAP_Atom YAP_AtomOfTerm(YAP_Term @var{t}) +@end table @noindent @findex YAP_LookupAtom (C-Interface function) @findex YAP_FullLookupAtom (C-Interface function) @findex YAP_AtomName (C-Interface function) The following primitives are available for associating atoms with their names -@example - YAP_Atom YAP_LookupAtom(char * @var{s}) - YAP_Atom YAP_FullLookupAtom(char * @var{s}) - char *YAP_AtomName(YAP_Atom @var{t}) -@end example +@table @code + @item YAP_Atom YAP_LookupAtom(char * @var{s}) + @item YAP_Atom YAP_FullLookupAtom(char * @var{s}) + @item char *YAP_AtomName(YAP_Atom @var{t}) +@end table The function @code{YAP_LookupAtom} looks up an atom in the standard hash table. The function @code{YAP_FullLookupAtom} will also search if the atom had been "hidden": this is useful for system maintenance from C @@ -9299,26 +9292,26 @@ for the atom. @findex YAP_WideAtomName (C-Interface function) The following primitives handle constructing atoms from strings with wide characters, and vice-versa: -@example - YAP_Atom YAP_LookupWideAtom(wchar_t * @var{s}) - wchar_t *YAP_WideAtomName(YAP_Atom @var{t}) -@end example +@table @code + @item YAP_Atom YAP_LookupWideAtom(wchar_t * @var{s}) + @item wchar_t *YAP_WideAtomName(YAP_Atom @var{t}) +@end table @noindent @findex YAP_IsIsWideAtom (C-Interface function) The following primitive tells whether an atom needs wide atoms in its representation: -@example - int YAP_IsWideAtom(YAP_Atom @var{t}) -@end example +@table @code +@item int YAP_IsWideAtom(YAP_Atom @var{t}) +@end table @noindent @findex YAP_AtomNameLength (C-Interface function) The following primitive can be used to obtain the size of an atom in a representation-independent way: -@example - int YAP_AtomNameLength(YAP_Atom @var{t}) -@end example +@table @code + @item int YAP_AtomNameLength(YAP_Atom @var{t}) +@end table @findex YAP_AtomGetHold (C-Interface function) @findex YAP_AtomReleaseHold (C-Interface function) @@ -9328,12 +9321,12 @@ garbage collector. They allow the user to guarantee that an atom is not to be garbage collected (this is important if the atom is hold externally to the Prolog engine, allow it to be collected, and call a hook on garbage collection: -@example - int YAP_AtomGetHold(YAP_Atom @var{at}) - int YAP_AtomReleaseHold(YAP_Atom @var{at}) - int YAP_AGCRegisterHook(YAP_AGC_hook @var{f}) - YAP_Term YAP_TailOfTerm(YAP_Term @var{t}) -@end example +@table @code + @item int YAP_AtomGetHold(YAP_Atom @var{at}) +@item int YAP_AtomReleaseHold(YAP_Atom @var{at}) + @item int YAP_AGCRegisterHook(YAP_AGC_hook @var{f}) + @item YAP_Term YAP_TailOfTerm(YAP_Term @var{t}) +@end table @findex YAP_MkPairTerm (C-Interface function) @findex YAP_MkNewPairTerm (C-Interface function) @@ -9344,13 +9337,13 @@ A @i{pair} is a Prolog term which consists of a tuple of two Prolog terms designated as the @i{head} and the @i{tail} of the term. Pairs are most often used to build @emph{lists}. The following primitives can be used to manipulate pairs: -@example - YAP_Term YAP_MkPairTerm(YAP_Term @var{Head}, YAP_Term @var{Tail}) - YAP_Term YAP_MkNewPairTerm(void) - YAP_Term YAP_HeadOfTerm(YAP_Term @var{t}) - YAP_Term YAP_TailOfTerm(YAP_Term @var{t}) - YAP_Term YAP_MkListFromTerms(YAP_Term *@var{pt}, YAP_Int *@var{sz}) -@end example +@table @code + @item YAP_Term YAP_MkPairTerm(YAP_Term @var{Head}, YAP_Term @var{Tail}) + @item YAP_Term YAP_MkNewPairTerm(void) + @item YAP_Term YAP_HeadOfTerm(YAP_Term @var{t}) + @item YAP_Term YAP_TailOfTerm(YAP_Term @var{t}) + @item YAP_Term YAP_MkListFromTerms(YAP_Term *@var{pt}, YAP_Int *@var{sz}) +@end table One can construct a new pair from two terms, or one can just build a pair whose head and tail are new unbound variables. Finally, one can fetch the head or the tail. @@ -9371,13 +9364,13 @@ length equal to the @i{arity} of the functor. A functor, described in C by the typedef @code{Functor}, consists of an atom and of an integer. The following primitives were designed to manipulate compound terms and functors -@example - YAP_Term YAP_MkApplTerm(YAP_Functor @var{f}, unsigned long int @var{n}, YAP_Term[] @var{args}) - YAP_Term YAP_MkNewApplTerm(YAP_Functor @var{f}, int @var{n}) - YAP_Term YAP_ArgOfTerm(int argno,YAP_Term @var{ts}) - YAP_Term *YAP_ArgsOfTerm(YAP_Term @var{ts}) - YAP_Functor YAP_FunctorOfTerm(YAP_Term @var{ts}) -@end example +@table @code +@item YAP_Term YAP_MkApplTerm(YAP_Functor @var{f}, unsigned long int @var{n}, YAP_Term[] @var{args}) +@item YAP_Term YAP_MkNewApplTerm(YAP_Functor @var{f}, int @var{n}) +@item YAP_Term YAP_ArgOfTerm(int argno,YAP_Term @var{ts}) + @item YAP_Term *YAP_ArgsOfTerm(YAP_Term @var{ts}) + @item YAP_Functor YAP_FunctorOfTerm(YAP_Term @var{ts}) +@end table @noindent The @code{YAP_MkApplTerm} function constructs a new term, with functor @var{f} (of arity @var{n}), and using an array @var{args} of @var{n} @@ -9399,20 +9392,20 @@ then allow one to construct functors, and to obtain their name and arity. @findex YAP_MkFunctor (C-Interface function) @findex YAP_NameOfFunctor (C-Interface function) @findex YAP_ArityOfFunctor (C-Interface function) -@example - YAP_Functor YAP_MkFunctor(YAP_Atom @var{a},unsigned long int @var{arity}) - YAP_Atom YAP_NameOfFunctor(YAP_Functor @var{f}) - YAP_Int YAP_ArityOfFunctor(YAP_Functor @var{f}) -@end example +@table @code + @item YAP_Functor YAP_MkFunctor(YAP_Atom @var{a},unsigned long int @var{arity}) + @item YAP_Atom YAP_NameOfFunctor(YAP_Functor @var{f}) + @item YAP_Int YAP_ArityOfFunctor(YAP_Functor @var{f}) +@end table @noindent Note that the functor is essentially a pair formed by an atom, and arity. Constructing terms in the stack may lead to overflow. The routine -@example - int YAP_RequiresExtraStack(size_t @var{min}) -@end example +@table @code + @item int YAP_RequiresExtraStack(size_t @var{min}) +@end table verifies whether you have at least @var{min} cells free in the stack, and it returns true if it has to ensure enough memory by calling the garbage collector and or stack shifter. The routine returns false if no @@ -9430,9 +9423,9 @@ code. Slots can also be used if there is small state. @findex YAP_Unify (C-Interface function) YAP provides a single routine to attempt the unification of two Prolog terms. The routine may succeed or fail: -@example - Int YAP_Unify(YAP_Term @var{a}, YAP_Term @var{b}) -@end example +@table @code + @item Int YAP_Unify(YAP_Term @var{a}, YAP_Term @var{b}) +@end table @noindent The routine attempts to unify the terms @var{a} and @var{b} returning @code{TRUE} if the unification succeeds and @code{FALSE} @@ -9444,9 +9437,9 @@ otherwise. @findex YAP_StringToBuffer (C-Interface function) The YAP C-interface now includes an utility routine to copy a string represented as a list of a character codes to a previously allocated buffer -@example - int YAP_StringToBuffer(YAP_Term @var{String}, char *@var{buf}, unsigned int @var{bufsize}) -@end example +@table @code + @item int YAP_StringToBuffer(YAP_Term @var{String}, char *@var{buf}, unsigned int @var{bufsize}) +@end table @noindent The routine copies the list of character codes @var{String} to a previously allocated buffer @var{buf}. The string including a @@ -9471,16 +9464,16 @@ is, to copy a from a buffer to a list of character codes, to a difference list, or to a list of character atoms. The routines work either on strings of characters or strings of wide characters: -@example - YAP_Term YAP_BufferToString(char *@var{buf}) - YAP_Term YAP_NBufferToString(char *@var{buf}, size_t @var{len}) - YAP_Term YAP_WideBufferToString(wchar_t *@var{buf}) - YAP_Term YAP_NWideBufferToString(wchar_t *@var{buf}, size_t @var{len}) - YAP_Term YAP_BufferToAtomList(char *@var{buf}) - YAP_Term YAP_NBufferToAtomList(char *@var{buf}, size_t @var{len}) - YAP_Term YAP_WideBufferToAtomList(wchar_t *@var{buf}) - YAP_Term YAP_NWideBufferToAtomList(wchar_t *@var{buf}, size_t @var{len}) -@end example +@table @code +@item YAP_Term YAP_BufferToString(char *@var{buf}) + @item YAP_Term YAP_NBufferToString(char *@var{buf}, size_t @var{len}) +@item YAP_Term YAP_WideBufferToString(wchar_t *@var{buf}) +@item YAP_Term YAP_NWideBufferToString(wchar_t *@var{buf}, size_t @var{len}) +@item YAP_Term YAP_BufferToAtomList(char *@var{buf}) +@item YAP_Term YAP_NBufferToAtomList(char *@var{buf}, size_t @var{len}) +@item YAP_Term YAP_WideBufferToAtomList(wchar_t *@var{buf}) +@item YAP_Term YAP_NWideBufferToAtomList(wchar_t *@var{buf}, size_t @var{len}) +@end table @noindent Users are advised to use the @var{N} version of the routines. Otherwise, the user-provided string must include a terminating null character. @@ -9488,9 +9481,9 @@ the user-provided string must include a terminating null character. @findex YAP_ReadBuffer (C-Interface function) The C-interface function calls the parser on a sequence of characters stored at @var{buf} and returns the resulting term. -@example - YAP_Term YAP_ReadBuffer(char *@var{buf},YAP_Term *@var{error}) -@end example +@table @code + @item YAP_Term YAP_ReadBuffer(char *@var{buf},YAP_Term *@var{error}) +@end table @noindent The user-provided string must include a terminating null character. Syntax errors will cause returning @code{FALSE} and binding @@ -9499,10 +9492,10 @@ character. Syntax errors will cause returning @code{FALSE} and binding @findex YAP_IntsToList (C-Interface function) @findex YAP_FloatsToList (C-Interface function) These C-interface functions are useful when converting chunks of data to Prolog: -@example - YAP_Term YAP_FloatsToList(double *@var{buf},size_t @var{sz}) - YAP_Term YAP_IntsToList(YAP_Int *@var{buf},size_t @var{sz}) -@end example +@table @code +@item YAP_Term YAP_FloatsToList(double *@var{buf},size_t @var{sz}) +@item YAP_Term YAP_IntsToList(YAP_Int *@var{buf},size_t @var{sz}) +@end table @noindent Notice that they are unsafe, and may call the garbage collector. They return 0 on error. @@ -9510,10 +9503,10 @@ return 0 on error. @findex YAP_ListToInts (C-Interface function) @findex YAP_ToListFloats (C-Interface function) These C-interface functions are useful when converting Prolog lists to arrays: -@example - YAP_Int YAP_IntsToList(YAP_Term t, YAP_Int *@var{buf},size_t @var{sz}) - YAP_Int YAP_FloatsToList(YAP_Term t, double *@var{buf},size_t @var{sz}) -@end example +@table @code +@item YAP_Int YAP_IntsToList(YAP_Term t, YAP_Int *@var{buf},size_t @var{sz}) +@item YAP_Int YAP_FloatsToList(YAP_Term t, double *@var{buf},size_t @var{sz}) +@end table @noindent They return the number of integers scanned, up to a maximum of @t{sz}, and @t{-1} on error. @@ -9523,9 +9516,9 @@ and @t{-1} on error. @findex YAP_AllocSpaceFromYAP (C-Interface function) The next routine can be used to ask space from the Prolog data-base: -@example - void *YAP_AllocSpaceFromYAP(int @var{size}) -@end example +@table @code + @item void *YAP_AllocSpaceFromYAP(int @var{size}) +@end table @noindent The routine returns a pointer to a buffer allocated from the code area, or @code{NULL} if sufficient space was not available. @@ -9533,9 +9526,9 @@ or @code{NULL} if sufficient space was not available. @findex YAP_FreeSpaceFromYAP (C-Interface function) The space allocated with @code{YAP_AllocSpaceFromYAP} can be released back to YAP by using: -@example - void YAP_FreeSpaceFromYAP(void *@var{buf}) -@end example +@table @code + @item void YAP_FreeSpaceFromYAP(void *@var{buf}) +@end table @noindent The routine releases a buffer allocated from the code area. The system may crash if @code{buf} is not a valid pointer to a buffer in the code @@ -9548,9 +9541,9 @@ area. The C-Interface also provides the C-application with a measure of control over the YAP Input/Output system. The first routine allows one to find a file number given a current stream: -@example - int YAP_StreamToFileNo(YAP_Term @var{stream}) -@end example +@table @code + @item int YAP_StreamToFileNo(YAP_Term @var{stream}) +@end table @noindent This function gives the file descriptor for a currently available stream. Note that null streams and in memory streams do not have @@ -9561,9 +9554,9 @@ stale. @findex YAP_CloseAllOpenStreams (C-Interface function) A second routine that is sometimes useful is: -@example - void YAP_CloseAllOpenStreams(void) -@end example +@table @code +@item void YAP_CloseAllOpenStreams(void) +@end table @noindent This routine closes the YAP Input/Output system except for the first three streams, that are always associated with the three standard Unix @@ -9571,9 +9564,9 @@ streams. It is most useful if you are doing @code{fork()}. @findex YAP_FlushAllStreams (C-Interface function) Last, one may sometimes need to flush all streams: -@example - void YAP_CloseAllOpenStreams(void) -@end example +@table @code + @item void YAP_CloseAllOpenStreams(void) +@end table @noindent It is also useful before you do a @code{fork()}, or otherwise you may have trouble with unflushed output. @@ -9582,9 +9575,9 @@ have trouble with unflushed output. The next routine allows a currently open file to become a stream. The routine receives as arguments a file descriptor, the true file name as a string, an atom with the user name, and a set of flags: -@example - void YAP_OpenStream(void *@var{FD}, char *@var{name}, YAP_Term @var{t}, int @var{flags}) -@end example +@table @code + @item void YAP_OpenStream(void *@var{FD}, char *@var{name}, YAP_Term @var{t}, int @var{flags}) +@end table @noindent The available flags are @code{YAP_INPUT_STREAM}, @code{YAP_OUTPUT_STREAM}, @code{YAP_APPEND_STREAM}, @@ -9603,18 +9596,18 @@ functions that are useful. @findex YAP_Record (C-Interface function) The first provides a way to insert a term into the data-base -@example - void *YAP_Record(YAP_Term @var{t}) -@end example +@table @code +@item void *YAP_Record(YAP_Term @var{t}) +@end table @noindent This function returns a pointer to a copy of the term in the database (or to @t{NULL} if the operation fails. @findex YAP_Recorded (C-Interface function) The next functions provides a way to recover the term from the data-base: -@example - YAP_Term YAP_Recorded(void *@var{handle}) -@end example +@table @code + @item YAP_Term YAP_Recorded(void *@var{handle}) +@end table @noindent Notice that the semantics are the same as for @code{recorded/3}: this function creates a new copy of the term in the stack, with fresh @@ -9622,9 +9615,9 @@ variables. The function returns @t{0L} if it cannot create a new term. @findex YAP_Erase (C-Interface function) Last, the next function allows one to recover space: -@example - int YAP_Erase(void *@var{handle}) -@end example +@table @code + @item int YAP_Erase(void *@var{handle}) +@end table @noindent Notice that any accesses using @var{handle} after this operation may lead to a crash. @@ -9634,47 +9627,47 @@ The following functions are often required to compare terms. @findex YAP_ExactlyEqual (C-Interface function) Succeed if two terms are actually the same term, as in @code{==/2}: -@example - int YAP_ExactlyEqual(YAP_Term t1, YAP_Term t2) -@end example +@table @code +@item int YAP_ExactlyEqual(YAP_Term t1, YAP_Term t2) +@end table @noindent The next function succeeds if two terms are variant terms, and returns 0 otherwise, as @code{=@=/2}: -@example - int YAP_Variant(YAP_Term t1, YAP_Term t2) -@end example +@table @code + @item int YAP_Variant(YAP_Term t1, YAP_Term t2) +@end table @noindent The next functions deal with numbering variables in terms: -@example - int YAP_NumberVars(YAP_Term t, YAP_Int first_number) - YAP_Term YAP_UnNumberVars(YAP_Term t) - int YAP_IsNumberedVariable(YAP_Term t) -@end example +@table @code + @item int YAP_NumberVars(YAP_Term t, YAP_Int first_number) + @item YAP_Term YAP_UnNumberVars(YAP_Term t) + @item int YAP_IsNumberedVariable(YAP_Term t) +@end table @noindent The next one returns the length of a well-formed list @var{t}, or @code{-1} otherwise: -@example - Int YAP_ListLength(YAP_Term t) -@end example +@table @code +@item Int YAP_ListLength(YAP_Term t) +@end table @noindent Last, this function succeeds if two terms are unifiable: @code{=@=/2}: -@example - int YAP_Unifiable(YAP_Term t1, YAP_Term t2) -@end example +@table @code + @item int YAP_Unifiable(YAP_Term t1, YAP_Term t2) +@end table @noindent The second function computes a hash function for a term, as in @code{term_hash/4}. -@example - YAP_Int YAP_TermHash(YAP_Term t, YAP_Int range, YAP_Int depth, int ignore_variables)); -@end example +@table @code + @item YAP_Int YAP_TermHash(YAP_Term t, YAP_Int range, YAP_Int depth, int ignore_variables)); +@end table @noindent The first three arguments follow @code{term_has/4}. The last argument indicates what to do if we find a variable: if @code{0} fail, otherwise @@ -9688,18 +9681,18 @@ There are several ways to call Prolog code from C-code. By default, the @code{YAP_RunGoal()} should be used for this task. It assumes the engine has been initialised before: -@example - YAP_Int YAP_RunGoal(YAP_Term Goal) -@end example +@table @code +@item YAP_Int YAP_RunGoal(YAP_Term Goal) +@end table Execute query @var{Goal} and return 1 if the query succeeds, and 0 otherwise. The predicate returns 0 if failure, otherwise it will return an @var{YAP_Term}. Quite often, one wants to run a query once. In this case you should use @var{Goal}: -@example - YAP_Int YAP_RunGoalOnce(YAP_Term Goal) -@end example +@table @code + @item YAP_Int YAP_RunGoalOnce(YAP_Term Goal) +@end table The @code{YAP_RunGoal()} function makes sure to recover stack space at the end of execution. @@ -9867,9 +9860,9 @@ runall(YAP_Term g) YAP allows calling a @strong{new} Prolog interpreter from @code{C}. One way is to first construct a goal @code{G}, and then it is sufficient to perform: -@example - YAP_Bool YAP_CallProlog(YAP_Term @var{G}) -@end example +@table @code + @item YAP_Bool YAP_CallProlog(YAP_Term @var{G}) +@end table @noindent the result will be @code{FALSE}, if the goal failed, or @code{TRUE}, if the goal succeeded. In this case, the variables in @var{G} will store @@ -9885,21 +9878,21 @@ have moved the terms YAP allows one to create a new module from C-code. To create the new code it is sufficient to call: -@example - YAP_Module YAP_CreateModule(YAP_Atom @var{ModuleName}) -@end example +@table @code + @item YAP_Module YAP_CreateModule(YAP_Atom @var{ModuleName}) +@end table @noindent Notice that the new module does not have any predicates associated and that it is not the current module. To find the current module, you can call: -@example - YAP_Module YAP_CurrentModule() -@end example +@table @code + @item YAP_Module YAP_CurrentModule() +@end table Given a module, you may want to obtain the corresponding name. This is possible by using: -@example - YAP_Term YAP_ModuleName(YAP_Module mod) -@end example +@table @code + @item YAP_Term YAP_ModuleName(YAP_Module mod) +@end table @noindent Notice that this function returns a term, and not an atom. You can @code{YAP_AtomOfTerm} to extract the corresponding Prolog atom. @@ -9974,9 +9967,9 @@ The first kind of predicates should be implemented as a C function with no arguments which should return zero if the predicate fails and a non-zero value otherwise. The predicate should be declared to YAP, in the initialization routine, with a call to -@example - void YAP_UserCPredicate(char *@var{name}, YAP_Bool *@var{fn}(), unsigned long int @var{arity}); -@end example +@table @code + @item void YAP_UserCPredicate(char *@var{name}, YAP_Bool *@var{fn}(), unsigned long int @var{arity}); +@end table @noindent where @var{name} is the name of the predicate, @var{fn} is the C function implementing the predicate and @var{arity} is its arity. @@ -10169,9 +10162,9 @@ in this case no code is executed at cut time. @section Loading Object Files The primitive predicate -@example - load_foreign_files(@var{Files},@var{Libs},@var{InitRoutine}) -@end example +@table @code +@item load_foreign_files(@var{Files},@var{Libs},@var{InitRoutine}) +@end table @noindent should be used, from inside YAP, to load object files produced by the C compiler. The argument @var{ObjectFiles} should be a list of atoms @@ -10196,7 +10189,7 @@ YAP also supports the SWI-Prolog interface to loading foreign code: library in MS-Windows). This file is attached to the current process and @var{Handle} is unified with a handle to the library. Equivalent to @code{open_shared_object(File, [], Handle)}. See also - load_foreign_library/[1,2]. + @code{load_foreign_library/1} and @code{load_foreign_library/2}. On errors, an exception @code{shared_object}(@var{Action}, @var{Message}) is raised. @var{Message} is the return value from @@ -10236,18 +10229,18 @@ YAP also supports the SWI-Prolog interface to loading foreign code: @section Saving and Restoring @comment The primitive predicates @code{save} and @code{restore} will save and restore -@comment object code loaded with @code{load_foreign_files}. However, the values of +@comment object code loaded with @code{load_foreign_files/3}. However, the values of @comment any non-static data created by the C files loaded will not be saved nor @comment restored. YAP4 currently does not support @code{save} and @code{restore} for object code -loaded with @code{load_foreign_files}. We plan to support save and restore +loaded with @code{load_foreign_files/3}. We plan to support save and restore in future releases of YAP. @node YAP4 Notes, , Save&Rest, C-Interface @section Changes to the C-Interface in YAP4 -YAP4 includes several changes over the previous @code{load_foreign_files} +YAP4 includes several changes over the previous @code{load_foreign_files/3} interface. These changes were required to support the new binary code formats, such as ELF used in Solaris2 and Linux. @itemize @bullet @@ -10719,12 +10712,14 @@ to @code{yap} (the default): @item The @code{consult/1} predicate in YAP follows C-Prolog semantics. That is, it adds clauses to the data base, even for preexisting procedures. This is different from @code{consult/1} in -SICStus Prolog. +SICStus Prolog or SWI-Prolog. -@cindex update semantics -@item By default, the data-base in YAP follows "immediate update -semantics", instead of "logical update semantics", as Quintus Prolog or -SICStus Prolog do. The difference is depicted in the next example: +@cindex logical update semantics +@item +By default, the data-base in YAP follows "logical update semantics", as +Quintus Prolog or SICStus Prolog do. Previous versions followed +"immediate update semantics". The difference is depicted in the next +example: @example :- dynamic a/1. diff --git a/pl/absf.yap b/pl/absf.yap index 5adbe049f..09b5efb76 100755 --- a/pl/absf.yap +++ b/pl/absf.yap @@ -31,11 +31,8 @@ /** * - * - * @mainpage Index YAP Main Page - * - * These are a few Prolog Built-ins - * + * @defgroup AbsoluteFileName File Name Resolution + * * @subsection sub:AbsFileName File Name Resolution in Prolog Support for file name resolution through absolute_file_name/3 and @@ -46,7 +43,7 @@ */ /** - @predicate absolute_file_name(+Name:atom,+Options:list) is nondet + @brief absolute_file_name(+Name:atom,+Options:list) is nondet Converts the given file specification into an absolute path, using default options. See absolute_file_name/3 for details on the options. */ @@ -62,8 +59,8 @@ absolute_file_name(File0,File) :- /** - @predicate absolute_file_name(+File:atom, +Options:list, +Path:atom) is nondet - @predicate absolute_file_name(-File:atom, +Path:atom, +Options:list) is nondet + @brief absolute_file_name(+File:atom, +Options:list, +Path:atom) is nondet + @brief absolute_file_name(-File:atom, +Path:atom, +Options:list) is nondet Option is a list of options to guide the conversion: @@ -458,7 +455,7 @@ absolute_file_name(File,Opts,TrueFileName) :- '$add_file_to_dir'(P0,A,Atoms,NFile) :- atom_concat([P0,A,Atoms],NFile). -/** @predicate path(-Directories:list) is det [DEPRECATED] +/** @brief path(-Directories:list) is det [DEPRECATED] YAP specific procedure that returns a list of user-defined directories in the library search-path. @@ -470,7 +467,7 @@ path(Path) :- findall(X,'$in_path'(X),Path). ( S = "" -> X = '.' ; atom_codes(X,S) ). -/** @predicate add_to_path(+Directory:atom) is det [DEPRECATED] +/** @brief add_to_path(+Directory:atom) is det [DEPRECATED] */ add_to_path(New) :- add_to_path(New,last). @@ -485,7 +482,7 @@ add_to_path(New,Pos) :- '$add_to_path'(New,last) :- !, recordz('$path',New,_). '$add_to_path'(New,first) :- recorda('$path',New,_). -/** @predicate remove_from_path(+Directory:atom) is det [DEPRECATED] +/** @brief remove_from_path(+Directory:atom) is det [DEPRECATED] */ remove_from_path(New) :- '$check_path'(New,Path), @@ -497,7 +494,7 @@ remove_from_path(New) :- '$check_path'(New,Path), '$check_path'([Ch],[Ch,A]) :- !, integer(Ch), '$dir_separator'(A). '$check_path'([N|S],[N|SN]) :- integer(N), '$check_path'(S,SN). -/** @predicate user:library_directory(Directory:atom) +/** @brief user:library_directory(Directory:atom) */ @@ -505,7 +502,7 @@ remove_from_path(New) :- '$check_path'(New,Path), :- dynamic user:library_directory/1. -/** @predicate user:commons_directory(Directory:atom) +/** @brief user:commons_directory(Directory:atom) */ @@ -513,7 +510,7 @@ remove_from_path(New) :- '$check_path'(New,Path), :- dynamic user:commons_directory/1. -/** @predicate user:prolog_file_type(Suffix:atom, Handler:atom) +/** @brief user:prolog_file_type(Suffix:atom, Handler:atom) */ @@ -534,7 +531,7 @@ user:prolog_file_type(A, prolog) :- user:prolog_file_type(A, executable) :- current_prolog_flag(shared_object_extension, A). -/** @predicate user:file_search_path(+Type:atom, -Directory:atom) +/** @brief user:file_search_path(+Type:atom, -Directory:atom) */