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-2016, 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(Singletons),
  134                          module(SM),
  135                          comments(Comments)
  136                        ]),
  137              E,
  138              read_error(E, TB, Start, Fd)),
  139        fix_operators(Term, SM, TB),
  140        colour_state_singletons(TB, Singletons),
  141        (   colourise_term(Term, TB, TermPos, Comments)
  142        ->  true
  143        ;   arg(1, TermPos, From),
  144            print_message(warning,
  145                          format('Failed to colourise ~p at index ~d~n',
  146                                 [Term, From]))
  147        ),
  148        Term == end_of_file,
  149    !.
  150
  151save_settings(TB, state(Style, Flags, OSM)) :-
  152    (   source_module(TB, SM)
  153    ->  true
  154    ;   SM = prolog_colour_ops
  155    ),
  156    '$set_source_module'(OSM, SM),
  157    colour_state_module(TB, SM),
  158    push_operators([]),
  159    syntax_flags(Flags),
  160    '$style_check'(Style, Style).
  161
  162restore_settings(state(Style, Flags, OSM)) :-
  163    restore_syntax_flags(Flags),
  164    '$style_check'(_, Style),
  165    pop_operators,
  166    '$set_source_module'(OSM).
  167
  168syntax_flags(Pairs) :-
  169    findall(set_prolog_flag(Flag, Value),
  170            syntax_flag(Flag, Value),
  171            Pairs).
  172
  173syntax_flag(Flag, Value) :-
  174    syntax_flag(Flag),
  175    current_prolog_flag(Flag, Value).
  176
  177restore_syntax_flags([]).
  178restore_syntax_flags([set_prolog_flag(Flag, Value)|T]) :-
  179    set_prolog_flag(Flag, Value),
  180    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.

  189source_module(TB, Module) :-
  190    colour_state_source_id_list(TB, []),
  191    !,
  192    colour_state_module(TB, Module).
  193source_module(TB, Module) :-
  194    colour_state_source_id(TB, SourceId),
  195    xref_option(SourceId, module(Module)),
  196    !.
  197source_module(TB, Module) :-
  198    (   colour_state_source_id(TB, File),
  199        atom(File)
  200    ;   colour_state_stream(TB, Fd),
  201        is_stream(Fd),
  202        stream_property(Fd, file_name(File))
  203    ),
  204    module_context(File, [], Module).
  205
  206module_context(File, _, Module) :-
  207    source_file_property(File, module(Module)),
  208    !.
  209module_context(File, Seen, Module) :-
  210    source_file_property(File, included_in(File2, _Line)),
  211    \+ memberchk(File, Seen),
  212    !,
  213    module_context(File2, [File|Seen], Module).
  214module_context(File, _, Module) :-
  215    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.

  222read_error(Error, TB, Start, EndSpec) :-
  223    (   syntax_error(Error, Id, CharNo)
  224    ->  message_to_string(error(syntax_error(Id), _), Msg),
  225        (   integer(EndSpec)
  226        ->  End = EndSpec
  227        ;   character_count(EndSpec, End)
  228        ),
  229        show_syntax_error(TB, CharNo:Msg, Start-End),
  230        fail
  231    ;   throw(Error)
  232    ).
  233
  234syntax_error(error(syntax_error(Id), stream(_S, _Line, _LinePos, CharNo)),
  235             Id, CharNo).
  236syntax_error(error(syntax_error(Id), file(_S, _Line, _LinePos, CharNo)),
  237             Id, CharNo).
  238syntax_error(error(syntax_error(Id), string(_Text, CharNo)),
  239             Id, CharNo).

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

  243colour_item(Class, TB, Pos) :-
  244    arg(1, Pos, Start),
  245    arg(2, Pos, End),
  246    Len is End - Start,
  247    colour_state_closure(TB, Closure),
  248    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.

  256safe_push_op(P, T, N0, State) :-
  257    colour_state_module(State, CM),
  258    strip_module(CM:N0, M, N),
  259    (   is_list(N)
  260    ->  acyclic_term(N),
  261        forall(member(Name, N),
  262               safe_push_op(P, T, M:Name, State))
  263    ;   push_op(P, T, M:N)
  264    ),
  265    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.

  273fix_operators((:- Directive), M, Src) :-
  274    ground(Directive),
  275    catch(process_directive(Directive, M, Src), _, true),
  276    !.
  277fix_operators(_, _, _).
  278
  279process_directive(style_check(X), _, _) :-
  280    !,
  281    style_check(X).
  282process_directive(set_prolog_flag(Flag, Value), M, _) :-
  283    syntax_flag(Flag),
  284    !,
  285    set_prolog_flag(M:Flag, Value).
  286process_directive(M:op(P,T,N), _, Src) :-
  287    !,
  288    process_directive(op(P,T,N), M, Src).
  289process_directive(op(P,T,N), M, Src) :-
  290    !,
  291    safe_push_op(P, T, M:N, Src).
  292process_directive(module(_Name, Export), M, Src) :-
  293    !,
  294    forall(member(op(P,A,N), Export),
  295           safe_push_op(P,A,M:N, Src)).
  296process_directive(use_module(Spec), _, Src) :-
  297    !,
  298    catch(process_use_module(Spec, Src), _, true).
  299process_directive(Directive, _, Src) :-
  300    prolog_source:expand((:-Directive), Src, _).
  301
  302syntax_flag(character_escapes).
  303syntax_flag(var_prefix).
  304syntax_flag(allow_variable_name_as_functor).
  305syntax_flag(allow_dot_in_atom).

 process_use_module(+Imports, +Src)

Get the exported operators from the referenced files.

  311process_use_module([], _) :- !.
  312process_use_module([H|T], Src) :-
  313    !,
  314    process_use_module(H, Src),
  315    process_use_module(T, Src).
  316process_use_module(File, Src) :-
  317    (   xref_public_list(File, Src,
  318                         [ exports(Exports),
  319                           silent(true),
  320                           path(Path)
  321                         ])
  322    ->  forall(member(op(P,T,N), Exports),
  323               safe_push_op(P,T,N,Src)),
  324        colour_state_module(Src, SM),
  325        (   member(Syntax/4, Exports),
  326            load_quasi_quotation_syntax(SM:Path, Syntax),
  327            fail
  328        ;   true
  329        )
  330    ;   true
  331    ).

 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.

  341prolog_colourise_query(QueryString, SourceID, ColourItem) :-
  342    query_colour_state(SourceID, ColourItem, TB),
  343    setup_call_cleanup(
  344        save_settings(TB, State),
  345        colourise_query(QueryString, TB),
  346        restore_settings(State)).
  347
  348query_colour_state(module(Module), ColourItem, TB) :-
  349    !,
  350    make_colour_state([ source_id_list([]),
  351                        module(Module),
  352                        closure(ColourItem)
  353                      ],
  354                      TB).
  355query_colour_state(SourceID, ColourItem, TB) :-
  356    to_list(SourceID, SourceIDList),
  357    make_colour_state([ source_id_list(SourceIDList),
  358                        closure(ColourItem)
  359                      ],
  360                      TB).
  361
  362
  363colourise_query(QueryString, TB) :-
  364    colour_state_module(TB, SM),
  365    string_length(QueryString, End),
  366    (   catch(term_string(Query, QueryString,
  367                          [ subterm_positions(TermPos),
  368                            singletons(Singletons),
  369                            module(SM),
  370                            comments(Comments)
  371                          ]),
  372              E,
  373              read_error(E, TB, 0, End))
  374    ->  colour_state_singletons(TB, Singletons),
  375        colourise_comments(Comments, TB),
  376        (   Query == end_of_file
  377        ->  true
  378        ;   colourise_body(Query, TB, TermPos)
  379        )
  380    ;   true                        % only a syntax error
  381    ).

 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)

  396prolog_colourise_term(Stream, SourceId, ColourItem, Options) :-
  397    to_list(SourceId, SourceIdList),
  398    make_colour_state([ source_id_list(SourceIdList),
  399                        stream(Stream),
  400                        closure(ColourItem)
  401                      ],
  402                      TB),
  403    option(subterm_positions(TermPos), Options, _),
  404    findall(Op, xref_op(SourceId, Op), Ops),
  405    findall(Opt, xref_flag_option(SourceId, Opt), Opts),
  406    character_count(Stream, Start),
  407    (   source_module(TB, Module)
  408    ->  true
  409    ;   Module = prolog_colour_ops
  410    ),
  411    read_source_term_at_location(
  412        Stream, Term,
  413        [ module(Module),
  414          operators(Ops),
  415          error(Error),
  416          subterm_positions(TermPos),
  417          singletons(Singletons),
  418          comments(Comments)
  419        | Opts
  420        ]),
  421    (   var(Error)
  422    ->  colour_state_singletons(TB, Singletons),
  423        colour_item(range, TB, TermPos),            % Call to allow clearing
  424        colourise_term(Term, TB, TermPos, Comments)
  425    ;   character_count(Stream, End),
  426        TermPos = error_position(Start, End, Pos),
  427        colour_item(range, TB, TermPos),
  428        show_syntax_error(TB, Error, Start-End),
  429        Error = Pos:_Message
  430    ).
  431
  432xref_flag_option(TB, var_prefix(Bool)) :-
  433    xref_prolog_flag(TB, var_prefix, Bool, _Line).
  434
  435show_syntax_error(TB, Pos:Message, Range) :-
  436    integer(Pos),
  437    !,
  438    End is Pos + 1,
  439    colour_item(syntax_error(Message, Range), TB, Pos-End).
  440show_syntax_error(TB, _:Message, Range) :-
  441    colour_item(syntax_error(Message, Range), TB, Range).
  442
  443
  444singleton(Var, TB) :-
  445    colour_state_singletons(TB, Singletons),
  446    member_var(Var, Singletons).
  447
  448member_var(V, [_=V2|_]) :-
  449    V == V2,
  450    !.
  451member_var(V, [_|T]) :-
  452    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.

  463colourise_term(Term, TB, TermPos, Comments) :-
  464    colourise_comments(Comments, TB),
  465    (   Term == end_of_file
  466    ->  true
  467    ;   colourise_term(Term, TB, TermPos),
  468        colourise_fullstop(TB, TermPos)
  469    ).
  470
  471colourise_fullstop(TB, TermPos) :-
  472    arg(2, TermPos, EndTerm),
  473    Start is EndTerm,
  474    End is Start+1,
  475    colour_item(fullstop, TB, Start-End).
  476
  477colourise_comments(-, _).
  478colourise_comments([], _).
  479colourise_comments([H|T], TB) :-
  480    colourise_comment(H, TB),
  481    colourise_comments(T, TB).
  482
  483colourise_comment((-)-_, _) :- !.
  484colourise_comment(Pos-Comment, TB) :-
  485    comment_style(Comment, Style),
  486    stream_position_data(char_count, Pos, Start),
  487    string_length(Comment, Len),
  488    End is Start + Len + 1,
  489    colour_item(comment(Style), TB, Start-End).
  490
  491comment_style(Comment, structured) :-           % Starts %%, %! or /**
  492    structured_comment_start(Start),
  493    sub_string(Comment, 0, Len, _, Start),
  494    Next is Len+1,
  495    string_code(Next, Comment, NextCode),
  496    code_type(NextCode, space),
  497    !.
  498comment_style(Comment, line) :-                 % Starts %
  499    sub_string(Comment, 0, _, _, '%'),
  500    !.
  501comment_style(_, block).                        % Starts /*

 structured_comment_start(-Start)

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

  508structured_comment_start('%%').
  509structured_comment_start('%!').
  510structured_comment_start('/**').

 colourise_term(+Term, +TB, +Pos)

Colorise a file toplevel term.

  516colourise_term(Var, TB, Start-End) :-
  517    var(Var),
  518    !,
  519    colour_item(instantiation_error, TB, Start-End).
  520colourise_term(_, _, Pos) :-
  521    var(Pos),
  522    !.
  523colourise_term(Term, TB, parentheses_term_position(PO,PC,Pos)) :-
  524    !,
  525    colour_item(parentheses, TB, PO-PC),
  526    colourise_term(Term, TB, Pos).
  527colourise_term(Term, TB, Pos) :-
  528    term_colours(Term, FuncSpec-ArgSpecs),
  529    !,
  530    Pos = term_position(F,T,FF,FT,ArgPos),
  531    colour_item(term, TB, F-T),     % TBD: Allow specifying by term_colours/2?
  532    specified_item(FuncSpec, Term, TB, FF-FT),
  533    specified_items(ArgSpecs, Term, TB, ArgPos).
  534colourise_term((Head :- Body), TB,
  535               term_position(F,T,FF,FT,[HP,BP])) :-
  536    !,
  537    colour_item(clause,         TB, F-T),
  538    colour_item(neck(clause),   TB, FF-FT),
  539    colourise_clause_head(Head, TB, HP),
  540    colourise_body(Body, Head,  TB, BP).
  541colourise_term(((Head,RHC) --> Body), TB,
  542               term_position(F,T,FF,FT,
  543                             [ term_position(_,_,_,_,[HP,RHCP]),
  544                               BP
  545                             ])) :-
  546    !,
  547    colour_item(grammar_rule,       TB, F-T),
  548    colour_item(dcg_right_hand_ctx, TB, RHCP),
  549    colourise_term_arg(RHC, TB, RHCP),
  550    colour_item(neck(grammar_rule), TB, FF-FT),
  551    colourise_extended_head(Head, 2, TB, HP),
  552    colourise_dcg(Body, Head,       TB, BP).
  553colourise_term((Head --> Body), TB,                     % TBD: expansion!
  554               term_position(F,T,FF,FT,[HP,BP])) :-
  555    !,
  556    colour_item(grammar_rule,       TB, F-T),
  557    colour_item(neck(grammar_rule), TB, FF-FT),
  558    colourise_extended_head(Head, 2, TB, HP),
  559    colourise_dcg(Body, Head,       TB, BP).
  560colourise_term(:->(Head, Body), TB,
  561               term_position(F,T,FF,FT,[HP,BP])) :-
  562    !,
  563    colour_item(method,             TB, F-T),
  564    colour_item(neck(method(send)), TB, FF-FT),
  565    colour_method_head(send(Head),  TB, HP),
  566    colourise_method_body(Body,     TB, BP).
  567colourise_term(:<-(Head, Body), TB,
  568               term_position(F,T,FF,FT,[HP,BP])) :-
  569    !,
  570    colour_item(method,            TB, F-T),
  571    colour_item(neck(method(get)), TB, FF-FT),
  572    colour_method_head(get(Head),  TB, HP),
  573    colourise_method_body(Body,    TB, BP).
  574colourise_term((:- Directive), TB, Pos) :-
  575    !,
  576    colour_item(directive, TB, Pos),
  577    Pos = term_position(_F,_T,FF,FT,[ArgPos]),
  578    colour_item(neck(directive), TB, FF-FT),
  579    colourise_directive(Directive, TB, ArgPos).
  580colourise_term((?- Directive), TB, Pos) :-
  581    !,
  582    colourise_term((:- Directive), TB, Pos).
  583colourise_term(end_of_file, _, _) :- !.
  584colourise_term(Fact, TB, Pos) :-
  585    !,
  586    colour_item(clause, TB, Pos),
  587    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.

  595colourise_extended_head(Head, N, TB, Pos) :-
  596    extend(Head, N, TheHead),
  597    colourise_clause_head(TheHead, TB, Pos).
  598
  599extend(M:Head, N, M:ExtHead) :-
  600    nonvar(Head),
  601    !,
  602    extend(Head, N, ExtHead).
  603extend(Head, N, ExtHead) :-
  604    compound(Head),
  605    !,
  606    compound_name_arguments(Head, Name, Args),
  607    length(Extra, N),
  608    append(Args, Extra, NArgs),
  609    compound_name_arguments(ExtHead, Name, NArgs).
  610extend(Head, N, ExtHead) :-
  611    atom(Head),
  612    !,
  613    length(Extra, N),
  614    compound_name_arguments(ExtHead, Head, Extra).
  615extend(Head, _, Head).
  616
  617
  618colourise_clause_head(_, _, Pos) :-
  619    var(Pos),
  620    !.
  621colourise_clause_head(Head, TB, parentheses_term_position(PO,PC,Pos)) :-
  622    colour_item(parentheses, TB, PO-PC),
  623    colourise_clause_head(Head, TB, Pos).
  624colourise_clause_head(M:Head, TB, QHeadPos) :-
  625    QHeadPos = term_position(_,_,QF,QT,[MPos,HeadPos]),
  626    head_colours(M:Head, meta-[_, ClassSpec-ArgSpecs]),
  627    !,
  628    colour_item(module(M), TB, MPos),
  629    colour_item(functor, TB, QF-QT),
  630    functor_position(HeadPos, FPos, ArgPos),
  631    (   ClassSpec == classify
  632    ->  classify_head(TB, Head, Class)
  633    ;   Class = ClassSpec
  634    ),
  635    colour_item(head_term(Class, Head), TB, QHeadPos),
  636    colour_item(head(Class, Head), TB, FPos),
  637    specified_items(ArgSpecs, Head, TB, ArgPos).
  638colourise_clause_head(Head, TB, Pos) :-
  639    head_colours(Head, ClassSpec-ArgSpecs),
  640    !,
  641    functor_position(Pos, FPos, ArgPos),
  642    (   ClassSpec == classify
  643    ->  classify_head(TB, Head, Class)
  644    ;   Class = ClassSpec
  645    ),
  646    colour_item(head_term(Class, Head), TB, Pos),
  647    colour_item(head(Class, Head), TB, FPos),
  648    specified_items(ArgSpecs, Head, TB, ArgPos).
  649colourise_clause_head(:=(Eval, Ret), TB,
  650                      term_position(_,_,AF,AT,
  651                                    [ term_position(_,_,SF,ST,
  652                                                    [ SelfPos,
  653                                                      FuncPos
  654                                                    ]),
  655                                      RetPos
  656                                    ])) :-
  657    Eval =.. [.,M,Func],
  658    FuncPos = term_position(_,_,FF,FT,_),
  659    !,
  660    colourise_term_arg(M, TB, SelfPos),
  661    colour_item(func_dot, TB, SF-ST),               % .
  662    colour_item(dict_function(Func), TB, FF-FT),
  663    colourise_term_args(Func, TB, FuncPos),
  664    colour_item(dict_return_op, TB, AF-AT),         % :=
  665    colourise_term_arg(Ret, TB, RetPos).
  666colourise_clause_head(Head, TB, Pos) :-
  667    functor_position(Pos, FPos, _),
  668    classify_head(TB, Head, Class),
  669    colour_item(head_term(Class, Head), TB, Pos),
  670    colour_item(head(Class, Head), TB, FPos),
  671    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.

  678colourise_extern_head(Head, M, TB, Pos) :-
  679    functor_position(Pos, FPos, _),
  680    colour_item(head(extern(M), Head), TB, FPos),
  681    colourise_term_args(Head, TB, Pos).
  682
  683colour_method_head(SGHead, TB, Pos) :-
  684    arg(1, SGHead, Head),
  685    functor_name(SGHead, SG),
  686    functor_position(Pos, FPos, _),
  687    colour_item(method(SG), TB, FPos),
  688    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'.

  695functor_position(term_position(_,_,FF,FT,ArgPos), FF-FT, ArgPos) :- !.
  696functor_position(list_position(F,_T,Elms,none), F-FT, Elms) :-
  697    !,
  698    FT is F + 1.
  699functor_position(dict_position(_,_,FF,FT,KVPos), FF-FT, KVPos) :- !.
  700functor_position(brace_term_position(F,T,Arg), F-T, [Arg]) :- !.
  701functor_position(Pos, Pos, []).

 colourise_directive(+Body, +TB, +Pos)

Colourise the body of a directive.

  708colourise_directive(_,_,Pos) :-
  709    var(Pos),
  710    !.
  711colourise_directive(Dir, TB, parentheses_term_position(PO,PC,Pos)) :-
  712    !,
  713    colour_item(parentheses, TB, PO-PC),
  714    colourise_directive(Dir, TB, Pos).
  715colourise_directive((A,B), TB, term_position(_,_,_,_,[PA,PB])) :-
  716    !,
  717    colourise_directive(A, TB, PA),
  718    colourise_directive(B, TB, PB).
  719colourise_directive(Body, TB, Pos) :-
  720    nonvar(Body),
  721    directive_colours(Body, ClassSpec-ArgSpecs),   % specified
  722    !,
  723    functor_position(Pos, FPos, ArgPos),
  724    (   ClassSpec == classify
  725    ->  goal_classification(TB, Body, [], Class)
  726    ;   Class = ClassSpec
  727    ),
  728    colour_item(goal(Class, Body), TB, FPos),
  729    specified_items(ArgSpecs, Body, TB, ArgPos).
  730colourise_directive(Body, TB, Pos) :-
  731    colourise_body(Body, TB, Pos).
  732
  733
  734%       colourise_body(+Body, +TB, +Pos)
  735%
  736%       Breaks down to colourise_goal/3.
  737
  738colourise_body(Body, TB, Pos) :-
  739    colourise_body(Body, [], TB, Pos).
  740
  741colourise_body(Body, Origin, TB, Pos) :-
  742    colour_item(body, TB, Pos),
  743    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.

  752colourise_method_body(_, _, Pos) :-
  753    var(Pos),
  754    !.
  755colourise_method_body(Body, TB, parentheses_term_position(PO,PC,Pos)) :-
  756    !,
  757    colour_item(parentheses, TB, PO-PC),
  758    colourise_method_body(Body, TB, Pos).
  759colourise_method_body(::(_Comment,Body), TB,
  760                      term_position(_F,_T,_FF,_FT,[CP,BP])) :-
  761    !,
  762    colour_item(comment(string), TB, CP),
  763    colourise_body(Body, TB, BP).
  764colourise_method_body(Body, TB, Pos) :-         % deal with pri(::) < 1000
  765    Body =.. [F,A,B],
  766    control_op(F),
  767    !,
  768    Pos = term_position(_F,_T,FF,FT,
  769                        [ AP,
  770                          BP
  771                        ]),
  772    colour_item(control, TB, FF-FT),
  773    colourise_method_body(A, TB, AP),
  774    colourise_body(B, TB, BP).
  775colourise_method_body(Body, TB, Pos) :-
  776    colourise_body(Body, TB, Pos).
  777
  778control_op(',').
  779control_op((;)).
  780control_op((->)).
  781control_op((*->)).

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

Colourise the goals in a body.

  787colourise_goals(_, _, _, Pos) :-
  788    var(Pos),
  789    !.
  790colourise_goals(Body, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  791    !,
  792    colour_item(parentheses, TB, PO-PC),
  793    colourise_goals(Body, Origin, TB, Pos).
  794colourise_goals(Body, Origin, TB, term_position(_,_,FF,FT,ArgPos)) :-
  795    body_compiled(Body),
  796    !,
  797    colour_item(control, TB, FF-FT),
  798    colourise_subgoals(ArgPos, 1, Body, Origin, TB).
  799colourise_goals(Goal, Origin, TB, Pos) :-
  800    colourise_goal(Goal, Origin, TB, Pos).
  801
  802colourise_subgoals([], _, _, _, _).
  803colourise_subgoals([Pos|T], N, Body, Origin, TB) :-
  804    arg(N, Body, Arg),
  805    colourise_goals(Arg, Origin, TB, Pos),
  806    NN is N + 1,
  807    colourise_subgoals(T, NN, Body, Origin, TB).

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

Breaks down to colourise_dcg_goal/3.

  813colourise_dcg(Body, Head, TB, Pos) :-
  814    colour_item(dcg, TB, Pos),
  815    (   dcg_extend(Head, Origin)
  816    ->  true
  817    ;   Origin = Head
  818    ),
  819    colourise_dcg_goals(Body, Origin, TB, Pos).
  820
  821colourise_dcg_goals(Var, _, TB, Pos) :-
  822    var(Var),
  823    !,
  824    colour_item(goal(meta,Var), TB, Pos).
  825colourise_dcg_goals(_, _, _, Pos) :-
  826    var(Pos),
  827    !.
  828colourise_dcg_goals(Body, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  829    !,
  830    colour_item(parentheses, TB, PO-PC),
  831    colourise_dcg_goals(Body, Origin, TB, Pos).
  832colourise_dcg_goals({Body}, Origin, TB, brace_term_position(F,T,Arg)) :-
  833    !,
  834    colour_item(dcg(plain), TB, F-T),
  835    colourise_goals(Body, Origin, TB, Arg).
  836colourise_dcg_goals([], _, TB, Pos) :-
  837    !,
  838    colour_item(dcg(terminal), TB, Pos).
  839colourise_dcg_goals(List, _, TB, list_position(F,T,Elms,Tail)) :-
  840    List = [_|_],
  841    !,
  842    colour_item(dcg(terminal), TB, F-T),
  843    colourise_list_args(Elms, Tail, List, TB, classify).
  844colourise_dcg_goals(_, _, TB, string_position(F,T)) :-
  845    integer(F),
  846    !,
  847    colour_item(dcg(string), TB, F-T).
  848colourise_dcg_goals(Body, Origin, TB, term_position(_,_,FF,FT,ArgPos)) :-
  849    dcg_body_compiled(Body),       % control structures
  850    !,
  851    colour_item(control, TB, FF-FT),
  852    colourise_dcg_subgoals(ArgPos, 1, Body, Origin, TB).
  853colourise_dcg_goals(Goal, Origin, TB, Pos) :-
  854    colourise_dcg_goal(Goal, Origin, TB, Pos).
  855
  856colourise_dcg_subgoals([], _, _, _, _).
  857colourise_dcg_subgoals([Pos|T], N, Body, Origin, TB) :-
  858    arg(N, Body, Arg),
  859    colourise_dcg_goals(Arg, Origin, TB, Pos),
  860    NN is N + 1,
  861    colourise_dcg_subgoals(T, NN, Body, Origin, TB).
  862
  863dcg_extend(Term, _) :-
  864    var(Term), !, fail.
  865dcg_extend(M:Term, M:Goal) :-
  866    dcg_extend(Term, Goal).
  867dcg_extend(Term, Goal) :-
  868    compound(Term),
  869    !,
  870    compound_name_arguments(Term, Name, Args),
  871    append(Args, [_,_], NArgs),
  872    compound_name_arguments(Goal, Name, NArgs).
  873dcg_extend(Term, Goal) :-
  874    atom(Term),
  875    !,
  876    compound_name_arguments(Goal, Term, [_,_]).
  877
  878dcg_body_compiled(G) :-
  879    body_compiled(G),
  880    !.
  881dcg_body_compiled((_|_)).
  882
  883%       colourise_dcg_goal(+Goal, +Origin, +TB, +Pos).
  884
  885colourise_dcg_goal(!, Origin, TB, TermPos) :-
  886    !,
  887    colourise_goal(!, Origin, TB, TermPos).
  888colourise_dcg_goal(Goal, Origin, TB, TermPos) :-
  889    dcg_extend(Goal, TheGoal),
  890    !,
  891    colourise_goal(TheGoal, Origin, TB, TermPos).
  892colourise_dcg_goal(Goal, _, TB, Pos) :-
  893    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.

  904                                        % Deal with list as goal (consult)
  905colourise_goal(_,_,_,Pos) :-
  906    var(Pos),
  907    !.
  908colourise_goal(Goal, Origin, TB, parentheses_term_position(PO,PC,Pos)) :-
  909    !,
  910    colour_item(parentheses, TB, PO-PC),
  911    colourise_goal(Goal, Origin, TB, Pos).
  912colourise_goal(Goal, _, TB, Pos) :-
  913    Pos = list_position(F,T,Elms,_),
  914    Goal = [_|_],
  915    !,
  916    FT is F + 1,
  917    AT is T - 1,
  918    colour_item(goal_term(built_in, Goal), TB, Pos),
  919    colour_item(goal(built_in, Goal), TB, F-FT),
  920    colour_item(goal(built_in, Goal), TB, AT-T),
  921    colourise_file_list(Goal, TB, Elms, any).
  922colourise_goal(Goal, Origin, TB, Pos) :-
  923    Pos = list_position(F,T,Elms,Tail),
  924    callable(Goal),
  925    Goal =.. [_,GH,GT|_],
  926    !,
  927    goal_classification(TB, Goal, Origin, Class),
  928    FT is F + 1,
  929    AT is T - 1,
  930    colour_item(goal_term(Class, Goal), TB, Pos),
  931    colour_item(goal(Class, Goal), TB, F-FT),
  932    colour_item(goal(Class, Goal), TB, AT-T),
  933    colourise_list_args(Elms, Tail, [GH|GT], TB, classify).
  934colourise_goal(Goal, _Origin, TB, Pos) :-
  935    Pos = quasi_quotation_position(_F,_T,_QQType,_QQTypePos,_CPos),
  936    !,
  937    colourise_term_arg(Goal, TB, Pos).
  938colourise_goal(Goal, Origin, TB, Pos) :-
  939    strip_module(Goal, _, PGoal),
  940    nonvar(PGoal),
  941    (   goal_classification(TB, Goal, Origin, ClassInferred),
  942        goal_colours(Goal, ClassInferred, ClassSpec-ArgSpecs)
  943    ->  true
  944    ;   goal_colours(Goal, ClassSpec-ArgSpecs)
  945    ),
  946    !,                                          % specified
  947    functor_position(Pos, FPos, ArgPos),
  948    (   ClassSpec == classify
  949    ->  goal_classification(TB, Goal, Origin, Class)
  950    ;   Class = ClassSpec
  951    ),
  952    colour_item(goal_term(Class, Goal), TB, Pos),
  953    colour_item(goal(Class, Goal), TB, FPos),
  954    colour_dict_braces(TB, Pos),
  955    specified_items(ArgSpecs, Goal, TB, ArgPos).
  956colourise_goal(Module:Goal, _Origin, TB, QGoalPos) :-
  957    QGoalPos = term_position(_,_,QF,QT,[PM,PG]),
  958    !,
  959    colour_item(module(Module), TB, PM),
  960    colour_item(functor, TB, QF-QT),
  961    (   PG = term_position(_,_,FF,FT,_)
  962    ->  FP = FF-FT
  963    ;   FP = PG
  964    ),
  965    (   callable(Goal)
  966    ->  qualified_goal_classification(Module:Goal, TB, Class),
  967        colour_item(goal_term(Class, Goal), TB, QGoalPos),
  968        colour_item(goal(Class, Goal), TB, FP),
  969        colourise_goal_args(Goal, Module, TB, PG)
  970    ;   var(Goal)
  971    ->  colourise_term_arg(Goal, TB, PG)
  972    ;   colour_item(type_error(callable), TB, PG)
  973    ).
  974colourise_goal(Op, _Origin, TB, Pos) :-
  975    nonvar(Op),
  976    Op = op(_,_,_),
  977    !,
  978    colourise_op_declaration(Op, TB, Pos).
  979colourise_goal(Goal, Origin, TB, Pos) :-
  980    goal_classification(TB, Goal, Origin, Class),
  981    (   Pos = term_position(_,_,FF,FT,_ArgPos)
  982    ->  FPos = FF-FT
  983    ;   FPos = Pos
  984    ),
  985    colour_item(goal_term(Class, Goal), TB, Pos),
  986    colour_item(goal(Class, Goal), TB, FPos),
  987    colourise_goal_args(Goal, TB, Pos).
  988
  989% make sure to emit a fragment for the braces of tag{k:v, ...} or
  990% {...} that is mapped to something else.
  991
  992colour_dict_braces(TB, dict_position(_F,T,_TF,TT,_KVPos)) :-
  993    !,
  994    BStart is TT+1,
  995    colour_item(dict_content, TB, BStart-T).
  996colour_dict_braces(TB, brace_term_position(F,T,_Arg)) :-
  997    !,
  998    colour_item(brace_term, TB, F-T).
  999colour_dict_braces(_, _).

 colourise_goal_args(+Goal, +TB, +Pos)

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

 1006colourise_goal_args(Goal, TB, Pos) :-
 1007    colourization_module(TB, Module),
 1008    colourise_goal_args(Goal, Module, TB, Pos).
 1009
 1010colourization_module(TB, Module) :-
 1011    (   colour_state_source_id(TB, SourceId),
 1012        xref_module(SourceId, Module)
 1013    ->  true
 1014    ;   Module = user
 1015    ).
 1016
 1017colourise_goal_args(Goal, M, TB, term_position(_,_,_,_,ArgPos)) :-
 1018    !,
 1019    (   meta_args(Goal, TB, MetaArgs)
 1020    ->  colourise_meta_args(1, Goal, M, MetaArgs, TB, ArgPos)
 1021    ;   colourise_goal_args(1, Goal, M, TB, ArgPos)
 1022    ).
 1023colourise_goal_args(Goal, M, TB, brace_term_position(_,_,ArgPos)) :-
 1024    !,
 1025    (   meta_args(Goal, TB, MetaArgs)
 1026    ->  colourise_meta_args(1, Goal, M, MetaArgs, TB, [ArgPos])
 1027    ;   colourise_goal_args(1, Goal, M, TB, [ArgPos])
 1028    ).
 1029colourise_goal_args(_, _, _, _).                % no arguments
 1030
 1031colourise_goal_args(_, _, _, _, []) :- !.
 1032colourise_goal_args(N, Goal, Module, TB, [P0|PT]) :-
 1033    colourise_option_arg(Goal, Module, N, TB, P0),
 1034    !,
 1035    NN is N + 1,
 1036    colourise_goal_args(NN, Goal, Module, TB, PT).
 1037colourise_goal_args(N, Goal, Module, TB, [P0|PT]) :-
 1038    arg(N, Goal, Arg),
 1039    colourise_term_arg(Arg, TB, P0),
 1040    NN is N + 1,
 1041    colourise_goal_args(NN, Goal, Module, TB, PT).
 1042
 1043
 1044colourise_meta_args(_, _, _, _, _, []) :- !.
 1045colourise_meta_args(N, Goal, Module, MetaArgs, TB, [P0|PT]) :-
 1046    colourise_option_arg(Goal, Module, N, TB, P0),
 1047    !,
 1048    NN is N + 1,
 1049    colourise_meta_args(NN, Goal, Module, MetaArgs, TB, PT).
 1050colourise_meta_args(N, Goal, Module, MetaArgs, TB, [P0|PT]) :-
 1051    arg(N, Goal, Arg),
 1052    arg(N, MetaArgs, MetaSpec),
 1053    colourise_meta_arg(MetaSpec, Arg, TB, P0),
 1054    NN is N + 1,
 1055    colourise_meta_args(NN, Goal, Module, MetaArgs, TB, PT).
 1056
 1057colourise_meta_arg(MetaSpec, Arg, TB, Pos) :-
 1058    expand_meta(MetaSpec, Arg, Expanded),
 1059    !,
 1060    colourise_goal(Expanded, [], TB, Pos). % TBD: recursion
 1061colourise_meta_arg(MetaSpec, Arg, TB, Pos) :-
 1062    MetaSpec == //,
 1063    !,
 1064    colourise_dcg_goals(Arg, //, TB, Pos).
 1065colourise_meta_arg(_, Arg, TB, Pos) :-
 1066    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.

 1079meta_args(Goal, TB, VarGoal) :-
 1080    colour_state_source_id(TB, SourceId),
 1081    xref_meta(SourceId, Goal, _),
 1082    !,
 1083    compound_name_arity(Goal, Name, Arity),
 1084    compound_name_arity(VarGoal, Name, Arity),
 1085    xref_meta(SourceId, VarGoal, MetaArgs),
 1086    instantiate_meta(MetaArgs).
 1087
 1088instantiate_meta([]).
 1089instantiate_meta([H|T]) :-
 1090    (   var(H)
 1091    ->  H = 0
 1092    ;   H = V+N
 1093    ->  V = N
 1094    ;   H = //(V)
 1095    ->  V = (//)
 1096    ),
 1097    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).

 1104expand_meta(MetaSpec, Goal, Goal) :-
 1105    MetaSpec == 0.
 1106expand_meta(MetaSpec, M:Goal, M:Expanded) :-
 1107    atom(M),
 1108    !,
 1109    expand_meta(MetaSpec, Goal, Expanded).
 1110expand_meta(MetaSpec, Goal, Expanded) :-
 1111    integer(MetaSpec),
 1112    callable(Goal),
 1113    !,
 1114    length(Extra, MetaSpec),
 1115    Goal =.. List0,
 1116    append(List0, Extra, List),
 1117    Expanded =.. List.

 colourise_setof(+Term, +TB, +Pos)

Colourise the 2nd argument of setof/bagof

 1123colourise_setof(Var^G, TB, term_position(_,_,FF,FT,[VP,GP])) :-
 1124    !,
 1125    colourise_term_arg(Var, TB, VP),
 1126    colour_item(ext_quant, TB, FF-FT),
 1127    colourise_setof(G, TB, GP).
 1128colourise_setof(Term, TB, Pos) :-
 1129    colourise_goal(Term, [], TB, Pos).
 1130
 1131%       colourise_db(+Arg, +TB, +Pos)
 1132%
 1133%       Colourise database modification calls (assert/1, retract/1 and
 1134%       friends.
 1135
 1136colourise_db((Head:-_Body), TB, term_position(_,_,_,_,[HP,_])) :-
 1137    !,
 1138    colourise_db(Head, TB, HP).
 1139colourise_db(Module:Head, TB, term_position(_,_,QF,QT,[MP,HP])) :-
 1140    !,
 1141    colour_item(module(Module), TB, MP),
 1142    colour_item(functor, TB, QF-QT),
 1143    (   atom(Module),
 1144        colour_state_source_id(TB, SourceId),
 1145        xref_module(SourceId, Module)
 1146    ->  colourise_db(Head, TB, HP)
 1147    ;   colourise_db(Head, TB, HP)
 1148    ).
 1149colourise_db(Head, TB, Pos) :-
 1150    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

 1159colourise_option_arg(Goal, Module, Arg, TB, ArgPos) :-
 1160    goal_name_arity(Goal, Name, Arity),
 1161    current_option_arg(Module:Name/Arity, Arg),
 1162    current_predicate_options(Module:Name/Arity, Arg, OptionDecl),
 1163    debug(emacs, 'Colouring option-arg ~w of ~p',
 1164          [Arg, Module:Name/Arity]),
 1165    arg(Arg, Goal, Options),
 1166    colourise_option(Options, Module, Goal, Arg, OptionDecl, TB, ArgPos).
 1167
 1168colourise_option(Options0, Module, Goal, Arg, OptionDecl, TB, Pos0) :-
 1169    strip_option_module_qualifier(Goal, Module, Arg, TB,
 1170                                  Options0, Pos0, Options, Pos),
 1171    (   Pos = list_position(F, T, ElmPos, TailPos)
 1172    ->  colour_item(list, TB, F-T),
 1173        colourise_option_list(Options, OptionDecl, TB, ElmPos, TailPos)
 1174    ;   (   var(Options)
 1175        ;   Options == []
 1176        )
 1177    ->  colourise_term_arg(Options, TB, Pos)
 1178    ;   colour_item(type_error(list), TB, Pos)
 1179    ).
 1180
 1181strip_option_module_qualifier(Goal, Module, Arg, TB,
 1182                              M:Options, term_position(_,_,_,_,[MP,Pos]),
 1183                              Options, Pos) :-
 1184    predicate_property(Module:Goal, meta_predicate(Head)),
 1185    arg(Arg, Head, :),
 1186    !,
 1187    colour_item(module(M), TB, MP).
 1188strip_option_module_qualifier(_, _, _, _,
 1189                              Options, Pos, Options, Pos).
 1190
 1191
 1192colourise_option_list(_, _, _, [], none) :- !.
 1193colourise_option_list(Tail, _, TB, [], TailPos) :-
 1194    !,
 1195    colourise_term_arg(Tail, TB, TailPos).
 1196colourise_option_list([H|T], OptionDecl, TB, [HPos|TPos], TailPos) :-
 1197    colourise_option(H, OptionDecl, TB, HPos),
 1198    colourise_option_list(T, OptionDecl, TB, TPos, TailPos).
 1199
 1200colourise_option(Opt, _, TB, Pos) :-
 1201    var(Opt),
 1202    !,
 1203    colourise_term_arg(Opt, TB, Pos).
 1204colourise_option(Opt, OptionDecl, TB, term_position(_,_,FF,FT,ValPosList)) :-
 1205    !,
 1206    generalise_term(Opt, GenOpt),
 1207    (   memberchk(GenOpt, OptionDecl)
 1208    ->  colour_item(option_name, TB, FF-FT),
 1209        Opt =.. [Name|Values],
 1210        GenOpt =.. [Name|Types],
 1211        colour_option_values(Values, Types, TB, ValPosList)
 1212    ;   colour_item(no_option_name, TB, FF-FT),
 1213        colourise_term_args(ValPosList, 1, Opt, TB)
 1214    ).
 1215colourise_option(_, _, TB, Pos) :-
 1216    colour_item(type_error(option), TB, Pos).
 1217
 1218colour_option_values([], [], _, _).
 1219colour_option_values([V0|TV], [T0|TT], TB, [P0|TP]) :-
 1220    (   (   var(V0)
 1221        ;   is_of_type(T0, V0)
 1222        ;   T0 = list(_),
 1223            member(E, V0),
 1224            var(E)
 1225        ;   functor(V0, '.', 2),
 1226            V0 \= [_|_]
 1227        )
 1228    ->  colourise_term_arg(V0, TB, P0)
 1229    ;   callable(V0),
 1230        (   T0 = callable
 1231        ->  N = 0
 1232        ;   T0 = (callable+N)
 1233        )
 1234    ->  colourise_meta_arg(N, V0, TB, P0)
 1235    ;   colour_item(type_error(T0), TB, P0)
 1236    ),
 1237    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

 1246colourise_files(List, TB, list_position(F,T,Elms,_), Why) :-
 1247    !,
 1248    colour_item(list, TB, F-T),
 1249    colourise_file_list(List, TB, Elms, Why).
 1250colourise_files(M:Spec, TB, term_position(_,_,_,_,[MP,SP]), Why) :-
 1251    !,
 1252    colour_item(module(M), TB, MP),
 1253    colourise_files(Spec, TB, SP, Why).
 1254colourise_files(Var, TB, P, _) :-
 1255    var(Var),
 1256    !,
 1257    colour_item(var, TB, P).
 1258colourise_files(Spec0, TB, Pos, Why) :-
 1259    strip_module(Spec0, _, Spec),
 1260    (   colour_state_source_id(TB, Source),
 1261        prolog_canonical_source(Source, SourceId),
 1262        catch(xref_source_file(Spec, Path, SourceId, [silent(true)]),
 1263              _, fail)
 1264    ->  (   Why = imported,
 1265            \+ resolves_anything(TB, Path),
 1266            exports_something(TB, Path)
 1267        ->  colour_item(file_no_depend(Path), TB, Pos)
 1268        ;   colour_item(file(Path), TB, Pos)
 1269        )
 1270    ;   colour_item(nofile, TB, Pos)
 1271    ).
 1272
 1273colourise_file_list([], _, _, _).
 1274colourise_file_list([H|T], TB, [PH|PT], Why) :-
 1275    colourise_files(H, TB, PH, Why),
 1276    colourise_file_list(T, TB, PT, Why).
 1277
 1278resolves_anything(TB, Path) :-
 1279    colour_state_source_id(TB, SourceId),
 1280    xref_defined(SourceId, Head, imported(Path)),
 1281    xref_called(SourceId, Head, _),
 1282    !.
 1283
 1284exports_something(TB, Path) :-
 1285    colour_state_source_id(TB, SourceId),
 1286    xref_defined(SourceId, _, imported(Path)),
 1287    !.

 colourise_directory(+Arg, +TB, +Pos)

Colourise argument that should be an existing directory.

 1293colourise_directory(Spec, TB, Pos) :-
 1294    (   colour_state_source_id(TB, SourceId),
 1295        catch(xref_source_file(Spec, Path, SourceId,
 1296                               [ file_type(directory),
 1297                                 silent(true)
 1298                               ]),
 1299              _, fail)
 1300    ->  colour_item(directory(Path), TB, Pos)
 1301    ;   colour_item(nofile, TB, Pos)
 1302    ).

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

Colourise the 3th argument of module/3

 1308colourise_langoptions([], _, _) :- !.
 1309colourise_langoptions([H|T], TB, list_position(PF,PT,[HP|TP],_)) :-
 1310    !,
 1311    colour_item(list, TB, PF-PT),
 1312    colourise_langoptions(H, TB, HP),
 1313    colourise_langoptions(T, TB, TP).
 1314colourise_langoptions(Spec, TB, Pos) :-
 1315    colourise_files(library(dialect/Spec), TB, Pos, imported).

 colourise_class(ClassName, TB, Pos)

Colourise an XPCE class.

 1321colourise_class(ClassName, TB, Pos) :-
 1322    colour_state_source_id(TB, SourceId),
 1323    classify_class(SourceId, ClassName, Classification),
 1324    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.

 1332classify_class(SourceId, Name, Class) :-
 1333    xref_defined_class(SourceId, Name, Class),
 1334    !.
 1335classify_class(_SourceId, Name, Class) :-
 1336    current_predicate(pce:send_class/3),
 1337    (   current_predicate(classify_class/2)
 1338    ->  true
 1339    ;   use_module(library(pce_meta), [classify_class/2])
 1340    ),
 1341    member(G, [classify_class(Name, Class)]),
 1342    call(G).

 colourise_term_args(+Term, +TB, +Pos)

colourise head/body principal terms.

 1348colourise_term_args(Term, TB,
 1349                    term_position(_,_,_,_,ArgPos)) :-
 1350    !,
 1351    colourise_term_args(ArgPos, 1, Term, TB).
 1352colourise_term_args(_, _, _).
 1353
 1354colourise_term_args([], _, _, _).
 1355colourise_term_args([Pos|T], N, Term, TB) :-
 1356    arg(N, Term, Arg),
 1357    colourise_term_arg(Arg, TB, Pos),
 1358    NN is N + 1,
 1359    colourise_term_args(T, NN, Term, TB).
 1360
 1361colourise_term_arg(_, _, Pos) :-
 1362    var(Pos),
 1363    !.
 1364colourise_term_arg(Arg, TB, parentheses_term_position(PO,PC,Pos)) :-
 1365    !,
 1366    colour_item(parentheses, TB, PO-PC),
 1367    colourise_term_arg(Arg, TB, Pos).
 1368colourise_term_arg(Var, TB, Pos) :-                     % variable
 1369    var(Var), Pos = _-_,
 1370    !,
 1371    (   singleton(Var, TB)
 1372    ->  colour_item(singleton, TB, Pos)
 1373    ;   colour_item(var, TB, Pos)
 1374    ).
 1375colourise_term_arg(List, TB, list_position(F, T, Elms, Tail)) :-
 1376    !,
 1377    colour_item(list, TB, F-T),
 1378    colourise_list_args(Elms, Tail, List, TB, classify).    % list
 1379colourise_term_arg(String, TB, string_position(F, T)) :-       % string
 1380    !,
 1381    (   string(String)
 1382    ->  colour_item(string, TB, F-T)
 1383    ;   String = [H|_]
 1384    ->  (   integer(H)
 1385        ->  colour_item(codes, TB, F-T)
 1386        ;   colour_item(chars, TB, F-T)
 1387        )
 1388    ;   String == []
 1389    ->  colour_item(codes, TB, F-T)
 1390    ).
 1391colourise_term_arg(_, TB,
 1392                   quasi_quotation_position(F,T,QQType,QQTypePos,CPos)) :-
 1393    !,
 1394    colourise_qq_type(QQType, TB, QQTypePos),
 1395    functor_name(QQType, Type),
 1396    colour_item(qq_content(Type), TB, CPos),
 1397    arg(1, CPos, SE),
 1398    SS is SE-2,
 1399    FE is F+2,
 1400    TS is T-2,
 1401    colour_item(qq(open),  TB, F-FE),
 1402    colour_item(qq(sep),   TB, SS-SE),
 1403    colour_item(qq(close), TB, TS-T).
 1404colourise_term_arg({Term}, TB, brace_term_position(F,T,Arg)) :-
 1405    !,
 1406    colour_item(brace_term, TB, F-T),
 1407    colourise_term_arg(Term, TB, Arg).
 1408colourise_term_arg(Map, TB, dict_position(F,T,TF,TT,KVPos)) :-
 1409    !,
 1410    is_dict(Map, Tag),
 1411    colour_item(dict, TB, F-T),
 1412    TagPos = TF-TT,
 1413    (   var(Tag)
 1414    ->  (   singleton(Tag, TB)
 1415        ->  colour_item(singleton, TB, TagPos)
 1416        ;   colour_item(var, TB, TagPos)
 1417        )
 1418    ;   colour_item(dict_tag, TB, TagPos)
 1419    ),
 1420    BStart is TT+1,
 1421    colour_item(dict_content, TB, BStart-T),
 1422    colourise_dict_kv(Map, TB, KVPos).
 1423colourise_term_arg([](List,Term), TB,                   % [] as operator
 1424                   term_position(_,_,0,0,[ListPos,ArgPos])) :-
 1425    !,
 1426    colourise_term_arg(List, TB, ListPos),
 1427    colourise_term_arg(Term, TB, ArgPos).
 1428colourise_term_arg(Compound, TB, Pos) :-                % compound
 1429    compound(Compound),
 1430    !,
 1431    (   Pos = term_position(_F,_T,FF,FT,_ArgPos)
 1432    ->  colour_item(functor, TB, FF-FT)             % TBD: Infix/Postfix?
 1433    ;   true                                        % TBD: When is this
 1434    ),
 1435    colourise_term_args(Compound, TB, Pos).
 1436colourise_term_arg(EmptyList, TB, Pos) :-
 1437    EmptyList == [],
 1438    !,
 1439    colour_item(empty_list, TB, Pos).
 1440colourise_term_arg(Atom, TB, Pos) :-
 1441    atom(Atom),
 1442    !,
 1443    colour_item(atom, TB, Pos).
 1444colourise_term_arg(Integer, TB, Pos) :-
 1445    integer(Integer),
 1446    !,
 1447    colour_item(int, TB, Pos).
 1448colourise_term_arg(Float, TB, Pos) :-
 1449    float(Float),
 1450    !,
 1451    colour_item(float, TB, Pos).
 1452colourise_term_arg(_Arg, _TB, _Pos) :-
 1453    true.
 1454
 1455colourise_list_args([HP|TP], Tail, [H|T], TB, How) :-
 1456    specified_item(How, H, TB, HP),
 1457    colourise_list_args(TP, Tail, T, TB, How).
 1458colourise_list_args([], none, _, _, _) :- !.
 1459colourise_list_args([], TP, T, TB, How) :-
 1460    specified_item(How, T, TB, TP).