1/*  Part of SWI-Prolog
    2
    3    Author:        Jan Wielemaker
    4    E-mail:        J.Wielemaker@vu.nl
    5    WWW:           http://www.swi-prolog.org/projects/xpce/
    6    Copyright (c)  2011-2023, University of Amsterdam
    7                              VU University Amsterdam
    8                              CWI, Amsterdam
    9                              SWI-Prolog Solutions b.v.
   10    All rights reserved.
   11
   12    Redistribution and use in source and binary forms, with or without
   13    modification, are permitted provided that the following conditions
   14    are met:
   15
   16    1. Redistributions of source code must retain the above copyright
   17       notice, this list of conditions and the following disclaimer.
   18
   19    2. Redistributions in binary form must reproduce the above copyright
   20       notice, this list of conditions and the following disclaimer in
   21       the documentation and/or other materials provided with the
   22       distribution.
   23
   24    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   25    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   26    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   27    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   28    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   29    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   30    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   31    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   32    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   34    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   35    POSSIBILITY OF SUCH DAMAGE.
   36*/
   37
   38:- module(prolog_colour,
   39          [ prolog_colourise_stream/3,  % +Stream, +SourceID, :ColourItem
   40            prolog_colourise_stream/4,  % +Stream, +SourceID, :ColourItem, +Opts
   41            prolog_colourise_term/4,    % +Stream, +SourceID, :ColourItem, +Opts
   42            prolog_colourise_query/3,   % +String, +SourceID, :ColourItem
   43            syntax_colour/2,            % +Class, -Attributes
   44            syntax_message//1           % +Class
   45          ]).   46:- use_module(library(record),[(record)/1, op(_,_,record)]).   47:- autoload(library(apply),[maplist/3]).   48:- autoload(library(debug),[debug/3]).   49:- autoload(library(error),[is_of_type/2]).   50:- autoload(library(lists),[member/2,append/3]).   51:- autoload(library(operators),
   52	    [push_operators/1,pop_operators/0,push_op/3]).   53:- autoload(library(option),[option/3]).   54:- autoload(library(predicate_options),
   55	    [current_option_arg/2,current_predicate_options/3]).   56:- autoload(library(prolog_clause),[predicate_name/2]).   57:- autoload(library(prolog_source),
   58	    [ load_quasi_quotation_syntax/2,
   59	      read_source_term_at_location/3,
   60	      prolog_canonical_source/2
   61	    ]).   62:- autoload(library(prolog_xref),
   63	    [ xref_option/2,
   64	      xref_public_list/3,
   65	      xref_op/2,
   66	      xref_prolog_flag/4,
   67	      xref_module/2,
   68	      xref_meta/3,
   69	      xref_source_file/4,
   70	      xref_defined/3,
   71	      xref_called/3,
   72	      xref_defined_class/3,
   73	      xref_exported/2,
   74	      xref_hook/1
   75	    ]).   76
   77:- meta_predicate
   78    prolog_colourise_stream(+, +, 3),
   79    prolog_colourise_stream(+, +, 3, +),
   80    prolog_colourise_query(+, +, 3),
   81    prolog_colourise_term(+, +, 3, +).   82
   83:- predicate_options(prolog_colourise_term/4, 4,
   84                     [ subterm_positions(-any)
   85                     ]).   86:- predicate_options(prolog_colourise_stream/4, 4,
   87                     [ operators(list(any))
   88                     ]).

   98:- multifile
   99    style/2,                        % +ColourClass, -Attributes
  100    message//1,                     % +ColourClass
  101    term_colours/2,                 % +SourceTerm, -ColourSpec
  102    goal_colours/2,                 % +Goal, -ColourSpec
  103    goal_colours/3,                 % +Goal, +Class, -ColourSpec
  104    directive_colours/2,            % +Goal, -ColourSpec
  105    goal_classification/2,          % +Goal, -Class
  106    vararg_goal_classification/3.   % +Name, +Arity, -Class
  107
  108
  109:- record
  110    colour_state(source_id_list,
  111                 module,
  112                 stream,
  113                 closure,
  114                 singletons).  115
  116colour_state_source_id(State, SourceID) :-
  117    colour_state_source_id_list(State, SourceIDList),
  118    member(SourceID, SourceIDList).

 prolog_colourise_stream(+Stream, +SourceID, :ColourItem) is det

 prolog_colourise_stream(+Stream, +SourceID, :ColourItem, +Opts) is det

Determine colour fragments for the data on Stream. SourceID is the canonical identifier of the input as known to the cross-referencer, i.e., as created using xref_source(SourceID).

ColourItem is a closure that is called for each identified fragment with three additional arguments:

• The syntactical category
• Start position (character offset) of the fragment
• Length of the fragment (in characters).

Options

operators(+Ops)

Provide an initial list of additional operators.

  139prolog_colourise_stream(Fd, SourceId, ColourItem) :-
  140    prolog_colourise_stream(Fd, SourceId, ColourItem, []).
  141prolog_colourise_stream(Fd, SourceId, ColourItem, Options) :-
  142    to_list(SourceId, SourceIdList),
  143    make_colour_state([ source_id_list(SourceIdList),
  144                        stream(Fd),
  145                        closure(ColourItem)
  146                      ],
  147                      TB),
  148    option(operators(Ops), Options, []),
  149    setup_call_cleanup(
  150        save_settings(TB, Ops, State),
  151        colourise_stream(Fd, TB),
  152        restore_settings(State)).
  153
  154to_list(List, List) :-
  155    is_list(List),
  156    !.
  157to_list(One, [One]).
  158
  159
  160colourise_stream(Fd, TB) :-
  161    (   peek_char(Fd, #)            % skip #! script line
  162    ->  skip(Fd, 10)
  163    ;   true
  164    ),
  165    repeat,
  166        colour_state_module(TB, SM),
  167        character_count(Fd, Start),
  168        catch(read_term(Fd, Term,
  169                        [ subterm_positions(TermPos),
  170                          singletons(Singletons0),
  171                          module(SM),
  172                          comments(Comments)
  173                        ]),
  174              E,
  175              read_error(E, TB, Start, Fd)),
  176        fix_operators(Term, SM, TB),
  177        warnable_singletons(Singletons0, Singletons),
  178        colour_state_singletons(TB, Singletons),
  179        (   colourise_term(Term, TB, TermPos, Comments)
  180        ->  true
  181        ;   arg(1, TermPos, From),
  182            print_message(warning,
  183                          format('Failed to colourise ~p at index ~d~n',
  184                                 [Term, From]))
  185        ),
  186        Term == end_of_file,
  187    !.
  188
  189save_settings(TB, Ops, state(Style, Flags, OSM, Xref)) :-
  190    (   source_module(TB, SM)
  191    ->  true
  192    ;   SM = prolog_colour_ops
  193    ),
  194    set_xref(Xref, true),
  195    '$set_source_module'(OSM, SM),
  196    colour_state_module(TB, SM),
  197    maplist(qualify_op(SM), Ops, QOps),
  198    push_operators(QOps),
  199    syntax_flags(Flags),
  200    '$style_check'(Style, Style).
  201
  202qualify_op(M, op(P,T,[]), Q)            => Q = op(P,T,M:[]).
  203qualify_op(M, op(P,T,N), Q), atom(N)    => Q = op(P,T,M:N).
  204qualify_op(M, op(P,T,L), Q), is_list(Q) =>
  205    Q = op(P, T, QL),
  206    maplist(qualify_op_name(M), L, QL).
  207qualify_op(_, Op, Q)			=> Q = Op.
  208
  209qualify_op_name(M, N,  Q), atom(N) => Q = M:N.
  210qualify_op_name(M, [], Q)          => Q = M:[].
  211qualify_op_name(_, V,  Q)          => Q = V.
  212
  213restore_settings(state(Style, Flags, OSM, Xref)) :-
  214    restore_syntax_flags(Flags),
  215    '$style_check'(_, Style),
  216    pop_operators,
  217    '$set_source_module'(OSM),
  218    set_xref(_, Xref).
  219
  220set_xref(Old, New) :-
  221    current_prolog_flag(xref, Old),
  222    !,
  223    set_prolog_flag(xref, New).
  224set_xref(false, New) :-
  225    set_prolog_flag(xref, New).
  226
  227
  228syntax_flags(Pairs) :-
  229    findall(set_prolog_flag(Flag, Value),
  230            syntax_flag(Flag, Value),
  231            Pairs).
  232
  233syntax_flag(Flag, Value) :-
  234    syntax_flag(Flag),
  235    current_prolog_flag(Flag, Value).
  236
  237restore_syntax_flags([]).
  238restore_syntax_flags([set_prolog_flag(Flag, Value)|T]) :-
  239    set_prolog_flag(Flag, Value),
  240    restore_syntax_flags(T).

 source_module(+State, -Module) is semidet

True when Module is the module context into which the file is loaded. This is the module of the file if File is a module file, or the load context of File if File is not included or the module context of the file into which the file was included.

  249source_module(TB, Module) :-
  250    colour_state_source_id_list(TB, []),
  251    !,
  252    colour_state_module(TB, Module).
  253source_module(TB, Module) :-
  254    colour_state_source_id(TB, SourceId),
  255    xref_option(SourceId, module(Module)),
  256    !.
  257source_module(TB, Module) :-
  258    (   colour_state_source_id(TB, File),
  259        atom(File)
  260    ;   colour_state_stream(TB, Fd),
  261        is_stream(Fd),
  262        stream_property(Fd, file_name(File))
  263    ),
  264    module_context(File, [], Module).
  265
  266module_context(File, _, Module) :-
  267    source_file_property(File, module(Module)),
  268    !.
  269module_context(File, Seen, Module) :-
  270    source_file_property(File, included_in(File2, _Line)),
  271    \+ memberchk(File, Seen),
  272    !,
  273    module_context(File2, [File|Seen], Module).
  274module_context(File, _, Module) :-
  275    source_file_property(File, load_context(Module, _, _)).

 read_error(+Error, +TB, +Start, +Stream) is failure

If this is a syntax error, create a syntax-error fragment.

  282read_error(Error, TB, Start, EndSpec) :-
  283    (   syntax_error(Error, Id, CharNo)
  284    ->  message_to_string(error(syntax_error(Id), _), Msg),
  285        (   integer(EndSpec)
  286        ->  End = EndSpec
  287        ;   character_count(EndSpec, End)
  288        ),
  289        show_syntax_error(TB, CharNo:Msg, Start-End),
  290        fail
  291    ;   throw(Error)
  292    ).
  293
  294syntax_error(error(syntax_error(Id), stream(_S, _Line, _LinePos, CharNo)),
  295             Id, CharNo).
  296syntax_error(error(syntax_error(Id), file(_S, _Line, _LinePos, CharNo)),
  297             Id, CharNo).
  298syntax_error(error(syntax_error(Id), string(_Text, CharNo)),
  299             Id, CharNo).

 warnable_singletons(+Singletons, -Warn) is det

Warn is the subset of the singletons that we warn about.

  305warnable_singletons([], []).
  306warnable_singletons([H|T0], List) :-
  307    H = (Name=_Var),
  308    (   '$is_named_var'(Name)
  309    ->  List = [H|T]
  310    ;   List = T
  311    ),
  312    warnable_singletons(T0, T).

 colour_item(+Class, +TB, +Pos) is det

  316colour_item(Class, TB, Pos) :-
  317    arg(1, Pos, Start),
  318    arg(2, Pos, End),
  319    Len is End - Start,
  320    colour_state_closure(TB, Closure),
  321    call(Closure, Class, Start, Len).

 safe_push_op(+Prec, +Type, :Name, +State)

Define operators into the default source module and register them to be undone by pop_operators/0.

  329safe_push_op(P, T, N0, State) :-
  330    colour_state_module(State, CM),
  331    strip_module(CM:N0, M, N),
  332    (   is_list(N),
  333        N \== []                                % define list as operator
  334    ->  acyclic_term(N),
  335        forall(member(Name, N),
  336               safe_push_op(P, T, M:Name, State))
  337    ;   push_op(P, T, M:N)
  338    ),
  339    debug(colour, ':- ~w.', [op(P,T,M:N)]).

 fix_operators(+Term, +Module, +State) is det

Fix flags that affect the syntax, such as operators and some style checking options. Src is the canonical source as required by the cross-referencer.

  347fix_operators((:- Directive), M, Src) :-
  348    ground(Directive),
  349    catch(process_directive(Directive, M, Src), _, true),
  350    !.
  351fix_operators(_, _, _).
  352
  353:- multifile
  354    prolog:xref_update_syntax/2.  355
  356process_directive(Directive, M, _Src) :-
  357    prolog:xref_update_syntax(Directive, M),
  358    !.
  359process_directive(style_check(X), _, _) :-
  360    !,
  361    style_check(X).
  362process_directive(set_prolog_flag(Flag, Value), M, _) :-
  363    syntax_flag(Flag),
  364    !,
  365    set_prolog_flag(M:Flag, Value).
  366process_directive(M:op(P,T,N), _, Src) :-
  367    !,
  368    process_directive(op(P,T,N), M, Src).
  369process_directive(op(P,T,N), M, Src) :-
  370    !,
  371    safe_push_op(P, T, M:N, Src).
  372process_directive(module(_Name, Export), M, Src) :-
  373    !,
  374    forall(member(op(P,A,N), Export),
  375           safe_push_op(P,A,M:N, Src)).
  376process_directive(use_module(Spec), _, Src) :-
  377    !,
  378    catch(process_use_module1(Spec, Src), _, true).
  379process_directive(use_module(Spec, Imports), _, Src) :-
  380    !,
  381    catch(process_use_module2(Spec, Imports, Src), _, true).
  382process_directive(Directive, _, Src) :-
  383    prolog_source:expand((:-Directive), Src, _).
  384
  385syntax_flag(character_escapes).
  386syntax_flag(var_prefix).
  387syntax_flag(allow_variable_name_as_functor).
  388syntax_flag(allow_dot_in_atom).

 process_use_module1(+Imports, +Src)

Get the exported operators from the referenced files.

  394process_use_module1([], _) :- !.
  395process_use_module1([H|T], Src) :-
  396    !,
  397    process_use_module1(H, Src),
  398    process_use_module1(T, Src).
  399process_use_module1(File, Src) :-
  400    (   xref_public_list(File, Src,
  401                         [ exports(Exports),
  402                           silent(true),
  403                           path(Path)
  404                         ])
  405    ->  forall(member(op(P,T,N), Exports),
  406               safe_push_op(P,T,N,Src)),
  407        colour_state_module(Src, SM),
  408        (   member(Syntax/4, Exports),
  409            load_quasi_quotation_syntax(SM:Path, Syntax),
  410            fail
  411        ;   true
  412        )
  413    ;   true
  414    ).
  415
  416process_use_module2(File, Imports, Src) :-
  417    (   xref_public_list(File, Src,
  418                         [ exports(Exports),
  419                           silent(true),
  420                           path(Path)
  421                         ])
  422    ->  forall(( member(op(P,T,N), Exports),
  423                 member(op(P,T,N), Imports)),
  424               safe_push_op(P,T,N,Src)),
  425        colour_state_module(Src, SM),
  426        (   member(Syntax/4, Exports),
  427            member(Syntax/4, Imports),
  428            load_quasi_quotation_syntax(SM:Path, Syntax),
  429            fail
  430        ;   true
  431        )
  432    ;   true
  433    ).

 prolog_colourise_query(+Query:string, +SourceId, :ColourItem)

Colourise a query, to be executed in the context of SourceId.

Arguments:

SourceId

- Execute Query in the context of the cross-referenced environment SourceID.

  442prolog_colourise_query(QueryString, SourceID, ColourItem) :-
  443    query_colour_state(SourceID, ColourItem, TB),
  444    setup_call_cleanup(
  445        save_settings(TB, [], State),
  446        colourise_query(QueryString, TB),
  447        restore_settings(State)).
  448
  449query_colour_state(module(Module), ColourItem, TB) :-
  450    !,
  451    make_colour_state([ source_id_list([]),
  452                        module(Module),
  453                        closure(ColourItem)
  454                      ],
  455                      TB).
  456query_colour_state(SourceID, ColourItem, TB) :-
  457    to_list(SourceID, SourceIDList),
  458    make_colour_state([ source_id_list(SourceIDList),
  459                        closure(ColourItem)
  460                      ],
  461                      TB).
  462
  463
  464colourise_query(QueryString, TB) :-
  465    colour_state_module(TB, SM),
  466    string_length(QueryString, End),
  467    (   catch(term_string(Query, QueryString,
  468                          [ subterm_positions(TermPos),
  469                            singletons(Singletons0),
  470                            module(SM),
  471                            comments(Comments)
  472                          ]),
  473              E,
  474              read_error(E, TB, 0, End))
  475    ->  warnable_singletons(Singletons0, Singletons),
  476        colour_state_singletons(TB, Singletons),
  477        colourise_comments(Comments, TB),
  478        (   Query == end_of_file
  479        ->  true
  480        ;   colourise_body(Query, TB, TermPos)
  481        )
  482    ;   true                        % only a syntax error
  483    ).

 prolog_colourise_term(+Stream, +SourceID, :ColourItem, +Options)

Colourise the next term on Stream. Unlike prolog_colourise_stream/3, this predicate assumes it is reading a single term rather than the entire stream. This implies that it cannot adjust syntax according to directives that precede it.

Options:

subterm_positions(-TermPos)

Return complete term-layout. If an error is read, this is a term error_position(StartClause, EndClause, ErrorPos)

  498prolog_colourise_term(Stream, SourceId, ColourItem, Options) :-
  499    to_list(SourceId, SourceIdList),
  500    make_colour_state([ source_id_list(SourceIdList),
  501                        stream(Stream),
  502                        closure(ColourItem)
  503                      ],
  504                      TB),
  505    option(subterm_positions(TermPos), Options, _),
  506    findall(Op, xref_op(SourceId, Op), Ops),
  507    debug(colour, 'Ops from ~p: ~p', [SourceId, Ops]),
  508    findall(Opt, xref_flag_option(SourceId, Opt), Opts),
  509    character_count(Stream, Start),
  510    (   source_module(TB, Module)
  511    ->  true
  512    ;   Module = prolog_colour_ops
  513    ),
  514    read_source_term_at_location(
  515        Stream, Term,
  516        [ module(Module),
  517          operators(Ops),
  518          error(Error),
  519          subterm_positions(TermPos),
  520          singletons(Singletons0),
  521          comments(Comments)
  522        | Opts
  523        ]),
  524    (   var(Error)
  525    ->  warnable_singletons(Singletons0, Singletons),
  526        colour_state_singletons(TB, Singletons),
  527        colour_item(range, TB, TermPos),            % Call to allow clearing
  528        colourise_term(Term, TB, TermPos, Comments)
  529    ;   character_count(Stream, End),
  530        TermPos = error_position(Start, End, Pos),
  531        colour_item(range, TB, TermPos),
  532        show_syntax_error(TB, Error, Start-End),
  533        Error = Pos:_Message
  534    ).
  535
  536xref_flag_option(TB, var_prefix(Bool)) :-
  537    xref_prolog_flag(TB, var_prefix, Bool, _Line).
  538
  539show_syntax_error(TB, Pos:Message, Range) :-
  540    integer(Pos),
  541    !,
  542    End is Pos + 1,
  543    colour_item(syntax_error(Message, Range), TB, Pos-End).
  544show_syntax_error(TB, _:Message, Range) :-
  545    colour_item(syntax_error(Message, Range), TB, Range).
  546
  547
  548singleton(Var, TB) :-
  549    colour_state_singletons(TB, Singletons),
  550    member_var(Var, Singletons).
  551
  552member_var(V, [_=V2|_]) :-
  553    V == V2,
  554    !.
  555member_var(V, [_|T]) :-
  556    member_var(V, T).

 colourise_term(+Term, +TB, +Termpos, +Comments)

Colourise the next Term.

bug

- The colour spec is closed with fullstop, but the position information does not include the full stop location, so all we can do is assume it is behind the term.

  567colourise_term(Term, TB, TermPos, Comments) :-
  568    colourise_comments(Comments, TB),
  569    (   Term == end_of_file
  570    ->  true
  571    ;   colourise_term(Term, TB, TermPos),
  572        colourise_fullstop(TB, TermPos)
  573    ).
  574
  575colourise_fullstop(TB, TermPos) :-
  576    arg(2, TermPos, EndTerm),
  577    Start is EndTerm,
  578    End is Start+1,
  579    colour_item(fullstop, TB, Start-End).
  580
  581colourise_comments(-, _).
  582colourise_comments([], _).
  583colourise_comments([H|T], TB) :-
  584    colourise_comment(H, TB),
  585    colourise_comments(T, TB).
  586
  587colourise_comment((-)-_, _) :- !.
  588colourise_comment(Pos-Comment, TB) :-
  589    comment_style(Comment, Style),
  590    stream_position_data(char_count, Pos, Start),
  591    string_length(Comment, Len),
  592    End is Start + Len + 1,
  593    colour_item(comment(Style), TB, Start-End).
  594
  595comment_style(Comment, structured) :-           % Starts %%, %! or /**
  596    structured_comment_start(Start),
  597    sub_string(Comment, 0, Len, _, Start),
  598    Next is Len+1,
  599    string_code(Next, Comment, NextCode),
  600    code_type(NextCode, space),
  601    !.
  602comment_style(Comment, line) :-                 % Starts %
  603    sub_string(Comment, 0, _, _, '%'),
  604    !.
  605comment_style(_, block).                        % Starts /*

 structured_comment_start(-Start)

Copied from library(pldoc/doc_process). Unfortunate, but we do not want to force loading pldoc.

  612structured_comment_start('%%').
  613structured_comment_start('%!').
  614structured_comment_start('/**').

 colourise_term(+Term, +TB, +Pos)

Colorise a file toplevel term.

  620colourise_term(Var, TB, Start-End) :-
  621    var(Var),
  622    !,
  623    colour_item(instantiation_error, TB, Start-End).
  624colourise_term(_, _, Pos) :-
  625    var(Pos),
  626    !.
  627colourise_term(Term, TB, parentheses_term_position(PO,PC,Pos)) :-
  628    !,
  629    colour_item(parentheses, TB, PO-PC),
  630    colourise_term(Term, TB, Pos).
  631colourise_term(Term, TB, Pos) :-
  632    term_colours(Term, FuncSpec-ArgSpecs),
  633    !,
  634    Pos = term_position(F,T,FF,FT,ArgPos),
  635    colour_item(term, TB, F-T),     % TBD: Allow specifying by term_colours/2?
  636    specified_item(FuncSpec, Term, TB, FF-FT),
  637    specified_items(ArgSpecs, Term, TB, ArgPos).
  638colourise_term((Pre=>Body), TB,
  639               term_position(F,T,FF,FT,[PP,BP])) :-
  640    nonvar(Pre),
  641    Pre = (Head,Cond),
  642    PP = term_position(_HF,_HT,_HFF,_HFT,[HP,CP]),
  643    !,
  644    colour_item(clause,         TB, F-T),
  645    colour_item(neck(=>),       TB, FF-FT),
  646    colourise_clause_head(Head, TB, HP),
  647    colour_item(rule_condition, TB, CP),
  648    colourise_body(Cond, Head,  TB, CP),
  649    colourise_body(Body, Head,  TB, BP).
  650colourise_term(Term, TB,
  651               term_position(F,T,FF,FT,[HP,BP])) :-
  652    neck(Term, Head, Body, Neck),
  653    !,
  654    colour_item(clause,         TB, F-T),
  655    colour_item(neck(Neck),     TB, FF-FT),
  656    colourise_clause_head(Head, TB, HP),
  657    colourise_body(Body, Head,  TB, BP).
  658colourise_term(((Head,RHC) --> Body), TB,
  659               term_position(F,T,FF,FT,
  660                             [ term_position(_,_,_,_,[HP,RHCP]),
  661                               BP
  662                             ])) :-
  663    !,
  664    colour_item(grammar_rule,       TB, F-T),
  665    colour_item(dcg_right_hand_ctx, TB, RHCP),
  666    colourise_term_arg(RHC, TB, RHCP),
  667    colour_item(neck(-->),          TB, FF-FT),
  668    colourise_extended_head(Head, 2, TB, HP),
  669    colourise_dcg(Body, Head,       TB, BP).
  670colourise_term((Head --> Body), TB,                     % TBD: expansion!
  671               term_position(F,T,FF,FT,[HP,BP])) :-
  672    !,
  673    colour_item(grammar_rule,       TB, F-T),
  674    colour_item(neck(-->),          TB, FF-FT),
  675    colourise_extended_head(Head, 2, TB, HP),
  676    colourise_dcg(Body, Head,       TB, BP).
  677colourise_term(:->(Head, Body), TB,
  678               term_position(F,T,FF,FT,[HP,BP])) :-
  679    !,
  680    colour_item(method,             TB, F-T),
  681    colour_item(neck(:->), TB, FF-FT),
  682    colour_method_head(send(Head),  TB, HP),
  683    colourise_method_body(Body,     TB, BP).
  684colourise_term(:<-(Head, Body), TB,
  685               term_position(F,T,FF,FT,[HP,BP])) :-
  686    !,
  687    colour_item(method,            TB, F-T),
  688    colour_item(neck(:<-), TB, FF-FT),
  689    colour_method_head(get(Head),  TB, HP),
  690    colourise_method_body(Body,    TB, BP).
  691colourise_term((:- Directive), TB, Pos) :-
  692    !,
  693    colour_item(directive, TB, Pos),
  694    Pos = term_position(_F,_T,FF,FT,[ArgPos]),
  695    colour_item(neck(directive), TB, FF-FT),
  696    colourise_directive(Directive, TB, ArgPos).
  697colourise_term((?- Directive), TB, Pos) :-
  698    !,
  699    colourise_term((:- Directive), TB, Pos).
  700colourise_term(end_of_file, _, _) :- !.
  701colourise_term(Fact, TB, Pos) :-
  702    !,
  703    colour_item(clause, TB, Pos),
  704    colourise_clause_head(Fact, TB, Pos).
  705
  706neck((Head  :- Body), Head, Body, :-).
  707neck((Head  => Body), Head, Body, =>).
  708neck(?=>(Head, Body), Head, Body, ?=>).

 colourise_extended_head(+Head, +ExtraArgs, +TB, +Pos) is det

Colourise a clause-head that is extended by term_expansion, getting ExtraArgs more arguments (e.g., DCGs add two more arguments.

  716colourise_extended_head(Head, N, TB, Pos) :-
  717    extend(Head, N, TheHead),
  718    colourise_clause_head(TheHead, TB, Pos).
  719
  720extend(M:Head, N, M:ExtHead) :-
  721    nonvar(Head),
  722    !,
  723    extend(Head, N, ExtHead).
  724extend(Head, N, ExtHead) :-
  725    compound(Head),
  726    !,
  727    compound_name_arguments(Head, Name, Args),
  728    length(Extra, N),
  729    append(Args, Extra, NArgs),
  730    compound_name_arguments(ExtHead, Name, NArgs).
  731extend(Head, N, ExtHead) :-
  732    atom(Head),
  733    !,
  734    length(Extra, N),
  735    compound_name_arguments(ExtHead, Head, Extra).
  736extend(Head, _, Head).
  737
  738
  739colourise_clause_head(_, _, Pos) :-
  740    var(Pos),
  741    !.
  742colourise_clause_head(Head, TB, parentheses_term_position(PO,PC,Pos)) :-
  743    colour_item(parentheses, TB, PO-PC),
  744    colourise_clause_head(Head, TB, Pos).
  745colourise_clause_head(M:Head, TB, QHeadPos) :-
  746    QHeadPos = term_position(_,_,QF,QT,[MPos,HeadPos]),
  747    head_colours(M:Head, meta-[_, ClassSpec-ArgSpecs]),
  748    !,
  749    colourise_module(M, TB, MPos),
  750    colour_item(functor, TB, QF-QT),
  751    functor_position(HeadPos, FPos, ArgPos),
  752    (   ClassSpec == classify
  753    ->  classify_head(TB, Head, Class)
  754    ;   Class = ClassSpec
  755    ),
  756    colour_item(head_term(Class, Head), TB, QHeadPos),
  757    colour_item(head(Class, Head), TB, FPos),
  758    specified_items(ArgSpecs, Head, TB, ArgPos).
  759colourise_clause_head(Head, TB, Pos) :-
  760    head_colours(Head, ClassSpec-ArgSpecs),
  761    !,
  762    functor_position(Pos, FPos, ArgPos),
  763    (   ClassSpec == classify
  764    ->  classify_head(TB, Head, Class)
  765    ;   Class = ClassSpec
  766    ),
  767    colour_item(head_term(Class, Head), TB, Pos),
  768    colour_item(head(Class, Head), TB, FPos),
  769    specified_items(ArgSpecs, Head, TB, ArgPos).
  770colourise_clause_head(:=(Eval, Ret), TB,
  771                      term_position(_,_,AF,AT,
  772                                    [ term_position(_,_,SF,ST,
  773                                                    [ SelfPos,
  774                                                      FuncPos
  775                                                    ]),
  776                                      RetPos
  777                                    ])) :-
  778    Eval =.. [.,M,Func],
  779    FuncPos = term_position(_,_,FF,FT,_),
  780    !,
  781    colourise_term_arg(M, TB, SelfPos),
  782    colour_item(func_dot, TB, SF-ST),               % .
  783    colour_item(dict_function(Func), TB, FF-FT),
  784    colourise_term_args(Func, TB, FuncPos),
  785    colour_item(dict_return_op, TB, AF-AT),         % :=
  786    colourise_term_arg(Ret, TB, RetPos).
  787colourise_clause_head(Head, TB, Pos) :-
  788    functor_position(Pos, FPos, _),
  789    classify_head(TB, Head, Class),
  790    colour_item(head_term(Class, Head), TB, Pos),
  791    colour_item(head(Class, Head), TB, FPos),
  792    colourise_term_args(Head, TB, Pos).

 colourise_extern_head(+Head, +Module, +TB, +Pos)

Colourise the head specified as Module:Head. Normally used for adding clauses to multifile predicates in other modules.

  799colourise_extern_head(Head, M, TB, Pos) :-
  800    functor_position(Pos, FPos, _),
  801    colour_item(head(extern(M), Head), TB, FPos),
  802    colourise_term_args(Head, TB, Pos).
  803
  804colour_method_head(SGHead, TB, Pos) :-
  805    arg(1, SGHead, Head),
  806    functor_name(SGHead, SG),
  807    functor_position(Pos, FPos, _),
  808    colour_item(method(SG), TB, FPos),
  809    colourise_term_args(Head, TB, Pos).

 functor_position(+Term, -FunctorPos, -ArgPosList)

Get the position of a functor and its argument. Unfortunately this goes wrong for lists, who have two `functor-positions'.

  816functor_position(term_position(_,_,FF,FT,ArgPos), FF-FT, ArgPos) :- !.
  817functor_position(list_position(F,_T,Elms,none), F-FT, Elms) :-
  818    !,
  819    FT is F + 1.
  820functor_position(dict_position(_,_,FF,FT,KVPos), FF-FT, KVPos) :- !.
  821functor_position(brace_term_position(F,T,Arg), F-T, [Arg]) :- !.
  822functor_position(Pos, Pos, []).
  823
  824colourise_module(Term, TB, Pos) :-
  825    (   var(Term)
  826    ;   atom(Term)
  827    ),
  828    !,
  829    colour_item(module(Term), TB, Pos).
  830colourise_module(_, TB, Pos) :-
  831    colour_item(type_error(module), TB, Pos).

 colourise_directive(+Body, +TB, +Pos)

Colourise the body of a directive.

  837colourise_directive(_,_,Pos) :-
  838    var(Pos),
  839    !.
  840colourise_directive(Dir, TB, parentheses_term_position(PO,PC,Pos)) :-
  841    !,
  842    colour_item(parentheses, TB, PO-PC),
  843    colourise_directive(Dir, TB, Pos).
  844colourise_directive((A,B), TB, term_position(_,_,_,_,[PA,PB])) :-
  845    !,
  846    colourise_directive(A, TB, PA),
  847    colourise_directive(B, TB, PB).
  848colourise_directive(Body, TB, Pos) :-
  849    nonvar(Body),
  850    directive_colours(Body, ClassSpec-ArgSpecs),   % specified
  851    !,
  852    functor_position(Pos, FPos, ArgPos),
  853    (   ClassSpec == classify
  854    ->  goal_classification(TB, Body, [], Class)
  855    ;   Class = ClassSpec
  856    ),
  857    colour_item(goal(Class, Body), TB, FPos),
  858    specified_items(ArgSpecs, Body, TB, ArgPos).
  859colourise_directive(Body, TB, Pos) :-
  860    colourise_body(Body, TB, Pos).
  861
  862
  863%       colourise_body(+Body, +TB, +Pos)
  864%
  865%       Breaks down to colourise_goal/3.
  866
  867colourise_body(Body, TB, Pos) :-
  868    colourise_body(Body, [], TB, Pos).
  869
  870colourise_body(Body, Origin, TB, Pos) :-
  871    colour_item(body, TB, Pos),
  872    colourise_goals(Body, Origin, TB, Pos).

 colourise_method_body(+MethodBody, +TB, +Pos)

Colourise the optional "comment":: as pce(comment) and proceed with the body.

To be done

- Get this handled by a hook.

  881colourise_method_body(_, _, Pos) :-
  882    var(Pos),
  883    !.
  884colourise_method_body(Body, TB, parentheses_term_position(PO,PC,Pos)) :-
  885    !,
  886    colour_item(parentheses, TB, PO-PC),
  887    colourise_method_body(Body, TB, Pos).
  888colourise_method_body(::(_Comment,Body), TB,
  889                      term_position(_F,_T,_FF,_FT,[CP,BP])) :-
  890    !,
  891    colour_item(comment(string), TB, CP),
  892    colourise_body(Body, TB, BP).
  893colourise_method_body(Body, TB, Pos) :-         % deal with pri(::) < 1000
  894    Body =.. [F,A,B],
  895    control_op(F),
  896    !,
  897    Pos = term_position(_F,_T,FF,FT,
  898                        [ AP,
  899                          BP
  900                        ]),
  901    colour_item(control, TB, FF-FT),
  902    colourise_method_body(A, TB, AP),
  903    colourise_body(B, TB, BP).
  904colourise_method_body(Body, TB, Pos) :-
  905    colourise_body(Body, TB, Pos).
  906
  907control_op(',').
  908control_op((;)).
  909control_op((->)).
  910control_op((*->)).

 colourise_goals(+Body, +Origin, +TB, +Pos)

Colourise the goals in a body.

  916colourise_goals(_, _, _, Pos) :-
  917    var(Pos),
  918    !.
  919colourise_goals(Body, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  920    !,
  921    colour_item(parentheses, TB, PO-PC),
  922    colourise_goals(Body, Origin, TB, Pos).
  923colourise_goals(Body, Origin, TB, term_position(_,_,FF,FT,ArgPos)) :-
  924    body_compiled(Body),
  925    !,
  926    colour_item(control, TB, FF-FT),
  927    colourise_subgoals(ArgPos, 1, Body, Origin, TB).
  928colourise_goals(Goal, Origin, TB, Pos) :-
  929    colourise_goal(Goal, Origin, TB, Pos).
  930
  931colourise_subgoals([], _, _, _, _).
  932colourise_subgoals([Pos|T], N, Body, Origin, TB) :-
  933    arg(N, Body, Arg),
  934    colourise_goals(Arg, Origin, TB, Pos),
  935    NN is N + 1,
  936    colourise_subgoals(T, NN, Body, Origin, TB).

 colourise_dcg(+Body, +Head, +TB, +Pos)

Breaks down to colourise_dcg_goal/3.

  942colourise_dcg(Body, Head, TB, Pos) :-
  943    colour_item(dcg, TB, Pos),
  944    (   dcg_extend(Head, Origin)
  945    ->  true
  946    ;   Origin = Head
  947    ),
  948    colourise_dcg_goals(Body, Origin, TB, Pos).
  949
  950colourise_dcg_goals(Var, _, TB, Pos) :-
  951    var(Var),
  952    !,
  953    colour_item(goal(meta,Var), TB, Pos).
  954colourise_dcg_goals(_, _, _, Pos) :-
  955    var(Pos),
  956    !.
  957colourise_dcg_goals(Body, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  958    !,
  959    colour_item(parentheses, TB, PO-PC),
  960    colourise_dcg_goals(Body, Origin, TB, Pos).
  961colourise_dcg_goals({Body}, Origin, TB, brace_term_position(F,T,Arg)) :-
  962    !,
  963    colour_item(dcg(plain), TB, F-T),
  964    colourise_goals(Body, Origin, TB, Arg).
  965colourise_dcg_goals([], _, TB, Pos) :-
  966    !,
  967    colour_item(dcg(terminal), TB, Pos).
  968colourise_dcg_goals(List, _, TB, list_position(F,T,Elms,Tail)) :-
  969    List = [_|_],
  970    !,
  971    colour_item(dcg(terminal), TB, F-T),
  972    colourise_list_args(Elms, Tail, List, TB, classify).
  973colourise_dcg_goals(_, _, TB, string_position(F,T)) :-
  974    integer(F),
  975    !,
  976    colour_item(dcg(string), TB, F-T).
  977colourise_dcg_goals(Body, Origin, TB, term_position(_,_,FF,FT,ArgPos)) :-
  978    dcg_body_compiled(Body),       % control structures
  979    !,
  980    colour_item(control, TB, FF-FT),
  981    colourise_dcg_subgoals(ArgPos, 1, Body, Origin, TB).
  982colourise_dcg_goals(Goal, Origin, TB, Pos) :-
  983    colourise_dcg_goal(Goal, Origin, TB, Pos).
  984
  985colourise_dcg_subgoals([], _, _, _, _).
  986colourise_dcg_subgoals([Pos|T], N, Body, Origin, TB) :-
  987    arg(N, Body, Arg),
  988    colourise_dcg_goals(Arg, Origin, TB, Pos),
  989    NN is N + 1,
  990    colourise_dcg_subgoals(T, NN, Body, Origin, TB).
  991
  992dcg_extend(Term, _) :-
  993    var(Term), !, fail.
  994dcg_extend(M:Term, M:Goal) :-
  995    dcg_extend(Term, Goal).
  996dcg_extend(Term, Goal) :-
  997    compound(Term),
  998    !,
  999    compound_name_arguments(Term, Name, Args),
 1000    append(Args, [_,_], NArgs),
 1001    compound_name_arguments(Goal, Name, NArgs).
 1002dcg_extend(Term, Goal) :-
 1003    atom(Term),
 1004    !,
 1005    compound_name_arguments(Goal, Term, [_,_]).
 1006
 1007dcg_body_compiled(G) :-
 1008    body_compiled(G),
 1009    !.
 1010dcg_body_compiled((_|_)).
 1011
 1012%       colourise_dcg_goal(+Goal, +Origin, +TB, +Pos).
 1013
 1014colourise_dcg_goal(!, Origin, TB, TermPos) :-
 1015    !,
 1016    colourise_goal(!, Origin, TB, TermPos).
 1017colourise_dcg_goal(Goal, Origin, TB, TermPos) :-
 1018    dcg_extend(Goal, TheGoal),
 1019    !,
 1020    colourise_goal(TheGoal, Origin, TB, TermPos).
 1021colourise_dcg_goal(Goal, _, TB, Pos) :-
 1022    colourise_term_args(Goal, TB, Pos).

 colourise_goal(+Goal, +Origin, +TB, +Pos)

Colourise access to a single goal.

To be done

- Quasi Quotations are coloured as a general term argument. Possibly we should do something with the goal information it refers to, in particular if this goal is not defined.

 1033                                        % Deal with list as goal (consult)
 1034colourise_goal(_,_,_,Pos) :-
 1035    var(Pos),
 1036    !.
 1037colourise_goal(Goal, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
 1038    !,
 1039    colour_item(parentheses, TB, PO-PC),
 1040    colourise_goal(Goal, Origin, TB, Pos).
 1041colourise_goal(Goal, _, TB, Pos) :-
 1042    Pos = list_position(F,T,Elms,TailPos),
 1043    Goal = [_|_],
 1044    !,
 1045    FT is F + 1,
 1046    AT is T - 1,
 1047    colour_item(goal_term(built_in, Goal), TB, Pos),
 1048    colour_item(goal(built_in, Goal), TB, F-FT),
 1049    colour_item(goal(built_in, Goal), TB, AT-T),
 1050    colourise_file_list(Goal, TB, Elms, TailPos, any).
 1051colourise_goal(Goal, Origin, TB, Pos) :-
 1052    Pos = list_position(F,T,Elms,Tail),
 1053    callable(Goal),
 1054    Goal =.. [_,GH,GT|_],
 1055    !,
 1056    goal_classification(TB, Goal, Origin, Class),
 1057    FT is F + 1,
 1058    AT is T - 1,
 1059    colour_item(goal_term(Class, Goal), TB, Pos),
 1060    colour_item(goal(Class, Goal), TB, F-FT),
 1061    colour_item(goal(Class, Goal), TB, AT-T),
 1062    colourise_list_args(Elms, Tail, [GH|GT], TB, classify).
 1063colourise_goal(Goal, _Origin, TB, Pos) :-
 1064    Pos = quasi_quotation_position(_F,_T,_QQType,_QQTypePos,_CPos),
 1065    !,
 1066    colourise_term_arg(Goal, TB, Pos).
 1067colourise_goal(Goal, Origin, TB, Pos) :-
 1068    strip_module(Goal, _, PGoal),
 1069    nonvar(PGoal),
 1070    (   goal_classification(TB, Goal, Origin, ClassInferred),
 1071        call_goal_colours(Goal, ClassInferred, ClassSpec-ArgSpecs)
 1072    ->  true
 1073    ;   call_goal_colours(Goal, ClassSpec-ArgSpecs)
 1074    ),
 1075    !,                                          % specified
 1076    functor_position(Pos, FPos, ArgPos),
 1077    (   ClassSpec == classify
 1078    ->  goal_classification(TB, Goal, Origin, Class)
 1079    ;   Class = ClassSpec
 1080    ),
 1081    colour_item(goal_term(Class, Goal), TB, Pos),
 1082    colour_item(goal(Class, Goal), TB, FPos),
 1083    colour_dict_braces(TB, Pos),
 1084    specified_items(ArgSpecs, Goal, TB, ArgPos).
 1085colourise_goal(Module:Goal, _Origin, TB, QGoalPos) :-
 1086    QGoalPos = term_position(_,_,QF,QT,[PM,PG]),
 1087    !,
 1088    colourise_module(Module, TB, PM),
 1089    colour_item(functor, TB, QF-QT),
 1090    (   PG = term_position(_,_,FF,FT,_)
 1091    ->  FP = FF-FT
 1092    ;   FP = PG
 1093    ),
 1094    (   callable(Goal)
 1095    ->  qualified_goal_classification(Module:Goal, TB, Class),
 1096        colour_item(goal_term(Class, Goal), TB, QGoalPos),
 1097        colour_item(goal(Class, Goal), TB, FP),
 1098        colourise_goal_args(Goal, Module, TB, PG)
 1099    ;   var(Goal)
 1100    ->  colourise_term_arg(Goal, TB, PG)
 1101    ;   colour_item(type_error(callable), TB, PG)
 1102    ).
 1103colourise_goal(Op, _Origin, TB, Pos) :-
 1104    nonvar(Op),
 1105    Op = op(_,_,_),
 1106    !,
 1107    colourise_op_declaration(Op, TB, Pos).
 1108colourise_goal(Goal, Origin, TB, Pos) :-
 1109    goal_classification(TB, Goal, Origin, Class),
 1110    (   Pos = term_position(_,_,FF,FT,_ArgPos)
 1111    ->  FPos = FF-FT
 1112    ;   FPos = Pos
 1113    ),
 1114    colour_item(goal_term(Class, Goal), TB, Pos),
 1115    colour_item(goal(Class, Goal), TB, FPos),
 1116    colourise_goal_args(Goal, TB, Pos).
 1117
 1118% make sure to emit a fragment for the braces of tag{k:v, ...} or
 1119% {...} that is mapped to something else.
 1120
 1121colour_dict_braces(TB, dict_position(_F,T,_TF,TT,_KVPos)) :-
 1122    !,
 1123    BStart is TT+1,
 1124    colour_item(dict_content, TB, BStart-T).
 1125colour_dict_braces(TB, brace_term_position(F,T,_Arg)) :-
 1126    !,
 1127    colour_item(brace_term, TB, F-T).
 1128colour_dict_braces(_, _).

 colourise_goal_args(+Goal, +TB, +Pos)

Colourise the arguments to a goal. This predicate deals with meta- and database-access predicates.

 1135colourise_goal_args(Goal, TB, Pos) :-
 1136    colourization_module(TB, Module),
 1137    colourise_goal_args(Goal, Module, TB, Pos).
 1138
 1139colourization_module(TB, Module) :-
 1140    (   colour_state_source_id(TB, SourceId),
 1141        xref_module(SourceId, Module)
 1142    ->  true
 1143    ;   Module = user
 1144    ).
 1145
 1146colourise_goal_args(Goal, M, TB, term_position(_,_,_,_,ArgPos)) :-
 1147    !,
 1148    (   meta_args(Goal, TB, MetaArgs)
 1149    ->  colourise_meta_args(1, Goal, M, MetaArgs, TB, ArgPos)
 1150    ;   colourise_goal_args(1, Goal, M, TB, ArgPos)
 1151    ).
 1152colourise_goal_args(Goal, M, TB, brace_term_position(_,_,ArgPos)) :-
 1153    !,
 1154    (   meta_args(Goal, TB, MetaArgs)
 1155    ->  colourise_meta_args(1, Goal, M, MetaArgs, TB, [ArgPos])
 1156    ;   colourise_goal_args(1, Goal, M, TB, [ArgPos])
 1157    ).
 1158colourise_goal_args(_, _, _, _).                % no arguments
 1159
 1160colourise_goal_args(_, _, _, _, []) :- !.
 1161colourise_goal_args(N, Goal, Module, TB, [P0|PT]) :-
 1162    colourise_option_arg(Goal, Module, N, TB, P0),
 1163    !,
 1164    NN is N + 1,
 1165    colourise_goal_args(NN, Goal, Module, TB, PT).
 1166colourise_goal_args(N, Goal, Module, TB, [P0|PT]) :-
 1167    arg(N, Goal, Arg),
 1168    colourise_term_arg(Arg, TB, P0),
 1169    NN is N + 1,
 1170    colourise_goal_args(NN, Goal, Module, TB, PT).
 1171
 1172
 1173colourise_meta_args(_, _, _, _, _, []) :- !.
 1174colourise_meta_args(N, Goal, Module, MetaArgs, TB, [P0|PT]) :-
 1175    colourise_option_arg(Goal, Module, N, TB, P0),
 1176    !,
 1177    NN is N + 1,
 1178    colourise_meta_args(NN, Goal, Module, MetaArgs, TB, PT).
 1179colourise_meta_args(N, Goal, Module, MetaArgs, TB, [P0|PT]) :-
 1180    arg(N, Goal, Arg),
 1181    arg(N, MetaArgs, MetaSpec),
 1182    colourise_meta_arg(MetaSpec, Arg, TB, P0),
 1183    NN is N + 1,
 1184    colourise_meta_args(NN, Goal, Module, MetaArgs, TB, PT).
 1185
 1186colourise_meta_arg(MetaSpec, Arg, TB, Pos) :-
 1187    nonvar(Arg),
 1188    expand_meta(MetaSpec, Arg, Expanded),
 1189    !,
 1190    colourise_goal(Expanded, [], TB, Pos). % TBD: recursion
 1191colourise_meta_arg(MetaSpec, Arg, TB, Pos) :-
 1192    nonvar(Arg),
 1193    MetaSpec == //,
 1194    !,
 1195    colourise_dcg_goals(Arg, //, TB, Pos).
 1196colourise_meta_arg(_, Arg, TB, Pos) :-
 1197    colourise_term_arg(Arg, TB, Pos).

 meta_args(+Goal, +TB, -ArgSpec) is semidet

Return a copy of Goal, where each meta-argument is an integer representing the number of extra arguments or the atom // for indicating a DCG body. The non-meta arguments are unbound variables.

E.g. meta_args(maplist(foo,x,y), X) --> X = maplist(2,_,_)

NOTE: this could be cached if performance becomes an issue.

 1210meta_args(Goal, TB, VarGoal) :-
 1211    colour_state_source_id(TB, SourceId),
 1212    xref_meta(SourceId, Goal, _),
 1213    !,
 1214    compound_name_arity(Goal, Name, Arity),
 1215    compound_name_arity(VarGoal, Name, Arity),
 1216    xref_meta(SourceId, VarGoal, MetaArgs),
 1217    instantiate_meta(MetaArgs).
 1218
 1219instantiate_meta([]).
 1220instantiate_meta([H|T]) :-
 1221    (   var(H)
 1222    ->  H = 0
 1223    ;   H = V+N
 1224    ->  V = N
 1225    ;   H = //(V)
 1226    ->  V = (//)
 1227    ),
 1228    instantiate_meta(T).

 expand_meta(+MetaSpec, +Goal, -Expanded) is semidet

Add extra arguments to the goal if the meta-specifier is an integer (see above).

 1235expand_meta(MetaSpec, Goal, Goal) :-
 1236    MetaSpec == 0.
 1237expand_meta(MetaSpec, M:Goal, M:Expanded) :-
 1238    atom(M),
 1239    !,
 1240    expand_meta(MetaSpec, Goal, Expanded).
 1241expand_meta(MetaSpec, Goal, Expanded) :-
 1242    integer(MetaSpec),
 1243    MetaSpec > 0,
 1244    (   atom(Goal)
 1245    ->  functor(Expanded, Goal, MetaSpec)
 1246    ;   compound(Goal)
 1247    ->  compound_name_arguments(Goal, Name, Args0),
 1248        length(Extra, MetaSpec),
 1249        append(Args0, Extra, Args),
 1250        compound_name_arguments(Expanded, Name, Args)
 1251    ).

 colourise_setof(+Term, +TB, +Pos)

Colourise the 2nd argument of setof/bagof

 1257colourise_setof(Var^G, TB, term_position(_,_,FF,FT,[VP,GP])) :-
 1258    !,
 1259    colourise_term_arg(Var, TB, VP),
 1260    colour_item(ext_quant, TB, FF-FT),
 1261    colourise_setof(G, TB, GP).
 1262colourise_setof(Term, TB, Pos) :-
 1263    colourise_goal(Term, [], TB, Pos).
 1264
 1265%       colourise_db(+Arg, +TB, +Pos)
 1266%
 1267%       Colourise database modification calls (assert/1, retract/1 and
 1268%       friends.
 1269
 1270colourise_db((Head:-Body), TB, term_position(_,_,_,_,[HP,BP])) :-
 1271    !,
 1272    colourise_db(Head, TB, HP),
 1273    colourise_body(Body, Head, TB, BP).
 1274colourise_db(Module:Head, TB, term_position(_,_,QF,QT,[MP,HP])) :-
 1275    !,
 1276    colourise_module(Module, TB, MP),
 1277    colour_item(functor, TB, QF-QT),
 1278    (   atom(Module),
 1279        colour_state_source_id(TB, SourceId),
 1280        xref_module(SourceId, Module)
 1281    ->  colourise_db(Head, TB, HP)
 1282    ;   colourise_db(Head, TB, HP)
 1283    ).
 1284colourise_db(Head, TB, Pos) :-
 1285    colourise_goal(Head, '<db-change>', TB, Pos).

 colourise_option_args(+Goal, +Module, +Arg:integer, +TB, +ArgPos) is semidet

Colourise predicate options for the Arg-th argument of Module:Goal

 1294colourise_option_arg(Goal, Module, Arg, TB, ArgPos) :-
 1295    goal_name_arity(Goal, Name, Arity),
 1296    current_option_arg(Module:Name/Arity, Arg),
 1297    current_predicate_options(Module:Name/Arity, Arg, OptionDecl),
 1298    debug(emacs, 'Colouring option-arg ~w of ~p',
 1299          [Arg, Module:Name/Arity]),
 1300    arg(Arg, Goal, Options),
 1301    colourise_option(Options, Module, Goal, Arg, OptionDecl, TB, ArgPos).
 1302
 1303colourise_option(Options0, Module, Goal, Arg, OptionDecl, TB, Pos0) :-
 1304    strip_option_module_qualifier(Goal, Module, Arg, TB,
 1305                                  Options0, Pos0, Options, Pos),
 1306    (   Pos = list_position(F, T, ElmPos, TailPos)
 1307    ->  colour_item(list, TB, F-T),
 1308        colourise_option_list(Options, OptionDecl, TB, ElmPos, TailPos)
 1309    ;   (   var(Options)
 1310        ;   Options == []
 1311        )
 1312    ->  colourise_term_arg(Options, TB, Pos)
 1313    ;   colour_item(type_error(list), TB, Pos)
 1314    ).
 1315
 1316strip_option_module_qualifier(Goal, Module, Arg, TB,
 1317                              M:Options, term_position(_,_,_,_,[MP,Pos]),
 1318                              Options, Pos) :-
 1319    predicate_property(Module:Goal, meta_predicate(Head)),
 1320    arg(Arg, Head, :),
 1321    !,
 1322    colourise_module(M, TB, MP).
 1323strip_option_module_qualifier(_, _, _, _,
 1324                              Options, Pos, Options, Pos).
 1325
 1326
 1327colourise_option_list(_, _, _, [], none) :- !.
 1328colourise_option_list(Tail, _, TB, [], TailPos) :-
 1329    !,
 1330    colourise_term_arg(Tail, TB, TailPos).
 1331colourise_option_list([H|T], OptionDecl, TB, [HPos|TPos], TailPos) :-
 1332    colourise_option(H, OptionDecl, TB, HPos),
 1333    colourise_option_list(T, OptionDecl, TB, TPos, TailPos).
 1334
 1335colourise_option(Opt, _, TB, Pos) :-
 1336    var(Opt),
 1337    !,
 1338    colourise_term_arg(Opt, TB, Pos).
 1339colourise_option(Opt, OptionDecl, TB, term_position(_,_,FF,FT,ValPosList)) :-
 1340    !,
 1341    generalise_term(Opt, GenOpt),
 1342    (   memberchk(GenOpt, OptionDecl)
 1343    ->  colour_item(option_name, TB, FF-FT),
 1344        Opt =.. [Name|Values],
 1345        GenOpt =.. [Name|Types],
 1346        colour_option_values(Values, Types, TB, ValPosList)
 1347    ;   colour_item(no_option_name, TB, FF-FT),
 1348        colourise_term_args(ValPosList, 1, Opt, TB)
 1349    ).
 1350colourise_option(_, _, TB, Pos) :-
 1351    colour_item(type_error(option), TB, Pos).
 1352
 1353colour_option_values([], [], _, _).
 1354colour_option_values([V0|TV], [T0|TT], TB, [P0|TP]) :-
 1355    (   (   var(V0)
 1356        ;   is_of_type(T0, V0)
 1357        ;   T0 = list(_),
 1358            member(E, V0),
 1359            var(E)
 1360        ;   dict_field_extraction(V0)
 1361        )
 1362    ->  colourise_term_arg(V0, TB, P0)
 1363    ;   callable(V0),
 1364        (   T0 = callable
 1365        ->  N = 0
 1366        ;   T0 = (callable+N)
 1367        )
 1368    ->  colourise_meta_arg(N, V0, TB, P0)
 1369    ;   colour_item(type_error(T0), TB, P0)
 1370    ),
 1371    colour_option_values(TV, TT, TB, TP).

 colourise_files(+Arg, +TB, +Pos, +Why)

Colourise the argument list of one of the file-loading predicates.

Arguments:

Why	- is one of any or imported

 1380colourise_files(List, TB, list_position(F,T,Elms,TailPos), Why) :-
 1381    !,
 1382    colour_item(list, TB, F-T),
 1383    colourise_file_list(List, TB, Elms, TailPos, Why).
 1384colourise_files(M:Spec, TB, term_position(_,_,_,_,[MP,SP]), Why) :-
 1385    !,
 1386    colourise_module(M, TB, MP),
 1387    colourise_files(Spec, TB, SP, Why).
 1388colourise_files(Var, TB, P, _) :-
 1389    var(Var),
 1390    !,
 1391    colour_item(var, TB, P).
 1392colourise_files(Spec0, TB, Pos, Why) :-
 1393    strip_module(Spec0, _, Spec),
 1394    (   colour_state_source_id(TB, Source),
 1395        prolog_canonical_source(Source, SourceId),
 1396        catch(xref_source_file(Spec, Path, SourceId, [silent(true)]),
 1397              _, fail)
 1398    ->  (   Why = imported,
 1399            \+ resolves_anything(TB, Path),
 1400            exports_something(TB, Path)
 1401        ->  colour_item(file_no_depend(Path), TB, Pos)
 1402        ;   colour_item(file(Path), TB, Pos)
 1403        )
 1404    ;   colour_item(nofile, TB, Pos)
 1405    ).