kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/dialect/xsb/machine.pl

@@ -0,0 +1,295 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2019-2025, VU University Amsterdam
+                              CWI, Amsterdam
+                              SWI-Prolog Solutions b.v.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(machine,
+          [ gc_heap/0,
+            trimcore/0,
+
+            abolish_table_info/0,
+            close_open_tables/1,          % ?
+
+            get_attr/3,
+            put_attr/3,
+            del_attr/2,
+            attv_unify/2,                       % AttVar, Value
+            install_verify_attribute_handler/4, % +Mod, -AttrValue,
+                                                % -Target, :Handler)
+            install_attribute_portray_hook/3,   % +Mod, -AttrValue, :Handler
+
+            str_cat/3,
+
+            parsort/4,                    % +List, +Spec, +Dupl, -Sorted
+
+            term_type/2,
+
+            xsb_expand_file_name/2,       % +File, -Expanded
+            expand_filename_no_prepend/2, % FileName, -ExpandedName
+            parse_filename/4,             % +FileName, -Dir, -Base, -Extension
+
+            conset/2,                     % +Term, +Value
+            conget/2,                     % +Term, -Value
+
+            slash/1,                      % -OSDirSlash
+
+            xsb_backtrace/1,              % -Backtrace
+            xwam_state/2                  % +Id, -Value
+            ]).
+:- use_module(library(debug)).
+:- use_module(library(error)).
+:- use_module(library(prolog_stack)).
+
+:- meta_predicate
+    install_verify_attribute_handler(+, -, -, 0).
+:- multifile
+    system:term_expansion/2.
+
+%!  gc_heap
+%
+%   Explicitly invoke heap garbage collection.
+
+gc_heap :-
+    garbage_collect.
+
+%!  trimcore
+%
+%   Trim the stacks.
+
+trimcore :-
+    trim_stacks.
+
+%!  abolish_table_info
+%
+%   Undocumented in the XSB manual.
+
+abolish_table_info.
+
+%!  close_open_tables(?Arg)
+%
+%   Undocumented in the XSB manual. Tables are always closed on
+%   exceptions, so it is unclear what this should do?
+
+close_open_tables(_).
+
+                /*******************************
+                *     ATTRIBUTED VARIABLES     *
+                *******************************/
+
+%!  attv_unify(?AttVar, ?Value) is semidet.
+%
+%   Unify AttVar with Value without causing a   wakeup. If AttVar is not
+%   an attributed variable, this is a normal unification.
+
+attv_unify(AttVar, Value) :-
+    '$attv_unify'(AttVar, Value).
+
+%!  install_verify_attribute_handler(+Mod, -AttrValue, -Target,
+%!                                   :Handler) is det.
+%!  install_attribute_portray_hook(+Mod, -AttrValue, :Handler) is det.
+%
+%   Install attributed variable hooks for Mod.
+
+install_verify_attribute_handler(Mod, AttrValue, Target, Handler) :-
+    retractall(Mod:attr_unify_hook(_,_)),
+    asserta(Mod:(attr_unify_hook(AttrValue, Target) :- Handler)).
+install_attribute_portray_hook(Mod, AttrValue, Handler) :-
+    retractall(Mod:attr_portray_hook(_,_)),
+    asserta(Mod:(attr_portray_hook(AttrValue, _Var) :- Handler)).
+
+system:term_expansion((:-install_verify_attribute_handler(Mod, AttrValue, Target, Handler)),
+                      (Mod:attr_unify_hook(AttrValue, Target) :- Handler)).
+system:term_expansion((:-install_attribute_portray_hook(Mod, AttrValue, Handler)),
+                      (Mod:attr_portray_hook(AttrValue, _Var) :- Handler)).
+
+                /*******************************
+                *             MISC             *
+                *******************************/
+
+%!  str_cat(+Atom1, +Atom2, -Atom3)
+
+str_cat(A, B, AB) :-
+    must_be(atom, A),
+    must_be(atom, B),
+    atom_concat(A, B, AB).
+
+%!  parsort(+List, +Order, +Dupl, -Sorted) is det.
+%
+%   parsort/4 is a very general sorting routine.
+
+parsort(_List, Spec, _Dupl, _Sorted) :-
+    var(Spec),
+    !,
+    uninstantiation_error(Spec).
+parsort(_List, _Spec, Dupl, _Sorted) :-
+    var(Dupl),
+    !,
+    uninstantiation_error(Dupl).
+parsort(List, asc,  0, Sorted) :- !, sort(0, @=<, List, Sorted).
+parsort(List, asc,  _, Sorted) :- !, sort(0, @<,  List, Sorted).
+parsort(List, [],   0, Sorted) :- !, sort(0, @=<, List, Sorted).
+parsort(List, [],   _, Sorted) :- !, sort(0, @<,  List, Sorted).
+parsort(List, desc, 0, Sorted) :- !, sort(0, @>=, List, Sorted).
+parsort(List, desc, _, Sorted) :- !, sort(0, @>,  List, Sorted).
+parsort(List, SortSpec, Dupl, Sorted) :-
+    must_be(list, SortSpec),
+    reverse(SortSpec, Rev),
+    parsort_(Rev, Dupl, List, Sorted).
+
+parsort_([], _, List, List).
+parsort_([H|T], Dupl, List0, List) :-
+    parsort_1(H, Dupl, List0, List1),
+    parsort_(T, Dupl, List1, List).
+
+parsort_1(asc(I),  0, List, Sorted) :- !, sort(I, @=<, List, Sorted).
+parsort_1(asc(I),  _, List, Sorted) :- !, sort(I, @<,  List, Sorted).
+parsort_1(desc(I), 0, List, Sorted) :- !, sort(I, @>=, List, Sorted).
+parsort_1(desc(I), _, List, Sorted) :- !, sort(I, @>,  List, Sorted).
+parsort_1(Spec,  _, _, _) :-
+    domain_error(parsort_spec, Spec).
+
+%!  term_type(+Term, -Type:integer)
+%
+%   Emulation of internal XSB predicate
+
+term_type(Term, Type) :-
+    (   atom(Term)
+    ->  Type = 5
+    ;   compound(Term)
+    ->  (   Term = [_|_]
+        ->  Type = 3
+        ;   Type = 1
+        )
+    ;   integer(Term)
+    ->  Type = 2
+    ;   float(Term)
+    ->  Type = 6
+    ;   var(Term)
+    ->  Type = 0
+    ;   assertion(fail)
+    ).
+
+		 /*******************************
+		 *              FILES		*
+		 *******************************/
+
+%!  xsb_expand_file_name(+File, -Expanded)
+%
+%
+
+xsb_expand_file_name(File, Expanded) :-
+    absolute_file_name(File, Expanded, [expand(true)]).
+
+%!  expand_filename_no_prepend(+FileName, -ExpandedName)
+%
+%
+
+expand_filename_no_prepend(File, Expanded) :-
+    expand_file_name(File, Absolute),
+    working_directory(Dir0, Dir0),
+    ensure_slash(Dir0, Dir),
+    (   atom_concat(Dir, Ex0, Absolute)
+    ->  Expanded = Ex0
+    ;   Expanded = Absolute
+    ).
+
+%!  parse_filename(+FileName, -Dir, -Base, -Extension)
+%
+%
+
+parse_filename(FileName, Dir, Base, Extension) :-
+    sub_atom(FileName, 0, _, _, '~'),
+    !,
+    expand_file_name(FileName, Absolute),
+    parse_filename_2(Absolute, Dir, Base, Extension).
+parse_filename(FileName, Dir, Base, Extension) :-
+    parse_filename_2(FileName, Dir, Base, Extension).
+
+parse_filename_2(FileName, Dir, Base, Extension) :-
+    file_directory_name(FileName, Dir0),
+    (   Dir0 == '.'
+    ->  Dir = ''
+    ;   ensure_slash(Dir0, Dir)
+    ),
+    file_base_name(FileName, File),
+    file_name_extension(Base, Extension, File).
+
+ensure_slash(Dir, DirS) :-
+    sub_atom(Dir, _, _, 0, '/'),
+    !,
+    DirS = Dir.
+ensure_slash(Dir, DirS) :-
+    atom_concat(Dir, '/', DirS).
+
+
+%!  conset(+Term, +Value) is det.
+%!  conget(+Term, -Value) is det.
+%
+%   Cheap set/get integer value associated with an atom. Seems this is a
+%   subset of what SWI-Prolog flags can do.
+
+conset(Name, Value) :-
+    set_flag(Name, Value).
+
+conget(Name, Value) :-
+    get_flag(Name, Value).
+
+%!  slash(-Slash)
+%
+%   Return the directory separator for the platform
+
+slash(Slash) :-
+    current_prolog_flag(dir_sep, Slash).
+
+%!  xsb_backtrace(-Backtrace)
+%
+%   Upon success Backtrace is  bound  to   a  structure  indicating  the
+%   forward continuations for  a  point   of  execution.  This structure
+%   should be treated as opaque.
+
+xsb_backtrace(Backtrace) :-
+    get_prolog_backtrace(25, Backtrace).
+
+%!  xwam_state(+Id, -Value)
+%
+%   Low-level query.  Used by the XSB test suite.
+
+xwam_state(2, DelayReg) :-
+    !,
+    (   '$tbl_delay_list'([_|_])
+    ->  DelayReg = 1
+    ;   DelayReg = 0
+    ).
+xwam_state(Id, _Value) :-
+    domain_error(xwam_state, Id).

package/lib/swipl/library/dialect/xsb/ordsets.pl

@@ -0,0 +1,53 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2019, VU University Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(xsb_ordsets,
+          [ ord_setproduct/3  % Set x Set -> SetOfPairs
+          ]).
+:- reexport(swi(library/ordsets)).
+
+%!  ord_setproduct(+Set1, +Set2, ?SetProduct)
+%
+%   is true when SetProduct is the cartesian   product of Set1 and Set2.
+%   The product is represented as pairs   Elem1-Elem2, where Elem1 is an
+%   element from Set1 and Elem2 is an element from Set2.
+
+ord_setproduct([], _, []).
+ord_setproduct([Head|Tail], Set, SetProduct)  :-
+    ord_setproduct(Set, Head, SetProduct, Rest),
+    ord_setproduct(Tail, Set, Rest).
+
+ord_setproduct([], _, Set, Set).
+ord_setproduct([Head|Tail], X, [X-Head|TailX], Tl) :-
+    ord_setproduct(Tail, X, TailX, Tl).

package/lib/swipl/library/dialect/xsb/setof.pl

@@ -0,0 +1,54 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2019, VU University Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(setof,
+          [ excess_vars/4	% +Term, +ExistVarTerm, +AddVarList, -VarList
+          ]).
+:- use_module(library(lists)).
+
+%!  excess_vars(+Term, +ExistVarTerm, +AddVarList, -VarList)
+%
+%   Returns in VarList the  list  of   (free)  variables  found  in Term
+%   concatenated to the end of AddVarList.   (In normal usage AddVarList
+%   is passed in as an empty list.)   ExistVarTerm  is a term containing
+%   variables assumed to  be  quantified  in   Term  so  none  of  these
+%   variables are returned in the  resulting   list  (unless they are in
+%   AddVarList.) Subterms of Term of   the  form `(VarTerm^SubTerm)` are
+%   treated specially: all variables  in  VarTerm   are  assumed  to  be
+%   quantified in SubTerm, and so no   occurrence  of these variables in
+%   SubTerm is collected into the resulting list.
+
+excess_vars(Term, ExistVarTerm, AddVarList, VarList) :-
+    '$free_variable_set'(ExistVarTerm^Term, _Goal, Vars0),
+    append(AddVarList, Vars0, VarList).

package/lib/swipl/library/dialect/xsb/source.pl

@@ -0,0 +1,308 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2019-2020, VU University Amsterdam
+                              CWI, Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(xsb_source, []).
+:- use_module(library(debug),  [debug/3]).
+:- autoload(library(apply),  [convlist/3,partition/4]).
+:- autoload(library(error),  [instantiation_error/1]).
+:- autoload(library(occurs), [sub_term/2]).
+
+/** <module> Support XSB source .P files
+
+This module is a lightweight module that  allows loading .P files as XSB
+source  files.  This   module   is   intended    to   be   loaded   from
+``<config>/init.pl``, providing transparent usage  of   XSB  files  with
+neglectable impact impact if no XSB sources are used.
+*/
+
+% xsb_max_file_size is used for buffering  the   source  in  memory when
+% reading a source file through the   gpp preprocessor. Eventually, this
+% should probably create an intermediate file.
+
+:- create_prolog_flag(xsb_max_file_size, 100 000 000,
+                      [ keep(true)
+                      ]).
+
+:- multifile
+    user:prolog_file_type/2,
+    user:term_expansion/2.
+
+user:prolog_file_type('P', prolog).
+
+user:term_expansion(begin_of_file, Out) :-
+    prolog_load_context(file, File),
+    file_name_extension(Path, 'P', File),
+    include_options(File, Include),
+    compiler_options(COptions),
+    '$append'(Include, COptions, Extra),
+    xsb_directives(File, Directives),
+    directive_exports(Directives, Public, Directives1),
+    (   Public == []
+    ->  Out = Out1
+    ;   file_base_name(Path, Module),
+        Out = [ (:- module(Module, Public))
+              | Out1
+              ]
+    ),
+    Out1 = [ (:- expects_dialect(xsb)),
+             (:- use_module(library(tables)))
+           | Out2
+           ],
+    '$append'(Extra, More, Out2),
+    (   nonvar(Module)
+    ->  setup_call_cleanup(
+            '$set_source_module'(OldM, Module),
+            phrase(head_directives(Directives1, File), More),
+            '$set_source_module'(OldM))
+    ;   phrase(head_directives(Directives1, File), More)
+    ),
+    debug(xsb(header), '~p: directives: ~p', [File, More]).
+
+include_options(File, Option) :-
+    (   xsb_header_file(File, FileH)
+    ->  Option = [(:- include(FileH))]
+    ;   Option = []
+    ).
+
+:- multifile xsb:xsb_compiler_option/1.
+:- dynamic   xsb:xsb_compiler_option/1.
+
+compiler_options(Directives) :-
+    findall(D, mapped_xsb_option(D), Directives).
+
+mapped_xsb_option((:- D)) :-
+    xsb:xsb_compiler_option(O),
+    map_compiler_option(O, D).
+
+map_compiler_option(singleton_warnings_off, style_check(-singleton)).
+map_compiler_option(optimize,               set_prolog_flag(optimise, true)).
+
+xsb_header_file(File, FileH) :-
+    file_name_extension(Base, _, File),
+    file_name_extension(Base, 'H', FileH),
+    exists_file(FileH).
+
+%!  directive_exports(+AllDirectives, -Public, -OtherDirectives)
+
+directive_exports(AllDirectives, Exports, RestDirectives) :-
+    partition(is_export, AllDirectives, ExportDirectives, RestDirectives),
+    phrase(exports(ExportDirectives), Exports).
+
+is_export(export(_)).
+
+exports([]) -->
+    [].
+exports([export(H)|T]) -->
+    export_decl(H),
+    exports(T).
+
+export_decl(Var) -->
+    { var(Var),
+      !,
+      instantiation_error(Var)
+    }.
+export_decl((A,B)) -->
+    !,
+    export_decl(A),
+    export_decl(B).
+export_decl(PI) -->
+    [PI].
+
+%!  head_directives(+Directives, +File)// is det.
+%!  head_directives_s(+Directives, +State)// is det.
+
+head_directives(Directives, File) -->
+    { current_prolog_flag(max_table_subgoal_size_action, Action),
+      (   current_prolog_flag(max_table_subgoal_size, Size)
+      ->  true
+      ;   Size = -1
+      )
+    },
+    head_directives_s(Directives,
+                      #{file: File,
+                        max_table_subgoal_size_action: Action,
+                        max_table_subgoal_size:Size
+                       }).
+
+
+head_directives_s([], _) --> [].
+head_directives_s([H|T], State0) -->
+    { update_state(H, State0, State) },
+    !,
+    head_directives_s(T, State).
+head_directives_s([H|T], State) -->
+    head_directive(H, State),
+    head_directives_s(T, State).
+
+update_state(set_prolog_flag(max_table_subgoal_size_action, Action),
+             State0, State) :-
+    State = State0.put(max_table_subgoal_size_action, Action).
+update_state(set_prolog_flag(max_table_subgoal_size, Size),
+             State0, State) :-
+    State = State0.put(max_table_subgoal_size, Size).
+
+%!  head_directive(+Directive, +State)// is det.
+
+head_directive(import(from(Preds, From)), State) -->
+    !,
+    { assertz(xsb:moved_directive(State.file, import(from(Preds, From))))
+    },
+    [ (:- xsb_import(Preds, From)) ].
+head_directive(table(Preds as XSBOptions), State) -->
+    !,
+    { ignored_table_options(XSBOptions, Options),
+      table_clauses(Preds, Options, Clauses, State),
+      assertz(xsb:moved_directive(State.file, table(Preds as XSBOptions)))
+    },
+    seq(Clauses).
+head_directive(table(Preds), State) -->
+    !,
+    { table_clauses(Preds, true, Clauses, State),
+      assertz(xsb:moved_directive(State.file, table(Preds)))
+    },
+    seq(Clauses).
+head_directive(_, _) -->
+    [].
+
+seq([]) --> [].
+seq([H|T]) --> [H], seq(T).
+
+ignored_table_options((A0,B0), Conj) :-
+    !,
+    ignored_table_options(A0, A),
+    ignored_table_options(B0, B),
+    mkconj(A, B, Conj).
+ignored_table_options(Option, Option) :-
+    supported_table_option(Option),
+    !.
+ignored_table_options(opaque, true) :-
+    !.
+ignored_table_options(Option, true) :-
+    print_message(warning, xsb(table_option_ignored(Option))).
+
+supported_table_option(variant).
+supported_table_option(subsumptive).
+supported_table_option(incremental).
+supported_table_option(shared).
+supported_table_option(private).
+supported_table_option(max_answers(_)).
+supported_table_option(subgoal_abstract(_)).
+supported_table_option(answer_abstract(_)).
+
+mkconj(true, X, X) :- !.
+mkconj(X, true, X) :- !.
+mkconj(X, Y, (X,Y)) :- !.
+
+table_clauses(Preds, Options0, Clauses, State) :-
+    add_defaults(Options0, Options, State),
+    (   Options == true
+    ->  expand_term((:- table(Preds)), Clauses)
+    ;   expand_term((:- table(Preds as Options)), Clauses)
+    ).
+
+add_defaults(Opts, Opts, _) :-
+    sub_term(subgoal_abstract(_), Opts),
+    !.
+add_defaults(Opts0, Opts, State) :-
+    #{max_table_subgoal_size_action:abstract,
+      max_table_subgoal_size:Size} :< State,
+    Size >= 0,
+    !,
+    mkconj(Opts0, subgoal_abstract(Size), Opts).
+add_defaults(Opts, Opts, _).
+
+%!  xsb_directives(+File, -Directives) is semidet.
+%
+%   Directives is a list of all directives in File and its header.
+%
+%   @bug: track :- op/3 declarations to update the syntax.
+
+xsb_directives(File, Directives) :-
+    setup_call_cleanup(
+        '$push_input_context'(xsb_directives),
+        xsb_directives_aux(File, Directives),
+        '$pop_input_context').
+
+xsb_directives_aux(File, Directives) :-
+    xsb_header_file(File, FileH),
+    !,
+    setup_call_cleanup(
+        open(FileH, read, In),
+        findall(D, stream_directive(In, D), Directives, PDirectives),
+        close(In)),
+    xsb_P_directives(PDirectives).
+xsb_directives_aux(_File, Directives) :-
+    xsb_P_directives(Directives).
+
+xsb_P_directives(Directives) :-
+    prolog_load_context(stream, In),
+    stream_property(In, reposition(true)),
+    !,
+    setup_call_cleanup(
+        stream_property(In, position(Pos)),
+        findall(PI, stream_directive(In, PI), Directives),
+        set_stream_position(In, Pos)).
+xsb_P_directives(Directives) :-
+    prolog_load_context(stream, In),
+    current_prolog_flag(xsb_max_file_size, MaxSize),
+    peek_string(In, MaxSize, String),
+    setup_call_cleanup(
+        open_string(String, In2),
+        findall(PI, stream_directive(In2, PI), Directives),
+        close(In2)).
+
+stream_directive(In, Directive) :-
+    repeat,
+        read_term(In, Term,
+                  [ syntax_errors(quiet),
+                    module(xsb_source)
+                  ]),
+        (   Term == end_of_file
+        ->  !, fail
+        ;   Term = (:- Directive),
+            nonvar(Directive)
+        ;   fail
+        ).
+
+% define the typical XSB operators to limit syntax errors while
+% scanning for :- export(_).
+:- op(1050,  fy, import).
+:- op(1100,  fx, export).
+:- op(1100,  fx, mode).
+:- op(1040, xfx, from).
+:- op(1100,  fy, index).
+:- op(1100,  fy, ti).
+:- op(1045, xfx, as).
+:- op(900,   fy, tnot).