highlight.lgt

    /*
       Highlighting test case for Logtalk

       Copied from the Logtalk distribution by the Logtalk copright holder
       and contributed using the Apache License 2.0
    */

    :- encoding(Encoding).	% this is a single-line comment

    /*
    this is
    a block
    comment
    */

    :- if(Goal).
    	% conditional
    :- elif(Goal).
    	% compilation
    :- else.
    	% directives
    :- endif.

    :- initialization(Goal).
    :- op(Precedence, Associativity, Operator).
    :- ensure_loaded(File).
    :- include(File).
    :- set_prolog_flag(Flag, Value).
    :- set_logtalk_flag(Flag, Value).

    :- object(prototype,
    	implements(protocol),
    	imports(category),
    	extends(parent)).

    	:- info([
    		version is 1:47:0,
    		author is 'Paulo Moura',
    		date is 2019-09-18,
    		comment is 'Sample prototype for testing syntax coloring.'
    	]).

    	:- built_in.
    	:- threaded.
    	:- dynamic.

    	:- initialization(some_goal(X, Y)).

    	:- uses([
    		foobar as fb
    	]).

    	:- alias(set, [member/2 as set_member/2]).
    	:- alias(words, [singular//0 as peculiar//0]).

    	:- uses(list, [append/3, member/2]).
    	:- uses(queues, [new/1 as new_queue/1]).

    	:- use_module(module).
    	:- use_module(module, [append/3, member/2]).

    	:- multifile(zzz/1).
    	:- multifile(module:zzz/1).
    	:- multifile(object::zzz/1).

    	:- coinductive(comember/1).

    	:- use_module(module, [xxx/1, yyy/2, zzz/3]).
    	:- export(bbb/3).
    	:- reexport(cccc/4).

    	:- public(aaa/2).
    	:- meta_predicate(aaa(::, *)).
    	:- discontiguous(aaa/2).
    	:- mode(aaa(+callable, ?integer), zero_or_one).
    	:- info(position/2, [
    		comment is 'Predicate brief description.',
    		arguments is ['Arg1'-'Arg1 description', 'Arg2'-'Arg2 description']
    	]).

    	:- public(nt//2).
    	:- meta_non_terminal(nt(1, *)).

    	:- protected(bbb/2).
    	:- synchronized(bbb/2).
    	:- mode(bbb(+integer, -float), one).
    	:- info(bbb/2, [
    		comment is 'Predicate brief description.',
    		argnames is ['Arg1', 'Arg2']
    	]).

    	:- private(ccc/2).
    	:- dynamic(ccc/2).
    	:- mode(ccc(@atom, ?atom, ++list, --ground), one_or_more).
    	:- info(ccc/2, [
    		comment is 'Predicate brief description.',
    		argnames is ['Arg1', 'Arg2']
    	]).

    	enumerating_entities(Object, Protocol, Category) :-
    		current_category(Category),
    		current_object(Object),
    		current_protocol(Protocol).

    	enumerating_properties :-
    		category_property(Category, Property),
    		object_property(Object, Property),
    		protocol_property(Protocol, Property).

    	creating_entities(Object, Protocol, Category) :-
    		create_category(Category, Relations, Directives, Clauses),
    		create_object(Object, Relations, Directives, Clauses),
    		create_protocol(Protocol, Relations, Directives).

    	abolishing_entities(Object, Protocol, Category) :-
    		abolish_category(Category),
    		abolish_object(Object),
    		abolish_protocol(Protocol).

    	entity_relations :-
    		extends_object(Prototype, Parent, Scope),
    		extends_protocol(Protocol1, Protocol2, Scope),
    		extends_category(Category1, Category2, Scope),
    		implements_protocol(Object, Protocol, Scope),
    		imports_category(Object, Category, Scope),
    		instantiates_class(Instance, Class, Scope),
    		specializes_class(Class, Superclass, Scope),
    		complements_object(Category, Object),
    		conforms_to_protocol(ObjOrCtg, Protocol, Scope).

    	event_handling :-
    		abolish_events(Event, Object, Message, Sender, Monitor),
    		current_event(Event, Object, Message, Sender, Monitor),
    		define_events(Event, Object, Message, Sender, Monitor).

    	multi_threading :-
    		threaded(Goals),
    		threaded_call(Goal),
    		threaded_call(Goal, Tag),
    		threaded_once(Goal),
    		threaded_once(Goal, Tag),
    		threaded_ignore(Goal),
    		threaded_exit(Goal),
    		threaded_exit(Goal, Tag),
    		threaded_peek(Goal),
    		threaded_peek(Goal, Tag),
    		threaded_cancel(Tag),
    		threaded_wait(Notification),
    		threaded_notify(Notification).

    	engines :-
    		threaded_engine(Engine),
    		threaded_engine_create(AnswerTemplate, Goal, Engine),
    		threaded_engine_destroy(Engine),
    		threaded_engine_self(Engine),
    		threaded_engine_next(Engine, Answer),
    		threaded_engine_next_reified(Engine, Answer),
    		threaded_engine_yield(Answer),
    		threaded_engine_post(Engine, Term),
    		threaded_engine_fetch(Term).

    	compiling_and_loading :-
    		logtalk_compile(File, Options),
    		logtalk_load(File, Options),
    		logtalk_library_path(Library, Path),
    		logtalk_load_context(Key, Value),
    		logtalk_make(Action),
    		logtalk_make,
    		logtalk_make_target_action(Target).

    	flags :-
    		current_logtalk_flag(Flag, Value),
    		set_logtalk_flag(Flag, Value),
    		create_logtalk_flag(Flag, Value, Options).

    	execution_context_methods :-
    		context(Context),
    		parameter(N, Parameter),
    		self(Self),
    		sender(Sender),
    		this(This).

    	reflection_methods :-
    		current_predicate(Predicate),
    		predicate_property(Predicate, Property).

    	database_methods :-
    		abolish(Name/Arity),
    		asserta(Clause),
    		assertz(Clause),
    		clause(Head, Body),
    		retract(Clause),
    		retractall(Head).

    	exception_methods :-
    		catch(Goal, Error, Catcher),
    		throw(Error),
    		instantiation_error,
    		type_error(Type, Culprit),
    		domain_error(Domain, Culprit),
    		existence_error(Thing, Culprit),
    		permission_error(Operation, Permission, Culprit),
    		representation_error(Flag),
    		evaluation_error(Exception),
    		resource_error(Resource),
    		syntax_error(Description),
    		system_error.

    	all_solutions_methods :-
    		bagof(Term, Goal, List),
    		bagof(Term, Var^Goal, List),
    		findall(Term, Goal, List),
    		forall(Generate, Test),
    		setof(Term, Goal, List),
    		setof(Term, Var1^Var2^Goal, List).

    	event_handler_methods :-
    		before(Object, Message, Sender),
    		after(Object, Message, Sender).

    	message_forwarding_method :-
    		forward(Message).

    	dcg_rules_parsing_methods :-
    		phrase(NonTerminal, Input, Rest).

    	term_expansion_methods :-
    		expand_term(Term, Expanded),
    		expand_goal(Goal, Expanded),
    		term_expansion(Term, Expanded),
    		goal_expansion(Goal, Expanded).

    	message_sending :-
    		Object::Message,
    		::Message,
    		^^Message.

    	calling_external_code :-
    		{goal1, goal2, goal3}.

    	context_switching_calls :-
    		Object<<Goal.

    	lambda_expressions :-
    		{X,Y,Z}/[P,Q]>>Goal.

    	explicitly_qualified_module_calls :-
    		Module:Goal.

    	if_then_else :-
    		(	If ->
    			Then
    		;	Else
    		).

    	numbers :-
    		X1 is 13, X2 is -13, X3 is +13,
    		Y1 is 13.13, Y2 is -13.13, Y3 is +13.13,
    		Z1 is 13.13e-23, Z2 is -13.13e-23, Z3 is +13.13e-23,
    		C1 is 0'A, C2 is 0'', C3 is 0'", C4 is 0'%,
    		C5 is 0'\n, C6 is 0'\\, C7 is 0'\', C8 is 0'\", C9 is 0'\`,
    		B1 is 0b1011101,
    		O1 is 0o1234560,
    		H1 is 0x1234567890abcDEF.

    	functions :-
    		A is atan(3.14) + atan2(1, 0) + acos(0.5) + asin(0.5) + sin(0.77) - cos(123.23) - tan(0.33),
    		B is sign(-12) * abs(35/78),
    		C is truncate(3.14) + round(-7.8) - ceiling(111.88),
    		D is exp(3.8) - log(123.98) / sqrt(33) * 23 ** 4 + 12345^2,
    		E is rem(3, 2) + mod(5, 3) - div(8, 4) * 2 rem 2 // 5 mod 3 - 8 div 4 + pi * e,
    		F is float_fractional_part(3.14) + float_integer_part(3.14),
    		G is float(33) + floor(99.99),
    		I is min(3,4) + max(4,5).

    	bitwise :-
    		A is 16 >> 2,
    		B is 16 << 2,
    		C is 10 /\ 12,
    		D is 10 \/ 12,
    		E is \ 10,
    		F is xor(13, 7).

    	term_unification :-
    		Term1 = Term2,
    		Term1 \= Term2,
    		unify_with_occurs_check(Term1, Term2),
    		subsumes_term(General, Specific).

    	term_testing :-
    		atom(Atom),
    		atomic(Atomic),
    		integer(Integer),
    		float(Float),
    		callable(Term),
    		compound(Term),
    		nonvar(Term),
    		var(Term),
    		number(Number),
    		ground(Term),
    		acyclic_term(Term).

    	term_comparison :-
    		compare(Order, Term1, Term2),
    		Term1 == Term2,
    		Term1 \== Term2,
    		Term1 @< Term2,
    		Term1 @=< Term2,
    		Term1 @>= Term2,
    		Term1 @> Term2.

    	term_creation_and_decomposition :-
    		functor(Term, Name, Arity),
    		arg(N, Term, Arg),
    		Term =.. [Functor| Args],
    		copy_term(Term, Copy),
    		numbervars(Term, Start, End),
    		term_variables(Term, Variables).

    	arithmetic_evaluation :-
    		X is Expression.

    	arithmetic_comparison :-
    		Exp1 =:= Exp2,
    		Exp1 =\= Exp2,
    		Exp1 < Exp2,
    		Exp1 =< Exp2,
    		Exp1 > Exp2,
    		Exp1 >= Exp2.

    	stream_selection_and_control :-
    		current_input(Stream),
    		current_output(Stream),
    		set_input(Stream),
    		set_output(Stream),
    		open(Source, Mode, Stream, Options),
    		close(Stream),
    		flush_output(Stream),
    		stream_property(Stream, Property),
    		at_end_of_stream(Stream),
    		set_stream_position(Stream, Position),
    		flush_output,
    		at_end_of_stream.

    	character_input_output :-
    		get_char(Char),
    		get_code(Code),
    		peek_char(Char),
    		peek_code(Code),
    		put_char(Char),
    		put_code(Code),
    		nl(Stream),
    		nl.

    	byte_input_output :-
    		get_byte(Byte),
    		peek_byte(Byte),
    		put_byte(Byte).

    	term_input_output :-
    		read(Term),
    		read_term(Stream, Term, Options),
    		write(Term),
    		write(Term),
    		write_canonical(Term),
    		write_term(Stream, Term, Options),
    		current_op(Precedence, Associativity, Operator),
    		op(Precedence, Associativity, Operator),
    		current_char_conversion(InChar, OutChar),
    		char_conversion(InChar, OutChar).

    	logic_and_control :-
    		\+ Goal,
    		call(Goal),
    		once(Goal),
    		ignore(Goal),
    		true,
    		fail,
    		false,
    		repeat,
    		!.

    	atomic_term_processing :-
    		atom_length(Atom, Length),
    		atom_chars(Atom, Chars),
    		atom_codes(Atom, Codes),
    		atom_concat(Atom1, Atom2, Atom),
    		sub_atom(Atom, Before, Length, After, SubAtom),
    		char_code(Char, Code),
    		number_chars(Number, Chars),
    		number_codes(Number, Codes).

    	implementation_defined_hooks :-
    		current_prolog_flag(Flag, Value),
    		set_prolog_flag(Flag, Value),
    		halt(ExitCode),
    		halt.

    	sorting :-
    		keysort(List, Sorted),
    		sort(List, Sorted).

    	number(C) --> "+", number(C).
    	number(C) --> "-", number(X), {C is -X}.
    	number(X) --> [C], {0'0 =< C, C =< 0'9, X is C - 0'0}.

    	escape_sequences :-
    		write('Quoted atom with a quote ('') inside.'),
    		write('Quoted atom with a quote (\') inside using a control escape sequence.'),
    		write('Quoted atom with a backslash (\\) inside.'),
    		write('Quoted atom with control escape sequences: \a \b \r \f \t \n \v'),
    		write('Quoted atom with an octal escape sequence: \123\.'),
    		write('Quoted atom with an hexadecimal escape sequence: \x123f\.').

    	% nothing in the following predicate definition should be highlighted
    	sort :-
    		forall,
    		object,
    		write,
    		number.

    :- end_object.

    :- object(class,
    	implements(protected::protocol),
    	imports(private::category),
    	instantiates(metaclass),
    	specializes(superclass)).

    :- end_object.

    :- object(parametric(Parameter, "String", 33.78),
    	implements(protocol),
    	imports(category),
    	extends(parent(Parameter))).

    :- end_object.

    :- category(category,
    	implements(protocol),
    	extends(other_category)).

    :- end_category.

    :- protocol(extended,
    	extends(minimal)).

    :- end_protocol.

    :- module(module, [foo/1, bar/2]).

    :- use_module(library).
    :- use_module(library, [baz/3]).

    :- reexport(library).
    :- reexport(library, [qux/4]).

    :- export(quux/5).