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-2018, University of Amsterdam
    7                              VU University Amsterdam
    8    All rights reserved.
    9
   10    Redistribution and use in source and binary forms, with or without
   11    modification, are permitted provided that the following conditions
   12    are met:
   13
   14    1. Redistributions of source code must retain the above copyright
   15       notice, this list of conditions and the following disclaimer.
   16
   17    2. Redistributions in binary form must reproduce the above copyright
   18       notice, this list of conditions and the following disclaimer in
   19       the documentation and/or other materials provided with the
   20       distribution.
   21
   22    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   23    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   24    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   25    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
   26    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   27    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   28    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   29    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   30    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   32    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   33    POSSIBILITY OF SUCH DAMAGE.
   34*/
   35
   36:- module(prolog_colour,
   37          [ prolog_colourise_stream/3,  % +Stream, +SourceID, :ColourItem
   38            prolog_colourise_term/4,    % +Stream, +SourceID, :ColourItem, +Opts
   39            prolog_colourise_query/3,   % +String, +SourceID, :ColourItem
   40            syntax_colour/2,            % +Class, -Attributes
   41            syntax_message//1           % +Class
   42          ]).   43:- use_module(library(prolog_xref)).   44:- use_module(library(predicate_options)).   45:- use_module(library(prolog_source)).   46:- use_module(library(lists)).   47:- use_module(library(operators)).   48:- use_module(library(debug)).   49:- use_module(library(error)).   50:- use_module(library(option)).   51:- use_module(library(record)).   52
   53:- meta_predicate
   54    prolog_colourise_stream(+, +, 3),
   55    prolog_colourise_query(+, +, 3),
   56    prolog_colourise_term(+, +, 3, +).   57
   58:- predicate_options(prolog_colourise_term/4, 4,
   59                     [ subterm_positions(-any)
   60                     ]).

   70:- multifile
   71    style/2,                        % +ColourClass, -Attributes
   72    message//1,                     % +ColourClass
   73    term_colours/2,                 % +SourceTerm, -ColourSpec
   74    goal_colours/2,                 % +Goal, -ColourSpec
   75    goal_colours/3,                 % +Goal, +Class, -ColourSpec
   76    directive_colours/2,            % +Goal, -ColourSpec
   77    goal_classification/2,          % +Goal, -Class
   78    vararg_goal_classification/3.   % +Name, +Arity, -Class
   79
   80
   81:- record
   82    colour_state(source_id_list,
   83                 module,
   84                 stream,
   85                 closure,
   86                 singletons).   87
   88colour_state_source_id(State, SourceID) :-
   89    colour_state_source_id_list(State, SourceIDList),
   90    member(SourceID, SourceIDList).

 prolog_colourise_stream(+Stream, +SourceID, :ColourItem) 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).

  105prolog_colourise_stream(Fd, SourceId, ColourItem) :-
  106    to_list(SourceId, SourceIdList),
  107    make_colour_state([ source_id_list(SourceIdList),
  108                        stream(Fd),
  109                        closure(ColourItem)
  110                      ],
  111                      TB),
  112    setup_call_cleanup(
  113        save_settings(TB, State),
  114        colourise_stream(Fd, TB),
  115        restore_settings(State)).
  116
  117to_list(List, List) :-
  118    is_list(List),
  119    !.
  120to_list(One, [One]).
  121
  122
  123colourise_stream(Fd, TB) :-
  124    (   peek_char(Fd, #)            % skip #! script line
  125    ->  skip(Fd, 10)
  126    ;   true
  127    ),
  128    repeat,
  129        colour_state_module(TB, SM),
  130        character_count(Fd, Start),
  131        catch(read_term(Fd, Term,
  132                        [ subterm_positions(TermPos),
  133                          singletons(Singletons0),
  134                          module(SM),
  135                          comments(Comments)
  136                        ]),
  137              E,
  138              read_error(E, TB, Start, Fd)),
  139        fix_operators(Term, SM, TB),
  140        warnable_singletons(Singletons0, Singletons),
  141        colour_state_singletons(TB, Singletons),
  142        (   colourise_term(Term, TB, TermPos, Comments)
  143        ->  true
  144        ;   arg(1, TermPos, From),
  145            print_message(warning,
  146                          format('Failed to colourise ~p at index ~d~n',
  147                                 [Term, From]))
  148        ),
  149        Term == end_of_file,
  150    !.
  151
  152save_settings(TB, state(Style, Flags, OSM, Xref)) :-
  153    (   source_module(TB, SM)
  154    ->  true
  155    ;   SM = prolog_colour_ops
  156    ),
  157    set_xref(Xref, true),
  158    '$set_source_module'(OSM, SM),
  159    colour_state_module(TB, SM),
  160    push_operators([]),
  161    syntax_flags(Flags),
  162    '$style_check'(Style, Style).
  163
  164restore_settings(state(Style, Flags, OSM, Xref)) :-
  165    restore_syntax_flags(Flags),
  166    '$style_check'(_, Style),
  167    pop_operators,
  168    '$set_source_module'(OSM),
  169    set_xref(_, Xref).
  170
  171set_xref(Old, New) :-
  172    current_prolog_flag(xref, Old),
  173    !,
  174    set_prolog_flag(xref, New).
  175set_xref(false, New) :-
  176    set_prolog_flag(xref, New).
  177
  178
  179syntax_flags(Pairs) :-
  180    findall(set_prolog_flag(Flag, Value),
  181            syntax_flag(Flag, Value),
  182            Pairs).
  183
  184syntax_flag(Flag, Value) :-
  185    syntax_flag(Flag),
  186    current_prolog_flag(Flag, Value).
  187
  188restore_syntax_flags([]).
  189restore_syntax_flags([set_prolog_flag(Flag, Value)|T]) :-
  190    set_prolog_flag(Flag, Value),
  191    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.

  200source_module(TB, Module) :-
  201    colour_state_source_id_list(TB, []),
  202    !,
  203    colour_state_module(TB, Module).
  204source_module(TB, Module) :-
  205    colour_state_source_id(TB, SourceId),
  206    xref_option(SourceId, module(Module)),
  207    !.
  208source_module(TB, Module) :-
  209    (   colour_state_source_id(TB, File),
  210        atom(File)
  211    ;   colour_state_stream(TB, Fd),
  212        is_stream(Fd),
  213        stream_property(Fd, file_name(File))
  214    ),
  215    module_context(File, [], Module).
  216
  217module_context(File, _, Module) :-
  218    source_file_property(File, module(Module)),
  219    !.
  220module_context(File, Seen, Module) :-
  221    source_file_property(File, included_in(File2, _Line)),
  222    \+ memberchk(File, Seen),
  223    !,
  224    module_context(File2, [File|Seen], Module).
  225module_context(File, _, Module) :-
  226    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.

  233read_error(Error, TB, Start, EndSpec) :-
  234    (   syntax_error(Error, Id, CharNo)
  235    ->  message_to_string(error(syntax_error(Id), _), Msg),
  236        (   integer(EndSpec)
  237        ->  End = EndSpec
  238        ;   character_count(EndSpec, End)
  239        ),
  240        show_syntax_error(TB, CharNo:Msg, Start-End),
  241        fail
  242    ;   throw(Error)
  243    ).
  244
  245syntax_error(error(syntax_error(Id), stream(_S, _Line, _LinePos, CharNo)),
  246             Id, CharNo).
  247syntax_error(error(syntax_error(Id), file(_S, _Line, _LinePos, CharNo)),
  248             Id, CharNo).
  249syntax_error(error(syntax_error(Id), string(_Text, CharNo)),
  250             Id, CharNo).

 warnable_singletons(+Singletons, -Warn) is det

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

  256warnable_singletons([], []).
  257warnable_singletons([H|T0], List) :-
  258    H = (Name=_Var),
  259    (   '$is_named_var'(Name)
  260    ->  List = [H|T]
  261    ;   List = T
  262    ),
  263    warnable_singletons(T0, T).

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

  267colour_item(Class, TB, Pos) :-
  268    arg(1, Pos, Start),
  269    arg(2, Pos, End),
  270    Len is End - Start,
  271    colour_state_closure(TB, Closure),
  272    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.

  280safe_push_op(P, T, N0, State) :-
  281    colour_state_module(State, CM),
  282    strip_module(CM:N0, M, N),
  283    (   is_list(N),
  284        N \== []                                % define list as operator
  285    ->  acyclic_term(N),
  286        forall(member(Name, N),
  287               safe_push_op(P, T, M:Name, State))
  288    ;   push_op(P, T, M:N)
  289    ),
  290    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.

  298fix_operators((:- Directive), M, Src) :-
  299    ground(Directive),
  300    catch(process_directive(Directive, M, Src), _, true),
  301    !.
  302fix_operators(_, _, _).
  303
  304process_directive(style_check(X), _, _) :-
  305    !,
  306    style_check(X).
  307process_directive(set_prolog_flag(Flag, Value), M, _) :-
  308    syntax_flag(Flag),
  309    !,
  310    set_prolog_flag(M:Flag, Value).
  311process_directive(M:op(P,T,N), _, Src) :-
  312    !,
  313    process_directive(op(P,T,N), M, Src).
  314process_directive(op(P,T,N), M, Src) :-
  315    !,
  316    safe_push_op(P, T, M:N, Src).
  317process_directive(module(_Name, Export), M, Src) :-
  318    !,
  319    forall(member(op(P,A,N), Export),
  320           safe_push_op(P,A,M:N, Src)).
  321process_directive(use_module(Spec), _, Src) :-
  322    !,
  323    catch(process_use_module1(Spec, Src), _, true).
  324process_directive(use_module(Spec, Imports), _, Src) :-
  325    !,
  326    catch(process_use_module2(Spec, Imports, Src), _, true).
  327process_directive(Directive, _, Src) :-
  328    prolog_source:expand((:-Directive), Src, _).
  329
  330syntax_flag(character_escapes).
  331syntax_flag(var_prefix).
  332syntax_flag(allow_variable_name_as_functor).
  333syntax_flag(allow_dot_in_atom).

 process_use_module1(+Imports, +Src)

Get the exported operators from the referenced files.

  339process_use_module1([], _) :- !.
  340process_use_module1([H|T], Src) :-
  341    !,
  342    process_use_module1(H, Src),
  343    process_use_module1(T, Src).
  344process_use_module1(File, Src) :-
  345    (   xref_public_list(File, Src,
  346                         [ exports(Exports),
  347                           silent(true),
  348                           path(Path)
  349                         ])
  350    ->  forall(member(op(P,T,N), Exports),
  351               safe_push_op(P,T,N,Src)),
  352        colour_state_module(Src, SM),
  353        (   member(Syntax/4, Exports),
  354            load_quasi_quotation_syntax(SM:Path, Syntax),
  355            fail
  356        ;   true
  357        )
  358    ;   true
  359    ).
  360
  361process_use_module2(File, Imports, Src) :-
  362    (   xref_public_list(File, Src,
  363                         [ exports(Exports),
  364                           silent(true),
  365                           path(Path)
  366                         ])
  367    ->  forall(( member(op(P,T,N), Exports),
  368                 member(op(P,T,N), Imports)),
  369               safe_push_op(P,T,N,Src)),
  370        colour_state_module(Src, SM),
  371        (   member(Syntax/4, Exports),
  372            member(Syntax/4, Imports),
  373            load_quasi_quotation_syntax(SM:Path, Syntax),
  374            fail
  375        ;   true
  376        )
  377    ;   true
  378    ).

 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.

  387prolog_colourise_query(QueryString, SourceID, ColourItem) :-
  388    query_colour_state(SourceID, ColourItem, TB),
  389    setup_call_cleanup(
  390        save_settings(TB, State),
  391        colourise_query(QueryString, TB),
  392        restore_settings(State)).
  393
  394query_colour_state(module(Module), ColourItem, TB) :-
  395    !,
  396    make_colour_state([ source_id_list([]),
  397                        module(Module),
  398                        closure(ColourItem)
  399                      ],
  400                      TB).
  401query_colour_state(SourceID, ColourItem, TB) :-
  402    to_list(SourceID, SourceIDList),
  403    make_colour_state([ source_id_list(SourceIDList),
  404                        closure(ColourItem)
  405                      ],
  406                      TB).
  407
  408
  409colourise_query(QueryString, TB) :-
  410    colour_state_module(TB, SM),
  411    string_length(QueryString, End),
  412    (   catch(term_string(Query, QueryString,
  413                          [ subterm_positions(TermPos),
  414                            singletons(Singletons0),
  415                            module(SM),
  416                            comments(Comments)
  417                          ]),
  418              E,
  419              read_error(E, TB, 0, End))
  420    ->  warnable_singletons(Singletons0, Singletons),
  421        colour_state_singletons(TB, Singletons),
  422        colourise_comments(Comments, TB),
  423        (   Query == end_of_file
  424        ->  true
  425        ;   colourise_body(Query, TB, TermPos)
  426        )
  427    ;   true                        % only a syntax error
  428    ).

 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 preceed it.

Options:

subterm_positions(-TermPos)

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

  443prolog_colourise_term(Stream, SourceId, ColourItem, Options) :-
  444    to_list(SourceId, SourceIdList),
  445    make_colour_state([ source_id_list(SourceIdList),
  446                        stream(Stream),
  447                        closure(ColourItem)
  448                      ],
  449                      TB),
  450    option(subterm_positions(TermPos), Options, _),
  451    findall(Op, xref_op(SourceId, Op), Ops),
  452    debug(colour, 'Ops from ~p: ~p', [SourceId, Ops]),
  453    findall(Opt, xref_flag_option(SourceId, Opt), Opts),
  454    character_count(Stream, Start),
  455    (   source_module(TB, Module)
  456    ->  true
  457    ;   Module = prolog_colour_ops
  458    ),
  459    read_source_term_at_location(
  460        Stream, Term,
  461        [ module(Module),
  462          operators(Ops),
  463          error(Error),
  464          subterm_positions(TermPos),
  465          singletons(Singletons0),
  466          comments(Comments)
  467        | Opts
  468        ]),
  469    (   var(Error)
  470    ->  warnable_singletons(Singletons0, Singletons),
  471        colour_state_singletons(TB, Singletons),
  472        colour_item(range, TB, TermPos),            % Call to allow clearing
  473        colourise_term(Term, TB, TermPos, Comments)
  474    ;   character_count(Stream, End),
  475        TermPos = error_position(Start, End, Pos),
  476        colour_item(range, TB, TermPos),
  477        show_syntax_error(TB, Error, Start-End),
  478        Error = Pos:_Message
  479    ).
  480
  481xref_flag_option(TB, var_prefix(Bool)) :-
  482    xref_prolog_flag(TB, var_prefix, Bool, _Line).
  483
  484show_syntax_error(TB, Pos:Message, Range) :-
  485    integer(Pos),
  486    !,
  487    End is Pos + 1,
  488    colour_item(syntax_error(Message, Range), TB, Pos-End).
  489show_syntax_error(TB, _:Message, Range) :-
  490    colour_item(syntax_error(Message, Range), TB, Range).
  491
  492
  493singleton(Var, TB) :-
  494    colour_state_singletons(TB, Singletons),
  495    member_var(Var, Singletons).
  496
  497member_var(V, [_=V2|_]) :-
  498    V == V2,
  499    !.
  500member_var(V, [_|T]) :-
  501    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.

  512colourise_term(Term, TB, TermPos, Comments) :-
  513    colourise_comments(Comments, TB),
  514    (   Term == end_of_file
  515    ->  true
  516    ;   colourise_term(Term, TB, TermPos),
  517        colourise_fullstop(TB, TermPos)
  518    ).
  519
  520colourise_fullstop(TB, TermPos) :-
  521    arg(2, TermPos, EndTerm),
  522    Start is EndTerm,
  523    End is Start+1,
  524    colour_item(fullstop, TB, Start-End).
  525
  526colourise_comments(-, _).
  527colourise_comments([], _).
  528colourise_comments([H|T], TB) :-
  529    colourise_comment(H, TB),
  530    colourise_comments(T, TB).
  531
  532colourise_comment((-)-_, _) :- !.
  533colourise_comment(Pos-Comment, TB) :-
  534    comment_style(Comment, Style),
  535    stream_position_data(char_count, Pos, Start),
  536    string_length(Comment, Len),
  537    End is Start + Len + 1,
  538    colour_item(comment(Style), TB, Start-End).
  539
  540comment_style(Comment, structured) :-           % Starts %%, %! or /**
  541    structured_comment_start(Start),
  542    sub_string(Comment, 0, Len, _, Start),
  543    Next is Len+1,
  544    string_code(Next, Comment, NextCode),
  545    code_type(NextCode, space),
  546    !.
  547comment_style(Comment, line) :-                 % Starts %
  548    sub_string(Comment, 0, _, _, '%'),
  549    !.
  550comment_style(_, block).                        % Starts /*

 structured_comment_start(-Start)

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

  557structured_comment_start('%%').
  558structured_comment_start('%!').
  559structured_comment_start('/**').

 colourise_term(+Term, +TB, +Pos)

Colorise a file toplevel term.

  565colourise_term(Var, TB, Start-End) :-
  566    var(Var),
  567    !,
  568    colour_item(instantiation_error, TB, Start-End).
  569colourise_term(_, _, Pos) :-
  570    var(Pos),
  571    !.
  572colourise_term(Term, TB, parentheses_term_position(PO,PC,Pos)) :-
  573    !,
  574    colour_item(parentheses, TB, PO-PC),
  575    colourise_term(Term, TB, Pos).
  576colourise_term(Term, TB, Pos) :-
  577    term_colours(Term, FuncSpec-ArgSpecs),
  578    !,
  579    Pos = term_position(F,T,FF,FT,ArgPos),
  580    colour_item(term, TB, F-T),     % TBD: Allow specifying by term_colours/2?
  581    specified_item(FuncSpec, Term, TB, FF-FT),
  582    specified_items(ArgSpecs, Term, TB, ArgPos).
  583colourise_term((Head :- Body), TB,
  584               term_position(F,T,FF,FT,[HP,BP])) :-
  585    !,
  586    colour_item(clause,         TB, F-T),
  587    colour_item(neck(clause),   TB, FF-FT),
  588    colourise_clause_head(Head, TB, HP),
  589    colourise_body(Body, Head,  TB, BP).
  590colourise_term(((Head,RHC) --> Body), TB,
  591               term_position(F,T,FF,FT,
  592                             [ term_position(_,_,_,_,[HP,RHCP]),
  593                               BP
  594                             ])) :-
  595    !,
  596    colour_item(grammar_rule,       TB, F-T),
  597    colour_item(dcg_right_hand_ctx, TB, RHCP),
  598    colourise_term_arg(RHC, TB, RHCP),
  599    colour_item(neck(grammar_rule), TB, FF-FT),
  600    colourise_extended_head(Head, 2, TB, HP),
  601    colourise_dcg(Body, Head,       TB, BP).
  602colourise_term((Head --> Body), TB,                     % TBD: expansion!
  603               term_position(F,T,FF,FT,[HP,BP])) :-
  604    !,
  605    colour_item(grammar_rule,       TB, F-T),
  606    colour_item(neck(grammar_rule), TB, FF-FT),
  607    colourise_extended_head(Head, 2, TB, HP),
  608    colourise_dcg(Body, Head,       TB, BP).
  609colourise_term(:->(Head, Body), TB,
  610               term_position(F,T,FF,FT,[HP,BP])) :-
  611    !,
  612    colour_item(method,             TB, F-T),
  613    colour_item(neck(method(send)), TB, FF-FT),
  614    colour_method_head(send(Head),  TB, HP),
  615    colourise_method_body(Body,     TB, BP).
  616colourise_term(:<-(Head, Body), TB,
  617               term_position(F,T,FF,FT,[HP,BP])) :-
  618    !,
  619    colour_item(method,            TB, F-T),
  620    colour_item(neck(method(get)), TB, FF-FT),
  621    colour_method_head(get(Head),  TB, HP),
  622    colourise_method_body(Body,    TB, BP).
  623colourise_term((:- Directive), TB, Pos) :-
  624    !,
  625    colour_item(directive, TB, Pos),
  626    Pos = term_position(_F,_T,FF,FT,[ArgPos]),
  627    colour_item(neck(directive), TB, FF-FT),
  628    colourise_directive(Directive, TB, ArgPos).
  629colourise_term((?- Directive), TB, Pos) :-
  630    !,
  631    colourise_term((:- Directive), TB, Pos).
  632colourise_term(end_of_file, _, _) :- !.
  633colourise_term(Fact, TB, Pos) :-
  634    !,
  635    colour_item(clause, TB, Pos),
  636    colourise_clause_head(Fact, TB, Pos).

 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.

  644colourise_extended_head(Head, N, TB, Pos) :-
  645    extend(Head, N, TheHead),
  646    colourise_clause_head(TheHead, TB, Pos).
  647
  648extend(M:Head, N, M:ExtHead) :-
  649    nonvar(Head),
  650    !,
  651    extend(Head, N, ExtHead).
  652extend(Head, N, ExtHead) :-
  653    compound(Head),
  654    !,
  655    compound_name_arguments(Head, Name, Args),
  656    length(Extra, N),
  657    append(Args, Extra, NArgs),
  658    compound_name_arguments(ExtHead, Name, NArgs).
  659extend(Head, N, ExtHead) :-
  660    atom(Head),
  661    !,
  662    length(Extra, N),
  663    compound_name_arguments(ExtHead, Head, Extra).
  664extend(Head, _, Head).
  665
  666
  667colourise_clause_head(_, _, Pos) :-
  668    var(Pos),
  669    !.
  670colourise_clause_head(Head, TB, parentheses_term_position(PO,PC,Pos)) :-
  671    colour_item(parentheses, TB, PO-PC),
  672    colourise_clause_head(Head, TB, Pos).
  673colourise_clause_head(M:Head, TB, QHeadPos) :-
  674    QHeadPos = term_position(_,_,QF,QT,[MPos,HeadPos]),
  675    head_colours(M:Head, meta-[_, ClassSpec-ArgSpecs]),
  676    !,
  677    colourise_module(M, TB, MPos),
  678    colour_item(functor, TB, QF-QT),
  679    functor_position(HeadPos, FPos, ArgPos),
  680    (   ClassSpec == classify
  681    ->  classify_head(TB, Head, Class)
  682    ;   Class = ClassSpec
  683    ),
  684    colour_item(head_term(Class, Head), TB, QHeadPos),
  685    colour_item(head(Class, Head), TB, FPos),
  686    specified_items(ArgSpecs, Head, TB, ArgPos).
  687colourise_clause_head(Head, TB, Pos) :-
  688    head_colours(Head, ClassSpec-ArgSpecs),
  689    !,
  690    functor_position(Pos, FPos, ArgPos),
  691    (   ClassSpec == classify
  692    ->  classify_head(TB, Head, Class)
  693    ;   Class = ClassSpec
  694    ),
  695    colour_item(head_term(Class, Head), TB, Pos),
  696    colour_item(head(Class, Head), TB, FPos),
  697    specified_items(ArgSpecs, Head, TB, ArgPos).
  698colourise_clause_head(:=(Eval, Ret), TB,
  699                      term_position(_,_,AF,AT,
  700                                    [ term_position(_,_,SF,ST,
  701                                                    [ SelfPos,
  702                                                      FuncPos
  703                                                    ]),
  704                                      RetPos
  705                                    ])) :-
  706    Eval =.. [.,M,Func],
  707    FuncPos = term_position(_,_,FF,FT,_),
  708    !,
  709    colourise_term_arg(M, TB, SelfPos),
  710    colour_item(func_dot, TB, SF-ST),               % .
  711    colour_item(dict_function(Func), TB, FF-FT),
  712    colourise_term_args(Func, TB, FuncPos),
  713    colour_item(dict_return_op, TB, AF-AT),         % :=
  714    colourise_term_arg(Ret, TB, RetPos).
  715colourise_clause_head(Head, TB, Pos) :-
  716    functor_position(Pos, FPos, _),
  717    classify_head(TB, Head, Class),
  718    colour_item(head_term(Class, Head), TB, Pos),
  719    colour_item(head(Class, Head), TB, FPos),
  720    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.

  727colourise_extern_head(Head, M, TB, Pos) :-
  728    functor_position(Pos, FPos, _),
  729    colour_item(head(extern(M), Head), TB, FPos),
  730    colourise_term_args(Head, TB, Pos).
  731
  732colour_method_head(SGHead, TB, Pos) :-
  733    arg(1, SGHead, Head),
  734    functor_name(SGHead, SG),
  735    functor_position(Pos, FPos, _),
  736    colour_item(method(SG), TB, FPos),
  737    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'.

  744functor_position(term_position(_,_,FF,FT,ArgPos), FF-FT, ArgPos) :- !.
  745functor_position(list_position(F,_T,Elms,none), F-FT, Elms) :-
  746    !,
  747    FT is F + 1.
  748functor_position(dict_position(_,_,FF,FT,KVPos), FF-FT, KVPos) :- !.
  749functor_position(brace_term_position(F,T,Arg), F-T, [Arg]) :- !.
  750functor_position(Pos, Pos, []).
  751
  752colourise_module(Term, TB, Pos) :-
  753    (   var(Term)
  754    ;   atom(Term)
  755    ),
  756    !,
  757    colour_item(module(Term), TB, Pos).
  758colourise_module(_, TB, Pos) :-
  759    colour_item(type_error(module), TB, Pos).

 colourise_directive(+Body, +TB, +Pos)

Colourise the body of a directive.

  765colourise_directive(_,_,Pos) :-
  766    var(Pos),
  767    !.
  768colourise_directive(Dir, TB, parentheses_term_position(PO,PC,Pos)) :-
  769    !,
  770    colour_item(parentheses, TB, PO-PC),
  771    colourise_directive(Dir, TB, Pos).
  772colourise_directive((A,B), TB, term_position(_,_,_,_,[PA,PB])) :-
  773    !,
  774    colourise_directive(A, TB, PA),
  775    colourise_directive(B, TB, PB).
  776colourise_directive(Body, TB, Pos) :-
  777    nonvar(Body),
  778    directive_colours(Body, ClassSpec-ArgSpecs),   % specified
  779    !,
  780    functor_position(Pos, FPos, ArgPos),
  781    (   ClassSpec == classify
  782    ->  goal_classification(TB, Body, [], Class)
  783    ;   Class = ClassSpec
  784    ),
  785    colour_item(goal(Class, Body), TB, FPos),
  786    specified_items(ArgSpecs, Body, TB, ArgPos).
  787colourise_directive(Body, TB, Pos) :-
  788    colourise_body(Body, TB, Pos).
  789
  790
  791%       colourise_body(+Body, +TB, +Pos)
  792%
  793%       Breaks down to colourise_goal/3.
  794
  795colourise_body(Body, TB, Pos) :-
  796    colourise_body(Body, [], TB, Pos).
  797
  798colourise_body(Body, Origin, TB, Pos) :-
  799    colour_item(body, TB, Pos),
  800    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.

  809colourise_method_body(_, _, Pos) :-
  810    var(Pos),
  811    !.
  812colourise_method_body(Body, TB, parentheses_term_position(PO,PC,Pos)) :-
  813    !,
  814    colour_item(parentheses, TB, PO-PC),
  815    colourise_method_body(Body, TB, Pos).
  816colourise_method_body(::(_Comment,Body), TB,
  817                      term_position(_F,_T,_FF,_FT,[CP,BP])) :-
  818    !,
  819    colour_item(comment(string), TB, CP),
  820    colourise_body(Body, TB, BP).
  821colourise_method_body(Body, TB, Pos) :-         % deal with pri(::) < 1000
  822    Body =.. [F,A,B],
  823    control_op(F),
  824    !,
  825    Pos = term_position(_F,_T,FF,FT,
  826                        [ AP,
  827                          BP
  828                        ]),
  829    colour_item(control, TB, FF-FT),
  830    colourise_method_body(A, TB, AP),
  831    colourise_body(B, TB, BP).
  832colourise_method_body(Body, TB, Pos) :-
  833    colourise_body(Body, TB, Pos).
  834
  835control_op(',').
  836control_op((;)).
  837control_op((->)).
  838control_op((*->)).

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

Colourise the goals in a body.

  844colourise_goals(_, _, _, Pos) :-
  845    var(Pos),
  846    !.
  847colourise_goals(Body, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  848    !,
  849    colour_item(parentheses, TB, PO-PC),
  850    colourise_goals(Body, Origin, TB, Pos).
  851colourise_goals(Body, Origin, TB, term_position(_,_,FF,FT,ArgPos)) :-
  852    body_compiled(Body),
  853    !,
  854    colour_item(control, TB, FF-FT),
  855    colourise_subgoals(ArgPos, 1, Body, Origin, TB).
  856colourise_goals(Goal, Origin, TB, Pos) :-
  857    colourise_goal(Goal, Origin, TB, Pos).
  858
  859colourise_subgoals([], _, _, _, _).
  860colourise_subgoals([Pos|T], N, Body, Origin, TB) :-
  861    arg(N, Body, Arg),
  862    colourise_goals(Arg, Origin, TB, Pos),
  863    NN is N + 1,
  864    colourise_subgoals(T, NN, Body, Origin, TB).

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

Breaks down to colourise_dcg_goal/3.

  870colourise_dcg(Body, Head, TB, Pos) :-
  871    colour_item(dcg, TB, Pos),
  872    (   dcg_extend(Head, Origin)
  873    ->  true
  874    ;   Origin = Head
  875    ),
  876    colourise_dcg_goals(Body, Origin, TB, Pos).
  877
  878colourise_dcg_goals(Var, _, TB, Pos) :-
  879    var(Var),
  880    !,
  881    colour_item(goal(meta,Var), TB, Pos).
  882colourise_dcg_goals(_, _, _, Pos) :-
  883    var(Pos),
  884    !.
  885colourise_dcg_goals(Body, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  886    !,
  887    colour_item(parentheses, TB, PO-PC),
  888    colourise_dcg_goals(Body, Origin, TB, Pos).
  889colourise_dcg_goals({Body}, Origin, TB, brace_term_position(F,T,Arg)) :-
  890    !,
  891    colour_item(dcg(plain), TB, F-T),
  892    colourise_goals(Body, Origin, TB, Arg).
  893colourise_dcg_goals([], _, TB, Pos) :-
  894    !,
  895    colour_item(dcg(terminal), TB, Pos).
  896colourise_dcg_goals(List, _, TB, list_position(F,T,Elms,Tail)) :-
  897    List = [_|_],
  898    !,
  899    colour_item(dcg(terminal), TB, F-T),
  900    colourise_list_args(Elms, Tail, List, TB, classify).
  901colourise_dcg_goals(_, _, TB, string_position(F,T)) :-
  902    integer(F),
  903    !,
  904    colour_item(dcg(string), TB, F-T).
  905colourise_dcg_goals(Body, Origin, TB, term_position(_,_,FF,FT,ArgPos)) :-
  906    dcg_body_compiled(Body),       % control structures
  907    !,
  908    colour_item(control, TB, FF-FT),
  909    colourise_dcg_subgoals(ArgPos, 1, Body, Origin, TB).
  910colourise_dcg_goals(Goal, Origin, TB, Pos) :-
  911    colourise_dcg_goal(Goal, Origin, TB, Pos).
  912
  913colourise_dcg_subgoals([], _, _, _, _).
  914colourise_dcg_subgoals([Pos|T], N, Body, Origin, TB) :-
  915    arg(N, Body, Arg),
  916    colourise_dcg_goals(Arg, Origin, TB, Pos),
  917    NN is N + 1,
  918    colourise_dcg_subgoals(T, NN, Body, Origin, TB).
  919
  920dcg_extend(Term, _) :-
  921    var(Term), !, fail.
  922dcg_extend(M:Term, M:Goal) :-
  923    dcg_extend(Term, Goal).
  924dcg_extend(Term, Goal) :-
  925    compound(Term),
  926    !,
  927    compound_name_arguments(Term, Name, Args),
  928    append(Args, [_,_], NArgs),
  929    compound_name_arguments(Goal, Name, NArgs).
  930dcg_extend(Term, Goal) :-
  931    atom(Term),
  932    !,
  933    compound_name_arguments(Goal, Term, [_,_]).
  934
  935dcg_body_compiled(G) :-
  936    body_compiled(G),
  937    !.
  938dcg_body_compiled((_|_)).
  939
  940%       colourise_dcg_goal(+Goal, +Origin, +TB, +Pos).
  941
  942colourise_dcg_goal(!, Origin, TB, TermPos) :-
  943    !,
  944    colourise_goal(!, Origin, TB, TermPos).
  945colourise_dcg_goal(Goal, Origin, TB, TermPos) :-
  946    dcg_extend(Goal, TheGoal),
  947    !,
  948    colourise_goal(TheGoal, Origin, TB, TermPos).
  949colourise_dcg_goal(Goal, _, TB, Pos) :-
  950    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.

  961                                        % Deal with list as goal (consult)
  962colourise_goal(_,_,_,Pos) :-
  963    var(Pos),
  964    !.
  965colourise_goal(Goal, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  966    !,
  967    colour_item(parentheses, TB, PO-PC),
  968    colourise_goal(Goal, Origin, TB, Pos).
  969colourise_goal(Goal, _, TB, Pos) :-
  970    Pos = list_position(F,T,Elms,TailPos),
  971    Goal = [_|_],
  972    !,
  973    FT is F + 1,
  974    AT is T - 1,
  975    colour_item(goal_term(built_in, Goal), TB, Pos),
  976    colour_item(goal(built_in, Goal), TB, F-FT),
  977    colour_item(goal(built_in, Goal), TB, AT-T),
  978    colourise_file_list(Goal, TB, Elms, TailPos, any).
  979colourise_goal(Goal, Origin, TB, Pos) :-
  980    Pos = list_position(F,T,Elms,Tail),
  981    callable(Goal),
  982    Goal =.. [_,GH,GT|_],
  983    !,
  984    goal_classification(TB, Goal, Origin, Class),
  985    FT is F + 1,
  986    AT is T - 1,
  987    colour_item(goal_term(Class, Goal), TB, Pos),
  988    colour_item(goal(Class, Goal), TB, F-FT),
  989    colour_item(goal(Class, Goal), TB, AT-T),
  990    colourise_list_args(Elms, Tail, [GH|GT], TB, classify).
  991colourise_goal(Goal, _Origin, TB, Pos) :-
  992    Pos = quasi_quotation_position(_F,_T,_QQType,_QQTypePos,_CPos),
  993    !,
  994    colourise_term_arg(Goal, TB, Pos).
  995colourise_goal(Goal, Origin, TB, Pos) :-
  996    strip_module(Goal, _, PGoal),
  997    nonvar(PGoal),
  998    (   goal_classification(TB, Goal, Origin, ClassInferred),
  999        goal_colours(Goal, ClassInferred, ClassSpec-ArgSpecs)
 1000    ->  true
 1001    ;   goal_colours(Goal, ClassSpec-ArgSpecs)
 1002    ),
 1003    !,                                          % specified
 1004    functor_position(Pos, FPos, ArgPos),
 1005    (   ClassSpec == classify
 1006    ->  goal_classification(TB, Goal, Origin, Class)
 1007    ;   Class = ClassSpec
 1008    ),
 1009    colour_item(goal_term(Class, Goal), TB, Pos),
 1010    colour_item(goal(Class, Goal), TB, FPos),
 1011    colour_dict_braces(TB, Pos),
 1012    specified_items(ArgSpecs, Goal, TB, ArgPos).
 1013colourise_goal(Module:Goal, _Origin, TB, QGoalPos) :-
 1014    QGoalPos = term_position(_,_,QF,QT,[PM,PG]),
 1015    !,
 1016    colourise_module(Module, TB, PM),
 1017    colour_item(functor, TB, QF-QT),
 1018    (   PG = term_position(_,_,FF,FT,_)
 1019    ->  FP = FF-FT
 1020    ;   FP = PG
 1021    ),
 1022    (   callable(Goal)
 1023    ->  qualified_goal_classification(Module:Goal, TB, Class),
 1024        colour_item(goal_term(Class, Goal), TB, QGoalPos),
 1025        colour_item(goal(Class, Goal), TB, FP),
 1026        colourise_goal_args(Goal, Module, TB, PG)
 1027    ;   var(Goal)
 1028    ->  colourise_term_arg(Goal, TB, PG)
 1029    ;   colour_item(type_error(callable), TB, PG)
 1030    ).
 1031colourise_goal(Op, _Origin, TB, Pos) :-
 1032    nonvar(Op),
 1033    Op = op(_,_,_),
 1034    !,
 1035    colourise_op_declaration(Op, TB, Pos).
 1036colourise_goal(Goal, Origin, TB, Pos) :-
 1037    goal_classification(TB, Goal, Origin, Class),
 1038    (   Pos = term_position(_,_,FF,FT,_ArgPos)
 1039    ->  FPos = FF-FT
 1040    ;   FPos = Pos
 1041    ),
 1042    colour_item(goal_term(Class, Goal), TB, Pos),
 1043    colour_item(goal(Class, Goal), TB, FPos),
 1044    colourise_goal_args(Goal, TB, Pos).
 1045
 1046% make sure to emit a fragment for the braces of tag{k:v, ...} or
 1047% {...} that is mapped to something else.
 1048
 1049colour_dict_braces(TB, dict_position(_F,T,_TF,TT,_KVPos)) :-
 1050    !,
 1051    BStart is TT+1,
 1052    colour_item(dict_content, TB, BStart-T).
 1053colour_dict_braces(TB, brace_term_position(F,T,_Arg)) :-
 1054    !,
 1055    colour_item(brace_term, TB, F-T).
 1056colour_dict_braces(_, _).

 colourise_goal_args(+Goal, +TB, +Pos)

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

 1063colourise_goal_args(Goal, TB, Pos) :-
 1064    colourization_module(TB, Module),
 1065    colourise_goal_args(Goal, Module, TB, Pos).
 1066
 1067colourization_module(TB, Module) :-
 1068    (   colour_state_source_id(TB, SourceId),
 1069        xref_module(SourceId, Module)
 1070    ->  true
 1071    ;   Module = user
 1072    ).
 1073
 1074colourise_goal_args(Goal, M, TB, term_position(_,_,_,_,ArgPos)) :-
 1075    !,
 1076    (   meta_args(Goal, TB, MetaArgs)
 1077    ->  colourise_meta_args(1, Goal, M, MetaArgs, TB, ArgPos)
 1078    ;   colourise_goal_args(1, Goal, M, TB, ArgPos)
 1079    ).
 1080colourise_goal_args(Goal, M, TB, brace_term_position(_,_,ArgPos)) :-
 1081    !,
 1082    (   meta_args(Goal, TB, MetaArgs)
 1083    ->  colourise_meta_args(1, Goal, M, MetaArgs, TB, [ArgPos])
 1084    ;   colourise_goal_args(1, Goal, M, TB, [ArgPos])
 1085    ).
 1086colourise_goal_args(_, _, _, _).                % no arguments
 1087
 1088colourise_goal_args(_, _, _, _, []) :- !.
 1089colourise_goal_args(N, Goal, Module, TB, [P0|PT]) :-
 1090    colourise_option_arg(Goal, Module, N, TB, P0),
 1091    !,
 1092    NN is N + 1,
 1093    colourise_goal_args(NN, Goal, Module, TB, PT).
 1094colourise_goal_args(N, Goal, Module, TB, [P0|PT]) :-
 1095    arg(N, Goal, Arg),
 1096    colourise_term_arg(Arg, TB, P0),
 1097    NN is N + 1,
 1098    colourise_goal_args(NN, Goal, Module, TB, PT).
 1099
 1100
 1101colourise_meta_args(_, _, _, _, _, []) :- !.
 1102colourise_meta_args(N, Goal, Module, MetaArgs, TB, [P0|PT]) :-
 1103    colourise_option_arg(Goal, Module, N, TB, P0),
 1104    !,
 1105    NN is N + 1,
 1106    colourise_meta_args(NN, Goal, Module, MetaArgs, TB, PT).
 1107colourise_meta_args(N, Goal, Module, MetaArgs, TB, [P0|PT]) :-
 1108    arg(N, Goal, Arg),
 1109    arg(N, MetaArgs, MetaSpec),
 1110    colourise_meta_arg(MetaSpec, Arg, TB, P0),
 1111    NN is N + 1,
 1112    colourise_meta_args(NN, Goal, Module, MetaArgs, TB, PT).
 1113
 1114colourise_meta_arg(MetaSpec, Arg, TB, Pos) :-
 1115    nonvar(Arg),
 1116    expand_meta(MetaSpec, Arg, Expanded),
 1117    !,
 1118    colourise_goal(Expanded, [], TB, Pos). % TBD: recursion
 1119colourise_meta_arg(MetaSpec, Arg, TB, Pos) :-
 1120    nonvar(Arg),
 1121    MetaSpec == //,
 1122    !,
 1123    colourise_dcg_goals(Arg, //, TB, Pos).
 1124colourise_meta_arg(_, Arg, TB, Pos) :-
 1125    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.

 1138meta_args(Goal, TB, VarGoal) :-
 1139    colour_state_source_id(TB, SourceId),
 1140    xref_meta(SourceId, Goal, _),
 1141    !,
 1142    compound_name_arity(Goal, Name, Arity),
 1143    compound_name_arity(VarGoal, Name, Arity),
 1144    xref_meta(SourceId, VarGoal, MetaArgs),
 1145    instantiate_meta(MetaArgs).
 1146
 1147instantiate_meta([]).
 1148instantiate_meta([H|T]) :-
 1149    (   var(H)
 1150    ->  H = 0
 1151    ;   H = V+N
 1152    ->  V = N
 1153    ;   H = //(V)
 1154    ->  V = (//)
 1155    ),
 1156    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).

 1163expand_meta(MetaSpec, Goal, Goal) :-
 1164    MetaSpec == 0.
 1165expand_meta(MetaSpec, M:Goal, M:Expanded) :-
 1166    atom(M),
 1167    !,
 1168    expand_meta(MetaSpec, Goal, Expanded).
 1169expand_meta(MetaSpec, Goal, Expanded) :-
 1170    integer(MetaSpec),
 1171    MetaSpec > 0,
 1172    (   atom(Goal)
 1173    ->  functor(Expanded, Goal, MetaSpec)
 1174    ;   compound(Goal)
 1175    ->  compound_name_arguments(Goal, Name, Args0),
 1176        length(Extra, MetaSpec),
 1177        append(Args0, Extra, Args),
 1178        compound_name_arguments(Expanded, Name, Args)
 1179    ).

 colourise_setof(+Term, +TB, +Pos)

Colourise the 2nd argument of setof/bagof

 1185colourise_setof(Var^G, TB, term_position(_,_,FF,FT,[VP,GP])) :-
 1186    !,
 1187    colourise_term_arg(Var, TB, VP),
 1188    colour_item(ext_quant, TB, FF-FT),
 1189    colourise_setof(G, TB, GP).
 1190colourise_setof(Term, TB, Pos) :-
 1191    colourise_goal(Term, [], TB, Pos).
 1192
 1193%       colourise_db(+Arg, +TB, +Pos)
 1194%
 1195%       Colourise database modification calls (assert/1, retract/1 and
 1196%       friends.
 1197
 1198colourise_db((Head:-_Body), TB, term_position(_,_,_,_,[HP,_])) :-
 1199    !,
 1200    colourise_db(Head, TB, HP).
 1201colourise_db(Module:Head, TB, term_position(_,_,QF,QT,[MP,HP])) :-
 1202    !,
 1203    colourise_module(Module, TB, MP),
 1204    colour_item(functor, TB, QF-QT),
 1205    (   atom(Module),
 1206        colour_state_source_id(TB, SourceId),
 1207        xref_module(SourceId, Module)
 1208    ->  colourise_db(Head, TB, HP)
 1209    ;   colourise_db(Head, TB, HP)
 1210    ).
 1211colourise_db(Head, TB, Pos) :-
 1212    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

 1221colourise_option_arg(Goal, Module, Arg, TB, ArgPos) :-
 1222    goal_name_arity(Goal, Name, Arity),
 1223    current_option_arg(Module:Name/Arity, Arg),
 1224    current_predicate_options(Module:Name/Arity, Arg, OptionDecl),
 1225    debug(emacs, 'Colouring option-arg ~w of ~p',
 1226          [Arg, Module:Name/Arity]),
 1227    arg(Arg, Goal, Options),
 1228    colourise_option(Options, Module, Goal, Arg, OptionDecl, TB, ArgPos).
 1229
 1230colourise_option(Options0, Module, Goal, Arg, OptionDecl, TB, Pos0) :-
 1231    strip_option_module_qualifier(Goal, Module, Arg, TB,
 1232                                  Options0, Pos0, Options, Pos),
 1233    (   Pos = list_position(F, T, ElmPos, TailPos)
 1234    ->  colour_item(list, TB, F-T),
 1235        colourise_option_list(Options, OptionDecl, TB, ElmPos, TailPos)
 1236    ;   (   var(Options)
 1237        ;   Options == []
 1238        )
 1239    ->  colourise_term_arg(Options, TB, Pos)
 1240    ;   colour_item(type_error(list), TB, Pos)
 1241    ).
 1242
 1243strip_option_module_qualifier(Goal, Module, Arg, TB,
 1244                              M:Options, term_position(_,_,_,_,[MP,Pos]),
 1245                              Options, Pos) :-
 1246    predicate_property(Module:Goal, meta_predicate(Head)),
 1247    arg(Arg, Head, :),
 1248    !,
 1249    colourise_module(M, TB, MP).
 1250strip_option_module_qualifier(_, _, _, _,
 1251                              Options, Pos, Options, Pos).
 1252
 1253
 1254colourise_option_list(_, _, _, [], none) :- !.
 1255colourise_option_list(Tail, _, TB, [], TailPos) :-
 1256    !,
 1257    colourise_term_arg(Tail, TB, TailPos).
 1258colourise_option_list([H|T], OptionDecl, TB, [HPos|TPos], TailPos) :-
 1259    colourise_option(H, OptionDecl, TB, HPos),
 1260    colourise_option_list(T, OptionDecl, TB, TPos, TailPos).
 1261
 1262colourise_option(Opt, _, TB, Pos) :-
 1263    var(Opt),
 1264    !,
 1265    colourise_term_arg(Opt, TB, Pos).
 1266colourise_option(Opt, OptionDecl, TB, term_position(_,_,FF,FT,ValPosList)) :-
 1267    !,
 1268    generalise_term(Opt, GenOpt),
 1269    (   memberchk(GenOpt, OptionDecl)
 1270    ->  colour_item(option_name, TB, FF-FT),
 1271        Opt =.. [Name|Values],
 1272        GenOpt =.. [Name|Types],
 1273        colour_option_values(Values, Types, TB, ValPosList)
 1274    ;   colour_item(no_option_name, TB, FF-FT),
 1275        colourise_term_args(ValPosList, 1, Opt, TB)
 1276    ).
 1277colourise_option(_, _, TB, Pos) :-
 1278    colour_item(type_error(option), TB, Pos).
 1279
 1280colour_option_values([], [], _, _).
 1281colour_option_values([V0|TV], [T0|TT], TB, [P0|TP]) :-
 1282    (   (   var(V0)
 1283        ;   is_of_type(T0, V0)
 1284        ;   T0 = list(_),
 1285            member(E, V0),
 1286            var(E)
 1287        ;   functor(V0, '.', 2),
 1288            V0 \= [_|_]
 1289        )
 1290    ->  colourise_term_arg(V0, TB, P0)
 1291    ;   callable(V0),
 1292        (   T0 = callable
 1293        ->  N = 0
 1294        ;   T0 = (callable+N)
 1295        )
 1296    ->  colourise_meta_arg(N, V0, TB, P0)
 1297    ;   colour_item(type_error(T0), TB, P0)
 1298    ),
 1299    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

 1308colourise_files(List, TB, list_position(F,T,Elms,TailPos), Why) :-
 1309    !,
 1310    colour_item(list, TB, F-T),
 1311    colourise_file_list(List, TB, Elms, TailPos, Why).
 1312colourise_files(M:Spec, TB, term_position(_,_,_,_,[MP,SP]), Why) :-
 1313    !,
 1314    colourise_module(M, TB, MP),
 1315    colourise_files(Spec, TB, SP, Why).
 1316colourise_files(Var, TB, P, _) :-
 1317    var(Var),
 1318    !,
 1319    colour_item(var, TB, P).
 1320colourise_files(Spec0, TB, Pos, Why) :-
 1321    strip_module(Spec0, _, Spec),
 1322    (   colour_state_source_id(TB, Source),
 1323        prolog_canonical_source(Source, SourceId),
 1324        catch(xref_source_file(Spec, Path, SourceId, [silent(true)]),
 1325              _, fail)
 1326    ->  (   Why = imported,
 1327            \+ resolves_anything(TB, Path),
 1328            exports_something(TB, Path)
 1329        ->  colour_item(file_no_depend(Path), TB, Pos)
 1330        ;   colour_item(file(Path), TB, Pos)
 1331        )
 1332    ;   colour_item(nofile, TB, Pos)
 1333    ).

 colourise_file_list(+Files, +TB, +ElmPos, +TailPos, +Why)

 1337colourise_file_list([], _, [], none, _).
 1338colourise_file_list(Last, TB, [], TailPos, _Why) :-
 1339    (   var(Last)
 1340    ->  colourise_term(Last, TB, TailPos)
 1341    ;   colour_item(type_error(list), TB, TailPos)
 1342    ).
 1343colourise_file_list([H|T], TB, [PH|PT], TailPos, Why) :-
 1344    colourise_files(H, TB, PH, Why),
 1345    colourise_file_list(T, TB, PT, TailPos, Why).
 1346
 1347resolves_anything(TB, Path) :-
 1348    colour_state_source_id(TB, SourceId),
 1349    xref_defined(SourceId, Head, imported(Path)),
 1350    xref_called(SourceId, Head, _),
 1351    !.
 1352
 1353exports_something(TB, Path) :-
 1354    colour_state_source_id(TB, SourceId),
 1355    xref_defined(SourceId, _, imported(Path)),
 1356    !.

 colourise_directory(+Arg, +TB, +Pos)

Colourise argument that should be an existing directory.

 1362colourise_directory(Spec, TB, Pos) :-
 1363    (   colour_state_source_id(TB, SourceId),
 1364        catch(xref_source_file(Spec, Path, SourceId,
 1365                               [ file_type(directory),
 1366                                 silent(true)
 1367                               ]),
 1368              _, fail)
 1369    ->  colour_item(directory(Path), TB, Pos)
 1370    ;   colour_item(nofile, TB, Pos)
 1371    ).

 colourise_langoptions(+Term, +TB, +Pos) is det

Colourise the 3th argument of module/3

 1377colourise_langoptions([], _, _) :- !.
 1378colourise_langoptions([H|T], TB, list_position(PF,PT,[HP|TP],_)) :-
 1379    !,
 1380    colour_item(list, TB, PF-PT),
 1381    colourise_langoptions(H, TB, HP),
 1382    colourise_langoptions(T, TB, TP).
 1383colourise_langoptions(Spec, TB, Pos) :-
 1384    colourise_files(library(dialect/Spec), TB, Pos, imported).

 colourise_class(ClassName, TB, Pos)

Colourise an XPCE class.

 1390colourise_class(ClassName, TB, Pos) :-
 1391    colour_state_source_id(TB, SourceId),
 1392    classify_class(SourceId, ClassName, Classification),
 1393    colour_item(class(Classification, ClassName), TB, Pos).

 classify_class(+SourceId, +ClassName, -Classification)

Classify an XPCE class. As long as this code is in this module rather than using hooks, we do not want to load xpce unless it is already loaded.

 1401classify_class(SourceId, Name, Class) :-
 1402    xref_defined_class(SourceId, Name, Class),
 1403    !.
 1404classify_class(_SourceId, Name, Class) :-
 1405    current_predicate(pce:send_class/3),
 1406    (   current_predicate(classify_class/2)
 1407    ->  true
 1408    ;   use_module(library(pce_meta), [classify_class/2])
 1409    ),
 1410    member(G, [classify_class(Name, Class)]),
 1411    call(G).

 colourise_term_args(+Term, +TB, +Pos)

colourise head/body principal terms.

 1417colourise_term_args(Term, TB,
 1418                    term_position(_,_,_,_,ArgPos)) :-
 1419    !,
 1420    colourise_term_args(ArgPos, 1, Term, TB).
 1421colourise_term_args(_, _, _).
 1422
 1423colourise_term_args([], _, _, _).
 1424colourise_term_args([Pos|T], N, Term, TB) :-
 1425    arg(N, Term, Arg),
 1426    colourise_term_arg(Arg, TB, Pos),
 1427    NN is N + 1,
 1428    colourise_term_args(T, NN, Term, TB).
 1429
 1430colourise_term_arg(_, _, Pos) :-
 1431    var(Pos),
 1432    !.
 1433colourise_term_arg(Arg, TB, parentheses_term_position(PO,PC,Pos)) :-
 1434    !,
 1435    colour_item(parentheses, TB, PO-PC),
 1436    colourise_term_arg(Arg, TB, Pos).
 1437colourise_term_arg(Var, TB, Pos) :-                     % variable
 1438    var(Var), Pos = _-_,
 1439    !,
 1440    (   singleton(Var, TB)
 1441    ->  colour_item(singleton, TB, Pos)
 1442    ;   colour_item(var, TB, Pos)
 1443    ).
 1444colourise_term_arg(List, TB, list_position(F, T, Elms, Tail)) :-
 1445    !,
 1446    colour_item(list, TB, F-T),
 1447    colourise_list_args(Elms, Tail, List, TB, classify).    % list
 1448colourise_term_arg(String, TB, string_position(F, T)) :-       % string
 1449    !,
 1450    (   string(String)
 1451    ->  colour_item(string, TB, F-T)
 1452    ;   String = [H|_]
 1453    ->  (   integer(H)
 1454        ->  colour_item(codes, TB, F-T)
 1455        ;   colour_item(chars, TB, F-T)
 1456        )
 1457    ;   String == []
 1458    ->  colour_item(codes, TB, F-T)
 1459    ).
 1460colourise_term_arg(_, TB,
 1461                   quasi_quotation_position(F,T,QQType,QQTypePos,CPos)) :-
 1462    !,
 1463    colourise_qq_type(QQType, TB, QQTypePos),
 1464    functor_name(QQType, Type),
 1465    colour_item(qq_content(Type), TB, CPos),
 1466    arg(1, CPos, SE),
 1467    SS is SE-2,
 1468    FE is F+2,
 1469    TS is T-2,
 1470    colour_item(qq(open),  TB, F-FE),
 1471    colour_item(qq(sep),   TB, SS-SE),
 1472    colour_item(qq(close), TB, TS-T).
 1473colourise_term_arg({Term}, TB, brace_term_position(F,T,Arg)) :-
 1474    !,
 1475    colour_item(brace_term, TB, F-T),
 1476    colourise_term_arg(Term, TB, Arg).
 1477colourise_term_arg(Map, TB, dict_position(F,T,TF,TT,KVPos)) :-
 1478    !,
 1479    is_dict(Map, Tag),
 1480    colour_item(dict, TB, F-T),
 1481    TagPos = TF-TT,
 1482    (   var(Tag)
 1483    ->  (   singleton(Tag, TB)
 1484        ->  colour_item(singleton, TB, TagPos)
 1485        ;   colour_item(var, TB, TagPos)
 1486        )
 1487    ;   colour_item(dict_tag, TB, TagPos)
 1488    ),
 1489    BStart is TT+1,
 1490    colour_item(dict_content, TB, BStart-T),
 1491    colourise_dict_kv(Map, TB, KVPos).
 1492colourise_term_arg([](List,Term), TB,                   % [] as operator
 1493                   term_position(_,_,0,0,[ListPos,ArgPos])) :-
 1494    !,
 1495    colourise_term_arg(List, TB, ListPos),
 1496    colourise_term_arg(Term, TB, ArgPos).
 1497colourise_term_arg(Compound, TB, Pos) :-                % compound
 1498    compound(Compound),
 1499    !,
 1500    (   Pos = term_position(_F,_T,FF,FT,_ArgPos)
 1501    ->  colour_item(functor, TB, FF-FT)             % TBD: Infix/Postfix?
 1502    ;   true                                        % TBD: When is this
 1503    ),
 1504    colourise_term_args(Compound, TB, Pos).
 1505colourise_term_arg(EmptyList, TB, Pos) :-
 1506    EmptyList == [],
 1507    !,
 1508    colour_item(empty_list, TB, Pos).
 1509colourise_term_arg(Atom, TB, Pos) :-
 1510    atom(Atom),
 1511    !,
 1512    colour_item(atom, TB, Pos).
 1513colourise_term_arg(Integer, TB, Pos) :-
 1514    integer(Integer),
 1515    !,
 1516    colour_item(int, TB, Pos).
 1517colourise_term_arg(Float, TB, Pos) :-
 1518    float(Float),
 1519    !,
 1520    colour_item(float, TB, Pos).
 1521colourise_term_arg(_Arg, _TB, _Pos) :-
 1522    true.
 1523
 1524colourise_list_args([HP|TP], Tail, [H|T], TB, How) :-
 1525    specified_item(How, H, TB, HP),
 1526    colourise_list_args(TP, Tail, T, TB, How).
 1527colourise_list_args([], none, _, _, _) :- !.
 1528colourise_list_args([], TP, T, TB, How) :-
 1529    specified_item(How, T, TB, TP).