kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/utf8.pl

@@ -0,0 +1,145 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2006-2011, University of 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(utf8,
+          [ utf8_codes//1               % ?String
+          ]).
+
+/** <module> UTF-8 encoding/decoding on lists of character codes.
+*/
+
+%!  utf8_codes(?Codes)// is det.
+%
+%   DCG translating between  a  Unicode   code-list  and  its  UTF-8
+%   encoded  byte-string.  The  DCG  works   two  ways.  Encoding  a
+%   code-list to a UTF-8 byte string is achieved using
+%
+%           phrase(utf8_codes(Codes), UTF8)
+%
+%   The  algorithm  is  a  close  copy    of  the  C-algorithm  used
+%   internally and defined in src/pl-utf8.c
+%
+%   NOTE: in many  cases  you  can   avoid  this  library  and leave
+%   encoding and decoding to I/O streams. If   only part of the data
+%   is to be encoded the  encoding  of   a  stream  can  be switched
+%   temporary using set_stream(Stream, encoding(utf8))
+%
+%   @see set_stream/2.
+
+utf8_codes([H|T]) -->
+    utf8_code(H),
+    !,
+    utf8_codes(T).
+utf8_codes([]) -->
+    [].
+
+utf8_code(C) -->
+    [C0],
+    { nonvar(C0) },                % decoding version
+    !,
+    (   {C0 < 0x80}
+    ->  {C = C0}
+    ;   {C0/\0xe0 =:= 0xc0}
+    ->  utf8_cont(C1, 0),
+        {C is (C0/\0x1f)<<6\/C1}
+    ;   {C0/\0xf0 =:= 0xe0}
+    ->  utf8_cont(C1, 6),
+        utf8_cont(C2, 0),
+        {C is ((C0/\0xf)<<12)\/C1\/C2}
+    ;   {C0/\0xf8 =:= 0xf0}
+    ->  utf8_cont(C1, 12),
+        utf8_cont(C2, 6),
+        utf8_cont(C3, 0),
+        {C is ((C0/\0x7)<<18)\/C1\/C2\/C3}
+    ;   {C0/\0xfc =:= 0xf8}
+    ->  utf8_cont(C1, 18),
+        utf8_cont(C2, 12),
+        utf8_cont(C3, 6),
+        utf8_cont(C4, 0),
+        {C is ((C0/\0x3)<<24)\/C1\/C2\/C3\/C4}
+    ;   {C0/\0xfe =:= 0xfc}
+    ->  utf8_cont(C1, 24),
+        utf8_cont(C2, 18),
+        utf8_cont(C3, 12),
+        utf8_cont(C4, 6),
+        utf8_cont(C5, 0),
+        {C is ((C0/\0x1)<<30)\/C1\/C2\/C3\/C4\/C5}
+    ).
+utf8_code(C) -->
+    { nonvar(C) },                 % encoding version
+    !,
+    (   { C < 0x80 }
+    ->  [C]
+    ;   { C < 0x800 }
+    ->  { C0 is 0xc0\/((C>>6)/\0x1f),
+          C1 is 0x80\/(C/\0x3f)
+        },
+        [C0,C1]
+    ;   { C < 0x10000 }
+    ->  { C0 is 0xe0\/((C>>12)/\0x0f),
+          C1 is 0x80\/((C>>6)/\0x3f),
+          C2 is 0x80\/(C/\0x3f)
+        },
+        [C0,C1,C2]
+    ;   { C < 0x200000 }
+    ->  { C0 is 0xf0\/((C>>18)/\0x07),
+          C1 is 0x80\/((C>>12)/\0x3f),
+          C2 is 0x80\/((C>>6)/\0x3f),
+          C3 is 0x80\/(C/\0x3f)
+        },
+        [C0,C1,C2,C3]
+    ;   { C < 0x4000000 }
+    ->  { C0 is 0xf8\/((C>>24)/\0x03),
+          C1 is 0x80\/((C>>18)/\0x3f),
+          C2 is 0x80\/((C>>12)/\0x3f),
+          C3 is 0x80\/((C>>6)/\0x3f),
+          C4 is 0x80\/(C/\0x3f)
+        },
+        [C0,C1,C2,C3,C4]
+    ;   { C < 0x80000000 }
+    ->  { C0 is 0xfc\/((C>>30)/\0x01),
+          C1 is 0x80\/((C>>24)/\0x3f),
+          C2 is 0x80\/((C>>18)/\0x3f),
+          C3 is 0x80\/((C>>12)/\0x3f),
+          C4 is 0x80\/((C>>6)/\0x3f),
+          C5 is 0x80\/(C/\0x3f)
+        },
+        [C0,C1,C2,C3,C4,C5]
+    ).
+
+utf8_cont(Val, Shift) -->
+    [C],
+    { C/\0xc0 =:= 0x80,
+      Val is (C/\0x3f)<<Shift
+    }.

package/lib/swipl/library/varnumbers.pl

@@ -0,0 +1,221 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2011-2016, 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(varnumbers,
+          [ numbervars/1,                       % +Term
+            varnumbers/2,                       % +Term, -Copy
+            max_var_number/3,                   % +Term, +Start, -Max
+            varnumbers/3,                       % +Term, +No, -Copy
+            varnumbers_names/3                  % +Term, -Copy, -VariableNames
+          ]).
+:- autoload(library(apply),[maplist/3]).
+:- autoload(library(assoc),
+	    [empty_assoc/1,assoc_to_list/2,get_assoc/3,put_assoc/4]).
+:- autoload(library(error),[must_be/2]).
+
+
+/** <module> Utilities for numbered terms
+
+This  library  provides  the  inverse   functionality  of  the  built-in
+numbervars/3. Note that this library suffers  from the known issues that
+'$VAR'(X) is a normal Prolog term and, -unlike the built-in numbervars-,
+the inverse predicates do _not_  process   cyclic  terms.  The following
+predicate is true for  any  acyclic   term  that  contains no '$VAR'(X),
+integer(X) terms and no constraint variables:
+
+  ==
+  always_true(X) :-
+        copy_term(X, X2),
+        numbervars(X),
+        varnumbers(X, Copy),
+        Copy =@= X2.
+  ==
+
+@see    numbervars/4, =@=/2 (variant/2).
+@compat This library was introduced by Quintus and available in
+        many related implementations, although not with exactly the
+        same set of predicates.
+*/
+
+%!  numbervars(+Term) is det.
+%
+%   Number  variables  in  Term   using    $VAR(N).   Equivalent  to
+%   numbervars(Term, 0, _).
+%
+%   @see numbervars/3, numbervars/4
+
+numbervars(Term) :-
+    numbervars(Term, 0, _).
+
+%!  varnumbers(+Term, -Copy) is det.
+%
+%   Inverse  of  numbervars/1.  Equivalent  to  varnumbers(Term,  0,
+%   Copy).
+
+varnumbers(Term, Copy) :-
+    varnumbers(Term, 0, Copy).
+
+%!  varnumbers(+Term, +Start, -Copy) is det.
+%
+%   Inverse of numbervars/3. True when Copy is   a copy of Term with
+%   all variables numbered >= Start   consistently replaced by fresh
+%   variables. Variables in Term are _shared_  with Copy rather than
+%   replaced by fresh variables.
+%
+%   @error domain_error(acyclic_term, Term) if Term is cyclic.
+%   @compat Quintus, SICStus.  Not in YAP version of this library
+
+varnumbers(Term, Min, Copy) :-
+    must_be(acyclic, Term),
+    MaxStart is Min-1,
+    max_var_number(Term, MaxStart, Max),
+    NVars is Max-MaxStart,
+    (   NVars == 0
+    ->  Copy = Term
+    ;   roundup_next_power_two(NVars, Len),
+        functor(Vars, v, Len),
+        varnumbers(Term, MaxStart, Vars, Copy)
+    ).
+
+varnumbers(Var, _, _, Copy) :-
+    var(Var),
+    !,
+    Copy = Var.
+varnumbers(Var, _, _, Copy) :-
+    atomic(Var),
+    !,
+    Copy = Var.
+varnumbers('$VAR'(I), Min, Vars, Copy) :-
+    integer(I),
+    I > Min,
+    !,
+    Index is I-Min,
+    arg(Index, Vars, Copy).
+varnumbers(Term, Min, Vars, Copy) :-
+    functor(Term, Name, Arity),
+    functor(Copy, Name, Arity),
+    varnumbers_args(1, Arity, Term, Min, Vars, Copy).
+
+varnumbers_args(I, Arity, Term, Min, Vars, Copy) :-
+    I =< Arity,
+    !,
+    arg(I, Term, AT),
+    arg(I, Copy, CT),
+    varnumbers(AT, Min, Vars, CT),
+    I2 is I + 1,
+    varnumbers_args(I2, Arity, Term, Min, Vars, Copy).
+varnumbers_args(_, _, _, _, _, _).
+
+%!  roundup_next_power_two(+Int, -NextPower) is det.
+%
+%   NextPower is I**2, such that NextPower >= Int.
+
+roundup_next_power_two(1, 1) :- !.
+roundup_next_power_two(N, L) :-
+    L is 1<<(msb(N-1)+1).
+
+%!  max_var_number(+Term, +Start, -Max) is det.
+%
+%   True when Max is the  max  of   Start  and  the highest numbered
+%   $VAR(N) term.
+%
+%   @author Vitor Santos Costa
+%   @compat YAP
+
+max_var_number(V, Max, Max) :-
+    var(V),
+    !.
+max_var_number('$VAR'(I), Max0, Max) :-
+    integer(I),
+    !,
+    Max is max(I,Max0).
+max_var_number(S, Max0, Max) :-
+    functor(S, _, Ar),
+    max_var_numberl(Ar, S, Max0, Max).
+
+max_var_numberl(0, _, Max, Max) :- !.
+max_var_numberl(I, T, Max0, Max) :-
+    arg(I, T, Arg),
+    I2 is I-1,
+    max_var_number(Arg, Max0, Max1),
+    max_var_numberl(I2, T, Max1, Max).
+
+%!  varnumbers_names(+Term, -Copy, -VariableNames) is det.
+%
+%   If Term is a term with numbered   and  named variables using the
+%   reserved term '$VAR'(X), Copy  is  a   copy  of  Term where each
+%   '$VAR'(X) is consistently  replaced  by   a  fresh  variable and
+%   Bindings is a list `X = Var`,   relating  the `X` terms with the
+%   variable it is mapped to.
+%
+%   @see numbervars/3, varnumbers/3, read_term/3 using the
+%   `variable_names` option.
+
+varnumbers_names(Term, Copy, Bindings) :-
+    must_be(acyclic, Term),
+    empty_assoc(Named),
+    varnumbers_names(Term, Named, BindingAssoc, Copy),
+    assoc_to_list(BindingAssoc, BindingPairs),
+    maplist(pair_equals, BindingPairs, Bindings).
+
+pair_equals(N-V, N=V).
+
+varnumbers_names(Var, Bindings, Bindings, Copy) :-
+    var(Var),
+    !,
+    Copy = Var.
+varnumbers_names(Var, Bindings, Bindings, Copy) :-
+    atomic(Var),
+    !,
+    Copy = Var.
+varnumbers_names('$VAR'(Name), Bindings0, Bindings, Copy) :-
+    !,
+    (   get_assoc(Name, Bindings0, Copy)
+    ->  Bindings = Bindings0
+    ;   put_assoc(Name, Bindings0, Copy, Bindings)
+    ).
+varnumbers_names(Term, Bindings0, Bindings, Copy) :-
+    functor(Term, Name, Arity),
+    functor(Copy, Name, Arity),
+    varnumbers_names_args(1, Arity, Term, Bindings0, Bindings, Copy).
+
+varnumbers_names_args(I, Arity, Term, Bindings0, Bindings, Copy) :-
+    I =< Arity,
+    !,
+    arg(I, Term, AT),
+    arg(I, Copy, CT),
+    varnumbers_names(AT, Bindings0, Bindings1, CT),
+    I2 is I + 1,
+    varnumbers_names_args(I2, Arity, Term, Bindings1, Bindings, Copy).
+varnumbers_names_args(_, _, _, Bindings, Bindings, _).

package/lib/swipl/library/vm.pl

@@ -0,0 +1,251 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           www.swi-prolog.org
+    Copyright (c)  2008-2020, University of Amsterdam
+                              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(prolog_vm,
+          [ vm_list/1,                  % :Spec
+            clause_vm/2,                % +ClauseRef,-VM:list
+            vmi_labels/2                % ?VMI,?Labeled
+          ]).
+:- autoload(library(lists), [member/2, selectchk/3]).
+:- autoload(library(prolog_clause), [predicate_name/2]).
+
+
+/** <module> SWI-Prolog Virtual Machine utilities
+
+This is an internal developers  module   to  manage  the virtual machine
+instructions.
+*/
+
+:- meta_predicate
+    vm_list(:).
+
+%!  vm_list(:Spec) is det.
+%
+%   Lists  the  definition  of  the   predicates  matching  Spec  to
+%   =current_output=. Spec is also allowed to be a clause-reference.
+
+vm_list(_:Ref) :-
+    blob(Ref, clause),
+    !,
+    (   nth_clause(_Head, N, Ref),
+        format('~40c~nclause ~d (~w):~n~40c~n', [0'-, N, Ref, 0'-]),
+        vm_list_clause(Ref),
+        fail
+    ;   true
+    ).
+vm_list(Spec) :-
+    '$find_predicate'(Spec, List),
+    (   member(PI, List),
+        pi_to_head(PI, Head),
+        unify_args(Head, Spec),
+        predicate_name(Head, Name),
+        format('~72c~n~w~n~72c~n', [0'=, Name, 0'=]),
+        (   '$fetch_vm'(Head, 0, _, _)
+        ->  vm_list_clause(Head)
+        ;   format('    (No supervisor)~n')
+        ),
+        (   nth_clause(Head, N, Ref),
+            clause(MHead, _, Ref),
+            same_head(Head, MHead),
+            format('~40c~nclause ~d (~w):~n~40c~n', [0'-, N, Ref, 0'-]),
+            vm_list_clause(Ref),
+            fail
+        ;   true
+        ),
+        fail
+    ;   true
+    ).
+
+pi_to_head(M:PI, M:Head) :-
+    !,
+    pi_to_head(PI, Head).
+pi_to_head(Name/Arity, Head) :-
+    functor(Head, Name, Arity).
+
+vm_list_clause(Clause) :-
+    clause_vm(Clause, VM),
+    vmi_labels(VM, Labeled),
+    vm_list_labeled(Labeled, 0).
+
+vm_list_labeled([], _).
+vm_list_labeled([label(L),vmi(break(VMI),Size)|T], PC) :-
+    !,
+    format('~w: ~t~d~8| ~q % <breakpoint>~n', [L, PC, VMI]),
+    PC1 is PC+Size,
+    vm_list_labeled(T, PC1).
+vm_list_labeled([label(L),vmi(VMI,Size)|T], PC) :-
+    format('~w: ~t~d~8| ~q~n', [L, PC, VMI]),
+    PC1 is PC+Size,
+    vm_list_labeled(T, PC1).
+vm_list_labeled([vmi(break(VMI),Size)|T], PC) :-
+    !,
+    format('~t~d~8| ~q % <breakpoint>~n', [PC, VMI]),
+    PC1 is PC+Size,
+    vm_list_labeled(T, PC1).
+vm_list_labeled([vmi(VMI,Size)|T], PC) :-
+    format('~t~d~8| ~q~n', [PC, VMI]),
+    PC1 is PC+Size,
+    vm_list_labeled(T, PC1).
+
+%       Unify the arguments of the specification with the given term,
+%       so we can partially instantate the head.
+
+unify_args(_, _/_) :- !.                % Name/arity spec
+unify_args(X, X) :- !.
+unify_args(_:X, X) :- !.
+unify_args(_, _).
+
+same_head(X, X) :- !.
+same_head(H1, H2) :-
+    strip_module(H1, _, H),
+    strip_module(H2, _, H).
+
+
+%!  clause_vm(+ClauseRef, -VM:list) is det.
+%
+%   True when VM  is  the  virtual   machine  code  of  ClauseRef.  Each
+%   instruction is a term vmi(VMI,Size).
+
+clause_vm(Ref, VM) :-
+    clause_vm(Ref, 0, VM).
+
+clause_vm(Clause, PC, [vmi(VMI,Size)|T]) :-
+    '$fetch_vm'(Clause, PC, NextPC, VMI),
+    !,
+    Size is NextPC-PC,
+    clause_vm(Clause, NextPC, T).
+clause_vm(_, _, []).
+
+
+%!  vmi_labels(?VMI, ?Labeled)
+%
+%   Translated between a raw and  a   labeled  representation  for a VMI
+%   sequence  as  produced  by  clause_vm/2.    Assumes   we  only  jump
+%   _forwards_.
+%
+%   In the labeled represention the `jump`   arguments of VMIs are label
+%   names and there are entries label(Name) in the list.
+
+vmi_labels(VMI, Labeled) :-
+    nonvar(VMI),
+    !,
+    label_vmi(VMI, 0, 0, [], Labeled).
+vmi_labels(VMI, Labeled) :-
+    unlabel_vmi(Labeled, 0, [], VMI).
+
+% Raw --> Labeled
+
+label_vmi([], _, _, _, []).
+label_vmi([H|T], Here0, LI0, Pending0, Labeled) :-
+    H = vmi(VMI0,Size),
+    Here is Here0+Size,
+    new_labels(VMI0, VMI, LI0, LI1, Here0, Here, Pending0, Pending1),
+    (   selectchk(Label-Here0, Pending1, Pending2)
+    ->  Labeled = [label(Label),vmi(VMI,Size)|Labeled1]
+    ;   Labeled = [vmi(VMI,Size)|Labeled1],
+        Pending2 = Pending1
+    ),
+    label_vmi(T, Here, LI1, Pending2, Labeled1).
+
+new_labels(break(VMI0), break(VMI), LI0, LI, Start, End, Labels0, Labels) :-
+    !,
+    new_labels(VMI0, VMI, LI0, LI, Start, End, Labels0, Labels).
+new_labels(VMI0, VMI, LI0, LI, Start, End, Labels0, Labels) :-
+    VMI0 =.. [Name|Argv0],
+    '$vmi_property'(Name, argv(ArgvTypes)),
+    jmp_rel(Name, Start, End, Rel),
+    new_labels_(ArgvTypes, Argv0, Argv, LI0, LI, Rel, Labels0, Labels),
+    VMI =.. [Name|Argv].
+
+%!  jmp_rel(+VMIName, +Start, +End, -JmpRel)
+%
+%   Relative position for the (choice) jump.  This   is  the  end of the
+%   instruction for most, but after the   address  for the compiled trie
+%   instructions.   Should be made consistent.
+
+jmp_rel(TrieVMI, Start, _End, Rel) :-
+    trie_vmi(TrieVMI), !,
+    Rel is Start+2.
+jmp_rel(_, _, End, End).
+
+trie_vmi(VMI) :- sub_atom(VMI, 0, _, _, t_).
+
+new_labels_([], [], [], LI, LI, _, Labels, Labels).
+new_labels_([jump|TT], [Offset|AT], [Label|LT], LI0, LI, End, Labels0, Labels) :-
+    !,
+    To is End+Offset,
+    (   memberchk(Label-To, Labels0)
+    ->  Labels1 = Labels0,
+        LI1 = LI0
+    ;   LI1 is LI0+1,
+        atom_concat('L', LI1, Label),
+        Labels1 = [Label-To|Labels0]
+    ),
+    new_labels_(TT, AT, LT, LI1, LI, End, Labels1, Labels).
+new_labels_([_|TT], [A|AT], [A|LT], LI0, LI, End, Labels0, Labels) :-
+    new_labels_(TT, AT, LT, LI0, LI, End, Labels0, Labels).
+
+% Labeled --> Raw
+
+unlabel_vmi([], _, _, []).
+unlabel_vmi([label(L)|T0], Here, Labels0, T) :-
+    !,
+    resolve_labels(L, Here, Labels0, Labels),
+    unlabel_vmi(T0, Here, Labels, T).
+unlabel_vmi([vmi(VMI0,Size)|T0], Here0, Labels0, [vmi(VMI,Size)|T]) :-
+    Here is Here0+Size,
+    get_labels(VMI0, VMI, Here, Labels0, Labels),
+    unlabel_vmi(T0, Here, Labels, T).
+
+get_labels(VMI0, VMI, Here, Labels0, Labels) :-
+    VMI0 =.. [Name|Argv0],
+    '$vmi_property'(Name, argv(ArgvTypes)),
+    get_labels_(ArgvTypes, Argv0, Argv, Here, Labels0, Labels),
+    VMI =.. [Name|Argv].
+
+get_labels_([], [], [], _, Labels, Labels).
+get_labels_([jump|TT], [Label|LT], [Offset|AT], Here,
+            Labels0, [l(Label,Here,Offset)|Labels]) :-
+    !,
+    get_labels_(TT, LT, AT, Here, Labels0, Labels).
+get_labels_([_|TT], [A|LT], [A|AT], Here, Labels0, Labels) :-
+    get_labels_(TT, LT, AT, Here, Labels0, Labels).
+
+resolve_labels(L, Here, Labels0, Labels) :-
+    selectchk(l(L,End,Offset), Labels0, Labels1),
+    !,
+    Offset is Here-End,
+    resolve_labels(L, Here, Labels1, Labels).
+resolve_labels(_, _, Labels, Labels).