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    nonvar(Goal),
  940    (   goal_classification(TB, Goal, Origin, ClassInferred),
  941        goal_colours(Goal, ClassInferred, ClassSpec-ArgSpecs)
  942    ->  true
  943    ;   goal_colours(Goal, ClassSpec-ArgSpecs)
  944    ),
  945    !,                                          % specified
  946    functor_position(Pos, FPos, ArgPos),
  947    (   ClassSpec == classify
  948    ->  goal_classification(TB, Goal, Origin, Class)
  949    ;   Class = ClassSpec
  950    ),
  951    colour_item(goal_term(Class, Goal), TB, Pos),
  952    colour_item(goal(Class, Goal), TB, FPos),
  953    colour_dict_braces(TB, Pos),
  954    specified_items(ArgSpecs, Goal, TB, ArgPos).
  955colourise_goal(Module:Goal, _Origin, TB, QGoalPos) :-
  956    QGoalPos = term_position(_,_,QF,QT,[PM,PG]),
  957    !,
  958    colour_item(module(Module), TB, PM),
  959    colour_item(functor, TB, QF-QT),
  960    (   PG = term_position(_,_,FF,FT,_)
  961    ->  FP = FF-FT
  962    ;   FP = PG
  963    ),
  964    colour_item(goal_term(extern(Module), Goal), TB, QGoalPos),
  965    colour_item(goal(extern(Module), Goal), TB, FP),
  966    colourise_goal_args(Goal, Module, TB, PG).
  967colourise_goal(Op, _Origin, TB, Pos) :-
  968    nonvar(Op),
  969    Op = op(_,_,_),
  970    !,
  971    colourise_op_declaration(Op, TB, Pos).
  972colourise_goal(Goal, Origin, TB, Pos) :-
  973    goal_classification(TB, Goal, Origin, Class),
  974    (   Pos = term_position(_,_,FF,FT,_ArgPos)
  975    ->  FPos = FF-FT
  976    ;   FPos = Pos
  977    ),
  978    colour_item(goal_term(Class, Goal), TB, Pos),
  979    colour_item(goal(Class, Goal), TB, FPos),
  980    colourise_goal_args(Goal, TB, Pos).
  981
  982% make sure to emit a fragment for the braces of tag{k:v, ...} or
  983% {...} that is mapped to something else.
  984
  985colour_dict_braces(TB, dict_position(_F,T,_TF,TT,_KVPos)) :-
  986    !,
  987    BStart is TT+1,
  988    colour_item(dict_content, TB, BStart-T).
  989colour_dict_braces(TB, brace_term_position(F,T,_Arg)) :-
  990    !,
  991    colour_item(brace_term, TB, F-T).
  992colour_dict_braces(_, _).

 colourise_goal_args(+Goal, +TB, +Pos)

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

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

 1072meta_args(Goal, TB, VarGoal) :-
 1073    colour_state_source_id(TB, SourceId),
 1074    xref_meta(SourceId, Goal, _),
 1075    !,
 1076    compound_name_arity(Goal, Name, Arity),
 1077    compound_name_arity(VarGoal, Name, Arity),
 1078    xref_meta(SourceId, VarGoal, MetaArgs),
 1079    instantiate_meta(MetaArgs).
 1080
 1081instantiate_meta([]).
 1082instantiate_meta([H|T]) :-
 1083    (   var(H)
 1084    ->  H = 0
 1085    ;   H = V+N
 1086    ->  V = N
 1087    ;   H = //(V)
 1088    ->  V = (//)
 1089    ),
 1090    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).

 1097expand_meta(MetaSpec, Goal, Goal) :-
 1098    MetaSpec == 0.
 1099expand_meta(MetaSpec, M:Goal, M:Expanded) :-
 1100    atom(M),
 1101    !,
 1102    expand_meta(MetaSpec, Goal, Expanded).
 1103expand_meta(MetaSpec, Goal, Expanded) :-
 1104    integer(MetaSpec),
 1105    callable(Goal),
 1106    !,
 1107    length(Extra, MetaSpec),
 1108    Goal =.. List0,
 1109    append(List0, Extra, List),
 1110    Expanded =.. List.

 colourise_setof(+Term, +TB, +Pos)

Colourise the 2nd argument of setof/bagof

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

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

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

 colourise_directory(+Arg, +TB, +Pos)

Colourise argument that should be an existing directory.

 1286colourise_directory(Spec, TB, Pos) :-
 1287    (   colour_state_source_id(TB, SourceId),
 1288        catch(xref_source_file(Spec, Path, SourceId,
 1289                               [ file_type(directory),
 1290                                 silent(true)
 1291                               ]),
 1292              _, fail)
 1293    ->  colour_item(directory(Path), TB, Pos)
 1294    ;   colour_item(nofile, TB, Pos)
 1295    ).

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

Colourise the 3th argument of module/3

 1301colourise_langoptions([], _, _) :- !.
 1302colourise_langoptions([H|T], TB, list_position(PF,PT,[HP|TP],_)) :-
 1303    !,
 1304    colour_item(list, TB, PF-PT),
 1305    colourise_langoptions(H, TB, HP),
 1306    colourise_langoptions(T, TB, TP).
 1307colourise_langoptions(Spec, TB, Pos) :-
 1308    colourise_files(library(dialect/Spec), TB, Pos, imported).

 colourise_class(ClassName, TB, Pos)

Colourise an XPCE class.

 1314colourise_class(ClassName, TB, Pos) :-
 1315    colour_state_source_id(TB, SourceId),
 1316    classify_class(SourceId, ClassName, Classification),
 1317    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.

 1325classify_class(SourceId, Name, Class) :-
 1326    xref_defined_class(SourceId, Name, Class),
 1327    !.
 1328classify_class(_SourceId, Name, Class) :-
 1329    current_predicate(pce:send_class/3),
 1330    (   current_predicate(classify_class/2)
 1331    ->  true
 1332    ;   use_module(library(pce_meta), [classify_class/2])
 1333    ),
 1334    member(G, [classify_class(Name, Class)]),
 1335    call(G).

 colourise_term_args(+Term, +TB, +Pos)

colourise head/body principal terms.

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