1		% (c) 2009-2026 Lehrstuhl fuer Softwaretechnik und Programmiersprachen,
2		% Heinrich Heine Universitaet Duesseldorf
3		% This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html)
4
5		:- module(translate,
6		[print_bexpr_or_subst/1, l_print_bexpr_or_subst/1,
7		print_bexpr/1, debug_print_bexpr/1,
8		nested_print_bexpr/1, nested_print_bexpr_up_to/2,
9		nested_print_bexpr_as_classicalb/1,
10		print_bexpr_stream/2,
11		print_components/1,
12		print_bexpr_with_limit/2, print_bexpr_with_limit_and_typing/3,
13		print_unwrapped_bexpr_with_limit/1,print_bvalue/1, l_print_bvalue/1, print_bvalue_stream/2,
14		translate_params_for_dot/2, translate_params_for_dot_nl/2,
15		print_machine/1,
16		translate_machine/3,
17		set_unicode_mode/0, unset_unicode_mode/0, unicode_mode/0,
18		unicode_translation/2, % unicode translation of a symbol/keyword
19		set_latex_mode/0, unset_latex_mode/0, latex_mode/0,
20		set_atelierb_mode/1, unset_atelierb_mode/0,
21		set_force_eventb_mode/0, unset_force_eventb_mode/0,
22		get_translation_mode/1, set_translation_mode/1, unset_translation_mode/1,
23		with_translation_mode/2,
24		get_language_mode/1, set_language_mode/1, with_language_mode/2,
25		translate_bexpression_to_unicode/2,
26		translate_bexpression/2, translate_subst_or_bexpr_in_mode/3,
27		translate_bexpression_with_limit/3, translate_bexpression_with_limit/2,
28		translate_bexpression_to_codes/2,
29		translate_bexpr_to_parseable/2,
30		translate_predicate_into_machine/3, nested_print_sequent_as_classicalb/6,
31		get_bexpression_column_template/4,
32		translate_subst_or_bexpr/2, translate_subst_or_bexpr_with_limit/3,
33		translate_substitution/2, print_subst/1,
34		convert_and_ajoin_ids/2,
35		translate_bvalue/2, translate_bvalue_to_codes/2, translate_bvalue_to_codes_with_limit/3,
36		translate_bvalue_to_parseable_classicalb/2,
37		translate_bvalue_for_dot/2,
38		translate_bvalue_with_limit/3,
39		translate_bvalue_with_type/3, translate_bvalue_with_type_and_limit/4,
40		translate_bvalue_for_expression/3, translate_bvalue_for_expression_with_limit/4,
41		translate_bvalue_with_tlatype/3,
42		translate_bvalue_kind/2,
43		print_state/1,
44		translate_bstate/2, translate_bstate_limited/2, translate_bstate_limited/3,
45		print_bstate/1, print_bstate_limited/3,
46		translate_b_state_to_comma_list/3,
47		translate_context/2, print_context/1,
48		translate_any_state/2,
49		print_value_variable/1,
50		print_cspm_state/1, translate_cspm_state/2,
51		print_csp_value/1, translate_csp_value/2,
52		translate_cspm_expression/2,
53		translate_properties_with_limit/2,
54		translate_event/2,translate_events/2,
55		translate_event_with_target_id/4,
56		translate_event_with_src_and_target_id/4, translate_event_with_src_and_target_id/5,
57		get_non_det_modified_vars_in_target_id/3,
58		translate_event_with_limit/3,
59		translate_state_errors/2,translate_state_error/2,
60		translate_event_error/2,
61		translate_call_stack/2, render_call_short/2,
62		translate_prolog_constructor/2, translate_prolog_constructor_in_mode/2,
63		get_texpr_top_level_symbol/4,
64		pretty_type/2, % pretty-prints a type (pp_type, translate_type)
65		explain_state_error/3, get_state_error_span/2,
66		explain_event_trace/3,
67		explain_transition_info/2,
68		generate_typing_predicates/2, % keeps sequence typing info
69
70		print_raw_machine_terms/1,
71		print_raw_bexpr/1, l_print_raw_bexpr/1,
72		translate_raw_bexpr/2, translate_raw_bexpr_with_limit/3,
73		transform_raw/2,
74
75		print_span/1, print_span_nl/1, translate_span/2,
76		translate_span_with_filename/2,
77		get_definition_context_from_span/2,
78
79		%set_type_to_maximal_texpr/2, type_set/2, % now in typing_tools as create_type_set
80
81		translate_error_term/2, translate_error_term/3,
82		translate_prolog_exception/2,
83		portray_open_streams/0, print_open_stream_stats/0,
84
85		set_translation_constants/1, set_translation_context/1,
86		clear_translation_constants/0,
87
88		set_print_type_infos/1,
89		set_print_type_infos/2, reset_print_type_infos/1,
90		suppress_rodin_positions/1, reset_suppress_rodin_positions/1,
91		add_normal_typing_predicates/3,
92
93		install_b_portray_hook/0,remove_b_portray_hook/0,
94
95		translate_eventb_to_classicalb/3,
96		translate_eventb_direct_definition_header/3, translate_eventb_direct_definition_body/2,
97		return_csp_closure_value/2,
98		latex_to_unicode/2, get_latex_keywords/1, get_latex_keywords_with_backslash/1,
99		ascii_to_unicode/2,
100
101		translate_xtl_value/2
102
103		]).
104
105		:- meta_predicate call_pp_with_no_limit_and_parseable(0).
106		:- meta_predicate with_translation_mode(+, 0).
107		:- meta_predicate with_language_mode(+, 0).
108
109		:- use_module(tools).
110		:- use_module(tools_lists,[is_list_simple/1]).
111		:- use_module(extrasrc(json_parser), [json_write_stream/1]).
112
113		:- use_module(module_information).
114		:- module_info(group,tools).
115		:- module_info(description,'This module is responsible for pretty-printing B and CSP, source spans, ...').
116
117		:- use_module(library(lists)).
118		:- use_module(library(codesio)).
119		:- use_module(library(terms)).
120		:- use_module(library(avl)).
121
122		:- use_module(debug).
123		:- use_module(error_manager).
124		:- use_module(self_check).
125		:- use_module(b_global_sets).
126		:- use_module(specfile,[csp_with_bz_mode/0,process_algebra_mode/0,
127		animation_minor_mode/1,set_animation_minor_mode/1,
128		remove_animation_minor_mode/0,
129		animation_mode/1,set_animation_mode/1, csp_mode/0,
130		translate_operation_name/2]).
131		:- use_module(bsyntaxtree).
132		%:- use_module('smv/smv_trans',[smv_print_initialisation/2]).
133		:- use_module(preferences,[get_preference/2, set_preference/2, eclipse_preference/2]).
134		:- use_module(bmachine_structure).
135		:- use_module(avl_tools,[check_is_non_empty_avl/1]).
136
137		:- set_prolog_flag(double_quotes, codes).
138
139		% print a list of expressions or substitutions
140		l_print_bexpr_or_subst([]).
141		l_print_bexpr_or_subst([H|T]) :-
142		print_bexpr_or_subst(H),
143		(T=[] -> true
144		; (get_texpr_type(H,Type),is_subst_type(Type) -> write('; ') ; write(', ')),
145		l_print_bexpr_or_subst(T)
146		).
147
148		is_subst_type(T) :- var(T),!,fail.
149		is_subst_type(subst).
150		is_subst_type(op(_,_)).
151
152		print_bexpr_or_subst(E) :- get_texpr_type(E,T),is_subst_type(T),!, print_subst(E).
153		print_bexpr_or_subst(precondition(A,B)) :- !, print_subst(precondition(A,B)).
154		print_bexpr_or_subst(any(A,B,C)) :- !, print_subst(any(A,B,C)).
155		print_bexpr_or_subst(select(A)) :- !, print_subst(select(A)). % TO DO: add more cases ?
156		print_bexpr_or_subst(E) :- print_bexpr(E).
157
158		print_unwrapped_bexpr_with_limit(Expr) :- print_unwrapped_bexpr_with_limit(Expr,200).
159		print_unwrapped_bexpr_with_limit(Expr,Limit) :-
160		translate:print_bexpr_with_limit(b(Expr,pred,[]),Limit),nl.
161		debug_print_bexpr(E) :- debug_mode(off) -> true ; print_bexpr(E).
162		print_bexpr(Expr) :- translate_bexpression(Expr,R), write(R).
163		print_bexpr_with_limit(Expr,Limit) :- translate_bexpression_with_limit(Expr,Limit,R), write(R).
164		print_bvalue(Val) :- translate_bvalue(Val,TV), write(TV).
165		print_bexpr_stream(S,Expr) :- translate_bexpression(Expr,R), write(S,R).
166		print_bvalue_stream(S,Val) :- translate_bvalue(Val,R), write(S,R).
167
168		print_bexpr_with_limit_and_typing(Expr,Limit,TypeInfos) :-
169		set_print_type_infos(TypeInfos,CHNG),
170		(get_texpr_type(Expr,pred)
171		-> find_typed_identifier_uses(Expr, TUsedIds),
172		add_typing_predicates(TUsedIds,Expr,Expr2)
173		; Expr2=Expr),
174		call_cleanup(print_bexpr_with_limit(Expr2,Limit),
175		reset_print_type_infos(CHNG)).
176
177		print_components(C) :- print_components(C,0).
178		print_components([],Nr) :- write('Nr of components: '),write(Nr),nl.
179		print_components([component(Pred,Vars)|T],Nr) :- N1 is Nr+1,
180		write('Component: '), write(N1), write(' over '), write(Vars),nl,
181		print_bexpr(Pred),nl,
182		print_components(T,N1).
183
184		l_print_bvalue([]).
185		l_print_bvalue([H|T]) :- print_bvalue(H), write(' : '),l_print_bvalue(T).
186
187		nested_print_bexpr_as_classicalb(E) :- nested_print_bexpr_as_classicalb2(E,0).
188
189		nested_print_bexpr_as_classicalb2(E,InitialPeanoIndent) :-
190		(animation_minor_mode(X)
191		-> remove_animation_minor_mode,
192		call_cleanup(nested_print_bexpr2(E,InitialPeanoIndent), set_animation_minor_mode(X))
193		; nested_print_bexpr2(E,InitialPeanoIndent)).
194
195
196		nested_print_bexpr_up_to(State,ExpandAvlUpTo) :-
197		temporary_set_preference(expand_avl_upto,ExpandAvlUpTo,CHNG),
198		call_cleanup(nested_print_bexpr(State),
199		reset_temporary_preference(expand_avl_upto,CHNG)).
200
201		% can also print lists of predicates and lists of lists, ...
202		nested_print_bexpr(Expr) :- nested_print_bexpr2(Expr,0).
203
204		% a version where one can specify the initial indent in peano numbering
205		nested_print_bexpr2([],_) :- !.
206		nested_print_bexpr2([H],InitialIndent) :- !,nested_print_bexpr2(H,InitialIndent).
207		nested_print_bexpr2([H|T],II) :- !,
208		nested_print_bexpr2(H,II),
209		print_indent(II), write('&'),nl,
210		nested_print_bexpr2(T,II).
211		nested_print_bexpr2(Expr,II) :- nbp(Expr,conjunct,II).
212
213		nbp(b(E,_,Info),Type,Indent) :- !,nbp2(E,Type,Info,Indent).
214		nbp(E,Type,Indent) :- format(user_error,'Missing b/3 wrapper!~n',[]),
215		nbp2(E,Type,[],Indent).
216		nbp2(E,Type,_Info,Indent) :- get_binary_connective(E,NewType,Ascii,LHS,RHS),!,
217		inc_indent(NewType,Type,Indent,NIndent),
218		print_bracket(Indent,NIndent,'('),
219		nbp(LHS,NewType,NIndent),
220		print_indent(NIndent),
221		translate_in_mode(NewType,Ascii,Symbol), write(Symbol),nl,
222		(is_associative(NewType) -> NewTypeR=NewType % no need for parentheses if same operator on right
223		; NewTypeR=right(NewType)),
224		nbp(RHS,NewTypeR,NIndent),
225		print_bracket(Indent,NIndent,')').
226		nbp2(lazy_let_pred(TID,LHS,RHS),Type,_Info,Indent) :-
227		def_get_texpr_id(TID,ID),!,
228		NewType=lazy_let_pred(TID),
229		inc_indent(NewType,Type,Indent,NIndent),
230		print_indent(Indent), format('LET ~w = (~n',[ID]),
231		nbp(LHS,NewType,NIndent),
232		print_indent(NIndent), write(') IN ('),nl,
233		nbp(RHS,NewType,NIndent),
234		print_indent(NIndent),write(')'),nl.
235		nbp2(negation(LHS),_Type,_Info,Indent) :- !,
236		inc_indent(negation,false,Indent,NIndent),
237		print_indent(Indent),
238		translate_in_mode(negation,'not',Symbol), format('~s(~n',[Symbol]),
239		nbp(LHS,negation,NIndent),
240		print_indent(Indent), write(')'),nl.
241		nbp2(let_predicate(Ids,Exprs,Pred),_Type,_Info,Indent) :- !,
242		inc_indent(let_predicate,false,Indent,NIndent),
243		pp_expr_ids_in_mode(Ids,_LR,Codes,[]),
244		print_indent(Indent),format('#~s.( /* LET */~n',[Codes]),
245		pp_expr_let_pred_exprs(Ids,Exprs,_LimitReached,Codes2,[]),
246		print_indent(Indent), format('~s~n',[Codes2]),
247		print_indent(NIndent), write('&'),nl,
248		nbp(Pred,let_predicate,NIndent),
249		print_indent(Indent), write(')'),nl.
250		nbp2(let_expression(Ids,Exprs,Pred),_Type,_Info,Indent) :- !,
251		inc_indent(let_expression,false,Indent,NIndent),
252		pp_expr_ids_in_mode(Ids,_LR,Codes,[]),
253		print_indent(Indent),format('LET ~s BE~n',[Codes]),
254		pp_expr_let_pred_exprs(Ids,Exprs,_LimitReached,Codes2,[]),
255		print_indent(Indent), format('~s~n',[Codes2]),
256		print_indent(NIndent), write('IN'),nl,
257		nbp(Pred,let_expression,NIndent),
258		print_indent(Indent), write('END'),nl.
259		nbp2(exists(Ids,Pred),_Type,_Infos,Indent) :- !,
260		inc_indent(exists,false,Indent,NIndent),
261		pp_expr_ids_in_mode(Ids,_LR,Codes,[]),
262		print_indent(Indent),
263		%(member(allow_to_lift_exists,_Infos) -> write('/* LIFT */ ') ; true),
264		exists_symbol(ExistsSymbol,[]), format('~s~s.(~n',[ExistsSymbol,Codes]),
265		nbp(Pred,exists,NIndent),
266		print_indent(Indent), write(')'),nl.
267		nbp2(forall(Ids,LHS,RHS),_Type,_Info,Indent) :- !,
268		inc_indent(forall,false,Indent,NIndent),
269		pp_expr_ids_in_mode(Ids,_LR,Codes,[]),
270		print_indent(Indent),
271		forall_symbol(ForallSymbol,[]), format('~s~s.(~n',[ForallSymbol,Codes]),
272		nbp(LHS,forall,NIndent),
273		print_indent(NIndent),
274		translate_in_mode(implication,'=>',Symbol),write(Symbol),nl,
275		nbp(RHS,forall,NIndent),
276		print_indent(Indent), write(')'),nl.
277		nbp2(if_then_else(Test,LHS,RHS),_Type,_Info,Indent) :- !,
278		inc_indent(if_then_else,false,Indent,NIndent),
279		print_indent(Indent), write('IF'),nl,
280		nbp(Test,if_then_else,NIndent),
281		print_indent(Indent), write('THEN'),nl,
282		nbp(LHS,if_then_else,NIndent),
283		print_indent(Indent), write('ELSE'),nl,
284		nbp(RHS,if_then_else,NIndent),
285		print_indent(Indent), write('END'),nl.
286		nbp2(BOP,_Type,_Info,Indent) :-
287		indent_binary_pred(BOP,LHS,RHS,NewType,Ascii),
288		get_texpr_id(LHS,_Id),
289		\+ simple_expr(RHS),
290		!,
291		print_indent(Indent),print_bexpr(LHS),write(' '),
292		translate_in_mode(NewType,Ascii,Symbol), write(Symbol),nl,
293		inc_indent(NewType,false,Indent,NIndent),
294		nbp(RHS,equal,NIndent). % do we need to put parentheses around this ?
295		nbp2(value(V),_,Info,Indent) :- !,
296		print_indent(Indent), print_bexpr(b(value(V),any,Info)),nl.
297		nbp2(E,_,Info,Indent) :-
298		print_indent(Indent), print_bexpr(b(E,pred,Info)),nl.
299
300		indent_binary_pred(equal(LHS,RHS),LHS,RHS,equal,'=').
301		indent_binary_pred(member(LHS,RHS),LHS,RHS,member,':').
302		%indent_binary_pred(couple(LHS,RHS),LHS,RHS,couple,'|->'). % TODO: process parentheses above
303		%indent_binary_pred(union(LHS,RHS),LHS,RHS,union,'\\/').
304		%indent_binary_pred(concat(LHS,RHS),LHS,RHS,concat,'^').
305		% ...
306
307		% simple texpr without subarguments
308		simple_expr(BExpr) :-
309		syntaxtraversion(BExpr,Expr,_Type,_Infos,Subs,_Names),
310		Subs=[],
311		(Expr=value(V),nonvar(V), V=closure(_,_,_) -> fail % closure value probably not simple; TODO: check for interval
312		; true).
313
314		% all left-associative
315		get_binary_connective(conjunct(LHS,RHS),conjunct,'&',LHS,RHS).
316		get_binary_connective(disjunct(LHS,RHS),disjunct,'or',LHS,RHS).
317		get_binary_connective(implication(LHS,RHS),implication,'=>',LHS,RHS).
318		get_binary_connective(equivalence(LHS,RHS),equivalence,'<=>',LHS,RHS).
319
320		inc_indent(Type,CurType,I,NewI) :- (Type=CurType -> NewI=I ; NewI=s(I)).
321		print_bracket(I,I,_) :- !.
322		print_bracket(I,_NewI,Bracket) :-
323		print_indent(I), write(Bracket),nl.
324
325		print_indent(s(X)):- !,
326		write(' '),
327		print_indent(X).
328		print_indent(_).
329
330
331		/* =============================================== */
332		/* Translating expressions and values into strings */
333		/* =============================================== */
334
335		translate_params_for_dot(List,TransList) :-
336		translate_params_for_dot(List,TransList,3,-3).
337		translate_params_for_dot_nl(List,TransList) :- % newline after every entry
338		translate_params_for_dot(List,TransList,1,-1).
339
340		translate_params_for_dot([],'',_,_).
341		translate_params_for_dot([H|T],Res,Lim,Nr) :-
342		translate_property_with_limit(H,100,TH),
343		(Nr>=Lim -> N1=1 % Limit reached, add newline
344		; N1 is Nr+1),
345		translate_params_for_dot(T,TT,Lim,N1),
346		string_concatenate(TH,TT,Res1),
347		(N1=1
348		-> string_concatenate(',\n',Res1,Res)
349		; (Nr>(-Lim) -> string_concatenate(',',Res1,Res)
350		; Res=Res1)).
351
352
353		translate_channel_values(X,['_'|T],T) :- var(X),!.
354		translate_channel_values([],S,S) :- !.
355		translate_channel_values([tuple([])|T],S,R) :- !,
356		translate_channel_values(T,S,R).
357		translate_channel_values([in(tuple([]))|T],S,R) :- !,
358		translate_channel_values(T,S,R).
359		translate_channel_values([H|T],['.'|S],R) :- !,
360		((nonvar(H),H=in(X))
361		-> Y=X
362		; Y=H
363		),
364		pp_csp_value(Y,S,S2),
365		translate_channel_values(T,S2,R).
366		translate_channel_values(tail_in(X),S,T) :-
367		(X=[] ; X=[_|_]), !, translate_channel_values(X,S,T).
368		translate_channel_values(_X,['??'|S],S).
369
370
371
372		pp_single_csp_value(V,'_') :- var(V),!.
373		pp_single_csp_value(X,'_cyclic_') :- cyclic_term(X),!.
374		pp_single_csp_value(int(X),A) :- atomic(X),!,number_chars(X,Chars),atom_chars(A,Chars).
375
376		:- assert_must_succeed((translate_cspm_expression(listExp(rangeOpen(2)),R), R == '<2..>')).
377		:- assert_must_succeed((translate_cspm_expression(listFrom(2),R), R == '<2..>')).
378		:- assert_must_succeed((translate_cspm_expression(listFromTo(2,6),R), R == '<2..6>')).
379		:- assert_must_succeed((translate_cspm_expression(setFromTo(2,6),R), R == '{2..6}')).
380		:- assert_must_succeed((translate_cspm_expression('#'(listFromTo(2,6)),R), R == '#<2..6>')).
381		:- assert_must_succeed((translate_cspm_expression(inGuard(x,setFromTo(1,5)),R), R == '?x:{1..5}')).
382		:- assert_must_succeed((translate_cspm_expression(builtin_call(int(3)),R), R == '3')).
383		:- assert_must_succeed((translate_cspm_expression(set_to_seq(setValue([int(1),int(2)])),R), R == 'seq({1,2})')).
384		:- assert_must_succeed((translate_cspm_expression(diff(setValue([int(1)]),setValue([])),R), R == 'diff({1},{})')).
385		:- assert_must_succeed((translate_cspm_expression(inter(setValue([int(1)]),setValue([])),R), R == 'inter({1},{})')).
386		:- assert_must_succeed((translate_cspm_expression(lambda([x,y],'*'(x,y)),R), R == '\\ x,y @ (x*y)')).
387		:- assert_must_succeed((translate_cspm_expression(lambda([x,y],'/'(x,y)),R), R == '\\ x,y @ (x/y)')).
388		:- assert_must_succeed((translate_cspm_expression(lambda([x,y],'%'(x,y)),R), R == '\\ x,y @ (x%y)')).
389		:- assert_must_succeed((translate_cspm_expression(rename(x,y),R), R == 'x <- y')).
390		:- assert_must_succeed((translate_cspm_expression(link(x,y),R), R == 'x <-> y')).
391		:- assert_must_succeed((translate_cspm_expression(agent_call_curry(f,[[a,b],[c]]),R), R == 'f(a,b)(c)')).
392
393		translate_cspm_expression(Expr, Text) :-
394		(pp_csp_value(Expr,Atoms,[]) -> ajoin(Atoms,Text)
395		; write('Pretty printing expression failed: '),print(Expr),nl).
396
397		pp_csp_value(X,[A|S],S) :- pp_single_csp_value(X,A),!.
398		pp_csp_value(setValue(L),['{'|S],T) :- !,pp_csp_value_l(L,',',S,['}'|T],inf).
399		pp_csp_value(setExp(rangeEnum(L)),['{'|S],T) :- !,pp_csp_value_l(L,',',S,['}'|T],inf).
400		pp_csp_value(setExp(rangeEnum(L),Gen),['{'|S],T) :- !,
401		copy_term((L,Gen),(L2,Gen2)), numbervars((L2,Gen2),1,_),
402		pp_csp_value_l(L2,',',S,['|'|S2],inf),
403		pp_csp_value_l(Gen2,',',S2,['}'|T],inf).
404		pp_csp_value(avl_set(A),['{'|S],T) :- !, check_is_non_empty_avl(A),
405		avl_domain(A,L),pp_csp_value_l(L,',',S,['}'|T],inf).
406		pp_csp_value(setExp(rangeClosed(L,U)),['{'|S],T) :- !, pp_csp_value(L,S,['..'|S2]),pp_csp_value(U,S2,['}'|T]).
407		pp_csp_value(setExp(rangeOpen(L)),['{'|S],T) :- !, pp_csp_value(L,S,['..}'|T]).
408		% TO DO: pretty print comprehensionGuard; see prints in coz-example.csp ; test 1846
409		pp_csp_value(comprehensionGenerator(Var,Body),S,T) :- !, pp_csp_value(Var,S,['<-'|S1]),
410		pp_csp_value(Body,S1,T).
411		pp_csp_value(listExp(rangeEnum(L)),['<'|S],T) :- !,pp_csp_value_l(L,',',S,['>'|T],inf).
412		pp_csp_value(listExp(rangeClosed(L,U)),['<'|S],T) :- !, pp_csp_value(L,S,['..'|S2]),pp_csp_value(U,S2,['>'|T]).
413		pp_csp_value(listExp(rangeOpen(L)),['<'|S],T) :- !, pp_csp_value(L,S,['..>'|T]).
414		pp_csp_value(setFromTo(L,U),['{'|S],T) :- !,
415		pp_csp_value(L,S,['..'|S2]),pp_csp_value(U,S2,['}'|T]).
416		pp_csp_value(setFrom(L),['{'|S],T) :- !,
417		pp_csp_value(L,S,['..}'|T]).
418		pp_csp_value(closure(L), ['{|'|S],T) :- !,pp_csp_value_l(L,',',S,['|}'|T],inf).
419		pp_csp_value(list(L),['<'|S],T) :- !,pp_csp_value_l(L,',',S,['>'|T],inf).
420		pp_csp_value(listFromTo(L,U),['<'|S],T) :- !,
421		pp_csp_value(L,S,['..'|S2]),pp_csp_value(U,S2,['>'|T]).
422		pp_csp_value(listFrom(L),['<'|S],T) :- !,
423		pp_csp_value(L,S,['..>'|T]).
424		pp_csp_value('#'(L),['#'|S],T) :- !,pp_csp_value(L,S,T).
425		pp_csp_value('^'(X,Y),S,T) :- !,pp_csp_value(X,S,['^'|S1]), pp_csp_value(Y,S1,T).
426		pp_csp_value(linkList(L),S,T) :- !,pp_csp_value_l(L,',',S,T,inf).
427		pp_csp_value(in(X),['?'|S],T) :- !,pp_csp_value(X,S,T).
428		pp_csp_value(inGuard(X,Set),['?'|S],T) :- !,pp_csp_value(X,S,[':'|S1]),
429		pp_csp_value(Set,S1,T).
430		pp_csp_value(out(X),['!'|S],T) :- !,pp_csp_value(X,S,T).
431		pp_csp_value(alsoPat(X,_Y),S,T) :- !,pp_csp_value(X,S,T).
432		pp_csp_value(appendPat(X,_Fun),S,T) :- !,pp_csp_value(X,S,T).
433		pp_csp_value(tuple(vclosure),S,T) :- !, S=T.
434		pp_csp_value(tuple([X]),S,T) :- !,pp_csp_value_in(X,S,T).
435		pp_csp_value(tuple([X|vclosure]),S,T) :- !,pp_csp_value_in(X,S,T).
436		pp_csp_value(tuple([H|TT]),S,T) :- !,pp_csp_value_in(H,S,['.'|S1]),pp_csp_value(tuple(TT),S1,T).
437		pp_csp_value(dotTuple([]),['unit_channel'|S],S) :- ! .
438		pp_csp_value(dotTuple([H]),S,T) :- !, pp_csp_value_in(H,S,T).
439		pp_csp_value(dotTuple([H|TT]),S,T) :- !, pp_csp_value_in(H,S,['.'|S1]),
440		pp_csp_value(dotTuple(TT),S1,T).
441		pp_csp_value(tupleExp(Args),S,T) :- !,pp_csp_args(Args,S,T,'(',')').
442		pp_csp_value(na_tuple(Args),S,T) :- !,pp_csp_args(Args,S,T,'(',')').
443		pp_csp_value(record(Name,Args),['('|S],T) :- !,pp_csp_value(tuple([Name|Args]),S,[')'|T]).
444		pp_csp_value(val_of(Name,_Span),S,T) :- !, pp_csp_value(Name,S,T).
445		pp_csp_value(builtin_call(X),S,T) :- !,pp_csp_value(X,S,T).
446		pp_csp_value(seq_to_set(X),['set('|S],T) :- !,pp_csp_value(X,S,[')'|T]).
447		pp_csp_value(set_to_seq(X),['seq('|S],T) :- !,pp_csp_value(X,S,[')'|T]).
448		%pp_csp_value('\\'(B,C,S),S1,T) :- !, pp_csp_process(ehide(B,C,S),S1,T).
449		pp_csp_value(agent_call(_Span,Agent,Parameters),['('|S],T) :- !,
450		pp_csp_value(Agent,S,S1),
451		pp_csp_args(Parameters,S1,[')'|T],'(',')').
452		pp_csp_value(agent_call_curry(Agent,Parameters),S,T) :- !,
453		pp_csp_value(Agent,S,S1),
454		pp_csp_curry_args(Parameters,S1,T).
455		pp_csp_value(lambda(Parameters,Body),['\\ '|S],T) :- !,
456		pp_csp_args(Parameters,S,[' @ '|S1],'',''),
457		pp_csp_value(Body,S1,T).
458		pp_csp_value(rename(X,Y),S,T) :- !,pp_csp_value(X,S,[' <- '|S1]),
459		pp_csp_value(Y,S1,T).
460		pp_csp_value(link(X,Y),S,T) :- !,pp_csp_value(X,S,[' <-> '|S1]),
461		pp_csp_value(Y,S1,T).
462		% binary operators:
463		pp_csp_value(Expr,['('|S],T) :- bynary_numeric_operation(Expr,E1,E2,OP),!,
464		pp_csp_value(E1,S,[OP|S2]),
465		pp_csp_value(E2,S2,[')'|T]).
466		% built-in functions for sets
467		pp_csp_value(empty(A),[empty,'('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
468		pp_csp_value(card(A),[card,'('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
469		pp_csp_value('Set'(A),['Set','('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
470		pp_csp_value('Inter'(A1),['Inter','('|S],T) :- !,pp_csp_value(A1,S,[')'|T]).
471		pp_csp_value('Union'(A1),['Union','('|S],T) :- !,pp_csp_value(A1,S,[')'|T]).
472		pp_csp_value(diff(A1,A2),[diff,'('|S],T) :- !,pp_csp_args([A1,A2],S,[')'|T],'','').
473		pp_csp_value(inter(A1,A2),[inter,'('|S],T) :- !,pp_csp_args([A1,A2],S,[')'|T],'','').
474		pp_csp_value(union(A1,A2),[union,'('|S],T) :- !,pp_csp_args([A1,A2],S,[')'|T],'','').
475		pp_csp_value(member(A1,A2),[member,'('|S],T) :- !,pp_csp_args([A1,A2],S,[')'|T],'','').
476		% built-in functions for sequences
477		pp_csp_value(null(A),[null,'('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
478		pp_csp_value(length(A),[length,'('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
479		pp_csp_value(head(A),[head,'('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
480		pp_csp_value(tail(A),[tail,'('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
481		pp_csp_value(elem(A1,A2),[elem,'('|S],T) :- !,pp_csp_args([A1,A2],S,[')'|T],'','').
482		pp_csp_value(concat(A1,A2),[concat,'('|S],T) :- !,pp_csp_args([A1,A2],S,[')'|T],'','').
483		pp_csp_value('Seq'(A),['Seq','('|S],T) :- !, pp_csp_value(A,S,[')'|T]).
484		% vclosure
485		pp_csp_value(Expr,S,T) :- is_list(Expr),!,pp_csp_value(closure(Expr),S,T).
486		% Type expressions
487		pp_csp_value(dotTupleType([H]),S,T) :- !, pp_csp_value_in(H,S,T).
488		pp_csp_value(dotTupleType([H|TT]),S,T) :- !,pp_csp_value_in(H,S,['.'|S1]), pp_csp_value(dotTupleType(TT),S1,T).
489		pp_csp_value(typeTuple(Args),S,T) :- !, pp_csp_args(Args,S,T,'(',')').
490		pp_csp_value(dataType(T),[T|S],S) :- ! .
491		pp_csp_value(boolType,['Bool'|S],S) :- ! .
492		pp_csp_value(intType,['Int'|S],S) :- ! .
493		pp_csp_value(dataTypeDef([H]),S,T) :- !, pp_csp_value(H,S,T).
494		pp_csp_value(dataTypeDef([H|TT]),S,T) :- !, pp_csp_value(H,S,['|'|S1]),
495		pp_csp_value(dataTypeDef(TT),S1,T).
496		pp_csp_value(constructor(Name),[Name|S],S) :- ! .
497		pp_csp_value(constructorC(C,Type),[C,'('|S],T) :- !, pp_csp_value(Type,S,[')'|T]).
498		% Argument of function can be process
499
500		pp_csp_value(Expr,S,T) :- pp_csp_process(Expr,S,T),!. % pp_csp_process has a catch-all !!! TO DO: look at this
501		pp_csp_value(Expr,S,T) :- csp_with_bz_mode,!,pp_value(Expr,S,T).
502		pp_csp_value(X, [A|S], S) :- % ['<< ',A,' >>'|S],S) :- % the << >> pose problems when checking against FDR
503		write_to_codes(X,Codes),atom_codes_with_limit(A,Codes).
504
505		pp_csp_value_in(H,S,T) :- nonvar(H),H=in(X),!, pp_csp_value(X,S,T).
506		pp_csp_value_in(H,S,T) :- pp_csp_value(H,S,T).
507
508		print_csp_value(Val) :- pp_csp_value(Val,Atoms,[]), ajoin(Atoms,Text),
509		write(Text).
510
511		translate_csp_value(Val,Text) :- pp_csp_value(Val,Atoms,[]), ajoin(Atoms,Text).
512
513		return_csp_closure_value(closure(S),List) :- pp_csp_value_l1(S,List).
514		return_csp_closure_value(setValue(S),List) :- pp_csp_value_l1(S,List).
515
516		pp_csp_value_l1([Expr|Rest],List) :-
517		( nonvar(Rest),Rest=[] ->
518		pp_csp_value(Expr,T,[]),ajoin(T,Value),List=[Value]
519		; pp_csp_value_l1(Rest,R),pp_csp_value(Expr,T,[]),ajoin(T,Value),List=[Value|R]
520		).
521
522		pp_csp_args([],T,T,_LPar,_RPar).
523		pp_csp_args([H|TT],[LPar|S],T,LPar,RPar) :- pp_csp_value(H,S,S1), pp_csp_args2(TT,S1,T,RPar).
524		pp_csp_args2([],[RPar|T],T,RPar).
525		pp_csp_args2([H|TT],[','|S],T,RPar) :- pp_csp_value(H,S,S1), pp_csp_args2(TT,S1,T,RPar).
526
527		pp_csp_curry_args([],T,T).
528		pp_csp_curry_args([H|TT],S,T) :- is_list(H), pp_csp_args(H,S,S1,'(',')'), pp_csp_curry_args(TT,S1,T).
529
530		pp_csp_value_l(V,_Sep,['...'|S],S,N) :- (var(V) ; (N \= inf -> N<1;fail)), !.
531		pp_csp_value_l([],_Sep,S,S,_).
532		pp_csp_value_l([Expr|Rest],Sep,S,T,Nr) :-
533		( nonvar(Rest),Rest=[] ->
534		pp_csp_value(Expr,S,T)
535		;
536		(Nr=inf -> N1 = Nr ; N1 is Nr-1),
537		pp_csp_value(Expr,S,[Sep|S1]),pp_csp_value_l(Rest,Sep,S1,T,N1)).
538
539		:- assert_must_succeed((translate:convert_set_into_sequence([(int(1),int(5))],Seq),
540		check_eqeq(Seq,[int(5)]))).
541		:- assert_must_succeed((translate:convert_set_into_sequence([(int(2),X),(int(1),int(5))],Seq),
542		check_eq(Seq,[int(5),X]))).
543
544		convert_set_into_sequence(Set,Seq) :-
545		nonvar(Set), \+ eventb_translation_mode,
546		convert_set_into_sequence1(Set,Seq).
547		convert_set_into_sequence1(avl_set(A),Seq) :- !, check_is_non_empty_avl(A),
548		avl_size(A,Sz),size_is_in_set_limit(Sz),convert_avlset_into_sequence(A,Seq).
549		convert_set_into_sequence1([],Seq) :- !, Seq=[].
550		convert_set_into_sequence1(Set,Seq) :-
551		convert_set_into_sequence2(Set,0,_,SetElems,Seq),ground(SetElems).
552		convert_set_into_sequence2([],_Max,([],[]),_,_Seq).
553		convert_set_into_sequence2([Pair|T],Max,Last,SetElems,Seq) :-
554		nonvar(Pair),nonvar(T),Pair=(Index,H),ground(Index),
555		Index=int(Nr),
556		insert_el_into_seq(Nr,H,Seq,SetElems,L),
557		(Nr>Max -> NMax=Nr,NLast=L ; NMax=Max,NLast=Last),
558		convert_set_into_sequence2(T,NMax,NLast,SetElems,Seq).
559		insert_el_into_seq(1,H,[H|L],[set|L2],(L,L2)) :- !.
560		insert_el_into_seq(N,H,[_|T],[_|T2],Last) :- N>1, N1 is N-1, insert_el_into_seq(N1,H,T,T2,Last).
561
562		convert_avlset_into_sequence(Avl,Sequence) :-
563		\+ eventb_translation_mode,
564		convert_avlset_into_sequence2(Avl,1,Sequence).
565		convert_avlset_into_sequence2(Avl,_Index,[]) :-
566		empty_avl(Avl),!.
567		convert_avlset_into_sequence2(Avl,Index,[Head|Tail]) :-
568		avl_del_min(Avl, Min, _ ,NewAvl),
569		nonvar(Min), Min=(L,Head),
570		ground(L), L=int(Index),
571		Index2 is Index + 1,
572		convert_avlset_into_sequence2(NewAvl,Index2,Tail).
573
574		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
575		% translate new syntax tree -- work in progress
576		:- assert_must_succeed((translate_cspm_state(lambda([x,y],'|~|'(prefix(_,[],x,skip(_),_),prefix(_,[],y,skip(_),_),_)),R), R == 'CSP: \\ x,y @ (x->SKIP) |~| (y->SKIP)')).
577		:- assert_must_succeed((translate_cspm_state(agent_call_curry('F',[[a,b],[c]]),R), R == 'CSP: F(a,b)(c)')).
578		:- assert_must_succeed((translate_cspm_state(ifte(bool_not('<'(x,3)),';'(esharing([a],'/\\'('P1','P2',span),procRenaming([rename(r,s)],'Q',span),span),lParallel([link(b,c)],'R','S',span),span),'[>'(elinkParallel([link(h1,h2)],'G1','G2',span),exception([a],'H1','H2',span),span),span1,span2,span3),R), R == 'CSP: if not((x<3)) then ((P1) /\\ (P2) [|{|a|}|] Q[[r <- s]]) ; (R [{|b <-> c|}] S) else (G1 [{|h1 <-> h2|}] G2) [> (H1 [|{|a|}|> H2)')).
579		:- assert_must_succeed((translate_cspm_state(aParallel([a,b],'P',[b,c],'Q',span),R), R == 'CSP: P [{|a,b|} || {|b,c|}] Q')).
580		:- assert_must_succeed((translate_cspm_state(eaParallel([a,b],'P',[b,c],'Q',span),R), R == 'CSP: P [{|a,b|} || {|b,c|}] Q')).
581		:- assert_must_succeed((translate_cspm_state(eexception([a,b],'P','Q',span),R), R == 'CSP: P [|{|a,b|}|> Q')).
582
583		print_cspm_state(State) :- translate_cspm_state(State,T), write(T).
584
585		translate_cspm_state(State,Text) :-
586		( pp_csp_process(State,Atoms,[]) -> true
587		; print(pp_csp_process_failed(State)),nl,Atoms=State),
588		ajoin(['CSP: '|Atoms],Text).
589
590		pp_csp_process(skip(_Span),S,T) :- !, S=['SKIP'|T].
591		pp_csp_process(stop(_Span),S,T) :- !, S=['STOP'|T].
592		pp_csp_process('CHAOS'(_Span,Set),['CHAOS('|S],T) :- !,
593		pp_csp_value(Set,S,[')'|T]).
594		pp_csp_process(val_of(Agent,_Span),S,T) :- !,
595		pp_csp_value(Agent,S,T).
596		pp_csp_process(builtin_call(X),S,T) :- !,pp_csp_process(X,S,T).
597		pp_csp_process(agent(F,Body,_Span),S,T) :- !,
598		F =.. [Agent|Parameters],
599		pp_csp_value(Agent,S,S1),
600		pp_csp_args(Parameters,S1,[' = '|S2],'(',')'),
601		pp_csp_value(Body,S2,T).
602		pp_csp_process(agent_call(_Span,Agent,Parameters),S,T) :- !,
603		pp_csp_value(Agent,S,S1),
604		pp_csp_args(Parameters,S1,T,'(',')').
605		pp_csp_process(agent_call_curry(Agent,Parameters),S,T) :- !,
606		pp_csp_value(Agent,S,S1),
607		pp_csp_curry_args(Parameters,S1,T).
608		pp_csp_process(lambda(Parameters,Body),['\\ '|S],T) :- !,
609		pp_csp_args(Parameters,S,[' @ '|S1],'',''),
610		pp_csp_value(Body,S1,T).
611		pp_csp_process('\\'(B,C,S),S1,T) :- !, pp_csp_process(ehide(B,C,S),S1,T).
612		pp_csp_process(ehide(Body,ChList,_Span),['('|S],T) :- !,
613		pp_csp_process(Body,S,[')\\('|S1]),
614		pp_csp_value(ChList,S1,[')'|T]).
615		pp_csp_process(let(Decls,P),['let '| S],T) :- !,
616		maplist(translate_cspm_state,Decls,Texts),
617		ajoin_with_sep(Texts,' ',Text),
618		S=[Text,' within '|S1],
619		pp_csp_process(P,S1,T).
620		pp_csp_process(Expr,['('|S],T) :- binary_csp_op(Expr,X,Y,Op),!,
621		pp_csp_process(X,S,[') ',Op,' ('|S1]),
622		pp_csp_process(Y,S1,[')'|T]).
623		pp_csp_process(Expr,S,T) :- sharing_csp_op(Expr,X,Middle,Y,Op1,Op2),!,
624		pp_csp_process(X,S,[Op1|S1]),
625		pp_csp_value(Middle,S1,[Op2|S2]),
626		pp_csp_process(Y,S2,T).
627		pp_csp_process(Expr,S,T) :- asharing_csp_op(Expr,X,MiddleX,MiddleY,Y,Op1,MOp,Op2),!,
628		pp_csp_process(X,S,[Op1|S1]),
629		pp_csp_value(MiddleX,S1,[MOp|S2]),
630		pp_csp_value(MiddleY,S2,[Op2|S3]),
631		pp_csp_process(Y,S3,T).
632		pp_csp_process(Expr,S,T) :- renaming_csp_op(Expr,X,RList,Op1,Op2),!,
633		pp_csp_process(X,S,[Op1|S1]),
634		pp_csp_value_l(RList,',',S1,[Op2|T],10).
635		pp_csp_process(prefix(_SPAN1,Values,ChannelExpr,CSP,_SPAN2),S,T) :- !,
636		pp_csp_value_l([ChannelExpr|Values],'',S,['->'|S2],20),
637		pp_csp_process(CSP,S2,T).
638		pp_csp_process('&'(Test,Then),S,T) :- !,
639		pp_csp_bool_expr(Test,S,['&'|S2]),
640		pp_csp_process(Then,S2,T).
641		pp_csp_process(ifte(Test,Then,Else,_SPAN1,_SPAN2,_SPAN3),[' if '|S],T) :- !,
642		pp_csp_bool_expr(Test,S,[' then '|S2]),
643		pp_csp_process(Then,S2,[' else '|S3]),
644		pp_csp_process(Else,S3,T).
645		pp_csp_process(head(A),[head,'('|S],T) :- !, pp_csp_process(A,S,[')'|T]).
646		pp_csp_process(X,[X|T],T).
647
648		pp_csp_bool_expr(bool_not(BE),['not('|S],T) :- !, pp_csp_bool_expr(BE,S,[')'|T]).
649		pp_csp_bool_expr(BE,['('|S],T) :- binary_bool_op(BE,BE1,BE2,OP), !,
650		pp_csp_bool_expr(BE1,S,[OP|S2]),
651		pp_csp_bool_expr(BE2,S2,[')'|T]).
652		pp_csp_bool_expr(BE,[OP,'('|S],T) :- binary_pred(BE,BE1,BE2,OP), !,
653		pp_csp_value(BE1,S,[','|S2]),
654		pp_csp_value(BE2,S2,[')'|T]).
655		pp_csp_bool_expr(BE,S,T) :- pp_csp_value(BE,S,T).
656
657		bynary_numeric_operation('+'(X,Y),X,Y,'+').
658		bynary_numeric_operation('-'(X,Y),X,Y,'-').
659		bynary_numeric_operation('*'(X,Y),X,Y,'*').
660		bynary_numeric_operation('/'(X,Y),X,Y,'/').
661		bynary_numeric_operation('%'(X,Y),X,Y,'%').
662
663		binary_pred('member'(X,Y),X,Y,member).
664		binary_pred('<'(X,Y),X,Y,'<').
665		binary_pred('>'(X,Y),X,Y,'>').
666		binary_pred('>='(X,Y),X,Y,'>=').
667		binary_pred('<='(X,Y),X,Y,'=<').
668		binary_pred('elem'(X,Y),X,Y,is_elem_list).
669		binary_pred('=='(X,Y),X,Y,equal_element).
670		binary_pred('!='(X,Y),X,Y,not_equal_element).
671
672
673		binary_bool_op('<'(X,Y),X,Y,'<').
674		binary_bool_op('>'(X,Y),X,Y,'>').
675		binary_bool_op('>='(X,Y),X,Y,'>=').
676		binary_bool_op('<='(X,Y),X,Y,'=<').
677		binary_bool_op('=='(X,Y),X,Y,'==').
678		binary_bool_op('!='(X,Y),X,Y,'!=').
679		binary_bool_op(bool_and(X,Y),X,Y,'&&').
680		binary_bool_op(bool_or(X,Y),X,Y,'||').
681
682		binary_csp_op('|||'(X,Y,_Span),X,Y,'|||').
683		binary_csp_op('[]'(X,Y,_Span),X,Y,'[]').
684		binary_csp_op('|~|'(X,Y,_Span),X,Y,'|~|').
685		binary_csp_op(';'(X,Y,_Span),X,Y,';').
686		binary_csp_op('[>'(P,Q,_SrcSpan),P,Q,'[>').
687		binary_csp_op('/\\'(P,Q,_SrcSpan),P,Q,'/\\').
688
689		sharing_csp_op(esharing(CList,X,Y,_SrcSpan),X,CList,Y,' [|','|] ').
690		sharing_csp_op(sharing(CList,X,Y,_SrcSpan),X,CList,Y,' [|','|] ').
691		sharing_csp_op(lParallel(LinkList,X,Y,_Span),X,LinkList,Y,' [','] ').
692		sharing_csp_op(elinkParallel(LinkList,X,Y,_Span),X,LinkList,Y,' [','] ').
693		sharing_csp_op(exception(CList,X,Y,_SrcSpan),X,CList,Y,' [|','|> ').
694		sharing_csp_op(eexception(CList,X,Y,_SrcSpan),X,CList,Y,' [|','|> ').
695
696		asharing_csp_op(aParallel(CListX,X,CListY,Y,_SrcSpan),X,CListX,CListY,Y,' [',' || ','] ').
697		asharing_csp_op(eaParallel(CListX,X,CListY,Y,_SrcSpan),X,CListX,CListY,Y,' [',' || ','] ').
698
699		renaming_csp_op(procRenaming(RenameList,X,_SrcSpan),X,RenameList,'[[',']]').
700		renaming_csp_op(eprocRenaming(RenameList,X,_SrcSpan),X,RenameList,'[[',']]').
701
702		:- use_module(bmachine,[b_get_machine_operation_parameter_types/2, b_is_operation_name/1]).
703
704		translate_events([],[]).
705		translate_events([E|Erest],[Out|Orest]) :-
706		translate_event(E,Out),
707		translate_events(Erest,Orest).
708
709
710		% a version of translate_event which has access to the target state id:
711		% this allows to translate setup_constants, intialise by inserting target constants or values
712
713		translate_event_with_target_id(Term,Dst,Limit,Str) :-
714		translate_event_with_src_and_target_id(Term,unknown,Dst,Limit,Str).
715		translate_event_with_src_and_target_id(Term,Src,Dst,Str) :-
716		translate_event_with_src_and_target_id(Term,Src,Dst,5000,Str).
717
718		translate_event_with_src_and_target_id(Term,Src,Dst,Limit,Str) :-
719		get_preference(expand_avl_upto,CurLim),
720		SetLim is Limit//2,% at least two symbols per element
721		(CurLim<0 ; SetLim < CurLim),!,
722		temporary_set_preference(expand_avl_upto,SetLim,CHNG),
723		call_cleanup(translate_event_with_target_id2(Term,Src,Dst,Limit,Str),
724		reset_temporary_preference(expand_avl_upto,CHNG)).
725		translate_event_with_src_and_target_id(Term,Src,Dst,Limit,Str) :-
726		translate_event_with_target_id2(Term,Src,Dst,Limit,Str).
727
728		setup_cst_functor('$setup_constants',"SETUP_CONSTANTS").
729		setup_cst_functor('$partial_setup_constants',"PARTIAL_SETUP_CONSTANTS").
730
731		translate_event_with_target_id2(Term,_,Dst,Limit,Str) :-
732		functor(Term,Functor,_),
733		setup_cst_functor(Functor,UI_Name),
734		get_preference(show_initialisation_arguments,true),
735		state_space:visited_expression(Dst,concrete_constants(State)),
736		get_non_det_constant(State,NonDetState),
737		!,
738		translate_b_state_to_comma_list_codes(UI_Name,NonDetState,Limit,Codes),
739		atom_codes_with_limit(Str,Limit,Codes).
740		translate_event_with_target_id2(Term,_,Dst,Limit,Str) :-
741		functor(Term,'$initialise_machine',_),
742		get_preference(show_initialisation_arguments,true),
743	?	bmachine:b_get_operation_non_det_modifies('$initialise_machine',NDModVars),
744		state_space:visited_expression(Dst,State), get_variables(State,VarsState),
745		(NDModVars \= []
746		->
747		include(non_det_modified_var(NDModVars),VarsState,ModVarsState) % first show non-det variables
748		% we could add a preference for whether to show the deterministicly assigned variables at all
749		%exclude(non_det_modified_var(NDModVars),VarsState,ModVarsState2),
750		%append(ModVarsState1,ModVarsState2,ModVarsState)
751		; ModVarsState = VarsState),
752		!,
753		translate_b_state_to_comma_list_codes("INITIALISATION",ModVarsState,Limit,Codes),
754		atom_codes_with_limit(Str,Limit,Codes).
755		translate_event_with_target_id2(Term,Src,Dst,Limit,Str) :-
756		atomic(Term), % only applied to operations without parameters
757	?	specfile:b_mode,
758		get_non_det_modified_vars_in_target_id(Term,Dst,ModVarsState0), % only show non-det variables
759		(Src \= unknown,
760		state_space:visited_expression(Src,SrcState), get_variables(SrcState,PriorVarsState)
761		-> exclude(var_not_really_modified(PriorVarsState),ModVarsState0,ModVarsState)
762		% we could also optionally filter out vars which have the same value for all outgoing transitions of Src
763		; ModVarsState = ModVarsState0
764		),
765		!,
766		atom_codes(Term,TermCodes),
767		translate_b_state_to_comma_list_codes(TermCodes,ModVarsState,Limit,Codes),
768		atom_codes_with_limit(Str,Limit,Codes).
769		translate_event_with_target_id2(Term,_,_,Limit,Str) :- translate_event_with_limit(Term,Limit,Str).
770
771
772		get_non_det_modified_vars_in_target_id(OpName,DstId,ModVarsState0) :-
773		bmachine:b_get_operation_non_det_modifies(OpName,NDModVars),
774		NDModVars \= [], % a variable is non-deterministically written
775		state_space:visited_expression(DstId,State), % TO DO: unpack only NModVars
776		get_variables(State,VarsState),
777		include(non_det_modified_var(NDModVars),VarsState,ModVarsState0).
778
779		:- use_module(library(ordsets)).
780		non_det_modified_var(NDModVars,bind(Var,_)) :- ord_member(Var,NDModVars).
781
782		var_not_really_modified(PriorState,bind(Var,Val)) :-
783	?	(member(bind(Var,PVal),PriorState) -> PVal=Val).
784
785		get_variables(const_and_vars(_,VarsState),S) :- !, S=VarsState.
786		get_variables(S,S).
787
788		:- dynamic non_det_constants/2.
789
790		% compute which constants are non-deterministically assigned and which ones not
791		% TODO: maybe move to state space and invalidate info in case execute operation by predicate used
792		get_non_det_constant(Template,Result) :- non_det_constants(A,B),!, (A,B)=(Template,Result).
793		get_non_det_constant(Template,Result) :-
794	?	state_space:transition(root,_,DstID),
795		state_space:visited_expression(DstID,concrete_constants(State)), %write(get_non_det_constant(DstID)),nl,
796		!,
797		findall(D,(state_space:transition(root,_,D),D \= DstID),OtherDst),
798		compute_non_det_constants2(OtherDst,State),
799		non_det_constants(Template,Result).
800		get_non_det_constant(A,A).
801
802		compute_non_det_constants2([],State) :- adapt_state(State,Template,Result),
803		(Result = [] -> assertz(non_det_constants(A,A)) % in case all variables are deterministic: just show them
804		; assertz(non_det_constants(Template,Result))).
805		compute_non_det_constants2([Dst|T],State) :-
806		state_space:visited_expression(Dst,concrete_constants(State2)),
807		lub_state(State,State2,NewState),
808		compute_non_det_constants2(T,NewState).
809
810		lub_state([],[],[]).
811		lub_state([bind(V,H1)|T1],[bind(V,H2)|T2],[bind(V,H3)|T3]) :-
812		(H1==H2 -> H3=H1 ; H3='$NONDET'), lub_state(T1,T2,T3).
813
814		adapt_state([],[],[]).
815		adapt_state([bind(ID,Val)|T],[bind(ID,X)|TX],[bind(ID,X)|TY]) :- Val='$NONDET',!,
816		adapt_state(T,TX,TY).
817		adapt_state([bind(ID,_)|T],[bind(ID,_)|TX],TY) :- % Value is deterministic: do not copy
818		adapt_state(T,TX,TY).
819
820
821
822		% ------------------------------------
823
824		translate_event_with_limit(Event,Limit,Out) :-
825		translate_event2(Event,Atoms,[]),!,
826		ajoin_with_limit(Atoms,Limit,Out).
827		%,write(done),debug:print_debug_stats,nl.% , write(Out),nl.
828		translate_event_with_limit(Event,_,Out) :- add_error(translate_event_with_limit,'Could not translate event: ', Event),
829		Out = '???'.
830
831		translate_event(Event,Out) :- %write(translate),print_debug_stats,nl,
832		translate_event2(Event,Atoms,[]),!,
833		ajoin(Atoms,Out).
834		%,write(done),debug:print_debug_stats,nl.% , write(Out),nl.
835		translate_event(Event,Out) :-
836		add_error(translate_event,'Could not translate event: ', Event),
837		Out = '???'.
838
839		/* BEGIN CSP */
840		translate_event2(start_cspm(Process),['start_cspm('|S],T) :- process_algebra_mode,!,pp_csp_value(Process,S,[')'|T]).
841		%% translate_event2(i(_Span),['i'|T],T) :- process_algebra_mode,!. /* CSP */ %% deprecated
842		translate_event2(tick(_Span),['tick'|T],T) :- process_algebra_mode,!. /* CSP */
843		translate_event2(tau(hide(Action)),['tau(hide('|S],T) :- process_algebra_mode,nonvar(Action), !,
844		translate_event2(Action,S,['))'|T]). /* CSP */
845		translate_event2(tau(link(Action1,Action2)),['tau(link('|S],T) :- /* CSP */
846		nonvar(Action1), nonvar(Action2), process_algebra_mode, !,
847		translate_event2(Action1,S,['<->'|S1]),
848		translate_event2(Action2,S1,['))'|T]).
849		translate_event2(tau(Info),['tau(',Fun,')'|T],T) :-
850		nonvar(Info), process_algebra_mode,!, /* CSP */
851		translate_csp_tau(Info,Fun).
852		translate_event2(io(V,Ch,_Span),S,T) :- process_algebra_mode,!, /* CSP */
853		(csp_with_bz_mode ->
854		S=['CSP:'|S1],
855		translate_event2(io(V,Ch),S1,T)
856		;
857		translate_event2(io(V,Ch),S,T)
858		).
859		translate_event2(io(X,Channel),S,T) :- process_algebra_mode,!, /* CSP */
860		(X=[] -> translate_event2(Channel,S,T)
861		; (translate_event2(Channel,S,S1),
862		translate_channel_values(X,S1,T))
863		).
864		/* END CSP */
865		translate_event2(Op,[A|T],T) :-
866		% this clause must be after the CSP code, test 756 sets process_algebra_mode via prob_pragma_string
867		% this allows xtl interpreters to use tau,tick,io events
868		animation_mode(xtl),
869		!,
870		translate_xtl_value(Op,A). /* XTL transitions can be arbitrary terms */
871		translate_event2('$JUMP'(Name),[A|T],T) :- write_to_codes(Name,Codes),
872		atom_codes_with_limit(A,Codes).
873		translate_event2('-->'(Operation,ResultValues),S,T) :- nonvar(ResultValues),
874		ResultValues=[_|_],!,
875		translate_event2(Operation,S,['-->',ValuesStr|T]),
876		translate_bvalues(ResultValues,ValuesStr).
877		translate_event2(Op,S,T) :-
878		nonvar(Op), Op =.. [OpName|Args],
879		translate_b_operation_call(OpName,Args,S,T),!.
880		translate_event2(Op,[A|T],T) :-
881		%['<< ',A,' >>'|T],T) :- % the << >> pose problems when checking against FDR
882		write_to_codes(Op,Codes),
883		atom_codes_with_limit(A,Codes).
884
885		translate_csp_tau('$setup_constants',T) :- csp_with_bz_mode,!, T='SETUP_CONSTANTS'.
886		translate_csp_tau('$initialise_machine',T) :- csp_with_bz_mode, !, T='INITIALISATION'.
887		translate_csp_tau(TauTerm,Fun) :- functor(TauTerm,Fun,_).
888		%(translate_event(TauTerm,Fun) -> true ; functor(TauTerm,Fun,_)).
889
890
891		% translate a B operation call to list of atoms in dcg style
892		translate_b_operation_call(OpName,Args,[TOpName|S],T) :-
893		translate_operation_name(OpName,TOpName),
894		( Args=[] -> S=T
895		;
896		S=['(',ValuesStr,')'|T],
897		( get_preference(show_eventb_any_arguments,false), % otherwise we have additional ANY parameters !
898		\+ is_init(OpName), % order of variables does not always correspond to Variable order used by b_get_machine_operation_parameter_types ! TO DO - Fix this in b_initialise_machine2 (see Interlocking.mch CSP||B model)
899	?	specfile:b_mode,
900		b_is_operation_name(OpName),
901	?	b_get_machine_operation_parameter_types(OpName,ParTypes),
902		ParTypes \= []
903		-> translate_bvalues_with_types(Args,ParTypes,ValuesStr)
904		%; is_init(OpName) -> b_get_machine_operation_typed_parameters(OpName,TypedParas),
905		; translate_bvalues(Args,ValuesStr))
906		).
907
908		% -----------------
909
910		% translate call stacks as stored in wait flag info fields
911		% (managed by push_wait_flag_call_stack_info)
912
913		translate_call_stack(Stack,Msg) :-
914		Opts = [detailed],
915		split_calls(Stack,DStack),
916		get_cs_avl_limit(ALimit),
917		temporary_set_preference(expand_avl_upto,ALimit,CHNG),
918		set_unicode_mode,
919		call_cleanup(render_call_stack(DStack,1,Opts,A,[]),
920		(unset_unicode_mode,
921		reset_temporary_preference(expand_avl_upto,CHNG))),
922		ajoin(['call stack: '|A],Msg).
923		render_call_stack([],_,_) --> [].
924		render_call_stack([H],Nr,Opts) --> !,
925		render_nr(Nr,H,_,Opts), render_call(H,Opts).
926		render_call_stack([H|T],Nr,Opts) -->
927		render_nr(Nr,H,Nr1,Opts),
928		render_call(H,Opts),
929		render_seperator(Opts),
930		render_call_stack(T,Nr1,Opts).
931
932		% render nr of call in call stack
933		render_nr(Pos,H,Pos1,Opts) --> {member(detailed,Opts)},!, ['\n '], render_pos_nr(Pos,H,Pos1).
934		render_nr(Pos,_,Pos,_) --> [].
935
936		render_pos_nr(Pos,definition_call(_,_),Pos) --> !,
937		[' ']. % definition calls are virtual and can appear multiple times for different entries in the call stack
938		% see e.g., public_examples/B/FeatureChecks/DEFINITIONS/DefCallStackDisplay2.mch
939		render_pos_nr(Pos,_,Pos1) --> [Pos] , {Pos1 is Pos+1}, [': '].
940
941		render_seperator(Opts) --> {member(detailed,Opts)},!. % we put newlines in render_nr
942		render_seperator(_Opts) -->
943		{call_stack_arrow_atom_symbol(Symbol)}, [Symbol].
944
945		render_call(definition_call(Name,Pos),Opts) --> !,
946		['within DEFINITION call '],[Name],
947		render_span(Pos,Opts).
948		render_call(operation_call(Op,Paras,Pos),Opts) --> !,
949		translate_b_operation_call(Op,Paras), % TODO: limit size?
950		render_span(Pos,Opts).
951		render_call(using_state(Name,State),_Opts) --> !,
952		[Name], [' with state: '],
953		{get_cs_limit(Limit),translate_bstate_limited(State,Limit,Str)},
954		[Str].
955		render_call(after_event(OpTerm),_Opts) --> !,
956		['after event: '],
957		{get_cs_limit(Limit),translate_event_with_limit(OpTerm,Limit,Str)},
958		[Str].
959		render_call(function_call(Fun,Paras,Pos),Opts) --> !,
960		render_function_call(Fun,Paras),
961		render_span(Pos,Opts).
962		render_call(b_operator_call(OP,Paras,Pos),Opts) --> !,
963		render_operator_arg(b_operator(OP,Paras)),
964		render_span(Pos,Opts).
965		render_call(id_equality_evaluation(ID,Kind,Pos),Opts) --> !,
966		['equality for '],[Kind],[' '],[ID],
967		render_span(Pos,Opts).
968		render_call(b_operator_arg_evaluation(OP,PosNr,Args,Pos),Opts) --> !,
969		['arg '],[PosNr],[' of '],
970		render_operator_arg(b_operator(OP,Args)),
971		render_span(Pos,Opts).
972		render_call(external_call(Name,Paras,Pos),Opts) --> !,
973		['external call '], [Name],['('],
974		{get_cs_limit(Limit),translate_bvalues_with_limit(Paras,Limit,PS)},[PS], [')'],
975		render_span(Pos,Opts).
976		render_call(prob_command_context(Name,Pos),Opts) --> !,
977		['checking '], render_prob_command(Name),
978		render_span(Pos,Opts).
979		render_call(quantifier_call(comprehension_set,ParaNames,ParaValues,Pos),Opts) --> % special case for lambda
980		{nth1(LPos,ParaNames,LambdaRes,RestParaNames),
981		is_lambda_result_name(LambdaRes,_),
982		nth1(LPos,ParaValues,LambdaVal,RestParaValues)},!, % we have found '_lambda_res_' amongst paras
983		render_quantifier(lambda), ['('],
984		render_paras(RestParaNames,RestParaValues),
985		['|'], render_para_val(LambdaVal),
986		[')'],
987		render_span(Pos,Opts).
988		render_call(quantifier_call(Kind,ParaNames,ParaValues,Pos),Opts) --> !,
989		render_quantifier(Kind), ['('],
990		render_paras(ParaNames,ParaValues), [')'],
991		render_span(Pos,Opts).
992		render_call(top_level_call(SpanPred),Opts) -->
993		render_call(SpanPred,Opts).
994		render_call(b_expr_call(Context,Expr),Opts) --> !,
995		[Context],[': '],
996		render_b_expr(Expr),
997		render_span(Expr,Opts).
998		render_call(b_subst_call(Context,Subst),Opts) --> !,
999		[Context],[': '],
1000		render_b_subst(Subst),
1001		render_span(Subst,Opts).
1002		render_call(span_predicate(Pred,LS,S),Opts) --> % Pred can also be an expression like function/2
1003		% infos could contain was(extended_expr(Op)); special case for: assertion_expression
1004		{Pred=b(_,_,Pos),
1005		b_compiler:b_compile(Pred,[],LS,S,CPred,no_wf_available) % inline actual parameters
1006		},
1007		!,
1008		render_b_expr(CPred),
1009		render_function_name(Pred), % try show function name from uncompiled Expr
1010		render_span(Pos,Opts).
1011		render_call(Other,_) --> [Other].
1012
1013		% get a brief description of call in call_stack
1014		render_call_short(after_event(OpTerm,_),R) :- !,R=OpTerm.
1015		render_call_short(using_state(Name,_),R) :- !,R=Name.
1016		render_call_short(definition_call(Name,_,_),R) :- !,R=Name.
1017		render_call_short(operation_call(Name,_,_),R) :- !,R=Name.
1018		render_call_short(function_call(Name,_,_),R) :- !,R=Name.
1019		render_call_short(b_operator_call(Name,_,_),R) :- !,R=Name.
1020		render_call_short(b_operator_arg_evaluation(Name,_,_,_),R) :- !,R=Name.
1021		render_call_short(external_call(Name,_,_),R) :- !,R=Name.
1022		render_call_short(prob_command_context(Name,_),R) :- !,R=Name.
1023		render_call_short(quantifier_call(Kind,_,_,_),R) :- !, R=Kind.
1024		render_call_short(top_level_call(_),R) :- !, R=top_level.
1025		render_call_short(E,F) :- functor(E,F,_).
1026
1027
1028		%render_operator(OP) -->
1029		% {(unicode_translation(OP,Unicode) -> FOP=Unicode ; FOP=OP)}, [FOP].
1030
1031		% render b operator arguments/calls:
1032		render_operator_arg(Var) --> {var(Var)},!,['_VARIABLE_']. % should not happen
1033		render_operator_arg(b_operator(OP,[Arg1,Arg2])) -->
1034		{binary_infix_in_mode(OP,Symbol,_,_)},!,
1035		{(unicode_translation(OP,Unicode) -> FOP=Unicode ; FOP=Symbol)}, %TODO: add parentheses if necessary
1036		render_operator_arg(Arg1),
1037		[' '],[FOP], [' '],
1038		render_operator_arg(Arg2).
1039		render_operator_arg(b_operator(OP,Args)) --> !,
1040		{(unicode_translation(OP,Unicode) -> FOP=Unicode ; function_like(OP,FOP) -> true ; FOP=OP)},
1041		[FOP], ['('],
1042		render_operator_args(Args),
1043		[')'].
1044		render_operator_arg(bind(Name,Value)) --> !,
1045		[Name], ['='],
1046		render_operator_arg(Value).
1047		render_operator_arg(identifier(ID)) --> !, [ID].
1048		render_operator_arg(Val) --> render_para_val(Val).
1049
1050		render_operator_args([]) --> !, [].
1051		render_operator_args([H]) --> !, render_operator_arg(H).
1052		render_operator_args([H|T]) --> !, render_operator_arg(H), [','], render_operator_args(T).
1053		render_operator_args(A) --> {add_internal_error('Not a list: ',A)}, ['???'].
1054
1055		render_prob_command(check_pred_command(PredKind,Arg)) --> !, ['predicate '], render_pred_nr(Arg), ['of '],[PredKind].
1056		render_prob_command(eval_expr_command(Kind,Arg)) --> !, ['expression '], render_pred_nr(Arg), ['of '],[Kind].
1057		render_prob_command(trace_replay(OpName,FromId)) --> !, ['Trace replay predicate for '],[OpName], [' from '],[FromId].
1058		render_prob_command(Cmd) --> [Cmd].
1059
1060		render_pred_nr(0) --> !. % 0 is special value to indicate we have no number/id within outer kind
1061		render_pred_nr(Nr) --> {number(Nr)},!,['# '],[Nr],[' '].
1062		render_pred_nr('') --> !.
1063		render_pred_nr(AtomId) --> ['for '], [AtomId],[' '].
1064
1065		render_function_name(b(function(Fun,_),_,_)) --> {try_get_identifier(Fun,FID)},!,
1066		% TODO: other means of extracting name; maybe we should render anything that is not a value?
1067		['\n (Function applied: '], [FID], [')'].
1068		render_function_name(b(_,_,Infos)) --> {member(was(extended_expr(OpID)),Infos)},!,
1069		['\n (Theory operator applied: '], [OpID], [')'].
1070		render_function_name(_) --> [].
1071
1072		try_get_identifier(Expr,Id) :- (get_texpr_id(Expr,Id) -> true ; get_was_identifier(Expr,Id)).
1073
1074		render_span(Span,Opts) --> {member(detailed,Opts),translate_span(Span,Atom), Atom \= ''},!,
1075		['\n '], [Atom],
1076		({member(additional_descr,Opts),translate_additional_description(Span,Descr)}
1077		-> [' within ',Descr]
1078		; []).
1079		render_span(_,_) --> [].
1080
1081		render_function_call(Fun,Paras) -->
1082		{(atomic(Fun) -> FS=Fun ; translate_bexpr_for_call_stack(Fun,FS))}, % memoization will only register atomic name
1083		[FS],['('], render_para_val(Paras), [')'].
1084
1085		render_b_expr(b(function(Fun,Paras),_,_)) --> !, % ensure we print both function and paras at least partially
1086		{translate_bexpr_for_call_stack(Fun,FS)}, [FS],['('],
1087		{translate_bexpr_for_call_stack(Paras,PS)},[PS], [')'].
1088		render_b_expr(b(assertion_expression(Pred,Msg,b(value(_),string,_)),_,_)) --> !,
1089		% Body is not source of error; probably better to use special call stack entry for assertion_expression
1090		['ASSERT '],[Msg],['\n '],
1091		{translate_bexpr_for_call_stack(Pred,PS)}, [PS].
1092		render_b_expr(CPred) --> {translate_bexpr_for_call_stack(CPred,PS)}, [PS].
1093
1094		translate_bexpr_for_call_stack(Expr,TS) :-
1095		get_cs_limit(Limit),
1096		translate_bexpr_with_limit_tl(Expr,Limit,TS).
1097
1098		render_b_subst(CPred) --> % TODO: try and fit this on a single line ?
1099		{get_cs_limit(Limit),translate_subst_or_bexpr_with_limit(CPred,Limit,PS)}, [PS].
1100
1101		% a variation to ensure that top-level operator is guaranteed to be shown
1102		% does not yet guarantee propert parentheses around arguments !
1103		% useful for showing call stack so that we at least see the operator and part of both args
1104		translate_bexpr_with_limit_tl(b(Special,pred,_),Limit,TS) :-
1105		special_binary_op(Special,LHS,RHS,Op),
1106		binary_infix_in_mode(Op,Trans,_Prio,_Assoc),
1107		!, Lim2 is (Limit+1)//2,
1108		translate_bexpression_with_limit(LHS,Lim2,TS1),
1109		translate_bexpression_with_limit(RHS,Lim2,TS2),
1110		ajoin([TS1,' ',Trans,' ',TS2],TS).
1111		translate_bexpr_with_limit_tl(Expr,Limit,TS) :-
1112		translate_bexpression_with_limit(Expr,Limit,TS).
1113
1114		special_binary_op(member(LHS,RHS),LHS,RHS,member).
1115		special_binary_op(not_member(LHS,RHS),LHS,RHS,not_member).
1116		special_binary_op(equal(LHS,RHS),LHS,RHS,equal).
1117		special_binary_op(not_equal(LHS,RHS),LHS,RHS,not_equal).
1118		special_binary_op(subset(LHS,RHS),LHS,RHS,subset).
1119		special_binary_op(subset_strict(LHS,RHS),LHS,RHS,subset_strict).
1120
1121		get_cs_limit(2000) :- !.
1122		get_cs_limit(Limit) :- debug_mode(on),!, debug_level(Level), % 19 regular, 5 very verbose
1123		Limit is 1000 - Level*20.
1124		get_cs_limit(200) :- get_preference(provide_trace_information,true),!.
1125		get_cs_limit(100).
1126
1127		get_cs_avl_limit(40) :- debug_mode(on),!.
1128		get_cs_avl_limit(6) :- get_preference(provide_trace_information,true),!.
1129		get_cs_avl_limit(4).
1130
1131		get_call_stack_span(operation_call(_,_,Pos),Pos).
1132		%get_call_stack_span(after_event(_),unknown).
1133		get_call_stack_span(function_call(_,_,Pos),Pos).
1134		get_call_stack_span(id_equality_evaluation(_ID,_Kind,Pos),Pos).
1135		get_call_stack_span(quantifier_call(_,_,_,Pos),Pos).
1136		get_call_stack_span(definition_call(_,Pos),Pos).
1137		get_call_stack_span(external_call(_,_,Pos),Pos).
1138		get_call_stack_span(prob_command_context(_,Pos),Pos).
1139		get_call_stack_span(top_level_call(Pos),Pos).
1140		get_call_stack_span(b_operator_call(_,_,Pos),Pos).
1141		get_call_stack_span(b_operator_arg_evaluation(_,_,_,Pos),Pos).
1142		get_call_stack_span(b_expr_call(_,Expr),Expr).
1143		get_call_stack_span(b_subst_call(_,Expr),Expr).
1144		get_call_stack_span(span_predicate(A,B,C),span_predicate(A,B,C)).
1145
1146		nop_call(top_level_call(X)) :- \+ is_top_level_function_call(X).
1147		% just there to insert virtual DEFINITION calls at top-level of call-stack
1148		is_top_level_function_call(span_predicate(b(Expr,_,_),_,_)) :-
1149		Expr = function(_,_),
1150		get_preference(provide_trace_information,false).
1151		% otherwise we push function_calls onto the stack; see opt_push_wait_flag_call_stack_info
1152
1153		% expand the call stack by creating entries for the definition calls
1154		split_calls([],[]).
1155		split_calls([Call|T],NewCalls) :- nop_call(Call),!, %write(nop(Call)),nl,
1156		split_calls(T,NewCalls).
1157		split_calls([Call|T],NewCalls) :-
1158		get_call_stack_span(Call,Span),!,
1159		NewCalls = [Call|New2],
1160		extract_def_calls(Span,New2,ST),
1161		split_calls(T,ST).
1162		split_calls([Call|T],[Call|ST]) :-
1163		split_calls(T,ST).
1164
1165		extract_def_calls(Span) -->
1166		{extract_pos_context(Span,MainPos,Context,CtxtPos)},
1167		{Context = definition_call(Name)},
1168		!,
1169		extract_def_calls(MainPos),
1170		[definition_call(Name,CtxtPos)],
1171		extract_def_calls(CtxtPos). % do we need this??
1172		extract_def_calls(_) --> [].
1173
1174		% a shorter version of extract_additional_description only accepting definition_calls
1175		translate_additional_description(Span,Desc) :-
1176		extract_pos_context(Span,MainPos,Context,CtxtPos),
1177		translate_span(CtxtPos,CtxtAtom),
1178		extract_def_context_msg(Context,OuterCMsg),
1179		(translate_additional_description(MainPos,InnerCMsg)
1180		-> ajoin([InnerCMsg,' within ',OuterCMsg, ' ', CtxtAtom],Desc)
1181		; ajoin([OuterCMsg, ' ', CtxtAtom],Desc)
1182		).
1183
1184		% try and get an immediate definition call context for a position
1185		get_definition_context_from_span(Span,DefCtxtMsg) :-
1186		extract_pos_context(Span,_MainPos,Context,_CtxtPos),
1187		extract_def_context_msg(Context,DefCtxtMsg).
1188
1189		extract_def_context_msg(definition_call(Name),Msg) :- !, % static Definition macro expansion call stack
1190		ajoin(['DEFINITION call of ',Name],Msg).
1191
1192		render_paras([],[]) --> !, [].
1193		render_paras([],_Vals) --> ['...?...']. % should not happen
1194		render_paras([Name],[Val]) --> !, render_para_name(Name), ['='], render_para_val(Val).
1195		render_paras([Name|TN],[Val|TV]) --> !,
1196		render_para_name(Name), ['='], render_para_val(Val), [','],
1197		render_paras(TN,TV).
1198		render_paras([N|Names],[]) --> !, render_para_name(N), render_paras(Names,[]). % value list can be empty
1199
1200		render_para_val(E) --> {nonvar(E),E=b(_,_,_)}, !, % only used in special cases; e.g., image_for_special_operator
1201		{get_cs_limit(Limit),translate_bexpression_with_limit(E,Limit,VS)}, [VS].
1202		render_para_val(Val) --> {get_cs_limit(Limit),translate_bvalue_with_limit(Val,Limit,VS)}, [VS].
1203
1204		% accept typed and atomic ids
1205		render_para_name(b(identifier(ID),_,_)) --> !, {translated_identifier(ID,TID)},[TID].
1206		render_para_name(ID) --> {translated_identifier(ID,TID)},[TID].
1207
1208		render_quantifier(lambda) --> !, {unicode_translation(lambda,Symbol)},[Symbol]. % ['{|}'].
1209		render_quantifier(comprehension_set) --> !, ['{|}'].
1210		render_quantifier(comprehension_set(NegationContext)) --> !,
1211		render_negation_context(NegationContext), [' {|}'].
1212		render_quantifier(exists) --> !, {unicode_translation(exists,Symbol)},[Symbol].
1213		render_quantifier(let_quantifier) --> !, ['LET'].
1214		render_quantifier(optimize) --> !, ['#optimize'].
1215		render_quantifier(forall) --> !, {unicode_translation(forall,Symbol)},[Symbol].
1216		render_quantifier(not(Q)) --> !, {unicode_translation(negation,Symbol)}, % not(exists)
1217		[Symbol, '('], render_quantifier(Q), [')'].
1218		render_quantifier(Q) --> !, [Q].
1219
1220		render_negation_context(positive) --> !, ['one solution'].
1221		render_negation_context(negative) --> !, ['no solution'].
1222		render_negation_context(all_solutions) --> !,['all solutions'].
1223		render_negation_context(C) --> [C].
1224
1225		call_stack_arrow_atom_symbol(' \x2192\ '). % see total function
1226		%call_stack_arrow_atom_symbol('\x27FF\ '). % long rightwards squiggle arrow
1227
1228		% -----------------
1229
1230
1231		is_init('$initialise_machine').
1232		is_init('$setup_constants').
1233		is_init('$partial_setup_constants').
1234
1235		translate_bvalues_with_types(Values,Types,Output) :-
1236		%set_up_limit_reached(Codes,1000,LimitReached),
1237		pp_value_l_with_types(Values,',',Types,_LimitReached,Codes,[]),!,
1238		atom_codes_with_limit(Output,Codes).
1239		translate_bvalues_with_types(Values,T,Output) :-
1240		add_internal_error('Call failed: ',translate_bvalues_with_types(Values,T,Output)),
1241		translate_bvalues(Values,Output).
1242
1243		pp_value_l_with_types([],_Sep,[],_) --> !.
1244		pp_value_l_with_types([Expr|Rest],Sep,[TE|TT],LimitReached) -->
1245		( {nonvar(Rest),Rest=[]} ->
1246		pp_value_with_type(Expr,TE,LimitReached)
1247		;
1248		pp_value_with_type(Expr,TE,LimitReached),ppatom(Sep),
1249		pp_value_l_with_types(Rest,Sep,TT,LimitReached)).
1250
1251
1252		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1253
1254		% pretty-print properties
1255		translate_properties_with_limit([],[]).
1256		translate_properties_with_limit([P|Prest],[Out|Orest]) :-
1257		translate_property_with_limit(P,320,Out), % reduced limit as we now have evaluation view + possibility to inspect all of value
1258		translate_properties_with_limit(Prest,Orest).
1259
1260		translate_property_with_limit(Prop,Limit,Output) :-
1261		(pp_property(Prop,Limit,Output) -> true ; (add_error(translate_property,'Could not translate property: ',Prop),Output='???')).
1262		pp_property(Prop,Limit,Output) :-
1263		pp_property_without_plugin(Prop,Limit,Output).
1264		pp_property_without_plugin(=(Key,Value),_,A) :-
1265		!,ajoin([Key,' = ',Value],A).
1266		pp_property_without_plugin(':'(Key,Value),_,A) :-
1267		!,ajoin([Key,' : ',Value],A).
1268		pp_property_without_plugin(info(I),_,I) :- !.
1269		pp_property_without_plugin(Prop,Limit,A) :-
1270		write_to_codes(Prop,Codes),
1271		atom_codes_with_limit(A,Limit,Codes).
1272
1273
1274		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1275		:- use_module(tools_meta,[translate_term_into_atom_with_max_depth/3]).
1276
1277		% pretty-print errors belonging to a certain state
1278		translate_error_term(Term,S) :- translate_error_term(Term,unknown,S).
1279		translate_error_term(Var,_,S) :- var(Var),!,
1280		translate_term_into_atom_with_max_depth(Var,5,S).
1281		translate_error_term('@fun'(X,F),Span,S) :-
1282		translate_bvalue(X,TX),
1283		(get_function_from_span(Span,Fun,LocState,State),
1284		translate_bexpression_with_limit(Fun,200,TSF)
1285		-> % we managed to extract the function from the span_predicate
1286		(is_compiled_value(Fun)
1287		-> (get_was_identifier(Fun,WasFunId) -> Rest = [', function: ',WasFunId | Rest1]
1288		; Rest = Rest1
1289		),
1290		TVal=TSF % use as value
1291		; Rest = [', function: ',TSF | Rest1],
1292		% try and extract value from span_predicate (often F=[] after traversing avl)
1293		(get_texpr_id(Fun,FID),
1294		(member(bind(FID,FVal),LocState) ; member(bind(FID,FVal),State))
1295		-> translate_bvalue(FVal,TVal)
1296		; translate_bvalue(F,TVal)
1297		)
1298		)
1299		; Rest=[], translate_bvalue(F,TVal)
1300		),!,
1301		% translate_term_into_atom_with_max_depth('@fun'(TX,TVal),5,S).
1302		(get_error_span_for_value(F,NewSpanTxt) % triggers in test 953
1303		-> Rest1 = [' defined at ',NewSpanTxt]
1304		; Rest1 = []
1305		),
1306		ajoin(['Function argument: ',TX, ', function value: ',TVal | Rest],S).
1307		translate_error_term('@rel'(Arg,Res1,Res2),_,S) :-
1308		translate_bvalue(Arg,TA), translate_bvalue(Res1,R1),
1309		translate_bvalue(Res2,R2),!,
1310		ajoin(['Function argument: ',TA, ', two possible values: ',R1,', ',R2],S).
1311		translate_error_term([Op|T],_,S) :- T==[], nonvar(Op), Op=operation(Name,Env),
1312		translate_any_state(Env,TEnv), !,
1313		translate_term_into_atom_with_max_depth(operation(Name,TEnv),10,S).
1314		translate_error_term(error(E1,E2),_,S) :- !, translate_prolog_error(E1,E2,S).
1315		translate_error_term(b(B,T,I),_,S) :-
1316		translate_subst_or_bexpr_with_limit(b(B,T,I),1000,do_not_report_errors,S),!. % do not report errors, otherwise we end in an infinite loop of adding errors while adding errors
1317		translate_error_term([H|T],_,S) :- nonvar(H), H=b(_,_,_), % typically a list of typed ids
1318		E=b(sequence_extension([H|T]),any,[]),
1319		translate_subst_or_bexpr_with_limit(E,1000,do_not_report_errors,S),!.
1320		translate_error_term([H|T],_,S) :- nonvar(H), H=bind(_,_), % a store
1321		translate_bstate_limited([H|T],1000,S),!.
1322		translate_error_term(Term,_,S) :-
1323		is_bvalue(Term),
1324		translate_bvalue_with_limit(Term,1000,S),!.
1325		translate_error_term(T,_,S) :-
1326		(debug_mode(on) -> Depth = 20 ; Depth = 5),
1327		translate_term_into_atom_with_max_depth(T,Depth,S).
1328
1329		get_function_from_span(Var,Fun,_,_) :- var(Var), !,
1330		add_internal_error('Variable span:',get_function_from_span(Var,Fun)),fail.
1331		get_function_from_span(pos_context(Span,_,_),Fun,LS,S) :- get_function_from_span(Span,Fun,LS,S).
1332		get_function_from_span(span_predicate(b(function(Function,_Arg),_T,_I),LocalState,State),Function,LocalState,State).
1333
1334		is_compiled_value(b(value(_),_,_)).
1335
1336		get_was_identifier(b(_,_,Info),Id) :- member(was_identifier(Id),Info). % added e.g. by b_compiler
1337
1338		% TODO: complete this
1339		% for recognising B values as error terms and automatically translating them
1340		is_bvalue(V) :- var(V),!,fail.
1341		is_bvalue([]).
1342		is_bvalue(closure(_,_,_)).
1343		is_bvalue(fd(_,_)).
1344		is_bvalue(freetype(_)).
1345		is_bvalue(freeval(_,_,_)).
1346		is_bvalue(avl_set(_)).
1347		is_bvalue(int(_)).
1348		is_bvalue(global_set(_)).
1349		is_bvalue(pred_true).
1350		is_bvalue(pred_false).
1351		is_bvalue(string(_)).
1352		is_bvalue(term(_)). % typically term(floating(_))
1353		is_bvalue(rec(Fields)) :- nonvar(Fields), Fields=[F1|_], nonvar(F1),
1354		F1=field(_,V1), is_bvalue(V1).
1355		is_bvalue((A,B)) :-
1356		(nonvar(A) -> is_bvalue(A) ; true),
1357		(nonvar(B) -> is_bvalue(B) ; true).
1358
1359		% try and get error location for span:
1360		get_error_span_for_value(Var,_) :- var(Var),!,fail.
1361		get_error_span_for_value(closure(_,_,Body),Span) :- translate_span_with_filename(Body,Span), Span \= ''.
1362
1363
1364		% translate something that was caught with catch/3
1365		translate_prolog_exception(user_interrupt_signal,R) :- !, R='User-Interrupt (CTRL-C)'.
1366		translate_prolog_exception(enumeration_warning(_,_,_,_,_),R) :- !, R='Enumeration Warning'.
1367		translate_prolog_exception(error(E1,E2),S) :- !, translate_prolog_error(E1,E2,S).
1368		translate_prolog_exception(E1,S) :- translate_term_into_atom_with_max_depth(E1,8,S).
1369
1370		% translate a Prolog error(E1,E2) exception
1371		translate_prolog_error(existence_error(procedure,Pred),_,S) :- !,
1372		translate_term_into_atom_with_max_depth('Unknown Prolog predicate:'(Pred),8,S).
1373		translate_prolog_error(existence_error(source_sink,File),ExcTerm,S) :- !,
1374		(arg(1,ExcTerm,Call), functor(Call,process_create,_)
1375		-> ajoin(['Program does not exist: ',File],S)
1376		; ajoin(['File does not exist: ',File],S)
1377		).
1378		translate_prolog_error(permission_error(Action,source_sink,File),_,S) :- !, % Action = open, ...
1379		ajoin(['Permission denied to ',Action,' the file: ',File],S).
1380		translate_prolog_error(permission_error(Action,past_end_of_stream,File),_,S) :- !, % Action = open, ...
1381		ajoin(['Permission denied to ',Action,' past end of file: ',File],S).
1382		translate_prolog_error(resource_error(memory),_,S) :- !,
1383		S = 'Resource error: Out of memory'. % GLOBALSTKSIZE=500M probcli ... could help ???
1384		translate_prolog_error(resource_error(file_handle),_,S) :- !,
1385		(debug_mode(on) -> print_open_stream_stats ; true),
1386		S = 'Resource error: Too many open files'.
1387		translate_prolog_error(system_error,system_error('SPIO_E_NET_CONNRESET'),S) :- !,
1388		S = 'System error: connection to process lost (SPIO_E_NET_CONNRESET)'.
1389		translate_prolog_error(system_error,system_error('SPIO_E_ENCODING_UNMAPPABLE'),S) :- !,
1390		S = 'System error: illegal character or encoding encountered (SPIO_E_ENCODING_UNMAPPABLE)'.
1391		translate_prolog_error(system_error,system_error('SPIO_E_NET_HOST_NOT_FOUND'),S) :- !,
1392		S = 'System error: could not find host (SPIO_E_NET_HOST_NOT_FOUND)'.
1393		translate_prolog_error(system_error,system_error('SPIO_E_CHARSET_NOT_FOUND'),S) :- !,
1394		S = 'System error: could not find character set encoding'.
1395		translate_prolog_error(system_error,system_error('SPIO_E_OS_ERROR'),S) :- !,
1396		S = 'System error due to some OS/system call (SPIO_E_OS_ERROR)'.
1397		translate_prolog_error(system_error,system_error('SPIO_E_END_OF_FILE'),S) :- !,
1398		S = 'System error: end of file (SPIO_E_END_OF_FILE)'.
1399		translate_prolog_error(system_error,system_error('SPIO_E_TOO_MANY_OPEN_FILES'),S) :- !,
1400		S = 'System error: too many open files (SPIO_E_TOO_MANY_OPEN_FILES)'.
1401		% current_stream(File,Mode,_),write(f(File,Mode)),nl,fail.
1402		translate_prolog_error(system_error,system_error(dlopen(Msg)),S) :- !,
1403		translate_term_into_atom_with_max_depth(Msg,4,MS),
1404		ajoin(['System error: could not load dynamic library (you may have to right-click on the library and open it in the macOS Finder): ', MS],S).
1405		translate_prolog_error(system_error,system_error(Err),S) :- !,
1406		% or Err is an atom dlopen( mach-o file, but is an incompatible architecture ...)
1407		% E.g., SPIO_E_NOT_SUPPORTED when doing open('/usr',r,S)
1408		translate_term_into_atom_with_max_depth('System error:'(Err),8,S).
1409		translate_prolog_error(existence_error(procedure,Module:Pred/Arity),_,S) :- !,
1410		ajoin(['Prolog predicate does not exist: ',Module,':', Pred, '/',Arity],S).
1411		translate_prolog_error(instantiation_error,instantiation_error(Call,_ArgNo),S) :- !,
1412		translate_term_into_atom_with_max_depth('Prolog instantiation error:'(Call),8,S).
1413		translate_prolog_error(uninstantiation_error(_),uninstantiation_error(Call,_ArgNo,_Culprit),S) :- !,
1414		translate_term_into_atom_with_max_depth('Prolog uninstantiation error:'(Call),8,S).
1415		translate_prolog_error(evaluation_error(zero_divisor),evaluation_error(Call,_,_,_),S) :- !,
1416		translate_term_into_atom_with_max_depth('Division by zero error:'(Call),8,S).
1417		translate_prolog_error(evaluation_error(float_overflow),evaluation_error(Call,_,_,_),S) :- !,
1418		translate_term_into_atom_with_max_depth('Float overflow:'(Call),8,S).
1419		translate_prolog_error(representation_error(Err),representation_error(Call,_,_),S) :-
1420		memberchk(Err, ['CLPFD integer overflow','max_clpfd_integer','min_clpfd_integer']),!,
1421		translate_term_into_atom_with_max_depth('Prolog CLP(FD) overflow:'(Call),8,S).
1422		% TODO: domain_error(list_to_fdset(FDLIST,_989819),_,_,_L)
1423		translate_prolog_error(syntax_error(Err),_,S) :- !,
1424		translate_term_into_atom_with_max_depth('Prolog syntax error:'(Err),8,S).
1425		translate_prolog_error(_,resource_error(open(File,Mode,_),Kind),S) :- !, % Kind e.g. file_handle
1426		ajoin(['Resource error (',Kind,
1427		'), could not open file ',File,' in mode ',Mode],S).
1428		:- if(predicate_property(message_to_string(_, _), _)).
1429		translate_prolog_error(E1,E2,S) :-
1430		% SWI-Prolog way to translate an arbitrary message term (such as an exception) to a string,
1431		% the same way that the built-in message handling system would print it.
1432		message_to_string(error(E1,E2), String),
1433		!,
1434		atom_string(S, String).
1435		:- endif.
1436		translate_prolog_error(E1,_,S) :- translate_term_into_atom_with_max_depth(E1,8,S).
1437		% we also have permission_error, context_error, domain_error
1438
1439		portray_open_streams :- current_stream(File,Mode,Stream),
1440		format('~w file: ~w, stream: ~w~n',[Mode,File,Stream]),
1441		fail.
1442		portray_open_streams :- print_open_stream_stats.
1443
1444		:- use_module(tools_lists,[count_occurences/2]).
1445		print_open_stream_stats :- findall(Mode,current_stream(_,Mode,_),L),
1446		count_occurences(L,Occ),
1447		length(L,Nr), format('Open streams: ~w ~w~n',[Nr,Occ]).
1448
1449
1450		translate_state_errors([],[]).
1451		translate_state_errors([E|ERest],[Out|ORest]) :-
1452		( E = eventerror(Event,EError,_) ->
1453		translate_event_error(EError,Msg),
1454		ajoin([Event,': ',Msg],Out)
1455		; translate_state_error(E,Out) -> true
1456		; functor(E,Out,_) ),
1457		translate_state_errors(ERest,ORest).
1458
1459		translate_error_context(E,TE) :- translate_error_context2(E,Codes,[]),
1460		atom_codes_with_limit(TE,Codes).
1461		translate_error_context2(span_context(Span,Context)) --> !,
1462		translate_error_context2(Context),
1463		translate_span(Span,only_subsidiary).
1464		translate_error_context2([H]) --> !,translate_error_context2(H).
1465		translate_error_context2(checking_invariant) --> !,
1466		{get_specification_description_codes(invariant,A)}, A. %"INVARIANT".
1467		translate_error_context2(checking_assertions) --> !,
1468		{get_specification_description_codes(assertions,A)}, A. %"ASSERTIONS".
1469		translate_error_context2(checking_negation_of_invariant(_State)) --> !,
1470		"not(INVARIANT)".
1471		translate_error_context2(operation(OpName,_State)) --> !,
1472		{translate_operation_name(OpName,TOp)},
1473		ppterm(TOp).
1474		translate_error_context2(checking_context(Check,Name)) --> !,
1475		ppterm(Check),ppterm(Name).
1476		translate_error_context2(loading_context(_Name)) --> !.
1477		translate_error_context2(visb_error_context(Class,SvgId,OpNameOrAttr,Span)) --> !,
1478		"VisB ", ppterm(Class), " for SVG ID ",
1479		ppterm(SvgId), " and attribute/event ",
1480		{translate_operation_name(OpNameOrAttr,TOp)},
1481		ppterm(TOp),
1482		translate_span(Span,only_subsidiary).
1483		translate_error_context2(X) --> "???:", ppterm(X).
1484
1485		print_span(Span) :- translate_span(Span,Atom), !, write(Atom).
1486		print_span(S) :- print(span(S)).
1487
1488		print_span_nl(Span) :- translate_span(Span,Atom), !,(Atom='' -> true ; write(Atom)),nl.
1489		print_span_nl(S) :- print(span(S)),nl.
1490
1491
1492		translate_span(Span,Atom) :- translate_span(Span,only_subsidiary,Codes,[]),
1493		atom_codes_with_limit(Atom,Codes).
1494		translate_span_with_filename(Span,Atom) :-
1495		translate_span(Span,always_print_filename,Codes,[]),
1496		atom_codes_with_limit(Atom,Codes).
1497
1498		translate_span(Span,_) --> {var(Span)},!, {add_internal_error('Variable span:',translate_span(Span,_))}, "_".
1499		translate_span(Span,PrintFileNames) --> {extract_line_col(Span,Srow,Scol,_Erow,_Ecol)},!,
1500		"(Line:",ppterm(Srow)," Col:",ppterm(Scol),
1501		%"-",ppterm(Erow),":",ppterm(Ecol),
1502		translate_span_file_opt(Span,PrintFileNames),
1503		% TO DO: print short version of extract_additional_description ?
1504		")".
1505		translate_span(Span,_PrintFileNames) --> {extract_symbolic_label(Span,Label)},!, "(label @",ppterm(Label),")".
1506		translate_span(Span,PrintFileNames) -->
1507		% for Event-B, e.g., line-col fails but we can get a section/file name
1508		"(File:",translate_span_file(Span,PrintFileNames),!,")".
1509		translate_span(_,_PrintFileNames) --> "".
1510
1511		translate_span_file(Span,always_print_filename) -->
1512		{extract_tail_file_name(Span,Filename)},!,
1513		%{bmachine:b_get_main_filenumber(MainFN), Nr \= MainFN},!,
1514		" File:", ppterm(Filename).
1515		translate_span_file(Span,_) -->
1516		{extract_subsidiary_tail_file_name(Span,Filename)},
1517		%{bmachine:b_get_main_filenumber(MainFN), Nr \= MainFN},!,
1518		!,
1519		" File:", ppterm(Filename).
1520		translate_span_file_opt(Span,Print) --> translate_span_file(Span,Print),!.
1521		translate_span_file_opt(_,_) --> "".
1522
1523
1524		explain_span_file(Span) -->
1525		{extract_subsidiary_tail_file_name(Span,Filename)},
1526		%{bmachine:b_get_main_filenumber(MainFN), Nr \= MainFN},!,
1527		"\n### File: ", ppterm(Filename).
1528		explain_span_file(_) --> "".
1529
1530		explain_span(V) --> {var(V)},!, "Internal error: Illegal variable span".
1531		explain_span(span_predicate(Pred,LS,S)) --> !, explain_span2(span_predicate(Pred,LS,S)),
1532		explain_local_state(LS). %, explain_global_state(S).
1533		explain_span(Span) --> explain_span2(Span).
1534		explain_span2(Span) --> {extract_line_col(Span,Srow,Scol,Erow,Ecol)},!,
1535		"\n### Line: ", ppterm(Srow), ", Column: ", ppterm(Scol),
1536		" until Line: ", ppterm(Erow), ", Column: ", ppterm(Ecol),
1537		explain_span_file(Span),
1538		explain_span_context(Span).
1539		explain_span2(Span) --> {extract_symbolic_label_pos(Span,Msg)},!,
1540		"\n @label: ", ppterm(Msg),
1541		explain_span_context(Span).
1542		explain_span2(Span) --> explain_span_context(Span).
1543
1544		explain_span_context(Span) --> {extract_additional_description(Span,Msg),!},
1545		"\n### within ", ppterm(Msg). % context of span, such as definition call hierarchy
1546		explain_span_context(_) --> "".
1547
1548		explain_local_state([]) --> !, "".
1549		explain_local_state(LS) --> "\n Local State: ", pp_b_state(LS,1000).
1550		%explain_global_state([]) --> !, "".
1551		%explain_global_state(LS) --> "\n Global State: ", pp_b_state(LS).
1552
1553		translate_event_error(Error,Out) :-
1554		( translate_event_error2(Error,Out) -> true
1555		;
1556		functor(Error,F,_),
1557		ajoin(['** Unable to translate event error: ',F,' **'],Out)).
1558		translate_event_error2(no_witness_found(Type,Var,_Predicate),Out) :-
1559		def_get_texpr_id(Var,Id),
1560		ajoin(['no witness was found for ',Type,' ',Id],Out).
1561		translate_event_error2(simulation_error(_Events),Out) :-
1562		Out = 'no matching abstract event was found'.
1563		translate_event_error2(action_not_executable(_Action,WDErr),Out) :-
1564		(WDErr=wd_error_possible -> Out = 'action was not executable (maybe with WD error)'
1565		; Out = 'action was not executable').
1566		translate_event_error2(invalid_modification(Var,_Pre,_Post),Out) :-
1567		def_get_texpr_id(Var,Id),
1568		ajoin(['modification of variable ', Id, ' not allowed'],Out).
1569		translate_event_error2(variant_negative(_CType,_Variant,_Value),Out) :-
1570		Out = 'enabled for negative variant'.
1571		translate_event_error2(invalid_variant(anticipated,_Expr,_Pre,_Post),Out) :-
1572		Out = 'variant increased'.
1573		translate_event_error2(invalid_variant(convergent,_Expr,_Pre,_Post),Out) :-
1574		Out = 'variant not decreased'.
1575		translate_event_error2(invalid_theorem_in_guard(_Theorem),Out) :-
1576		Out = 'theorem in guard evaluates to false'.
1577		translate_event_error2(event_wd_error(_TExpr,Source),Out) :-
1578		ajoin(['WD error for ',Source],Out).
1579		translate_event_error2(event_other_error(Msg),Out) :- Out=Msg.
1580
1581		translate_state_error(abort_error(_TYPE,Msg,ErrTerm,ErrorContext),Out) :- !,
1582		translate_error_term(ErrTerm,ES),
1583		translate_error_context(ErrorContext,EC),
1584		ajoin([EC,': ',Msg,': ',ES],Out).
1585		translate_state_error(clpfd_overflow_error(Context),Out) :- !, % 'CLPFD_integer_overflow'
1586		ajoin(['CLPFD integer overflow while ', Context],Out).
1587		translate_state_error(max_state_errors_reached(Nr),Out) :- !,
1588		ajoin(['Max. number of state errors reached: ', Nr],Out).
1589		translate_state_error(Unknown,Out) :-
1590		add_error(translate_state_error,'Unknown state error: ',Unknown),
1591		Out = '*** Unknown State Error ***'.
1592
1593
1594		get_span_from_context([H],Span) :- !, get_span_from_context(H,Span).
1595		get_span_from_context(span_context(Span,_),Res) :- !, Res=Span.
1596		get_span_from_context(_,unknown).
1597
1598		explain_error_context1([H]) --> !,explain_error_context1(H).
1599		explain_error_context1(span_context(Span,Context)) --> !,
1600		explain_span(Span),"\n",
1601		explain_error_context2(Context).
1602		explain_error_context1(Ctxt) --> explain_error_context2(Ctxt).
1603
1604		explain_error_context2([H]) --> !,explain_error_context2(H).
1605		explain_error_context2(span_context(Span,Context)) --> !,
1606		explain_span(Span),"\n",
1607		explain_error_context2(Context).
1608		explain_error_context2(checking_invariant) --> !,
1609		{get_specification_description_codes(invariant,I)}, I, ":\n ", %"INVARIANT:\n ",
1610		pp_current_state. % assumes explain is called in the right state ! ; otherwise we need to store the state id
1611		explain_error_context2(checking_assertions) --> !,
1612		{get_specification_description_codes(assertions,A)}, A, ":\n ", %"ASSERTIONS:\n ",
1613		pp_current_state. % assumes explain is called in the right state ! ; otherwise we need to store the state id
1614		explain_error_context2(checking_negation_of_invariant(State)) --> !,
1615		"not(INVARIANT):\n State: ",
1616		pp_b_state(State,1000).
1617		explain_error_context2(operation('$setup_constants',StateID)) --> !,
1618		{get_specification_description_codes(properties,P)}, P, ":\n State: ",
1619		pp_context_state(StateID).
1620		explain_error_context2(operation(OpName,StateID)) --> !,
1621		{get_specification_description_codes(operation,OP)}, OP, ": ", %"EVENT/OPERATION: ",
1622		{translate_operation_name(OpName,TOp)},
1623		ppterm(TOp), "\n ",
1624		pp_context_state(StateID).
1625		explain_error_context2(checking_context(Check,Name)) --> !,
1626		ppterm(Check),ppterm(Name), "\n ".
1627		explain_error_context2(loading_context(Name)) --> !,
1628		"Loading: ",ppterm(Name), "\n ".
1629		explain_error_context2(visb_error_context(Class,SvgId,OpNameOrAttr,Span)) --> !,
1630		translate_error_context2(visb_error_context(Class,SvgId,OpNameOrAttr,Span)).
1631		explain_error_context2(X) --> "UNKNOWN ERROR CONTEXT:\n ", ppterm(X).
1632
1633		:- use_module(specfile,[get_specification_description/2]).
1634		get_specification_description_codes(Tag,Codes) :- get_specification_description(Tag,Atom), atom_codes(Atom,Codes).
1635
1636		explain_state_error(Error,Span,Out) :-
1637		explain_state_error2(Error,Span,Out,[]),!.
1638		explain_state_error(_Error,unknown,"Sorry, the detailed output failed.\n").
1639
1640		explain_abort_error_type(well_definedness_error) --> !, "An expression was not well-defined.\n".
1641		explain_abort_error_type(card_overflow_error) --> !, "The cardinality of a finite set was too large to be represented.\n".
1642		explain_abort_error_type(while_variant_error) --> !, "A while-loop VARIANT error occurred.\n".
1643		explain_abort_error_type(while_invariant_violation) --> !, "A while-loop INVARIANT error occurred.\n".
1644		explain_abort_error_type(precondition_error) --> !, "A precondition (PRE) error occurred.\n".
1645		explain_abort_error_type(feasibility_error) --> !, "A feasibility error occurred.\n".
1646		explain_abort_error_type(assert_error) --> !, "An ASSERT error occurred.\n".
1647		explain_abort_error_type(Type) --> "Error occurred: ", ppterm(Type), "\n".
1648
1649		explain_state_error2(abort_error(TYPE,Msg,ErrTerm,ErrContext),Span) -->
1650		explain_abort_error_type(TYPE),
1651		"Reason: ", ppterm(Msg), "\n",
1652		{get_span_from_context(ErrContext,Span)},
1653		({ErrTerm=''} -> ""
1654		; "Details: ", {translate_error_term(ErrTerm,Span,ErrS)},ppterm(ErrS), "\n"
1655		),
1656		"Context: ", explain_error_context1(ErrContext).
1657		explain_state_error2(max_state_errors_reached(Nr),unknown) -->
1658		"Too many error occurred for this state.\n",
1659		"Not all errors are shown.\n",
1660		"Number of errors is at least: ", ppterm(Nr).
1661		explain_state_error2(eventerror(_Event,Error,Trace),Span) --> % TO DO: also extract loc info ?
1662		{translate_event_error(Error,Msg)},
1663		ppatom(Msg),
1664		"\nA detailed trace containing the error:\n",
1665		"--------------------------------------\n",
1666		explain_event_trace(Trace,Span).
1667		explain_state_error2(clpfd_overflow_error(Context),unknown) --> % CLPFD_integer_overflow
1668		"An overflow occurred inside the CLP(FD) library.\n",
1669		"Context: ", ppterm(Context), "\n",
1670		"You may try and set the CLPFD preference to FALSE.\n".
1671
1672		% try and get span from state error:
1673		get_state_error_span(abort_error(_,_,_,Context),Span) :- get_span_context_span(Context,Span).
1674
1675		get_span_context_span(span_context(Span,_),Span).
1676		get_span_context_span([H],Span) :- get_span_context_span(H,Span).
1677
1678
1679
1680		show_parameter_values([],[]) --> !.
1681		show_parameter_values([P|Prest],[V|Vrest]) -->
1682		show_parameter_value(P,V),
1683		show_parameter_values(Prest,Vrest).
1684		show_parameter_value(P,V) -->
1685		" ",pp_expr(P,_,_LR)," = ",pp_value(V),"\n".
1686
1687		% translate an Event-B error trace (error occurred during multi-level animation)
1688		% into a textual description (Codes) and a span_predicate term which can be visualised
1689		explain_event_trace(Trace,Codes,Span) :-
1690		explain_event_trace(Trace,Span,Codes,[]).
1691
1692		explain_event_trace(Trace,span_predicate(SpanPred,[],[])) -->
1693		% evaluating the span predicate will require access to current state, which needs to be added later
1694		explain_event_trace4(Trace,'?','?',SpanPred).
1695
1696		explain_event_trace4([],_,_,b(truth,pred,[])) --> !.
1697		explain_event_trace4([event(Name,Section)|Trest],_,_,SpanPred) --> !,
1698		"\n",
1699		"Event ",ppterm(Name)," in model ",ppterm(Section),
1700		":\n",
1701		% pass new current event name and section for processing tail:
1702		explain_event_trace4(Trest,Name,Section,SpanPred).
1703		explain_event_trace4([Step|Trest],Name,Section,SpanPred) -->
1704		"\n",
1705		( explain_event_step4(Step,StepPred) -> ""
1706		; {functor(Step,F,_)} ->
1707		" (no rule to explain event step ",ppatom(F),")\n"),
1708		explain_event_trace4(Trest,Name,Section,RestSpanPred),
1709		{combine_span_pred(StepPred,RestSpanPred,Name,Section,SpanPred)}.
1710
1711		% create a span predicate from the event error trace to display relevant values and predicates
1712		combine_span_pred(unknown,S,_,_,Res) :- !, Res=S.
1713		combine_span_pred(new_scope(Kind,Paras,Vals,P1),P2,Name,Section,Res) :- !,
1714		maplist(create_tvalue,Paras,Vals,TVals),
1715		add_span_label(Kind,Name,Section,P1,P1L),
1716		conjunct_predicates([P1L,P2],Body),
1717		(Paras=[] -> Res=Body ; Res = b(let_predicate(Paras,TVals,Body),pred,[])). % translate:print_bexpr(Res),nl.
1718		% we could also do: add_texpr_description
1719		combine_span_pred(P1,P2,_,_,Res) :-
1720		conjunct_predicates([P1,P2],Res).
1721
1722		add_span_label(Kind,Name,Section,Pred,NewPred) :-
1723		(Kind=[Label] -> true % already has position info
1724		; create_label(Kind,Name,Section,Label)),
1725		add_labels_to_texpr(Pred,[Label],NewPred).
1726		create_label(Kind,Name,Section,Label) :- ajoin([Kind,' in ',Section,':',Name],Label).
1727
1728		create_tvalue(b(_,Type,_),Value,b(value(Value),Type,[])).
1729
1730		explain_event_step4(true_guard(Parameters,Values,Guard),new_scope('guard true',Parameters,Values,Guard)) --> !,
1731		( {Parameters==[]} -> ""
1732		; " for the parameters:\n",
1733		show_parameter_values(Parameters,Values)),
1734		" the guard is true:",
1735		explain_predicate(Guard,4),"\n".
1736		explain_event_step4(eval_witness(Type,Id,Value,Predicate),new_scope('witness',[Id],[Value],Predicate)) -->
1737		witness_intro(Id,Predicate,Type),
1738		" found witness:\n",
1739		" ", pp_expr(Id,_,_LR), " = ", pp_value(Value), "\n".
1740		explain_event_step4(simulation_error(Errors),SpanPred) -->
1741		" no guard of a refined event was satisfiable:\n",
1742		explain_simulation_errors(Errors,Guards),
1743		{disjunct_predicates(Guards,SpanPred)}.
1744		explain_event_step4(invalid_theorem_in_guard(Theorem),new_scope('false theorem',[],[],Theorem)) -->
1745		" the following theorem evaluates to false:",
1746		explain_predicate(Theorem,4),"\n".
1747		explain_event_step4(invalid_modification(Var,Pre,Post),
1748		new_scope('invalid modification',[Var],[Post],b(falsity,pred,[]))) -->
1749		" the variable ", pp_expr(Var,_,_LR), " has been modified.\n",
1750		" The event is not allowed to modify the variable because its abstract event does not modify it.\n",
1751		" Old value: ", pp_value(Pre), "\n",
1752		" New value: ", pp_value(Post), "\n".
1753		explain_event_step4(action_not_executable(TAction,WDErr),new_scope('action not executable',[],[],Equalities)) -->
1754		{exctract_span_pred_from_subst(TAction,Equalities)},
1755		explain_action_not_executable(TAction,WDErr).
1756		explain_event_step4(Step,unknown) -->
1757		explain_event_step(Step).
1758		% TODO: add span predicates for the errors below:
1759
1760		extract_equality(Infos,TID,NewExpr,b(equal(TID,NewExpr),pred,Infos)). % TODO: introduce TID' primed?
1761		exctract_span_pred_from_subst(b(assign(TIDs,Exprs),subst,Infos),SpanPred) :-
1762		maplist(extract_equality(Infos),TIDs,Exprs,List),
1763		conjunct_predicates(List,SpanPred).
1764		% todo: becomes_such, ...
1765
1766		explain_event_step(variant_checked_pre(CType,Variant,Value)) -->
1767		" ",ppatom(CType)," event: checking if the variant is non-negative:\n",
1768		" variant: ",pp_expr(Variant,_,_LR),"\n",
1769		" its value: ",pp_value(Value),"\n".
1770		explain_event_step(variant_negative(CType,Variant,Value)) -->
1771		explain_event_step(variant_checked_pre(CType,Variant,Value)),
1772		" ERROR: variant is negative\n".
1773		explain_event_step(variant_checked_post(CType,Variant,EntryValue,ExitValue)) -->
1774		" ",ppatom(CType)," event: checking if the variant is ",
1775		( {CType==convergent} -> "decreased:\n" ; "not increased:\n"),
1776		" variant: ", pp_expr(Variant,_,_LR), "\n",
1777		" its value before: ", pp_value(EntryValue),"\n",
1778		" its value after: ", pp_value(ExitValue),"\n".
1779		explain_event_step(invalid_variant(CType,Variant,EntryValue,ExitValue)) -->
1780		explain_event_step(variant_checked_post(CType,Variant,EntryValue,ExitValue)),
1781		" ERROR: variant has ",
1782		({CType==convergent} -> "not been decreased\n"; "has been increased\n").
1783		explain_event_step(no_witness_found(Type,Id,Predicate)) -->
1784		witness_intro(Id,Predicate,Type),
1785		" ERROR: no solution for witness predicate found!\n".
1786		explain_event_step(action(Lhs,_Rhs,Values)) -->
1787		" executing an action:\n",
1788		show_assignments(Lhs,Values).
1789		explain_event_step(action_set(Lhs,_Rhs,ValueSet,Values)) -->
1790		" executing an action:\n ",
1791		pp_expr_l(Lhs,_LR)," :: ",pp_value(ValueSet),"\n choosing\n",
1792		show_assignments(Lhs,Values).
1793		explain_event_step(action_pred(Ids,Pred,Values)) -->
1794		" executing an action:\n ",
1795		pp_expr_l(Ids,_LR1)," :| ",pp_expr(Pred,_,_LR2),"\n choosing\n",
1796		show_assignments(Ids,Values).
1797		explain_event_step(error(Error,_Id)) -->
1798		% the error marker serves to link to a stored state-error by its ID
1799		explain_event_step(Error).
1800		explain_event_step(event_wd_error(TExpr,Source)) -->
1801		" Well-Definedness ERROR for ", ppatom(Source), "\n",
1802		" ", pp_expr(TExpr,_,_LR), "\n".
1803		explain_event_step(event_other_error(Msg)) --> ppatom(Msg).
1804
1805		explain_action_not_executable(TAction,no_wd_error) --> {is_assignment_to(TAction,IDs)},!,
1806		" ERROR: the following assignment to ", ppatoms(IDs),"was not executable\n",
1807		" (probably in conflict with another assignment, check SIM or EQL PO):", % or WD error
1808		translate_subst_with_indention_and_label(TAction,4).
1809		explain_action_not_executable(TAction,wd_error_possible) --> !,
1810		" ERROR: the following action was not executable\n",
1811		" (possibly due to a WD error):",
1812		translate_subst_with_indention_and_label(TAction,4).
1813		explain_action_not_executable(TAction,_WDErr) -->
1814		" ERROR: the following action was not executable:",
1815		translate_subst_with_indention_and_label(TAction,4).
1816
1817		is_assignment_to(b(assign(LHS,_),_,_),IDs) :- get_texpr_ids(LHS,IDs).
1818		is_assignment_to(b(assign_single_id(LHS,_),_,_),IDs) :- get_texpr_ids([LHS],IDs).
1819
1820
1821		witness_intro(Id,Predicate,Type) -->
1822		" evaluating witness for abstract ", ppatom(Type), " ", pp_expr(Id,_,_LR1), "\n",
1823		" witness predicate: ", pp_expr(Predicate,_,_LR2), "\n".
1824
1825		show_assignments([],[]) --> !.
1826		show_assignments([Lhs|Lrest],[Val|Vrest]) -->
1827		" ",pp_expr(Lhs,_,_LimitReached), " := ", pp_value(Val), "\n",
1828		show_assignments(Lrest,Vrest).
1829
1830		/* unused at the moment:
1831		explain_state([]) --> !.
1832		explain_state([bind(Varname,Value)|Rest]) --> !,
1833		" ",ppterm(Varname)," = ",pp_value(Value),"\n",
1834		explain_state(Rest).
1835		explain_guards([]) --> "".
1836		explain_guards([Event|Rest]) -->
1837		{get_texpr_expr(Event,rlevent(Name,_Section,_Status,_Params,Guard,_Theorems,_Act,_VWit,_PWit,_Unmod,_Evt))},
1838		"\n",ppatom(Name),":",
1839		explain_predicate(Guard),
1840		explain_guards(Rest).
1841		explain_predicate(Guard,I,O) :-
1842		explain_predicate(Guard,2,I,O).
1843		*/
1844		explain_predicate(Guard,Indention,I,O) :-
1845		pred_over_lines(0,'@grd',Guard,(Indention,I),(_,O)).
1846
1847		explain_simulation_errors([],[]) --> !.
1848		explain_simulation_errors([Error|Rest],[Grd|Gs]) -->
1849		explain_simulation_error(Error,Grd),
1850		explain_simulation_errors(Rest,Gs).
1851		explain_simulation_error(event(Name,Section,Guard),SpanPred) -->
1852		{add_span_label('guard false',Name,Section,Guard,SpanPred)},
1853		" guard for event ", ppatom(Name),
1854		" in ", ppatom(Section), ":",
1855		explain_predicate(Guard,6),"\n".
1856
1857
1858		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1859
1860		% explain a b_interpreter Classical B Path transition info
1861
1862		explain_transition_info(eventtrace(Trace),Codes) :- explain_event_trace(Trace,Codes,_Span).
1863		explain_transition_info(path(Trace),Codes) :- explain_classicb_path(Trace,0,Codes,[]).
1864
1865		explain_classicb_path(skip,I) --> indent_ws(I), "skip".
1866		explain_classicb_path(parallel(L),I) --> indent_ws(I), "BEGIN\n", {I1 is I+1}, explain_parallel(L,I1), " END".
1867		explain_classicb_path(sequence(A,B),I) --> explain_classicb_path(A,I), " ;\n", explain_classicb_path(B,I).
1868		explain_classicb_path(if_skip,I) --> indent_ws(I), "IF skipped (no branch applicable)".
1869		explain_classicb_path(if(CaseNr,Path),I) --> indent_ws(I), "IF branch ", ppnumber(CaseNr),"\n",
1870		{I1 is I+1}, explain_classicb_path(Path,I1).
1871		explain_classicb_path(pre(Cond,Path),I) --> indent_ws(I), "PRE ",
1872		{translate_bvalue_with_limit(Cond,50,CS),I1 is I+1}, ppatom(CS), " THEN\n", explain_classicb_path(Path,I1).
1873		explain_classicb_path(let(Path),I) --> indent_ws(I), "LET\n", {I1 is I+1}, explain_classicb_path(Path,I1).
1874		explain_classicb_path(assertion_violated,I) --> indent_ws(I), "ASSERT FALSE".
1875		explain_classicb_path(assertion(Path),I) --> indent_ws(I), "ASSERT TRUE THEN\n",
1876		{I1 is I+1}, explain_classicb_path(Path,I1).
1877		explain_classicb_path(witness(Path),I) --> indent_ws(I), "WITNESS TRUE THEN\n",
1878		{I1 is I+1}, explain_classicb_path(Path,I1).
1879		explain_classicb_path(any(_,Path),I) --> indent_ws(I), "ANY\n", {I1 is I+1}, explain_classicb_path(Path,I1).
1880		explain_classicb_path(var(Names,Path),I) --> indent_ws(I), "VAR ",
1881		{convert_and_ajoin_ids(Names,NS),I1 is I+1}, ppatom(NS), " IN\n", explain_classicb_path(Path,I1).
1882		explain_classicb_path(select(Nr,Path),I) --> indent_ws(I),
1883		"SELECT branch ", ({Nr=else} -> "ELSE" ; ppnumber(Nr)), "\n",
1884		{I1 is I+1}, explain_classicb_path(Path,I1).
1885		explain_classicb_path(choice(Nr,Path),I) --> indent_ws(I), "CHOICE branch ", ppnumber(Nr), "\n",
1886		{I1 is I+1}, explain_classicb_path(Path,I1).
1887		explain_classicb_path(while(Variant,while_bpath(LoopCount,LastIterPath)),I) --> indent_ws(I), {translate_bvalue_with_limit(Variant,400,VS)},
1888		"WHILE (VARIANT = ", ppatom(VS), ", iterations=", ppnumber(LoopCount), ")",
1889		({LastIterPath=none} -> ""
1890		; " DO (last iteration)\n", {I1 is I+1}, explain_classicb_path(LastIterPath,I1)).
1891		explain_classicb_path(assign_single_id(ID,Value),I) --> {translate_bvalue_with_limit(Value,400,VS)},
1892		indent_ws(I), ppatom(ID), " := ", ppatom(VS).
1893		explain_classicb_path(assign(LHS,Vals),I) -->
1894		{translate_bexpression_with_limit(LHS,LS),translate_bvalues_with_limit(Vals,400,VS)},
1895		indent_ws(I), ppatom(LS), " := ", ppatom(VS).
1896		explain_classicb_path(becomes_element_of(LHS,Value),I) -->
1897		{translate_bexpression_with_limit(LHS,LS),translate_bvalue_with_limit(Value,400,VS)},
1898		indent_ws(I), ppatom(LS), " :: {", ppatom(VS), "}".
1899		explain_classicb_path(becomes_such(Names,Values),I) --> indent_ws(I),
1900		{convert_and_ajoin_ids(Names,NS),translate_bvalues_with_limit(Values,400,VS)},
1901		ppatom(NS), " : ( ", ppatom(VS)," )".
1902		explain_classicb_path(operation_call(Name,ResultNames,Paras,Results, IPath),I) --> indent_ws(I),
1903		{translate_bvalues_with_limit(Paras,400,PS)},
1904		({Results=[_|_],translate_bvalues_with_limit(Results,400,RS),
1905		translate_bexpression_with_limit(ResultNames,RNS)}
1906		-> ppatom(RNS), " := ", ppatom(RS)," <-- " ; ""),
1907		ppatom(Name), "(", ppatom(PS), ") == BEGIN\n", explain_classicb_path(IPath,I), "\n",
1908		indent_ws(I), "END".
1909		explain_classicb_path(external_subst(Name),I) --> indent_ws(I), ppatom(Name).
1910		explain_classicb_path([H|T],I) -->
1911		{member(path(Path),[H|T]),I1 is I+1},!,explain_classicb_path(Path,I1). % inner path of operation_call
1912		explain_classicb_path(P,_I) --> {write(unknown_path(P)),nl}, "??".
1913
1914		explain_parallel([],_I) --> "".
1915		explain_parallel([H],I) --> !, explain_classicb_path(H,I).
1916		explain_parallel([H|T],I) --> explain_classicb_path(H,I), " ||\n", explain_parallel(T,I).
1917
1918		indent_ws(N) --> {N<1},!,"".
1919		indent_ws(L) --> " ", {L1 is L-1}, indent_ws(L1).
1920
1921
1922		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1923		% pretty-print a state
1924
1925
1926		print_state(State) :- b_state(State), !,print_bstate(State).
1927		print_state(csp_and_b_root) :- csp_with_bz_mode, !,
1928		write('(MAIN || B)').
1929		print_state(csp_and_b(CSPState,BState)) :- csp_with_bz_mode, !,
1930		print_bstate(BState), translate_cspm_state(CSPState,Text), write(Text).
1931		print_state(CSPState) :- csp_mode,!,translate_cspm_state(CSPState,Text), write(Text).
1932		print_state(State) :- animation_mode(xtl),!,translate_xtl_value(State,Text), write(Text).
1933		print_state(State) :- write('*** Unknown state: '),print(State).
1934
1935		b_state(root).
1936		b_state(concrete_constants(_)).
1937		b_state(const_and_vars(_,_)).
1938		b_state(expanded_const_and_vars(_,_,_,_)).
1939		b_state(expanded_vars(_,_)).
1940		b_state([bind(_,_)|_]).
1941		b_state([]).
1942
1943		print_bstate(State) :- print_bstate_limited(State,1000,-1).
1944		print_bstate_limited(State,VarLimit,OverallLimit) :-
1945		translate_bstate_limited(State,VarLimit,OverallLimit,Output),
1946		write(' '),write(Output).
1947
1948		translate_any_state(State,Output) :-
1949		get_pp_state_limit(Limit),
1950		pp_any_state(State,Limit,Codes,[]),
1951		atom_codes_with_limit(Output,Codes).
1952		translate_bstate(State,Output) :-
1953		get_pp_state_limit(Limit),
1954		pp_b_state(State,Limit,Codes,[]),
1955		atom_codes_with_limit(Output,Codes).
1956
1957		get_pp_state_limit(Limit) :-
1958		(get_preference(expand_avl_upto,-1) -> Limit = -1 ; Limit = 1000).
1959
1960		% a version which tries to generate smaller strings
1961		translate_bstate_limited(State,Output) :-
1962		temporary_set_preference(expand_avl_upto,2,CHNG),
1963		call_cleanup(translate_bstate_limited(State,200,Output),
1964		reset_temporary_preference(expand_avl_upto,CHNG)).
1965
1966		translate_bstate_limited(State,Limit,Output) :-
1967		translate_bstate_limited(State,Limit,Limit,Output).
1968		translate_bstate_limited(State,VarLimit,Limit,Output) :-
1969		pp_b_state(State,VarLimit,Codes,[]), % this limit VarLimit applies to every variable
1970		atom_codes_with_limit(Output,Limit,Codes). % Limit applies to the full translation
1971
1972		pp_b_state(X,Limit) --> try_pp_b_state(X,Limit),!.
1973		pp_b_state(X,_Limit) --> {add_error(pp_b_state,'Could not translate state: ',X)}.
1974
1975		% Limit is pretty-print limit for every value printed
1976		try_pp_b_state(VAR,_) --> {var(VAR)},!, "_?VAR?_", {add_error(pp_b_state,'Variable state: ',VAR)}.
1977		try_pp_b_state(root,_) --> !, "root".
1978		try_pp_b_state(csp_and_b_root,_) --> !, "CSP||B root".
1979		try_pp_b_state(concrete_constants(Constants),Limit) --> !,"Constants: ",
1980		pp_b_state(Constants,Limit).
1981		try_pp_b_state(const_and_vars(ID,Vars),Limit) --> !,
1982		"Constants:",ppterm(ID),", Vars:",
1983		{set_translation_constants(ID)}, /* extract constants which stand for deferred set elements */
1984		pp_b_state(Vars,Limit),
1985		{clear_translation_constants}.
1986		try_pp_b_state(expanded_const_and_vars(ID,Vars,_,_Infos),Limit) --> !, "EXPANDED ",
1987		try_pp_b_state(const_and_vars(ID,Vars),Limit).
1988		try_pp_b_state(expanded_vars(Vars,_Infos),Limit) --> !, "EXPANDED ",
1989		try_pp_b_state(Vars,Limit).
1990		try_pp_b_state([],_) --> !, "/* empty state */".
1991		try_pp_b_state([bind(Varname,Value)|Rest],Limit) --> !,
1992		"( ",ppterm(Varname),"=",
1993		dcg_set_up_limit_reached(Limit,LimitReached),
1994		pp_value(Value,LimitReached),
1995		({Rest = []} -> []; " ",and_symbol,"\n "),
1996		pp_b_state_list(Rest,Limit).
1997
1998
1999		pp_b_state_list([],_) --> !, " )".
2000		pp_b_state_list([bind(Varname,Value)|Rest],Limit) --> !,
2001		ppterm(Varname),"=",
2002		dcg_set_up_limit_reached(Limit,LimitReached),
2003		pp_value(Value,LimitReached),
2004		({Rest = []} -> [] ; " ",and_symbol,"\n "),
2005		pp_b_state_list(Rest,Limit).
2006		pp_b_state_list(X,_) --> {add_error(pp_b_state_list,'Could not translate: ',X)}.
2007
2008		% a version of pp which generates no newline; can be used for printing SETUP_CONSTANTS, INITIALISATION
2009		pp_b_state_comma_list([],_,_) --> !, ")".
2010		pp_b_state_comma_list(_,Cur,Limit) --> {Cur >= Limit}, !, "...".
2011		pp_b_state_comma_list([bind(Varname,Value)|Rest],Cur,Limit) --> !,
2012		%{write(c(Varname,Cur,Limit)),nl},
2013		start_size(Ref),
2014		ppterm(Varname),"=",
2015		pp_value(Value),
2016		({Rest = []}
2017		-> ")"
2018		; ",",
2019		end_size(Ref,Size), % compute size increase wrt Ref point
2020		{Cur1 is Cur+Size},
2021		pp_b_state_comma_list(Rest,Cur1,Limit)
2022		).
2023		pp_b_state_comma_list(X,_,_) --> {add_error(pp_b_state_comma_list,'Could not translate: ',X)}.
2024
2025		start_size(X,X,X).
2026		end_size(RefVar,Len,X,X) :- % compute how many chars the dcg has added wrt start_size
2027		len(RefVar,X,Len).
2028		len(Var,X,Len) :- (var(Var) ; Var==X),!, Len=0.
2029		len([],_,0).
2030		len([_|T],X,Len) :- len(T,X,L1), Len is L1+1.
2031
2032		% can be used e.g. for setup_constants, initialise
2033		translate_b_state_to_comma_list_codes(FUNCTORCODES,State,Limit,ResCodes) :-
2034		pp_b_state_comma_list(State,0,Limit,Codes,[]),
2035		append("(",Codes,C0),
2036		append(FUNCTORCODES,C0,ResCodes).
2037
2038		% translate to a single line without newlines
2039		translate_b_state_to_comma_list(State,Limit,ResAtom) :-
2040		pp_b_state_comma_list(State,0,Limit,Codes,[]),
2041		append("(",Codes,C0),
2042		atom_codes(ResAtom,C0).
2043
2044		% ----------------
2045
2046		% printing and translating error contexts
2047		print_context(State) :- translate_context(State,Output), write(Output).
2048
2049		translate_context(Context,Output) :-
2050		pp_b_context(Context,Codes,[]),
2051		atom_codes_with_limit(Output,250,Codes).
2052
2053		pp_b_context([]) --> !.
2054		pp_b_context([C|Rest]) --> !,
2055		pp_b_context(C),
2056		pp_b_context(Rest).
2057		pp_b_context(translate_context) --> !, " ERROR CONTEXT: translate_context". % error occurred within translate_context
2058		pp_b_context(span_context(Span,Context)) --> !,
2059		pp_b_context(Context), " ", translate_span(Span,only_subsidiary).
2060		pp_b_context(operation(Name,StateID)) --> !,
2061		" ERROR CONTEXT: ",
2062		{get_specification_description_codes(operation,OP)}, OP, ":", % "OPERATION:"
2063		({var(Name)} -> ppterm('ALL') ; {translate_operation_name(Name,TName)},ppterm(TName)),
2064		",",pp_context_state(StateID).
2065		pp_b_context(checking_invariant) --> !,
2066		" ERROR CONTEXT: INVARIANT CHECKING,", pp_cur_context_state.
2067		pp_b_context(checking_negation_of_invariant(State)) --> !,
2068		" ERROR CONTEXT: NEGATION_OF_INVARIANT CHECKING, State:", pp_b_state(State,1000).
2069		pp_b_context(checking_assertions) --> !,
2070		" ERROR CONTEXT: ASSERTION CHECKING,", pp_cur_context_state.
2071		pp_b_context(checking_context(Check,Name)) --> !,
2072		" ERROR CONTEXT: ", ppterm(Check),ppterm(Name).
2073		pp_b_context(loading_context(_FName)) --> !.
2074		pp_b_context(unit_test_context(Module,TotNr,Line,Call)) --> !,
2075		" ERROR CONTEXT: Unit Test ", ppterm(TotNr), " in module ", ppterm(Module),
2076		" at line ", ppterm(Line), " calling ", pp_functor(Call).
2077		pp_b_context(visb_error_context(Class,ID,OpNameOrAttr,Span)) --> !,
2078		" ERROR CONTEXT: VisB ", ppterm(Class), " with ID ", ppterm(ID),
2079		({OpNameOrAttr='all_attributes'} -> ""
2080		; " and attribute/event ", ppterm(OpNameOrAttr)
2081		),
2082		" ", translate_span(Span,only_subsidiary).
2083		pp_b_context(C) --> ppterm(C),pp_cur_context_state.
2084
2085		pp_functor(V) --> {var(V)},!, ppterm(V).
2086		pp_functor(T) --> {functor(T,F,N)}, ppterm(F),"/",ppterm(N).
2087
2088		pp_cur_context_state --> {state_space:get_current_context_state(ID)}, !,pp_context_state(ID).
2089		pp_cur_context_state --> ", unknown context state.".
2090
2091		% assumes we are in the right state:
2092		pp_current_state --> {state_space:current_expression(ID,_)}, !,pp_context_state(ID).
2093		pp_current_state --> ", unknown current context state.".
2094
2095		% TO DO: limit length/size of generated error description
2096		pp_context_state(ID) --> {state_space:visited_expression(ID,State)},!, % we have a state ID
2097		" State ID:", ppterm(ID),
2098		pp_context_state2(State).
2099		pp_context_state(State) --> pp_context_state3(State).
2100
2101		pp_context_state2(_) --> {debug_mode(off)},!.
2102		pp_context_state2(State) --> ",", pp_context_state3(State).
2103
2104		pp_context_state3(State) --> " State: ",pp_any_state_with_limit(State,10).
2105
2106		pp_any_state_with_limit(State,Limit) -->
2107		{ get_preference(expand_avl_upto,CurLim),
2108		(CurLim<0 ; Limit < CurLim),
2109		!,
2110		temporary_set_preference(expand_avl_upto,Limit,CHNG),
2111		VarLimit is Limit*10
2112		},
2113		pp_any_state(State,VarLimit),
2114		{reset_temporary_preference(expand_avl_upto,CHNG)}.
2115		pp_any_state_with_limit(State,_Limit) -->
2116		{get_preference(expand_avl_upto,CurLim), VarLimit is CurLim*10},
2117		pp_any_state(State,VarLimit).
2118
2119		pp_any_state(X,VarLimit) --> try_pp_b_state(X,VarLimit),!.
2120		pp_any_state(csp_and_b(P,B),VarLimit) --> "CSP: ",{pp_csp_process(P,Atoms,[])},!,atoms_to_codelist(Atoms),
2121		" || B: ", try_pp_b_state(B,VarLimit).
2122		pp_any_state(X,_) --> {animation_mode(xtl)}, !, "XTL: ",pp_xtl_value(X). % XTL/CSP state
2123		pp_any_state(P,_) --> "CSP: ",{pp_csp_process(P,Atoms,[])},!,atoms_to_codelist(Atoms).
2124		pp_any_state(X,_) --> "Other formalism: ",ppterm(X). % CSP state
2125
2126		atoms_to_codelist([]) --> [].
2127		atoms_to_codelist([Atom|T]) --> ppterm(Atom), atoms_to_codelist(T).
2128
2129		% ----------------
2130
2131		:- dynamic deferred_set_constant/3.
2132
2133		set_translation_context(const_and_vars(ConstID,_)) :- !,
2134		%% print_message(setting_translation_constants(ConstID)),
2135		set_translation_constants(ConstID).
2136		set_translation_context(expanded_const_and_vars(ConstID,_,_,_)) :- !,
2137		set_translation_constants(ConstID).
2138		set_translation_context(_).
2139
2140		set_translation_constants(_) :- clear_translation_constants,
2141		get_preference(dot_print_use_constants,false),!.
2142		set_translation_constants(ConstID) :- var(ConstID),!,
2143		add_error(set_translation_constants,'Variable used as ConstID: ',ConstID).
2144		set_translation_constants(ConstID) :-
2145		state_space:visited_expression(ConstID,concrete_constants(ConstantsStore)),!,
2146		%% print_message(setting_constants(ConstID)),%%
2147		(treat_constants(ConstantsStore) -> true ; print_message(fail)).
2148		set_translation_constants(ConstID) :-
2149		add_error(set_translation_constants,'Unknown ConstID: ',ConstID).
2150
2151		clear_translation_constants :- %print_message(clearing),%%
2152		retractall(deferred_set_constant(_,_,_)).
2153
2154		treat_constants([]).
2155		treat_constants([bind(CstName,Val)|T]) :-
2156		((Val=fd(X,GSet),b_global_deferred_set(GSet))
2157		-> (deferred_set_constant(GSet,X,_)
2158		-> true /* duplicate def of value */
2159		; assertz(deferred_set_constant(GSet,X,CstName))
2160		)
2161		; true
2162		),
2163		treat_constants(T).
2164
2165
2166
2167		translate_bvalue_with_tlatype(Value,Type,Output) :-
2168		( pp_tla_value(Type,Value,Codes,[]) ->
2169		atom_codes_with_limit(Output,Codes)
2170		; add_error(translate_bvalue,'Could not translate TLA value: ',Value),
2171		Output='???').
2172
2173		pp_tla_value(function(_Type1,_Type2),[]) --> !,
2174		ppcodes("<<>>").
2175		pp_tla_value(function(integer,T2),avl_set(Set)) -->
2176		{convert_avlset_into_sequence(Set,Seq)}, !,
2177		pp_tla_with_sep("<< "," >>",",",T2,Seq).
2178		pp_tla_value(function(T1,T2),Set) -->
2179		{is_printable_set(Set,Values)},!,
2180		pp_tla_with_sep("(",")"," @@ ",function_value(T1,T2),Values).
2181		pp_tla_value(function_value(T1,T2),(L,R)) -->
2182		!,pp_tla_value(T1,L),":>",pp_tla_value(T2,R).
2183		pp_tla_value(set(Type),Set) -->
2184		{is_printable_set(Set,Values)},!,
2185		pp_tla_with_sep("{","}",",",Type,Values).
2186		pp_tla_value(tuple(Types),Value) -->
2187		{pairs_to_list(Types,Value,Values,[]),!},
2188		pp_tla_with_sep("<< "," >>",",",Types,Values).
2189		pp_tla_value(record(Fields),rec(FieldValues)) -->
2190		% TODO: Check if we can safely assume that Fields and FieldValues have the
2191		% same order
2192		!, {sort_tla_fields(Fields,FieldValues,RFields,RFieldValues)},
2193		pp_tla_with_sep("[","]",", ",RFields,RFieldValues).
2194		pp_tla_value(field(Name,Type),field(_,Value)) -->
2195		!, ppatom_opt_scramble(Name)," |-> ",pp_tla_value(Type,Value).
2196		pp_tla_value(_Type,Value) -->
2197		% fallback: use B's pretty printer
2198		pp_value(Value).
2199
2200		is_printable_set(avl_set(A),List) :- avl_domain(A,List).
2201		is_printable_set([],[]).
2202		is_printable_set([H|T],[H|T]).
2203
2204		pairs_to_list([_],Value) --> !,[Value].
2205		pairs_to_list([_|Rest],(L,R)) -->
2206		pairs_to_list(Rest,L),[R].
2207
2208
2209		sort_tla_fields([],_,[],[]).
2210		sort_tla_fields([Field|RFields],ValueFields,RFieldTypes,ResultValueFields) :-
2211		( Field=field(Name,Type) -> true
2212		; Field= opt(Name,Type) -> true),
2213		( selectchk(field(Name,Value),ValueFields,RestValueFields),
2214		field_value_present(Field,Value,Result) ->
2215		% Found the field in the record value
2216		RFieldTypes = [field(Name,Type) |RestFields],
2217		ResultValueFields = [field(Name,Result)|RestValues],
2218		sort_tla_fields(RFields,RestValueFields,RestFields,RestValues)
2219		;
2220		% didn't found the field in the value -> igore
2221		sort_tla_fields(RFields,ValueFields,RFieldTypes,ResultValueFields)
2222		).
2223		field_value_present(field(_,_),RecValue,RecValue). % Obligatory fields are always present
2224		field_value_present(opt(_,_),OptValue,Value) :-
2225		% Optional fields are present if the field is of the form TRUE |-> Value.
2226		( is_printable_set(OptValue,Values) -> Values=[(_TRUE,Value)]
2227		;
2228		add_error(translate,'exptected set for TLA optional record field'),
2229		fail
2230		).
2231
2232		pp_tla_with_sep(Start,End,Sep,Type,Values) -->
2233		ppcodes(Start),pp_tla_with_sep_aux(Values,End,Sep,Type).
2234		pp_tla_with_sep_aux([],End,_Sep,_Type) -->
2235		ppcodes(End).
2236		pp_tla_with_sep_aux([Value|Rest],End,Sep,Type) -->
2237		% If a single type is given, we interpret it as the type
2238		% for each element of the list, if it is a list, we interpret
2239		% it one different type for every value in the list.
2240		{ (Type=[CurrentType|RestTypes] -> true ; CurrentType = Type, RestTypes=Type) },
2241		pp_tla_value(CurrentType,Value),
2242		( {Rest=[_|_]} -> ppcodes(Sep); {true} ),
2243		pp_tla_with_sep_aux(Rest,End,Sep,RestTypes).
2244
2245
2246		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2247		% pretty-print a value
2248
2249		translate_bvalue_for_dot(string(S),Translation) :- !,
2250		% normal quotes confuse dot
2251		%ajoin(['''''',S,''''''],Translation).
2252		string_escape(S,ES),
2253		ajoin(['\\"',ES,'\\"'],Translation).
2254		translate_bvalue_for_dot(Val,ETranslation) :-
2255		translate_bvalue(Val,Translation),
2256		string_escape(Translation,ETranslation).
2257
2258		translate_bvalue_to_codes(V,Output) :-
2259		( pp_value(V,_LimitReached,Codes,[]) ->
2260		Output=Codes
2261		; add_error(translate_bvalue_to_codes,'Could not translate bvalue: ',V),
2262		Output="???").
2263		translate_bvalue_to_codes_with_limit(V,Limit,Output) :-
2264		set_up_limit_reached(Codes,Limit,LimitReached), % TODO: also limit expand_avl_upto
2265		( pp_value(V,LimitReached,Codes,[]) ->
2266		Output=Codes
2267		; add_error(translate_bvalue_to_codes,'Could not translate bvalue: ',V),
2268		Output="???").
2269
2270		translate_bvalue(V,Output) :-
2271		%set_up_limit_reached(Codes,1000000,LimitReached), % we could set a very high-limit, like max_atom_length
2272		( pp_value(V,_LimitReached,Codes,[]) ->
2273		atom_codes_with_limit(Output,Codes) % just catches representation error
2274		; add_error(translate_bvalue,'Could not translate bvalue: ',V),
2275		Output='???').
2276		:- use_module(preferences).
2277		translate_bvalue_with_limit(V,Limit,Output) :-
2278		get_preference(expand_avl_upto,Max),
2279		((Max > Limit % no sense in printing larger AVL trees
2280		; (Max < 0, Limit >= 0)) % or setting limit to -1 for full value
2281		-> temporary_set_preference(expand_avl_upto,Limit,CHNG)
2282		; CHNG=false),
2283		call_cleanup(translate_bvalue_with_limit_aux(V,Limit,Output),
2284		reset_temporary_preference(expand_avl_upto,CHNG)).
2285		translate_bvalue_with_limit_aux(V,Limit,OutputAtom) :-
2286		set_up_limit_reached(Codes,Limit,LimitReached),
2287		( pp_value(V,LimitReached,Codes,[]) ->
2288		atom_codes_with_limit(OutputAtom,Limit,Codes)
2289		% ,length(Codes,Len), (Len>Limit -> format('pp(~w) codes:~w, limit:~w, String=~s~n~n',[LimitReached,Len,Limit,Codes]) ; true)
2290		; add_error(translate_bvalue_with_limit,'Could not translate bvalue: ',V),
2291		OutputAtom='???').
2292
2293		translate_bvalues(Values,Output) :-
2294		translate_bvalues_with_limit(Values,no_limit,Output). % we could set a very high-limit, like max_atom_length
2295
2296		translate_bvalues_with_limit(Values,Limit,Output) :-
2297		(Limit==no_limit -> true %
2298		; set_up_limit_reached(Codes,Limit,LimitReached)
2299		),
2300		pp_value_l(Values,',',LimitReached,Codes,[]),!,
2301		atom_codes_with_limit(Output,Codes).
2302		translate_bvalues_with_limit(Values,Limit,O) :-
2303		add_internal_error('Call failed: ',translate_bvalues(Values,Limit,O)), O='??'.
2304
2305		translate_bvalue_for_expression(Value,TExpr,Output) :-
2306		animation_minor_mode(tla),
2307		expression_has_tla_type(TExpr,TlaType),!,
2308		translate_bvalue_with_tlatype(Value,TlaType,Output).
2309		translate_bvalue_for_expression(Value,TExpr,Output) :-
2310		get_texpr_type(TExpr,Type),
2311		translate_bvalue_with_type(Value,Type,Output).
2312
2313		translate_bvalue_for_expression_with_limit(Value,TExpr,_Limit,Output) :-
2314		animation_minor_mode(tla),
2315		expression_has_tla_type(TExpr,TlaType),!,
2316		translate_bvalue_with_tlatype(Value,TlaType,Output). % TO DO: treat Limit
2317		translate_bvalue_for_expression_with_limit(Value,TExpr,Limit,Output) :-
2318		get_texpr_type(TExpr,Type),
2319		translate_bvalue_with_type_and_limit(Value,Type,Limit,Output).
2320
2321		expression_has_tla_type(TExpr,Type) :-
2322		get_texpr_info(TExpr,Infos),
2323		memberchk(tla_type(Type),Infos).
2324
2325
2326		translate_bvalue_to_parseable_classicalb(Val,Str) :-
2327		% corresponds to set_print_type_infos(needed)
2328		temporary_set_preference(translate_force_all_typing_infos,false,CHNG),
2329		temporary_set_preference(translate_print_typing_infos,true,CHNG2),
2330		(animation_minor_mode(X)
2331		-> remove_animation_minor_mode,
2332		call_cleanup(translate_bvalue_to_parseable_aux(Val,Str),
2333		(reset_temporary_preference(translate_force_all_typing_infos,CHNG),
2334		reset_temporary_preference(translate_print_typing_infos,CHNG2),
2335		set_animation_minor_mode(X)))
2336		; call_cleanup(translate_bvalue_to_parseable_aux(Val,Str),
2337		(reset_temporary_preference(translate_force_all_typing_infos,CHNG),
2338		reset_temporary_preference(translate_print_typing_infos,CHNG2)))
2339		).
2340		translate_bvalue_to_parseable_aux(Val,Str) :-
2341		call_pp_with_no_limit_and_parseable(translate_bvalue(Val,Str)).
2342
2343
2344		translate_bexpr_to_parseable(Expr,Str) :-
2345		call_pp_with_no_limit_and_parseable(translate_bexpression(Expr,Str)).
2346
2347		% a more refined pretty printing: takes Type information into account; useful for detecting sequences
2348		translate_bvalue_with_type(Value,_,Output) :- var(Value),!,
2349		translate_bvalue(Value,Output).
2350		translate_bvalue_with_type(Value,Type,Output) :-
2351		adapt_value_according_to_type(Type,Value,NewValue),
2352		translate_bvalue(NewValue,Output).
2353
2354		translate_bvalue_with_type_and_limit(Value,Type,Limit,Output) :-
2355		(Limit < 0 -> SetLim = -1 ; SetLim is Limit//2), % at least two symbols per element
2356		get_preference(expand_avl_upto,CurLim),
2357		((CurLim < 0, SetLim >= 0) ; SetLim < CurLim),!,
2358		temporary_set_preference(expand_avl_upto,SetLim,CHNG),
2359		translate_bvalue_with_type_and_limit2(Value,Type,Limit,Output),
2360		reset_temporary_preference(expand_avl_upto,CHNG).
2361		translate_bvalue_with_type_and_limit(Value,Type,Limit,Output) :-
2362		translate_bvalue_with_type_and_limit2(Value,Type,Limit,Output).
2363		translate_bvalue_with_type_and_limit2(Value,_,Limit,Output) :- var(Value),!,
2364		translate_bvalue_with_limit(Value,Limit,Output).
2365		translate_bvalue_with_type_and_limit2(Value,Type,Limit,Output) :-
2366		adapt_value_according_to_type(Type,Value,NewValue),
2367		translate:translate_bvalue_with_limit(NewValue,Limit,Output).
2368		%debug:watch(translate:translate_bvalue_with_limit(NewValue,Limit,Output)).
2369
2370		adapt_value_according_to_type(T,V,R) :-
2371		(adapt_value_according_to_type3(T,V,R) -> true
2372		; add_error(translate,'Value does not have the expected type:',V),
2373		R=V
2374		).
2375		:- use_module(avl_tools,[quick_avl_approximate_size/2]).
2376		adapt_value_according_to_type3(_,Var,R) :- var(Var),!,R=Var.
2377		adapt_value_according_to_type3(T,V,R) :- var(T),!,
2378		add_internal_error('Variable type: ',adapt_value_according_to_type3(T,V,R)),
2379		R=V.
2380		adapt_value_according_to_type3(integer,V,R) :- !,R=V.
2381		adapt_value_according_to_type3(string,V,R) :- !,R=V.
2382		adapt_value_according_to_type3(boolean,V,R) :- !,R=V.
2383		adapt_value_according_to_type3(global(_),V,R) :- !,R=V.
2384		adapt_value_according_to_type3(couple(TA,TB),(VA,VB),R) :- !, R=(RA,RB),
2385		adapt_value_according_to_type(TA,VA,RA),
2386		adapt_value_according_to_type(TB,VB,RB).
2387		adapt_value_according_to_type3(set(Type),avl_set(A),Res) :- check_is_non_empty_avl(A),
2388		quick_avl_approximate_size(A,S),S<20,
2389		custom_explicit_sets:expand_custom_set_to_list(avl_set(A),List),!,
2390		maplist(adapt_value_according_to_type3(Type),List,Res).
2391		adapt_value_according_to_type3(set(_Type),V,R) :- !,R=V.
2392		adapt_value_according_to_type3(seq(Type),V,R) :- !, % the type tells us it is a sequence
2393		(convert_set_into_sequence(V,VS)
2394		-> l_adapt_value_according_to_type3(VS,Type,AVS),
2395		R=sequence(AVS)
2396		; R=V).
2397		adapt_value_according_to_type3(record(Fields),rec(Values),R) :- !,
2398		R=rec(AdaptedValues),
2399		% fields and values should be in the same (alphabetical) order
2400		maplist(adapt_record_field_according_to_type,Fields,Values,AdaptedValues).
2401		adapt_value_according_to_type3(freetype(_),Value,R) :-
2402		Value = freeval(ID,_,Term),
2403		nonvar(Term), Term=term(ID), % not a constructor, just a value
2404		!,
2405		R = Value.
2406		adapt_value_according_to_type3(freetype(_),freeval(ID,Case,SubValue),R) :- nonvar(Case),
2407		!,
2408		R = freeval(ID,Case,AdaptedSubValue),
2409		(kernel_freetypes:get_freeval_type(ID,Case,SubType)
2410		-> adapt_value_according_to_type(SubType,SubValue,AdaptedSubValue)
2411		; write(could_not_get_freeval_type(ID,Case)),nl,
2412		AdaptedSubValue = SubValue
2413		).
2414		adapt_value_according_to_type3(freetype(_),Value,R) :- !, R=Value.
2415		adapt_value_according_to_type3(any,Value,R) :- !, R=Value.
2416		adapt_value_according_to_type3(pred,Value,R) :- !, R=Value.
2417		adapt_value_according_to_type3(_,term(V),R) :- !, R=term(V). % appears for unknown values (no_value_for) when ALLOW_INCOMPLETE_SETUP_CONSTANTS is true
2418		adapt_value_according_to_type3(Type,Value,R) :- write(adapt_value_according_to_type_unknown(Type,Value)),nl,
2419		R=Value.
2420
2421		l_adapt_value_according_to_type3([],_Type,R) :- !,R=[].
2422		l_adapt_value_according_to_type3([H|T],Type,[AH|AT]) :-
2423		adapt_value_according_to_type3(Type,H,AH),
2424		l_adapt_value_according_to_type3(T,Type,AT).
2425
2426		adapt_record_field_according_to_type(field(Name,HTy),field(Name2,H),field(Name,R)) :-
2427		(Name=Name2 -> adapt_value_according_to_type3(HTy,H,R)
2428		; ajoin(['Record field ',Name,' does not match expected name from type:'],Msg),
2429		add_error(translate,Msg,Name2),fail
2430		).
2431
2432
2433		pp_value_with_type(E,T,LimitReached) --> {adapt_value_according_to_type(T,E,AdaptedE)},
2434		pp_value(AdaptedE,LimitReached).
2435
2436		pp_value(V,In,Out) :-
2437		set_up_limit_reached(In,1000,LimitReached),
2438		pp_value(V,LimitReached,In,Out).
2439
2440		% LimitReached is a flag: when it is grounded to limit_reached this instructs pp_value to stop generating output
2441		pp_value(_,LimitReached) --> {LimitReached==limit_reached},!, "...".
2442		pp_value(V,_) --> {var(V)},!, pp_variable(V).
2443		pp_value('$VAR'(N),_) --> !,pp_numberedvar(N).
2444		pp_value(fd(X,GSet),_) --> {var(X)},!,
2445		ppatom(GSet),":", ppnumber(X). %":??".
2446		pp_value(fd(X,GSet),_) -->
2447		{b_global_sets:is_b_global_constant_hash(GSet,X,Res)},!,
2448		pp_identifier(Res).
2449		pp_value(fd(X,GSet),_) --> {deferred_set_constant(GSet,X,Cst)},!,
2450		pp_identifier(Cst).
2451		pp_value(fd(X,M),_) --> !,ppatom_opt_scramble(M),ppnumber(X).
2452		pp_value(int(X),_) --> !,ppnumber(X).
2453		pp_value(term(floating(X)),_) --> !,ppnumber(X).
2454		pp_value(string(X),_) --> !,string_start_symbol,ppstring_opt_scramble(X),string_end_symbol.
2455		pp_value(global_set(X),_) --> {atomic(X),integer_set_mapping(X,Kind,Y)},!,
2456		({Kind=integer_set} -> ppatom(Y) ; ppatom_opt_scramble(X)).
2457		pp_value(term(X),_) --> {var(X)},!,"term(",pp_variable(X),")".
2458		pp_value(freetype(X),_) --> {pretty_freetype(X,P)},!,ppatom_opt_scramble(P).
2459		pp_value(pred_true /* bool_true */,_) --> %!,"TRUE". % TO DO: in latex_mode: surround by mathit
2460		{constants_in_mode(pred_true,Symbol)},!,ppatom(Symbol).
2461		pp_value(pred_false /* bool_false */,_) --> %!,"FALSE".
2462		{constants_in_mode(pred_false,Symbol)},!,ppatom(Symbol).
2463		%pp_value(bool_true) --> !,"TRUE". % old version; still in some test traces which are printed
2464		%pp_value(bool_false) --> !,"FALSE".
2465		pp_value([],_) --> !,empty_set_symbol.
2466		pp_value(closure(Variables,Types,Predicate),LimitReached) --> !,
2467		pp_closure_value(Variables,Types,Predicate,LimitReached).
2468		pp_value(avl_set(A),LimitReached) --> !,
2469		{check_is_non_empty_avl(A),
2470		avl_size(A,Sz) % we could use quick_avl_approximate_size for large sets
2471		},
2472		{set_brackets(LBrace,RBrace)},
2473		( {size_is_in_set_limit(Sz),
2474		%(Sz>2 ; get_preference(translate_print_all_sequences,true)),
2475		get_preference(translate_print_all_sequences,true), % no longer try and convert any sequence longer than 2 to sequence notation
2476		avl_max(A,(int(Sz),_)), % a sequence has minimum int(1) and maximum int(Sz)
2477		convert_avlset_into_sequence(A,Seq)} ->
2478		pp_sequence(Seq,LimitReached)
2479		;
2480		( {Sz=0} -> left_set_bracket," /* empty avl_set */ ",right_set_bracket
2481		; {(size_is_in_set_limit(Sz) ; Sz < 3)} -> % if Sz 3 we will print at least two elements anyway
2482		{avl_domain(A,List)},
2483		ppatom(LBrace),pp_value_l(List,',',LimitReached),ppatom(RBrace)
2484		; {(Sz<5 ; \+ size_is_in_set_limit(4))} ->
2485		{avl_min(A,Min),avl_max(A,Max)},
2486		hash_card_symbol, % "#"
2487		ppnumber(Sz),":", left_set_bracket,
2488		pp_value(Min,LimitReached),",",ldots,",",pp_value(Max,LimitReached),right_set_bracket
2489		;
2490		{avl_min(A,Min),avl_next(Min,A,Nxt),avl_max(A,Max),avl_prev(Max,A,Prev)},
2491		hash_card_symbol, % "#",
2492		ppnumber(Sz),":", left_set_bracket,
2493		pp_value(Min,LimitReached),",",pp_value(Nxt,LimitReached),",",ldots,",",
2494		pp_value(Prev,LimitReached),",",pp_value(Max,LimitReached),right_set_bracket )).
2495		pp_value( (A,B) ,LimitReached) --> !,
2496		"(",pp_inner_value(A,LimitReached),
2497		maplet_symbol,
2498		pp_value(B,LimitReached),")".
2499		pp_value(field(Name,Value),LimitReached) --> !,
2500		pp_identifier(Name),":",pp_value(Value,LimitReached). % : for fields has priority 120 in French manual
2501		pp_value(rec(Rec),LimitReached) --> !,
2502		{function_like_in_mode(rec,Symbol)},
2503		ppatom(Symbol), "(",pp_value_l(Rec,',',LimitReached),")".
2504		pp_value(struct(Rec),LimitReached) --> !,
2505		{function_like_in_mode(struct,Symbol)},
2506		ppatom(Symbol), "(", pp_value_l(Rec,',',LimitReached),")".
2507		% check for cyclic after avl_set / closure case: AVL sets can be huge !
2508		pp_value(X,_) --> {cyclic_term(X),functor(X,F,_N)},!,
2509		underscore_symbol,"cyclic",underscore_symbol,
2510		ppatom(F),underscore_symbol.
2511		pp_value(sequence(List),LimitReached) --> !,
2512		({List=[]} -> pp_empty_sequence ; pp_sequence_with_limit(List,LimitReached)).
2513		pp_value([Head|Tail],LimitReached) --> {get_preference(translate_print_all_sequences,true),
2514		convert_set_into_sequence([Head|Tail],Elements)},
2515		!,
2516		pp_sequence(Elements,LimitReached).
2517		pp_value([Head|Tail],LimitReached) --> !, {set_brackets(L,R)},
2518		ppatom(L),
2519		pp_value_l_with_limit([Head|Tail],',',LimitReached),
2520		ppatom(R).
2521		%pp_value([Head|Tail]) --> !,
2522		% {( convert_set_into_sequence([Head|Tail],Elements) ->
2523		% (Start,End) = ('[',']')
2524		% ;
2525		% Elements = [Head|Tail],
2526		% (Start,End) = ('{','}'))},
2527		% ppatom(Start),pp_value_l(Elements,','),ppatom(End).
2528		pp_value(term(no_value_for(Id)),_) --> !,
2529		"undefined ",ppatom(Id).
2530		pp_value(freeval(Freetype,Case,Value),LimitReached) --> !,
2531		({ground(Case),ground(Value),Value=term(Case)} -> ppatom_opt_scramble(Case)
2532		; {ground(Case)} -> ppatom_opt_scramble(Case),"(",pp_value(Value,LimitReached),")"
2533		; {pretty_freetype(Freetype,P)},
2534		"FREEVALUE[",ppatom_opt_scramble(P),
2535		",",write_to_codes(Case),
2536		"](",pp_value(Value,LimitReached),")"
2537		).
2538		pp_value(X,_) --> {animation_mode(xtl)},!,
2539		write_to_codes(X).
2540		pp_value(term('$MATCH'),_) --> !, gen_term_color(magenta),"*",gen_term_color(reset). % MATCH found by find_value
2541		pp_value(term('$FUZZYMATCH'(S)),_) --> !, gen_term_color(magenta), % ditto find_value
2542		"*",ppatom(S),"*",gen_term_color(reset).
2543		pp_value(X,_) --> % the << >> pose problems when checking against FDR
2544		"<< ",write_to_codes(X)," >>".
2545
2546		pp_variable(V) --> write_to_codes(V). %underscore_symbol.
2547
2548		:- use_module(closures,[is_recursive_closure/3]).
2549
2550		pp_closure_value(Ids,Type,B,_LimitReached) -->
2551		{var(Ids) ; var(Type) ; var(B)},!,
2552		add_internal_error('Illegal value: ',pp_value_illegal_closure(Ids,Type,B)),
2553		"<< ILLEGAL ",write_to_codes(closure(Ids,Type,B))," >>".
2554		pp_closure_value(Variables,Types,Predicate,LimitReached) --> {\+ size_is_in_set_limit(1)},
2555		!, % do not print body; just print hash value
2556		{make_closure_ids(Variables,Types,Ids), term_hash(Predicate,PH)},
2557		left_set_bracket, % { Ids | #PREDICATE#(HASH) }
2558		pp_expr_l_pair_in_mode(Ids,LimitReached),
2559		pp_such_that_bar,
2560		" ",hash_card_symbol,"PREDICATE",hash_card_symbol,"(",ppnumber(PH),") ", right_set_bracket.
2561		pp_closure_value(Variables,Types,Predicate,LimitReached) -->
2562		{get_preference(translate_ids_to_parseable_format,true),
2563		is_recursive_closure(Variables,Types,Predicate),
2564		get_texpr_info(Predicate,Infos),
2565		member(prob_annotation(recursive(TID)),Infos),
2566		def_get_texpr_id(TID,ID)}, !,
2567		% write recursive let for f as : CHOOSE(.) or MU({f|f= SET /*@desc letrec */ })
2568		% an alternate syntax could be RECLET f BE f = SET IN f END
2569		"MU({", pp_identifier(ID), % TODO: we can now use the post-fix mu_operator '?'
2570		"|",
2571		pp_identifier(ID)," = ",
2572		pp_closure_value2(Variables,Types,Predicate,LimitReached),
2573		"/*@desc letrec */ }) ".
2574		pp_closure_value([Id],[Type],Membership,LimitReached) -->
2575		{ get_texpr_expr(Membership,member(Elem,Set)),
2576		get_texpr_id(Elem,Id),
2577		\+ occurs_in_expr(Id,Set), % detect things like {s|s : 1 .. card(s) --> T} (test 1030)
2578		get_texpr_type(Elem,Type),
2579		!},
2580		pp_expr_m(Set,299,LimitReached).
2581		pp_closure_value(Variables,Types,Predicate,LimitReached) --> pp_closure_value2(Variables,Types,Predicate,LimitReached).
2582
2583		pp_closure_value2(Variables,Types,Predicate,LimitReached) --> !,
2584		{make_closure_ids(Variables,Types,Ids)},
2585		pp_comprehension_set(Ids,Predicate,[],LimitReached). % TODO: propagate LimitReached
2586
2587		% avoid printing parentheses:
2588		% (x,y,z) = ((x,y),z)
2589		pp_inner_value( AB , LimitReached) --> {nonvar(AB),AB=(A,B)}, !, % do not print parentheses in this context
2590		pp_inner_value(A,LimitReached),maplet_symbol,
2591		pp_value(B,LimitReached).
2592		pp_inner_value( Value , LimitReached) --> pp_value( Value , LimitReached).
2593
2594		size_is_in_set_limit(Size) :- get_preference(expand_avl_upto,Max),
2595		(Max<0 -> true /* no limit */
2596		; Size =< Max).
2597
2598		dcg_set_up_limit_reached(Limit,LimitReached,InList,InList) :- set_up_limit_reached(InList,Limit,LimitReached).
2599
2600		% instantiate LimitReached argument as soon as a list exceeds a certain limit
2601		set_up_limit_reached(_,Neg,_) :- Neg<0,!. % negative number means unlimited
2602		set_up_limit_reached(_,0,LimitReached) :- !, LimitReached = limit_reached.
2603		set_up_limit_reached(List,Limit,LimitReached) :-
2604		block_set_up_limit_reached(List,Limit,LimitReached).
2605		:- block block_set_up_limit_reached(-,?,?).
2606		block_set_up_limit_reached([],_,_).
2607		block_set_up_limit_reached([_|T],Limit,LimitReached) :-
2608		(Limit<1 -> LimitReached=limit_reached
2609		; L1 is Limit-1, block_set_up_limit_reached(T,L1,LimitReached)).
2610
2611		% pretty print LimitReached, requires %:- block block_set_up_limit_reached(-,?,-).
2612		/*
2613		pp_lr(LR) --> {LR==limit_reached},!, " *LR* ".
2614		pp_lr(LR) --> {frozen(LR,translate:block_set_up_limit_reached(_,Lim,_))},!, " ok(", ppnumber(Lim),") ".
2615		pp_lr(LR) --> {frozen(LR,G)},!, " ok(", ppterm(G),") ".
2616		pp_lr(_) --> " ok ".
2617		*/
2618
2619
2620		pp_value_l_with_limit(V,Sep,LimitReached) --> {get_preference(expand_avl_upto,Max)},
2621		pp_value_l(V,Sep,Max,LimitReached).
2622		pp_value_l(V,Sep,LimitReached) --> pp_value_l(V,Sep,-1,LimitReached).
2623
2624		pp_value_l(V,_Sep,_,_) --> {var(V)},!,"...".
2625		pp_value_l(_,_,_,LimitReached) --> {LimitReached==limit_reached},!,"...".
2626		pp_value_l('$VAR'(N),_Sep,_,_) --> !,"}\\/{",pp_numberedvar(N),"}".
2627		pp_value_l([],_Sep,_,_) --> !.
2628		pp_value_l([Expr|Rest],Sep,Limit,LimitReached) -->
2629		( {nonvar(Rest),Rest=[]} ->
2630		pp_value(Expr,LimitReached)
2631		; {Limit=0} -> "..."
2632		;
2633		pp_value(Expr,LimitReached),
2634		% no separator for closure special case
2635		({nonvar(Rest) , Rest = closure(_,_,_)} -> {true} ; ppatom(Sep)) ,
2636		{L1 is Limit-1} ,
2637		% convert avl_set(_) in a list's tail to a Prolog list
2638		{nonvar(Rest) , Rest = avl_set(_) -> custom_explicit_sets:expand_custom_set_to_list(Rest,LRest) ; LRest = Rest} ,
2639		pp_value_l(LRest,Sep,L1,LimitReached)).
2640		pp_value_l(avl_set(A),_Sep,_,LimitReached) --> pp_value(avl_set(A),LimitReached).
2641		pp_value_l(closure(A,B,C),_Sep,_,LimitReached) --> "}\\/", pp_value(closure(A,B,C),LimitReached).
2642
2643		make_closure_ids([],[],[]).
2644		make_closure_ids([V|Vrest],[T|Trest],[TExpr|TErest]) :-
2645		(var(V) -> V2='_', format('Illegal variable identifier in make_closure_ids: ~w~n',[V])
2646		; V2=V),
2647		create_texpr(identifier(V2),T,[],TExpr),
2648		make_closure_ids(Vrest,Trest,TErest).
2649
2650		% symbol for starting and ending a sequence:
2651		pp_begin_sequence --> {animation_minor_mode(tla)},!,"<<".
2652		pp_begin_sequence --> {get_preference(translate_print_cs_style_sequences,true)},!,"".
2653		pp_begin_sequence --> "[".
2654		pp_end_sequence --> {animation_minor_mode(tla)},!,">>".
2655		pp_end_sequence --> {get_preference(translate_print_cs_style_sequences,true)},!,"".
2656		pp_end_sequence --> "]".
2657
2658		pp_separator_sequence('') :- get_preference(translate_print_cs_style_sequences,true),!.
2659		pp_separator_sequence(',').
2660
2661		% string for empty sequence
2662		pp_empty_sequence --> {animation_minor_mode(tla)},!, "<< >>".
2663		pp_empty_sequence --> {get_preference(translate_print_cs_style_sequences,true)},!,
2664		( {latex_mode} -> "\\lambda" ; [955]). % 955 is lambda symbol in Unicode
2665		pp_empty_sequence --> {atelierb_mode(prover(_))},!, "{}".
2666		pp_empty_sequence --> "[]".
2667
2668		% symbols for function application:
2669		pp_function_left_bracket --> {animation_minor_mode(tla)},!, "[".
2670		pp_function_left_bracket --> "(".
2671
2672		pp_function_right_bracket --> {animation_minor_mode(tla)},!, "]".
2673		pp_function_right_bracket --> ")".
2674
2675		pp_sequence(Elements,LimitReached) --> {pp_separator_sequence(Sep)},
2676		pp_begin_sequence,
2677		pp_value_l(Elements,Sep,LimitReached),
2678		pp_end_sequence.
2679		pp_sequence_with_limit(Elements,LimitReached) --> {pp_separator_sequence(Sep)},
2680		pp_begin_sequence,
2681		pp_value_l_with_limit(Elements,Sep,LimitReached),
2682		pp_end_sequence.
2683
2684		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2685		% machines
2686
2687		:- use_module(eventhandling,[register_event_listener/3]).
2688		:- register_event_listener(clear_specification,reset_translate,
2689		'Reset Translation Caches.').
2690		reset_translate :- retractall(bugly_scramble_id_cache(_,_)), retractall(non_det_constants(_,_)).
2691		%reset_translate :- set_print_type_infos(none),
2692		% set_preference(translate_suppress_rodin_positions_flag,false).
2693
2694		suppress_rodin_positions(CHNG) :- set_suppress_rodin_positions(true,CHNG).
2695		set_suppress_rodin_positions(Value,CHNG) :-
2696		temporary_set_preference(translate_suppress_rodin_positions_flag,Value,CHNG).
2697		reset_suppress_rodin_positions(CHNG) :-
2698		reset_temporary_preference(translate_suppress_rodin_positions_flag,CHNG).
2699
2700		set_print_type_infos(none) :- !,
2701		set_preference(translate_force_all_typing_infos,false),
2702		set_preference(translate_print_typing_infos,false).
2703		set_print_type_infos(needed) :- !,
2704		set_preference(translate_force_all_typing_infos,false),
2705		set_preference(translate_print_typing_infos,true).
2706		set_print_type_infos(all) :- !,
2707		set_preference(translate_force_all_typing_infos,true),
2708		set_preference(translate_print_typing_infos,true).
2709		set_print_type_infos(Err) :-
2710		add_internal_error('Illegal typing setting: ',set_print_type_infos(Err)).
2711
2712		type_info_setting(none,false,false).
2713		type_info_setting(needed,false,true).
2714		type_info_setting(all,true,true).
2715
2716		set_print_type_infos(Setting,[CHNG1,CHNG2]) :-
2717		type_info_setting(Setting,Value1,Value2),!,
2718		temporary_set_preference(translate_force_all_typing_infos,Value1,CHNG1),
2719		temporary_set_preference(translate_print_typing_infos,Value2,CHNG2).
2720		set_print_type_infos(Err,_) :-
2721		add_internal_error('Illegal typing setting: ',set_print_type_infos(Err,_)),fail.
2722		reset_print_type_infos([CHNG1,CHNG2]) :-
2723		reset_temporary_preference(translate_force_all_typing_infos,CHNG1),
2724		reset_temporary_preference(translate_print_typing_infos,CHNG2).
2725
2726		:- use_module(tools_files,[put_codes/2]).
2727		print_machine(M) :-
2728		nl, translate_machine(M,Msg,true), put_codes(Msg,user_output), nl,
2729		flush_output(user_output),!.
2730		print_machine(M) :- add_internal_error('Printing failed: ',print_machine(M)).
2731
2732		%
2733		translate_machine(M,Codes,AdditionalInfo) :-
2734		retractall(print_additional_machine_info),
2735		(AdditionalInfo=true -> assertz(print_additional_machine_info) ; true),
2736		call_pp_with_no_limit_and_parseable(translate_machine1(M,(0,Codes),(_,[]))).
2737
2738		% perform a call by forcing parseable output and removing limit to set
2739		call_pp_with_no_limit_and_parseable(PP_Call) :-
2740		temporary_set_preference(translate_ids_to_parseable_format,true,CHNG),
2741		temporary_set_preference(expand_avl_upto,-1,CHNG2),
2742		call_cleanup(call(PP_Call),
2743		(reset_temporary_preference(translate_ids_to_parseable_format,CHNG),
2744		reset_temporary_preference(expand_avl_upto,CHNG2))).
2745
2746
2747		% useful if we wish to translate just a selection of sections without MACHINE/END
2748		translate_section_list(SL,Codes) :- init_machine_translation,
2749		translate_machine2(SL,SL,no_end,(0,Codes),(_,[])).
2750
2751		translate_machine1(machine(Name,Sections)) -->
2752		indent('MACHINE '), {adapt_machine_name(Name,AName), pp_identifier(AName,CName,[])}, insertcodes(CName),
2753		{init_machine_translation},
2754		translate_machine2(Sections,Sections,end).
2755		translate_machine2([],_,end) --> !, insertstr('\nEND\n').
2756		translate_machine2([],_,_) --> !, insertstr('\n').
2757		translate_machine2([P|Rest],All,End) -->
2758		translate_mpart(P,All),
2759		translate_machine2(Rest,All,End).
2760
2761		adapt_machine_name('dummy(uses)',R) :- !,R='MAIN'.
2762		adapt_machine_name(X,X).
2763
2764		:- dynamic section_header_generated/1.
2765		:- dynamic print_additional_machine_info/0.
2766		print_additional_machine_info.
2767
2768		init_machine_translation :- retractall(section_header_generated(_)).
2769
2770		% start a part of a section
2771		mpstart(Title,I) -->
2772		insertstr('\n'),insertstr(Title),
2773		indention_level(I,I2), {I2 is I+2}.
2774		% end a part of a section
2775		mpend(I) -->
2776		indention_level(_,I).
2777
2778		mpstart_section(Section,Title,AltTitle,I,In,Out) :-
2779		(\+ section_header_generated(Section)
2780		-> mpstart(Title,I,In,Out), assertz(section_header_generated(Section))
2781		; mpstart(AltTitle,I,In,Out) /* use alternative title; section header already generated */
2782		).
2783
2784		translate_mpart(Section/I,All) --> %{write(Section),nl},
2785		( {I=[]} -> {true}
2786		; translate_mpart2(Section,I,All) -> {true}
2787		;
2788		insertstr('\nSection '),insertstr(Section),insertstr(': '),
2789		insertstr('<< pretty-print failed >>')
2790		).
2791		translate_mpart2(deferred_sets,I,_) -->
2792		mpstart_section(sets,'SETS /* deferred */',' ; /* deferred */',P),
2793		indent_expr_l_sep(I,';'),mpend(P).
2794		translate_mpart2(enumerated_sets,_I,_) --> []. % these are now pretty printed below
2795		%mpstart('ENUMERATED SETS',P),indent_expr_l_sep(I,';'),mpend(P).
2796		translate_mpart2(enumerated_elements,I,_) --> %{write(enum_els(I)),nl},
2797		{translate_enums(I,[],Res)},
2798		mpstart_section(sets,'SETS /* enumerated */',' ; /* enumerated */',P),
2799		indent_expr_l_sep(Res,';'),mpend(P).
2800		translate_mpart2(parameters,I,_) --> mpstart('PARAMETERS',P),indent_expr_l_sep(I,','),mpend(P).
2801		translate_mpart2(internal_parameters,I,_) --> {print_additional_machine_info},!,
2802		mpstart('/* INTERNAL_PARAMETERS',P),indent_expr_l_sep(I,','),insertstr(' */'),mpend(P).
2803		translate_mpart2(internal_parameters,_I,_) --> [].
2804		translate_mpart2(abstract_variables,I,_) --> mpstart('ABSTRACT_VARIABLES',P),indent_exprs(I),mpend(P).
2805		translate_mpart2(concrete_variables,I,_) --> mpstart('CONCRETE_VARIABLES',P),indent_exprs(I),mpend(P).
2806		translate_mpart2(abstract_constants,I,_) --> mpstart('ABSTRACT_CONSTANTS',P),indent_exprs(I),mpend(P).
2807		translate_mpart2(concrete_constants,I,_) --> mpstart('CONCRETE_CONSTANTS',P),indent_exprs(I),mpend(P).
2808		translate_mpart2(promoted,I,_) --> {print_additional_machine_info},!,
2809		mpstart('/* PROMOTED OPERATIONS',P),indent_expr_l_sep(I,','),insertstr(' */'),mpend(P).
2810		translate_mpart2(promoted,_I,_) --> [].
2811		translate_mpart2(unpromoted,I,_) --> {print_additional_machine_info},!,
2812		mpstart('/* NOT PROMOTED OPERATIONS',P),indent_expr_l_sep(I,','),insertstr(' */'),mpend(P).
2813		translate_mpart2(unpromoted,_I,_) --> [].
2814		translate_mpart2(constraints,I,All) --> mpart_typing(constraints,[parameters],All,I).
2815		translate_mpart2(invariant,I,All) --> mpart_typing(invariant, [abstract_variables,concrete_variables],All,I).
2816		translate_mpart2(linking_invariant,_I,_) --> [].
2817		translate_mpart2(properties,I,All) --> mpart_typing(properties,[abstract_constants,concrete_constants],All,I).
2818		translate_mpart2(assertions,I,_) -->
2819		mpstart_spec_desc(assertions,P),
2820		%indent_expr_l_sep(I,';'),
2821		preds_over_lines(1,'@thm','; ',I),
2822		mpend(P). % TO DO:
2823		translate_mpart2(initialisation,S,_) --> mpstart_spec_desc(initialisation,P),translate_inits(S),mpend(P).
2824		translate_mpart2(definitions,Defs,_) --> {(standard_library_required(Defs,_) ; set_pref_used(Defs))},!,
2825		mpstart('DEFINITIONS',P),
2826		insertstr('\n'),
2827		{findall(Lib,standard_library_required(Defs,Lib),Libs)},
2828		insert_library_usages(Libs),
2829		translate_set_pref_defs(Defs),
2830		mpend(P),
2831		translate_other_defpart(Defs).
2832		translate_mpart2(definitions,Defs,_) --> !, translate_other_defpart(Defs).
2833		translate_mpart2(operation_bodies,Ops,_) --> mpstart_spec_desc(operations,P),translate_ops(Ops),mpend(P).
2834		translate_mpart2(used,Used,_) --> {print_additional_machine_info},!,
2835		mpstart('/* USED',P),translate_used(Used),insertstr(' */'),mpend(P).
2836		translate_mpart2(used,_Used,_) --> [].
2837		translate_mpart2(freetypes,Freetypes,_) -->
2838		mpstart('FREETYPES',P),translate_freetypes(Freetypes),mpend(P).
2839		translate_mpart2(meta,_Infos,_) --> [].
2840		translate_mpart2(operators,Operators,_) -->
2841		insertstr('\n/* Event-B operators:'), % */
2842		indention_level(I,I2), {I2 is I+2},
2843		translate_eventb_operators(Operators),
2844		indention_level(I2,I),
2845		insertstr('\n*/').
2846		translate_mpart2(values,Values,_) -->
2847		mpstart('VALUES',P),indent_expr_l_sep(Values,';'),mpend(P).
2848
2849		indent_exprs(I) --> {force_eventb_rodin_mode},!, indent_expr_l_sep(I,' '). % Event-B Camille style
2850		indent_exprs(I) --> indent_expr_l_sep(I,',').
2851
2852
2853		% Add typing predicates to a predicate
2854		mpart_typing(Title,Section,Sections,PredI) -->
2855		{mpart_typing2(Section,Sections,PredI,PredO)},
2856		( {is_truth(PredO)} -> [] % TO DO: in animation_minor_mode(z) for INVARIANT: force adding typing predicates (translate_print_typing_infos)
2857		;
2858		mpstart_spec_desc(Title,P),
2859		section_pred_over_lines(0,Title,PredO),
2860		mpend(P)).
2861
2862		mpstart_spec_desc(Title,P) --> {get_specification_description(Title,Atom)},!, mpstart(Atom,P).
2863		mpstart_spec_desc(Title,P) --> mpstart(Title,P).
2864
2865		mpart_typing2(Sections,AllSections,PredI,PredO) :-
2866		get_preference(translate_print_typing_infos,true),!,
2867		get_all_ids(Sections,AllSections,Ids),
2868		add_typing_predicates(Ids,PredI,PredO).
2869		mpart_typing2(_Section,_Sections,Pred,Pred).
2870
2871		get_all_ids([],_Sections,[]).
2872		get_all_ids([Section|Srest],Sections,Ids) :-
2873		memberchk(Section/Ids1,Sections),
2874		append(Ids1,Ids2,Ids),
2875		get_all_ids(Srest,Sections,Ids2).
2876
2877		add_optional_typing_predicates(Ids,In,Out) :-
2878		( get_preference(translate_print_typing_infos,true) -> add_typing_predicates(Ids,In,Out)
2879		; is_truth(In) -> add_typing_predicates(Ids,In,Out)
2880		; In=Out).
2881
2882		add_normal_typing_predicates(Ids,In,Out) :- % used to call add_typing_predicates directly
2883		(add_optional_typing_predicates(Ids,In,Out) -> true
2884		; add_internal_error('Failed: ',add_normal_typing_predicates(Ids)), In=Out).
2885
2886		add_typing_predicates([],P,P) :- !.
2887		add_typing_predicates(Ids,Pin,Pout) :-
2888		remove_already_typed_ids(Pin,Ids,UntypedIds),
2889		KeepSeq=false,
2890		generate_typing_predicates(UntypedIds,KeepSeq,Typing),
2891		conjunction_to_list(Pin,Pins),
2892		remove_duplicate_predicates(Typing,Pins,Typing2),
2893		append(Typing2,[Pin],Preds),
2894		conjunct_predicates(Preds,Pout).
2895
2896		remove_already_typed_ids(_TExpr,Ids,Ids) :-
2897		get_preference(translate_force_all_typing_infos,true),!.
2898		remove_already_typed_ids(TExpr,Ids,UntypedIds) :-
2899		get_texpr_expr(TExpr,Expr),!,
2900		remove_already_typed_ids2(Expr,Ids,UntypedIds).
2901		remove_already_typed_ids(TExpr,Ids,Res) :-
2902		add_internal_error('Not a typed expression: ',remove_already_typed_ids(TExpr,Ids,_)),
2903		Res=Ids.
2904		remove_already_typed_ids2(conjunct(A,B),Ids,UntypedIds) :- !,
2905		remove_already_typed_ids(A,Ids,I1),
2906		remove_already_typed_ids(B,I1,UntypedIds).
2907		remove_already_typed_ids2(lazy_let_pred(_,_,A),Ids,UntypedIds) :- !,
2908		remove_already_typed_ids(A,Ids,UntypedIds). % TO DO: check for variable clases with lazy_let ids ???
2909		remove_already_typed_ids2(Expr,Ids,UntypedIds) :-
2910		is_typing_predicate(Expr,Id),
2911		create_texpr(identifier(Id),_,_,TId),
2912		select(TId,Ids,UntypedIds),!.
2913		remove_already_typed_ids2(_,Ids,Ids).
2914		is_typing_predicate(member(A,_),Id) :- get_texpr_id(A,Id).
2915		is_typing_predicate(subset(A,_),Id) :- get_texpr_id(A,Id).
2916		is_typing_predicate(subset_strict(A,_),Id) :- get_texpr_id(A,Id).
2917
2918		remove_duplicate_predicates([],_Old,[]).
2919		remove_duplicate_predicates([Pred|Prest],Old,Result) :-
2920		(is_duplicate_predicate(Pred,Old) -> Result = Rest ; Result = [Pred|Rest]),
2921		remove_duplicate_predicates(Prest,Old,Rest).
2922		is_duplicate_predicate(Pred,List) :-
2923		remove_all_infos(Pred,Pattern),
2924		memberchk(Pattern,List).
2925
2926		:- use_module(typing_tools,[create_type_set/3]).
2927		generate_typing_predicates(TIds,Preds) :-
2928		generate_typing_predicates(TIds,true,Preds).
2929		generate_typing_predicates(TIds,KeepSeq,Preds) :-
2930		maplist(generate_typing_predicate(KeepSeq), TIds, Preds).
2931		generate_typing_predicate(KeepSeq,TId,Pred) :-
2932		get_texpr_type(TId,Type),
2933		remove_all_infos_and_ground(TId,TId2), % clear all infos
2934		(create_type_set(Type,KeepSeq,TSet) -> create_texpr(member(TId2,TSet),pred,[],Pred)
2935		; TId = b(_,any,[raw]) -> is_truth(Pred) % this comes from transform_raw
2936		; add_error(generate_typing_predicate,'Illegal type in identifier: ',Type,TId),
2937		is_truth(Pred)
2938		).
2939
2940
2941
2942
2943		% translate enumerated constant list into enumerate set definition
2944		translate_enums([],Acc,Acc).
2945		translate_enums([EnumCst|T],Acc,Res) :- %get_texpr_id(EnumCst,Id),
2946		get_texpr_type(EnumCst,global(GlobalSet)),
2947		insert_enum_cst(Acc,EnumCst,GlobalSet,Acc2),
2948		translate_enums(T,Acc2,Res).
2949
2950		insert_enum_cst([],ID,Type,[enumerated_set_def(Type,[ID])]).
2951		insert_enum_cst([enumerated_set_def(Type,Lst)|T],ID,Type2,[enumerated_set_def(Type,Lst2)|TT]) :-
2952		(Type=Type2
2953		-> Lst2 = [ID|Lst], TT=T
2954		; Lst2 = Lst, insert_enum_cst(T,ID,Type2,TT)
2955		).
2956
2957		% pretty-print the initialisation section of a machine
2958		translate_inits(Inits) -->
2959		( {is_list_simple(Inits)} ->
2960		translate_inits2(Inits)
2961		;
2962		indention_level(I,I2),{I2 is I+2},
2963		translate_subst_begin_end(Inits),
2964		indention_level(_,I)).
2965		translate_inits2([]) --> !.
2966		translate_inits2([init(Name,Subst)|Rest]) -->
2967		indent('/* '),insertstr(Name),insertstr(': */ '),
2968		translate_subst_begin_end(Subst),
2969		translate_inits2(Rest).
2970
2971		translate_other_defpart(Defs) --> {print_additional_machine_info},!,
2972		mpstart('/* DEFINITIONS',P),translate_defs(Defs),insertstr(' */'),mpend(P).
2973		translate_other_defpart(_) --> [].
2974
2975		% pretty-print the definitions of a machine
2976		translate_defs([]) --> !.
2977		translate_defs([Def|Rest]) --> translate_def(Def),translate_defs(Rest).
2978		translate_def(definition_decl(Name,_,_DefType,_Pos,_Args,Expr,_Deps)) -->
2979		{dummy_def_body(Name,Expr)},!.
2980		% this is a DEFINITION from a standard library; do not show it
2981		translate_def(definition_decl(Name,DefType,_DefInfos,_Pos,Args,Expr,_Deps)) -->
2982		{def_description(DefType,Desc)}, indent(Desc),insertstr(Name),
2983		{transform_raw_list(Args,TArgs)},
2984		translate_op_params(TArgs),
2985		( {show_def_body(Expr)}
2986		-> insertstr(' '),{translate_in_mode(eqeq,'==',EqEqStr)}, insertstr(EqEqStr), insertstr(' '),
2987		{transform_raw(Expr,TExpr)},
2988		(translate_def_body(DefType,TExpr) -> [] ; insertstr('CANNOT PRETTY PRINT'))
2989		; {true}
2990		),
2991		insertstr(';').
2992		def_description(substitution,'SUBSTITUTION ').
2993		def_description(expression,'EXPRESSION ').
2994		def_description(predicate,'PREDICATE ').
2995		translate_def_body(substitution,B) --> translate_subst_begin_end(B).
2996		translate_def_body(expression,B) --> indent_expr(B).
2997		translate_def_body(predicate,B) --> indent_expr(B).
2998
2999		show_def_body(integer(_,_)).
3000		show_def_body(boolean_true(_)).
3001		show_def_body(boolean_false(_)).
3002		% show_def_body(_) % comment in to pretty print all defs
3003
3004		% check if we have a dummy definition body from a ProB Library file for external functions:
3005		dummy_def_body(Name,Expr) :-
3006		functor(Expr,F,_), (F=external_function_call ; F=external_pred_call),
3007		arg(2,Expr,Name).
3008		%external_function_declarations:external_function_library(Name,NrArgs,DefType,_),length(Args,NrArgs)
3009
3010		% utility to print definitions in JSON format for use in a VisB file:
3011		% useful when converting a B DEFINITIONS file for use in Event-B, TLA+,...
3012		:- public print_defs_as_json/0.
3013		print_defs_as_json :-
3014		findall(json([name=string(Name), value=string(BS)]), (
3015		bmachine:b_get_definition_with_pos(Name,expression,_DefPos,_Args,RawExpr,_Deps),
3016		\+ dummy_def_body(Name,RawExpr),
3017		transform_raw(RawExpr,Body),
3018		translate_subst_or_bexpr(Body,BS)
3019		), Defs),
3020		Json = json([svg=string(''), definitions=array(Defs)]),
3021		json_write_stream(Json).
3022
3023	?	set_pref_used(Defs) :- member(definition_decl(Name,_,_,_,[],_,_),Defs),
3024		(is_set_pref_def_name(Name,_,_) -> true).
3025
3026		is_set_pref_def_name(Name,Pref,CurValAtom) :-
3027		atom_codes(Name,Codes),append("SET_PREF_",RestCodes,Codes),
3028		atom_codes(Pref,RestCodes),
3029		(eclipse_preference(Pref,P) -> get_preference(P,CurVal), translate_pref_val(CurVal,CurValAtom)
3030		; deprecated_eclipse_preference(Pref,_,NewP,Mapping) -> get_preference(NewP,V), member(CurVal/V,Mapping)
3031		; get_preference(Pref,CurVal), translate_pref_val(CurVal,CurValAtom)),
3032		translate_pref_val(CurVal,CurValAtom).
3033		translate_pref_val(true,'TRUE').
3034		translate_pref_val(false,'FALSE').
3035		translate_pref_val(Nr,NrAtom) :- number(Nr),!, number_codes(Nr,C), atom_codes(NrAtom,C).
3036		translate_pref_val(Atom,Atom) :- atom(Atom).
3037
3038		is_set_pref(definition_decl(Name,_,_,_Pos,[],_Expr,_Deps)) :-
3039		is_set_pref_def_name(Name,_,_).
3040		translate_set_pref_defs(Defs) -->
3041		{include(is_set_pref,Defs,SPDefs),
3042		sort(SPDefs,SortedDefs)},
3043		translate_set_pref_defs1(SortedDefs).
3044		translate_set_pref_defs1([]) --> !.
3045		translate_set_pref_defs1([Def|Rest]) -->
3046		translate_set_pref_def(Def),translate_set_pref_defs1(Rest).
3047		translate_set_pref_def(definition_decl(Name,_,_,_Pos,[],_Expr,_Deps)) -->
3048		{is_set_pref_def_name(Name,_Pref,CurValAtom)},!,
3049		insertstr(' '),insertstr(Name),
3050		insertstr(' '),
3051		{translate_in_mode(eqeq,'==',EqEqStr)}, insertstr(EqEqStr), insertstr(' '),
3052		insertstr(CurValAtom), % pretty print current value; Expr could be a more complicated non-atomic expression
3053		insertstr(';\n').
3054		translate_set_pref_def(_) --> [].
3055
3056		standard_library_required(Defs,Library) :-
3057	?	member(Decl,Defs),
3058		definition_decl_from_library(Decl,Library).
3059
3060		% TODO: we could also look in the list of loaded files and search for standard libraries
3061		definition_decl_from_library(definition_decl(printf,predicate,_,_,[_,_],_,_Deps),'LibraryIO.def').
3062		definition_decl_from_library(definition_decl('STRING_IS_DECIMAL',predicate,_,_,[_],_,_Deps),'LibraryStrings.def').
3063		definition_decl_from_library(definition_decl('SHA_HASH',expression,_,_,[_],_,_Deps),'LibraryHash.def').
3064		definition_decl_from_library(definition_decl('CHOOSE',expression,_,_,[_],_,_Deps),'CHOOSE.def').
3065		definition_decl_from_library(definition_decl('SCCS',expression,_,_,[_],_,_Deps),'SCCS.def').
3066		definition_decl_from_library(definition_decl('SORT',expression,_,_,[_],_,_Deps),'SORT.def').
3067		definition_decl_from_library(definition_decl('random_element',expression,_,_,[_],_,_Deps),'LibraryRandom.def').
3068		definition_decl_from_library(definition_decl('SIN',expression,_,_,[_],_,_Deps),'LibraryMath.def').
3069		definition_decl_from_library(definition_decl('RMUL',expression,_,_,[_,_],_,_Deps),'LibraryReals.def').
3070		definition_decl_from_library(definition_decl('REGEX_MATCH',predicate,_,_,[_,_],_,_Deps),'LibraryRegex.def').
3071		definition_decl_from_library(definition_decl('ASSERT_EXPR',expression,_,_,[_,_,_],_,_Deps),'LibraryProB.def').
3072		definition_decl_from_library(definition_decl('svg_points',expression,_,_,[_],_,_Deps),'LibrarySVG.def').
3073		definition_decl_from_library(definition_decl('FULL_FILES',expression,_,_,[_],_,_Deps),'LibraryFiles.def').
3074		definition_decl_from_library(definition_decl('READ_XML_FROM_STRING',expression,_,_,[_],_,_Deps),'LibraryXML.def').
3075		definition_decl_from_library(definition_decl('READ_CSV',expression,_,_,[_],_,_Deps),'LibraryCSV.def').
3076
3077		insert_library_usages([]) --> [].
3078		insert_library_usages([Library|T]) -->
3079		insertstr(' "'),insertstr(Library),insertstr('";\n'), % insert inclusion of ProB standard library
3080		insert_library_usages(T).
3081
3082		% ------------- RAW EXPRESSIONS
3083
3084		% try and print raw machine term or parts thereof (e.g. sections)
3085		print_raw_machine_terms(Var) :- var(Var), !,write('VAR !!'),nl.
3086		print_raw_machine_terms([]) :- !.
3087		print_raw_machine_terms([H|T]) :- !,
3088		print_raw_machine_terms(H), write(' '),
3089		print_raw_machine_terms(T).
3090		print_raw_machine_terms(Term) :- raw_machine_term(Term,String,Sub),!,
3091		format('~n~w ',[String]),
3092		print_raw_machine_terms(Sub),nl.
3093		print_raw_machine_terms(expression_definition(A,B,C,D)) :- !,
3094		print_raw_machine_terms(predicate_definition(A,B,C,D)).
3095		print_raw_machine_terms(substitution_definition(A,B,C,D)) :- !,
3096		print_raw_machine_terms(predicate_definition(A,B,C,D)).
3097		print_raw_machine_terms(expression(A,B,C,D)) :- !,
3098		print_raw_machine_terms(predicate_definition(A,B,C,D)).
3099		print_raw_machine_terms(predicate(A,B,C,D)) :- !,
3100		print_raw_machine_terms(predicate_definition(A,B,C,D)).
3101		print_raw_machine_terms(substitution(A,B,C,D)) :- !,
3102		print_raw_machine_terms(predicate_definition(A,B,C,D)).
3103		print_raw_machine_terms(predicate_definition(_,Name,Paras,RHS)) :-
3104		Paras==[],!,
3105		format('~n ~w == ',[Name]),
3106		print_raw_machine_terms(RHS),nl.
3107		print_raw_machine_terms(predicate_definition(_,Name,Paras,RHS)) :- !,
3108		format('~n ~w(',[Name]),
3109		print_raw_machine_terms_sep(Paras,','),
3110		format(') == ',[]),
3111		print_raw_machine_terms(RHS),nl.
3112		print_raw_machine_terms(operation(_,Name,Return,Paras,RHS)) :- !,
3113		format('~n ',[]),
3114		(Return=[] -> true
3115		; print_raw_machine_terms_sep(Return,','),
3116		format(' <-- ',[])
3117		),
3118		print_raw_machine_terms(Name),
3119		(Paras=[] -> true
3120		; format(' (',[]),
3121		print_raw_machine_terms_sep(Paras,','),
3122		format(')',[])
3123		),
3124		format(' = ',[]),
3125		print_raw_machine_terms(RHS),nl.
3126		print_raw_machine_terms(Term) :- print_raw_bexpr(Term).
3127
3128
3129		print_raw_machine_terms_sep([],_) :- !.
3130		print_raw_machine_terms_sep([H],_) :- !,
3131		print_raw_machine_terms(H).
3132		print_raw_machine_terms_sep([H|T],Sep) :- !,
3133		print_raw_machine_terms(H),write(Sep),print_raw_machine_terms_sep(T,Sep).
3134
3135		raw_machine_term(machine(M),'',M).
3136		raw_machine_term(generated(_,M),'',M).
3137		raw_machine_term(machine_header(_,Name,_Params),Name,[]). % TO DO: treat Params
3138		raw_machine_term(abstract_machine(_,_,Header,M),'MACHINE',[Header,M]).
3139		raw_machine_term(properties(_,P),'PROPERTIES',P).
3140		raw_machine_term(operations(_,P),'OPERATIONS',P).
3141		raw_machine_term(definitions(_,P),'DEFINITIONS',P).
3142		raw_machine_term(constants(_,P),'CONSTANTS',P).
3143		raw_machine_term(variables(_,P),'VARIABLES',P).
3144		raw_machine_term(invariant(_,P),'INVARIANT',P).
3145		raw_machine_term(assertions(_,P),'ASSERTIONS',P).
3146		raw_machine_term(constraints(_,P),'CONSTRAINTS',P).
3147		raw_machine_term(sets(_,P),'SETS',P).
3148		raw_machine_term(deferred_set(_,P),P,[]). % TO DO: enumerated_set ...
3149		%raw_machine_term(identifier(_,P),P,[]).
3150
3151		l_print_raw_bexpr([]).
3152		l_print_raw_bexpr([Raw|T]) :- write(' '),
3153		print_raw_bexpr(Raw),nl, l_print_raw_bexpr(T).
3154
3155		print_raw_bexpr(Raw) :- % a tool (not perfect) to print raw ASTs
3156		transform_raw(Raw,TExpr),!,
3157		print_bexpr_or_subst(TExpr).
3158
3159		translate_raw_bexpr(Raw,TS) :- transform_raw(Raw,TExpr), translate_subst_or_bexpr(TExpr,TS).
3160		translate_raw_bexpr_with_limit(Raw,Limit,TS) :- transform_raw(Raw,TExpr),
3161		translate_subst_or_bexpr_with_limit(TExpr,Limit,TS).
3162
3163		transform_raw_list(Var,Res) :- var(Var),!,
3164		add_internal_error('Var raw expression list:',transform_raw_list(Var,Res)),
3165		Res= [b(identifier('$$VARIABLE_LIST$$'),any,[raw])].
3166		transform_raw_list(Args,TArgs) :- l_transform_raw(Args,TArgs).
3167
3168		:- use_module(input_syntax_tree,[raw_symbolic_annotation/2]).
3169
3170		transform_raw(Var,Res) :- %write(raw(Var)),nl,
3171		var(Var), !, add_internal_error('Var raw expression:',transform_raw(Var,Res)),
3172		Res= b(identifier('$$VARIABLE$$'),any,[raw]).
3173		transform_raw(precondition(_,Pre,Body),Res) :- !, Res= b(precondition(TP,TB),subst,[raw]),
3174		transform_raw(Pre,TP),
3175		transform_raw(Body,TB).
3176		transform_raw(typeof(_,E,Type),Res) :- !, Res = b(typeof(TE,TType),any,[]),
3177		transform_raw(E,TE), transform_raw(Type,TType).
3178		transform_raw(identifier(_,M),Res) :- !, Res= b(identifier(M),any,[raw]).
3179		transform_raw(integer(_,M),Res) :- !, Res= b(integer(M),integer,[raw]).
3180		% rules from btype_rewrite2:
3181		transform_raw(integer_set(_),Res) :- !, generate_typed_int_set('INTEGER',Res).
3182		transform_raw(natural_set(_),Res) :- !, generate_typed_int_set('NATURAL',Res).
3183		transform_raw(natural1_set(_),Res) :- !, generate_typed_int_set('NATURAL1',Res).
3184		transform_raw(nat_set(_),Res) :- !, generate_typed_int_set('NAT',Res).
3185		transform_raw(nat1_set(_),Res) :- !, generate_typed_int_set('NAT1',Res).
3186		transform_raw(int_set(_),Res) :- !, generate_typed_int_set('INT',Res).
3187		transform_raw(let_expression(_,_Ids,Eq,Body),Res) :- !,
3188		transform_raw(conjunct(_,Eq,Body),Res). % TO DO: fix and generate let_expression(Ids,ListofExprs,Body)
3189		transform_raw(let_predicate(_,_Ids,Eq,Body),Res) :- !,
3190		transform_raw(conjunct(_,Eq,Body),Res). % ditto
3191		transform_raw(forall(_,Ids,Body),Res) :- !,
3192		(Body=implication(_,LHS,RHS) -> true ; LHS=truth,RHS=Body),
3193		transform_raw(forall(_,Ids,LHS,RHS),Res).
3194		transform_raw(record_field(_,Rec,identifier(_,Field)),Res) :- !, Res = b(record_field(TRec,Field),any,[]),
3195		transform_raw(Rec,TRec).
3196		transform_raw(rec_entry(_,identifier(_,Field),Rec),Res) :- !, Res = field(Field,TRec),
3197		transform_raw(Rec,TRec).
3198		transform_raw(conjunct(_,List),Res) :- !,
3199	?	transform_raw_list_to_conjunct(List,Res). % sometimes conjunct/1 with list is used (e.g., .eventb files)
3200		transform_raw(couple(_,L),Res) :- !, transform_raw_list_to_couple(L,Res). % couples are represented by lists
3201		transform_raw(extended_expr(Pos,Op,L,_TypeParas),Res) :- !,
3202		(L=[] -> transform_raw(identifier(none,Op),Res) % no arguments
3203		; transform_raw(function(Pos,identifier(none,Op),L),Res)).
3204		transform_raw(extended_pred(Pos,Op,L,_TypeParas),Res) :- !,
3205		transform_raw(function(Pos,identifier(none,Op),L),Res). % not of correct type pred, but seems to work
3206		transform_raw(external_function_call_auto(Pos,Name,Para),Res) :- !,
3207		transform_raw(external_function_call(Pos,Name,Para),Res). % we assume expr rather than pred and hope for the best
3208		transform_raw(function(_,F,L),Res) :- !, transform_raw(F,TF),
3209		Res = b(function(TF,Args),any,[]),
3210		transform_raw_list_to_couple(L,Args). % args are represented by lists
3211		transform_raw(Atom,Res) :- atomic(Atom),!,Res=Atom.
3212		transform_raw([H|T],Res) :- !, l_transform_raw([H|T],Res).
3213		transform_raw(Symbolic,Res) :- raw_symbolic_annotation(Symbolic,Body),!,
3214		transform_raw(Body,Res).
3215		transform_raw(OtherOp,b(Res,Type,[])) :- OtherOp =..[F,_Pos|Rest],
3216		l_transform_raw(Rest,TRest),
3217		(get_type(F,FT) -> Type=FT ; Type=any),
3218		Res =.. [F|TRest].
3219		transform_raw_list_to_couple([R],Res) :- !, transform_raw(R,Res).
3220		transform_raw_list_to_couple([R1|T],Res) :- !, Res=b(couple(TR1,TT),any,[]),
3221		transform_raw(R1,TR1),transform_raw_list_to_couple(T,TT).
3222		transform_raw_list_to_conjunct([R],Res) :- !, transform_raw(R,Res).
3223		transform_raw_list_to_conjunct([R1|T],Res) :-
3224		transform_raw(R1,TR1),
3225	?	transform_raw_list_to_conjunct2(TR1,T,Res).
3226		transform_raw_list_to_conjunct2(Res,[],Res).
3227		transform_raw_list_to_conjunct2(Conj,[R1|T],Res) :-
3228		transform_raw(R1,TR1),
3229		Conj1 = b(conjunct(Conj,TR1),pred,[]), % conjunct from left to right, e.g. [A,B,C] -> conjunct(conjunct(A,B),C)
3230	?	transform_raw_list_to_conjunct2(Conj1,T,Res).
3231
3232		l_transform_raw([],[]).
3233		l_transform_raw([H|T],[RH|RT]) :- transform_raw(H,RH), l_transform_raw(T,RT).
3234
3235		generate_typed_int_set(Name,b(integer_set(Name),set(integer),[])).
3236		get_type(truth,pred).
3237		get_type(falsity,pred).
3238		get_type(conjunct,pred).
3239		get_type(disjunct,pred).
3240		get_type(forall,pred).
3241		get_type(equivalence,pred).
3242		get_type(exists,pred).
3243		get_type(implication,pred).
3244		get_type(equal,pred).
3245		get_type(not_equal,pred).
3246		get_type(member,pred).
3247		get_type(negation,pred).
3248		get_type(not_member,pred).
3249		get_type(subset,pred).
3250		get_type(subset_strict,pred).
3251		get_type(not_subset,pred).
3252		get_type(not_subset_strict,pred).
3253		get_type(less_equal,pred).
3254		get_type(less,pred).
3255		get_type(less_equal_real,pred).
3256		get_type(less_real,pred).
3257		get_type(greater_equal,pred).
3258		get_type(greater,pred).
3259		get_type(finite,pred).
3260		get_type(card,integer).
3261		get_type(size,integer).
3262		get_type(convert_int_floor,integer).
3263		get_type(convert_int_ceiling,integer).
3264		get_type(predecessor,integer).
3265		get_type(successor,integer).
3266		get_type(boolean_false,boolean).
3267		get_type(boolean_true,boolean).
3268		get_type(convert_bool,boolean).
3269		get_type(add_real,real).
3270		get_type(convert_real,real).
3271		get_type(div_real,real).
3272		get_type(max_real,real).
3273		get_type(min_real,real).
3274		get_type(minus_real,real).
3275		get_type(multiplication_real,real).
3276		get_type(power_of_real,real).
3277		get_type(real,real). % real literal
3278		get_type(string,string). % string literal
3279		get_type(bool_set,set(boolean)).
3280		get_type(float_set,set(real)).
3281		get_type(real_set,set(real)).
3282		get_type(string_set,set(real)).
3283
3284		get_type(any,subst).
3285		get_type(assertion,subst).
3286		get_type(assign,subst).
3287		get_type(becomes_element_of,subst).
3288		get_type(becomes_such,subst).
3289		get_type(case,subst).
3290		get_type(choice,subst).
3291		get_type(external_subst_call,subst).
3292		get_type(if,subst).
3293		get_type(let,subst).
3294		get_type(operation_call,subst).
3295		get_type(parallel,subst).
3296		get_type(precondition,subst).
3297		get_type(select,subst).
3298		get_type(sequence,subst).
3299		get_type(skip,subst).
3300		get_type(var,subst).
3301		get_type(while,subst).
3302		get_type(while1,subst).
3303		get_type(witness_then,subst).
3304
3305		:- assert_must_succeed((transform_raw(conjunct(none,[member(none,identifier(none,x),integer_set(none)),
3306		less_equal(none,identifier(none,y),integer(none,5)),
3307		equal(none,integer(none,1),integer(none,1))]),R),
3308		% check that list of conjunctions is transformed left-associatively
3309		R == b(conjunct(b(conjunct(b(member(b(identifier(x),any,[raw]),b(integer_set('INTEGER'),set(integer),[])),pred,[]),
3310		b(less_equal(b(identifier(y),any,[raw]),b(integer(5),integer,[raw])),pred,[])),pred,[]),
3311		b(equal(b(integer(1),integer,[raw]),b(integer(1),integer,[raw])),pred,[])),pred,[]))).
3312
3313		% -------------
3314
3315
3316		% pretty-print the operations of a machine
3317		translate_ops([]) --> !.
3318		translate_ops([Op|Rest]) -->
3319		translate_op(Op),
3320		({Rest=[]} -> {true}; insertstr(';'),indent),
3321		translate_ops(Rest).
3322		translate_op(Op) -->
3323		{ get_texpr_expr(Op,operation(Id,Res,Params,Body)) },
3324		translate_operation(Id,Res,Params,Body).
3325		translate_operation(Id,Res,Params,Body) -->
3326		indent,translate_op_results(Res),
3327		pp_expr_indent(Id),
3328		translate_op_params(Params),
3329		insertstr(' = '),
3330		indention_level(I1,I2),{I2 is I1+2,type_infos_in_subst(Params,Body,Body2)},
3331		translate_subst_begin_end(Body2),
3332		pp_description_pragma_of(Body2),
3333		indention_level(_,I1).
3334		translate_op_results([]) --> !.
3335		translate_op_results(Ids) --> pp_expr_indent_l(Ids), insertstr(' <-- ').
3336		translate_op_params([]) --> !.
3337		translate_op_params(Ids) --> insertstr('('),pp_expr_indent_l(Ids), insertstr(')').
3338
3339		translate_subst_begin_end(TSubst) -->
3340		{get_texpr_expr(TSubst,Subst),subst_needs_begin_end(Subst),
3341		create_texpr(block(TSubst),subst,[],Block)},!,
3342		translate_subst(Block).
3343		translate_subst_begin_end(Subst) -->
3344		translate_subst(Subst).
3345
3346		subst_needs_begin_end(assign(_,_)).
3347		subst_needs_begin_end(assign_single_id(_,_)).
3348		subst_needs_begin_end(parallel(_)).
3349		subst_needs_begin_end(sequence(_)).
3350		subst_needs_begin_end(operation_call(_,_,_)).
3351
3352		type_infos_in_subst([],Subst,Subst) :- !.
3353		type_infos_in_subst(Ids,SubstIn,SubstOut) :-
3354		get_preference(translate_print_typing_infos,true),!,
3355		type_infos_in_subst2(Ids,SubstIn,SubstOut).
3356		type_infos_in_subst(_Ids,Subst,Subst).
3357		type_infos_in_subst2(Ids,SubstIn,SubstOut) :-
3358		get_texpr_expr(SubstIn,precondition(P1,S)),!,
3359		get_texpr_info(SubstIn,Info),
3360		create_texpr(precondition(P2,S),pred,Info,SubstOut),
3361		add_typing_predicates(Ids,P1,P2).
3362		type_infos_in_subst2(Ids,SubstIn,SubstOut) :-
3363		create_texpr(precondition(P,SubstIn),pred,[],SubstOut),
3364		generate_typing_predicates(Ids,Typing),
3365		conjunct_predicates(Typing,P).
3366
3367
3368
3369
3370
3371		% pretty-print the internal section about included and used machines
3372		translate_used([]) --> !.
3373		translate_used([Used|Rest]) -->
3374		translate_used2(Used),
3375		translate_used(Rest).
3376		translate_used2(includeduse(Name,Id,NewTExpr)) -->
3377		indent,pp_expr_indent(NewTExpr),
3378		insertstr(' --> '), insertstr(Name), insertstr(':'), insertstr(Id).
3379
3380		% pretty-print the internal information about freetypes
3381		translate_freetypes([]) --> !.
3382		translate_freetypes([Freetype|Frest]) -->
3383		translate_freetype(Freetype),
3384		translate_freetypes(Frest).
3385		translate_freetype(freetype(Name,Cases)) -->
3386		{pretty_freetype(Name,PName)},
3387		indent(PName),insertstr('= '),
3388		indention_level(I1,I2),{I2 is I1+2},
3389		translate_freetype_cases(Cases),
3390		indention_level(_,I1).
3391		translate_freetype_cases([]) --> !.
3392		translate_freetype_cases([case(Name,Type)|Rest]) --> {nonvar(Type),Type=constant(_)},
3393		!,indent(Name),insert_comma(Rest),
3394		translate_freetype_cases(Rest).
3395		translate_freetype_cases([case(Name,Type)|Rest]) -->
3396		{pretty_type(Type,PT)},
3397		indent(Name),
3398		insertstr('('),insertstr(PT),insertstr(')'),
3399		insert_comma(Rest),
3400		translate_freetype_cases(Rest).
3401
3402		insert_comma([]) --> [].
3403		insert_comma([_|_]) --> insertstr(',').
3404
3405		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3406		% substitutions
3407
3408		translate_subst_or_bexpr(Stmt,String) :- get_texpr_type(Stmt,subst),!,
3409		translate_substitution(Stmt,String).
3410		translate_subst_or_bexpr(ExprOrPred,String) :-
3411		translate_bexpression(ExprOrPred,String).
3412
3413		translate_subst_or_bexpr_with_limit(Stmt,Limit,String) :-
3414		translate_subst_or_bexpr_with_limit(Stmt,Limit,report_errors,String).
3415		translate_subst_or_bexpr_with_limit(Stmt,_Limit,ReportErrors,String) :- get_texpr_type(Stmt,subst),!,
3416		translate_substitution(Stmt,String,ReportErrors). % TO DO: use limit
3417		translate_subst_or_bexpr_with_limit(ExprOrPred,Limit,ReportErrors,String) :-
3418		translate_bexpression_with_limit(ExprOrPred,Limit,ReportErrors,String).
3419
3420		print_subst(Stmt) :- translate_substitution(Stmt,T), write(T).
3421		translate_substitution(Stmt,String) :- translate_substitution(Stmt,String,report_errors).
3422		translate_substitution(Stmt,String,_) :-
3423		translate_subst_with_indention(Stmt,0,Codes,[]),
3424		(Codes = [10|C] -> true ; Codes=[13|C] -> true ; Codes=C), % peel off leading newline
3425		atom_codes_with_limit(String, C),!.
3426		translate_substitution(Stmt,String,report_errors) :-
3427		add_error(translate_substitution,'Could not translate substitution: ',Stmt),
3428		String='???'.
3429
3430		translate_subst_with_indention(TS,Indention,I,O) :-
3431		translate_subst(TS,(Indention,I),(_,O)).
3432		translate_subst_with_indention_and_label(TS,Indention,I,O) :-
3433		translate_subst_with_label(TS,(Indention,I),(_,O)).
3434
3435		translate_subst(TS) -->
3436		( {get_texpr_expr(TS,S)} ->
3437		translate_subst2(S)
3438		; translate_subst2(TS)).
3439
3440		translate_subst_with_label(TS) -->
3441		( {get_texpr_expr(TS,S)} ->
3442		indent_rodin_label(TS), % pretty print substitution labels
3443		translate_subst2(S)
3444		; translate_subst2(TS)).
3445
3446		% will print (first) rodin or pragma label indendent
3447		:- public indent_rodin_label/3.
3448		indent_rodin_label(_TExpr) --> {get_preference(translate_suppress_rodin_positions_flag,true),!}.
3449		indent_rodin_label(_TExpr) --> {get_preference(bugly_pp_scrambling,true),!}.
3450		indent_rodin_label(TExpr) --> {get_texpr_labels(TExpr,Names)},!, % note: this will only get the first label
3451		indent('/* @'),pp_ids_indent(Names),insertstr('*/ '). % this Camille syntax cannot be read back in by B parser
3452		indent_rodin_label(_TExpr) --> [].
3453
3454		pp_ids_indent([]) --> !, [].
3455		pp_ids_indent([ID]) --> !,pp_expr_indent(identifier(ID)).
3456		pp_ids_indent([ID|T]) --> !,pp_expr_indent(identifier(ID)), insertstr(' '),pp_ids_indent(T).
3457		pp_ids_indent(X) --> {add_error(pp_ids_indent,'Not a list of atoms: ',pp_ids_indent(X))}.
3458
3459		translate_subst2(Var) --> {var(Var)}, !, "_", {add_warning(translate_subst,'Variable subst:',Var)}.
3460		translate_subst2(skip) -->
3461		indent(skip).
3462		translate_subst2(operation(Id,Res,Params,Body)) --> translate_operation(Id,Res,Params,Body). % not really a substition that can appear normally
3463		translate_subst2(precondition(P,S)) -->
3464		indent('PRE '), pred_over_lines(2,'@grd',P), indent('THEN'), insert_subst(S), indent('END').
3465		translate_subst2(assertion(P,S)) -->
3466		indent('ASSERT '), pp_expr_indent(P), indent('THEN'), insert_subst(S), indent('END').
3467		translate_subst2(witness_then(P,S)) -->
3468		indent('WITNESS '), pp_expr_indent(P), indent('THEN'), insert_subst(S), indent('END').
3469		translate_subst2(block(S)) -->
3470		indent('BEGIN'), insert_subst(S), indent('END').
3471		translate_subst2(assign([L],[R])) --> !,
3472		indent,pp_expr_indent(L),insertstr(' := '),pp_expr_indent(R).
3473		translate_subst2(assign(L,R)) -->
3474	?	{(member(b(E,_,_),R), can_indent_expr(E)
3475		-> maplist(create_assign,L,R,ParAssigns))},!, % split into parallel assignments so that we can indent
3476		translate_subst2(parallel(ParAssigns)).
3477		translate_subst2(assign(L,R)) -->
3478		indent,pp_expr_indent_l(L),insertstr(' := '),pp_expr_indent_l(R).
3479		translate_subst2(assign_single_id(L,R)) -->
3480		translate_subst2(assign([L],[R])).
3481		translate_subst2(becomes_element_of(L,R)) -->
3482		indent,pp_expr_indent_l(L),insertstr(' :: '),pp_expr_indent(R).
3483		translate_subst2(becomes_such(L,R)) -->
3484		indent,pp_expr_indent_l(L),insertstr(' : '), insertstr('('),
3485		{ add_optional_typing_predicates(L,R,R1) },
3486		pp_expr_indent(R1), insertstr(')').
3487		translate_subst2(evb2_becomes_such(L,R)) --> translate_subst2(becomes_such(L,R)).
3488		translate_subst2(if([Elsif|Rest])) -->
3489		{ get_if_elsif(Elsif,P,S) },
3490		indent('IF '), pp_expr_indent(P), insertstr(' THEN'),
3491		insert_subst(S),
3492		translate_ifs(Rest).
3493		translate_subst2(if_elsif(P,S)) --> % not a legal top-level construct; but can be called in b_portray_hook
3494		indent('IF '), pp_expr_indent(P), insertstr(' THEN'),
3495		insert_subst(S),
3496		indent('END').
3497		translate_subst2(choice(Ss)) --> indent(' CHOICE'),
3498		split_over_lines(Ss,'OR'),
3499		indent('END'). % indentation seems too far
3500		translate_subst2(parallel(Ss)) -->
3501		split_over_lines(Ss,'||').
3502		translate_subst2(init_statement(S)) --> insert_subst(S).
3503		translate_subst2(sequence(Ss)) -->
3504		split_over_lines(Ss,';').
3505		translate_subst2(operation_call(Id,Rs,As)) -->
3506		indent,translate_op_results(Rs),
3507		pp_expr_indent(Id),
3508		translate_op_params(As).
3509		translate_subst2(identifier(op(Id))) --> % shouldn't normally appear
3510		indent,pp_expr_indent(identifier(Id)).
3511		translate_subst2(external_subst_call(Symbol,Args)) -->
3512		indent,
3513		pp_expr_indent(identifier(Symbol)),
3514		translate_op_params(Args).
3515		translate_subst2(any(Ids,Pred,Subst)) -->
3516		indent('ANY '), pp_expr_indent_l(Ids),
3517		indent('WHERE '),
3518		{add_optional_typing_predicates(Ids,Pred,Pred2)},
3519		pred_over_lines(2,'@grd',Pred2), indent('THEN'),
3520		insert_subst(Subst),
3521		indent('END').
3522		translate_subst2(select(Whens)) -->
3523		translate_whens(Whens,'SELECT '),
3524		indent('END').
3525		translate_subst2(select_when(Cond,Then)) --> % not a legal top-level construct; but can be called in b_portray_hook
3526		indent('WHEN'),
3527		pp_expr_indent(Cond),
3528		indent('THEN'),
3529		insert_subst(Then),
3530		indent('END').
3531		translate_subst2(select(Whens,Else)) -->
3532		translate_whens(Whens,'SELECT '),
3533		indent('ELSE'), insert_subst(Else),
3534		indent('END').
3535		translate_subst2(var(Ids,S)) -->
3536		indent('VAR '),
3537		pp_expr_indent_l(Ids),
3538		indent('IN'),insert_subst(S),
3539		indent('END').
3540		translate_subst2(let(Ids,P,S)) -->
3541		indent('LET '),
3542		pp_expr_indent_l(Ids),
3543		insertstr(' BE '), pp_expr_indent(P),
3544		indent('IN'), insert_subst(S),
3545		indent('END').
3546		translate_subst2(lazy_let_subst(TID,P,S)) -->
3547		indent('LET '),
3548		pp_expr_indent_l([TID]),
3549		insertstr(' BE '), pp_expr_indent(P), % could be expr or pred
3550		indent('IN'), insert_subst(S),
3551		indent('END').
3552		translate_subst2(case(Expression,Cases,ELSE)) -->
3553		% CASE E OF EITHER m THEN G OR n THEN H ... ELSE I END END
3554		indent('CASE '),
3555		pp_expr_indent(Expression), insertstr(' OF'),
3556		indent('EITHER '), translate_cases(Cases),
3557		indent('ELSE '), insert_subst(ELSE), % we could drop this if ELSE is skip ?
3558		indent('END END').
3559		translate_subst2(while(Pred,Subst,Inv,Var)) -->
3560		indent('WHILE '), pp_expr_indent(Pred),
3561		indent('DO'),insert_subst(Subst),
3562		indent('INVARIANT '),pp_expr_indent(Inv),
3563		indent('VARIANT '),pp_expr_indent(Var),
3564		indent('END').
3565		translate_subst2(while1(Pred,Subst,Inv,Var)) -->
3566		indent('WHILE /* 1 */ '), pp_expr_indent(Pred),
3567		indent('DO'),insert_subst(Subst),
3568		indent('INVARIANT '),pp_expr_indent(Inv),
3569		indent('VARIANT '),pp_expr_indent(Var),
3570		indent('END').
3571		translate_subst2(rlevent(Id,Section,Status,Parameters,Guard,Theorems,Actions,VWitnesses,PWitnesses,_Unmod,Refines)) -->
3572		indent,
3573		insert_status(Status),
3574		insertstr('EVENT '),
3575		({Id = 'INITIALISATION'}
3576		-> [] % avoid BLexer error in ProB2-UI, BLexerException: Invalid combination of symbols: 'INITIALISATION' and '='.
3577		; insertstr(Id), insertstr(' = ')),
3578		insertstr('/'), insertstr('* of machine '),
3579		insertstr(Section),insertstr(' */'),
3580		insert_variant(Status),
3581		( {Parameters=[], get_texpr_expr(Guard,truth)} ->
3582		{NoGuard=true} % indent('BEGIN ')
3583		; {Parameters=[]} ->
3584		indent('WHEN '),
3585		pred_over_lines(2,'@grd',Guard)
3586		;
3587		indent('ANY '),pp_expr_indent_l(Parameters),
3588		indent('WHERE '),
3589		pred_over_lines(2,'@grd',Guard)
3590		),
3591		( {VWitnesses=[],PWitnesses=[]} ->
3592		[]
3593		;
3594		{append(VWitnesses,PWitnesses,Witnesses)},
3595		indent('WITH '),pp_witness_l(Witnesses)
3596		),
3597		{( Actions=[] ->
3598		create_texpr(skip,subst,[],Subst)
3599		;
3600		create_texpr(parallel(Actions),subst,[],Subst)
3601		)},
3602		( {Theorems=[]} -> {true}
3603		;
3604		indent('THEOREMS '),
3605		preds_over_lines(2,'@thm',Theorems)
3606		),
3607		({NoGuard==true, Actions=[]}
3608		-> pp_refines_l(Refines,Id) % we do not need a BEGIN END block and we need no substitution to be shown
3609		; ({NoGuard==true}
3610		-> indent('BEGIN ') % avoid BLexer errors in ProB2-UI Syntax highlighting
3611		; indent('THEN ')
3612		),
3613		insert_subst(Subst),
3614		pp_refines_l(Refines,Id),
3615		indent('END')
3616		).
3617
3618
3619		% translate cases of a CASE statement
3620		translate_cases([]) --> !,[].
3621		translate_cases([CaseOr|T]) -->
3622		{get_texpr_expr(CaseOr,case_or(Exprs,Subst))},!,
3623		pp_expr_indent_l(Exprs),
3624		insertstr(' THEN '),
3625		insert_subst(Subst),
3626		({T==[]} -> {true}
3627		; indent('OR '), translate_cases(T)).
3628		translate_cases(L) -->
3629		{add_internal_error('Cannot translate CASE list: ',translate_cases(L,_,_))}.
3630
3631		insert_status(TStatus) -->
3632		{get_texpr_expr(TStatus,Status),
3633		status_string(Status,String)},
3634		insertstr(String).
3635		status_string(ordinary,'').
3636		status_string(anticipated(_),'ANTICIPATED ').
3637		status_string(convergent(_),'CONVERGENT ').
3638
3639		insert_variant(TStatus) -->
3640		{get_texpr_expr(TStatus,Status)},
3641		insert_variant2(Status).
3642		insert_variant2(ordinary) --> !.
3643		insert_variant2(anticipated(Variant)) --> insert_variant3(Variant).
3644		insert_variant2(convergent(Variant)) --> insert_variant3(Variant).
3645		insert_variant3(Variant) -->
3646		indent('USING VARIANT '),pp_expr_indent(Variant).
3647
3648		pp_refines_l([],_) --> [].
3649		pp_refines_l([Ref|Rest],Id) -->
3650		pp_refines(Ref,Id),pp_refines_l(Rest,Id).
3651		pp_refines(Refined,_Id) -->
3652		% indent(Id), insertstr(' REFINES '),
3653		({is_extended_rlevent(Refined)} -> indent('EXTENDS') ; indent('REFINES ')),
3654		insert_subst(Refined).
3655
3656		is_extended_rlevent(b(rlevent(_Id,_Sect,_Status,_Paras,Guard,Theorems,Actions,_VWitn,_PWitn,_Unmod,_Refines),subst,_)) :-
3657		get_texpr_expr(Guard,truth), % bmachine_eventb:optimise_events has removed all guards
3658		Theorems=[], % and all theorems
3659		Actions = []. % ditto for actions: everything removed by optimise_events
3660
3661		pp_witness_l([]) --> [].
3662		pp_witness_l([Witness|WRest]) -->
3663		pp_witness(Witness),pp_witness_l(WRest).
3664		pp_witness(Expr) -->
3665		indention_level(I1,I2),
3666		{get_texpr_expr(Expr,witness(Id,Pred)),
3667		I2 is I1+2},
3668		indent, pp_expr_indent(Id), insertstr(': '),
3669		pp_expr_indent(Pred),
3670		pp_description_pragma_of(Pred),
3671		indention_level(_,I1).
3672
3673
3674		translate_whens([],_) --> !.
3675		translate_whens([When|Rest],T) -->
3676		{get_texpr_expr(When,select_when(P,S))},!,
3677		indent(T), pred_over_lines(2,'@grd',P),
3678		indent('THEN '),
3679		insert_subst(S),
3680		translate_whens(Rest,'WHEN ').
3681		translate_whens(L,_) -->
3682		{add_internal_error('Cannot translate WHEN: ',translate_whens(L,_,_,_))}.
3683
3684
3685
3686		create_assign(LHS,RHS,b(assign([LHS],[RHS]),subst,[])).
3687
3688		split_over_lines([],_) --> !.
3689		split_over_lines([S|Rest],Symbol) --> !,
3690		indention_level(I1,I2),{atom_codes(Symbol,X),length(X,N),I2 is I1+N+1},
3691		translate_subst_check(S),
3692		split_over_lines2(Rest,Symbol,I1,I2).
3693		split_over_lines(S,Symbol) --> {add_error(split_over_lines,'Illegal argument: ',Symbol:S)}.
3694
3695		split_over_lines2([],_,_,_) --> !.
3696		split_over_lines2([S|Rest],Symbol,I1,I2) -->
3697		indention_level(_,I1), indent(Symbol),
3698		indention_level(_,I2), translate_subst(S),
3699		split_over_lines2(Rest,Symbol,I1,I2).
3700
3701		% print a predicate over several lines, at most one conjunct per line
3702		% N is the increment that should be added to the indentation
3703		%pred_over_lines(N,Pred) --> pred_over_lines(N,'@pred',Pred).
3704		pred_over_lines(N,Lbl,Pred) -->
3705		{conjunction_to_list(Pred,List)},
3706		preds_over_lines(N,Lbl,List).
3707		section_pred_over_lines(N,Title,Pred) -->
3708		({get_eventb_default_label(Title,Lbl)} -> [] ; {Lbl='@pred'}),
3709		pred_over_lines(N,Lbl,Pred).
3710		get_eventb_default_label(properties,'@axm').
3711		get_eventb_default_label(assertions,'@thm').
3712
3713		% print a list of predicates over several lines, at most one conjunct per line
3714		preds_over_lines(N,Lbl,Preds) --> preds_over_lines(N,Lbl,'& ',Preds).
3715		% preds_over_lines(IndentationIncrease,EventBDefaultLabel,ClassicalBSeperator,ListOfPredicates)
3716		preds_over_lines(N,Lbl,Sep,Preds) -->
3717		indention_level(I1,I2),{I2 is I1+N},
3718		preds_over_lines1(Preds,Lbl,1,Sep),
3719		indention_level(_,I1).
3720		preds_over_lines1([],Lbl,Nr,Sep) --> !,
3721		preds_over_lines1([b(truth,pred,[])],Lbl,Nr,Sep).
3722		preds_over_lines1([H|T],Lbl,Nr,Sep) -->
3723		indent(' '), pp_label(Lbl,Nr),
3724		%({T==[]} -> pp_expr_indent(H) ; pp_expr_m_indent(H,40)),
3725		({T==[]} -> pp_pred_nested(H,conjunct,0) ; pp_pred_nested(H,conjunct,40)),
3726		pp_description_pragma_of(H),
3727		{N1 is Nr+1},
3728		preds_over_lines2(T,Lbl,N1,Sep).
3729		preds_over_lines2([],_,_,_Sep) --> !.
3730		preds_over_lines2([E|Rest],Lbl,Nr,Sep) -->
3731		({force_eventb_rodin_mode} -> indent(' '), pp_label(Lbl,Nr) ; indent(Sep)),
3732		pp_pred_nested(E,conjunct,40),
3733		pp_description_pragma_of(E),
3734		{N1 is Nr+1},
3735		preds_over_lines2(Rest,Lbl,N1,Sep).
3736
3737		% print event-b label for Rodin/Camille:
3738		pp_label(Lbl,Nr) -->
3739		({force_eventb_rodin_mode}
3740		-> {atom_codes(Lbl,C1), number_codes(Nr,NC), append(C1,NC,AC), atom_codes(A,AC)},
3741		pp_atom_indent(A), pp_atom_indent(' ')
3742		; []).
3743
3744		% a version of nested_print_bexpr / nbp that does not directly print to stream conjunct
3745		pp_pred_nested(TExpr,CurrentType,_) --> {TExpr = b(E,pred,_)},
3746		{get_binary_connective(E,NewType,Ascii,LHS,RHS), binary_infix(NewType,Ascii,Prio,left)},
3747		!,
3748		pp_rodin_label_indent(TExpr), % print any label
3749		inc_lvl(CurrentType,NewType),
3750		pp_pred_nested(LHS,NewType,Prio),
3751		{translate_in_mode(NewType,Ascii,Symbol)},
3752		indent(' '),pp_atom_indent(Symbol),
3753		indent(' '),
3754		{(is_associative(NewType) -> NewTypeR=NewType % no need for parentheses if same operator on right
3755		; NewTypeR=right(NewType))},
3756		pp_pred_nested(RHS,NewTypeR,Prio),
3757		dec_lvl(CurrentType,NewType).
3758		pp_pred_nested(TExpr,_,_) --> {is_nontrivial_negation(TExpr,NExpr,InnerType,Prio)},
3759		!,
3760		pp_rodin_label_indent(TExpr), % print any label
3761		{translate_in_mode(negation,'not',Symbol)},
3762		pp_atom_indent(Symbol),
3763		inc_lvl(other,negation), % always need parentheses for negation
3764		pp_pred_nested(NExpr,InnerType,Prio),
3765		dec_lvl(other,negation).
3766		pp_pred_nested(TExpr,_,_) --> {TExpr = b(exists(Ids,RHS),pred,_)},
3767		!,
3768		pp_rodin_label_indent(TExpr), % print any label
3769		{translate_in_mode(exists,'#',FSymbol)},
3770		%indent(' '),
3771		pp_atom_indent(FSymbol),
3772		pp_expr_ids_in_mode_indent(Ids),pp_atom_indent('.'),
3773		inc_lvl(other,conjunct), % always need parentheses here
3774		{add_normal_typing_predicates(Ids,RHS,RHST), Prio=40}, % Prio of conjunction
3775		pp_pred_nested(RHST,conjunct,Prio),
3776		dec_lvl(other,conjunct).
3777		pp_pred_nested(TExpr,_,_) --> {TExpr = b(forall(Ids,LHS,RHS),pred,_)},
3778		!,
3779		pp_rodin_label_indent(TExpr), % print any label
3780		{translate_in_mode(forall,'!',FSymbol)},
3781		%indent(' '),
3782		pp_atom_indent(FSymbol),
3783		pp_expr_ids_in_mode_indent(Ids),pp_atom_indent('.'),
3784		inc_lvl(other,implication), % always need parentheses here
3785		{add_normal_typing_predicates(Ids,LHS,LHST), Prio=30}, % Prio of implication
3786		pp_pred_nested(LHST,implication,Prio),
3787		{translate_in_mode(implication,'=>',Symbol)},
3788		indent(' '),pp_atom_indent(Symbol),
3789		indent(' '),
3790		pp_pred_nested(RHS,right(implication),Prio),
3791		dec_lvl(other,implication).
3792		pp_pred_nested(TExpr,_,_) -->
3793		{\+ eventb_translation_mode,
3794		TExpr = b(let_predicate(Ids,Exprs,Body),pred,_)
3795		}, %Ids=[_]}, % TODO: enable printing with more than one id; see below
3796		!,
3797		pp_let_nested(Ids,Exprs,Body).
3798		pp_pred_nested(b(BOP,pred,_),_CurrentType,CurMinPrio) -->
3799		{indent_binary_predicate(BOP,LHS,RHS,OpStr),
3800		get_texpr_id(LHS,_),can_indent_texpr(RHS)},!,
3801		pp_expr_m_indent(LHS,CurMinPrio),
3802		insertstr(OpStr),
3803		increase_indentation_level(2),
3804		indent(''),
3805		pp_expr_indent(RHS), % only supports %, {}, bool which do not need parentheses
3806		decrease_indentation_level(2).
3807		pp_pred_nested(Expr,_CurrentType,CurMinPrio) --> {can_indent_texpr(Expr)},!,
3808		pp_expr_m_indent(Expr,CurMinPrio).
3809		pp_pred_nested(Expr,_CurrentType,CurMinPrio) --> pp_expr_m_indent(Expr,CurMinPrio).
3810
3811		indent_binary_predicate(equal(LHS,RHS),LHS,RHS,' = ').
3812		indent_binary_predicate(member(LHS,RHS),LHS,RHS,' : ').
3813
3814		pp_let_nested(Ids,Exprs,Body) -->
3815		indent('LET '),
3816		pp_expr_indent_l(Ids),
3817		insertstr(' BE '),
3818		{maplist(create_equality,Ids,Exprs,Equalities)},
3819		preds_over_lines(2,'@let_eq',Equalities),
3820		indent(' IN '),
3821		increase_indentation_level(2),
3822		pp_pred_nested(Body,let_predicate,40),
3823		decrease_indentation_level(2),
3824		indent(' END').
3825		pp_let_expr_nested(Ids,Exprs,Body) -->
3826		insertstr('LET '),
3827		pp_expr_indent_l(Ids),
3828		insertstr(' BE '),
3829		{maplist(create_equality,Ids,Exprs,Equalities)},
3830		preds_over_lines(2,'@let_eq',Equalities),
3831		indent('IN '),
3832		increase_indentation_level(2),
3833		pp_expr_indent(Body),
3834		decrease_indentation_level(2),
3835		indent('END').
3836
3837		is_nontrivial_negation(b(negation(NExpr),pred,_),NExpr,NewType,Prio) :-
3838		get_texpr_expr(NExpr,E),
3839		(E=negation(_) -> NewType=other,Prio=0
3840		; get_binary_connective(E,NewType,Ascii,_,_),
3841		binary_infix(NewType,Ascii,Prio,_Assoc)).
3842
3843		pp_rodin_label_indent(b(_,_,Infos),(I,S),(I,T)) :- pp_rodin_label(Infos,S,T).
3844		% note: below we will print unnecessary parentheses in case of Atelier-B mode; but for readability it maye be better to add them
3845		inc_lvl(Old,New) --> {New=Old}, !,[].
3846		inc_lvl(_,_) --> pp_atom_indent('('), % not strictly necessary if higher_prio
3847		increase_indentation_level, indent(' ').
3848		dec_lvl(Old,New) --> {New=Old}, !,[].
3849		dec_lvl(_,_) --> decrease_indentation_level, indent(' '),pp_atom_indent(')').
3850
3851		is_associative(conjunct).
3852		is_associative(disjunct).
3853
3854		%higher_prio(conjunct,implication).
3855		%higher_prio(disjunct,implication).
3856		% priority of equivalence changes in Rodin vs Atelier-B, maybe better add parentheses
3857
3858		translate_ifs([]) --> !,
3859		indent('END').
3860		translate_ifs([Elsif]) -->
3861		{get_if_elsif(Elsif,P,S),
3862		optional_type(P,truth)},!,
3863		indent('ELSE'), insert_subst(S), indent('END').
3864		translate_ifs([Elsif|Rest]) -->
3865		{get_if_elsif(Elsif,P,S)},!,
3866		indent('ELSIF '), pp_expr_indent(P), insertstr(' THEN'),
3867		insert_subst(S),
3868		translate_ifs(Rest).
3869		translate_ifs(ElseList) -->
3870		{functor(ElseList,F,A),add_error(translate_ifs,'Could not translate IF-THEN-ELSE: ',F/A-ElseList),fail}.
3871
3872		get_if_elsif(Elsif,P,S) :-
3873		(optional_type(Elsif,if_elsif(P,S)) -> true
3874		; add_internal_error('Is not an if_elsif:',get_if_elsif(Elsif,P,S)), fail).
3875
3876		insert_subst(S) -->
3877		indention_level(I,I2),{I2 is I+2},
3878		translate_subst_check(S),
3879		indention_level(_,I).
3880
3881		translate_subst_check(S) --> translate_subst(S),!.
3882		translate_subst_check(S) -->
3883		{b_functor(S,F,A),add_error(translate_subst,'Could not translate substitution: ',F/A-S),fail}.
3884
3885		b_functor(b(E,_,_),F,A) :- !,functor(E,F,A).
3886		b_functor(E,F,A) :- functor(E,F,A).
3887
3888		pp_description_pragma_of(enumerated_set_def(_,_)) --> !, "".
3889		pp_description_pragma_of(Expr) -->
3890		({get_texpr_description(Expr,Desc)}
3891		-> insert_atom(' /*@desc '), insert_atom(Desc), insert_atom(' */')
3892		; {true}).
3893		indent_expr(Expr) -->
3894		indent, pp_expr_indent(Expr),
3895		pp_description_pragma_of(Expr).
3896		%indent_expr_l([]) --> !.
3897		%indent_expr_l([Expr|Rest]) -->
3898		% indent_expr(Expr), indent_expr_l(Rest).
3899		indent_expr_l_sep([],_) --> !.
3900		indent_expr_l_sep([Expr|Rest],Sep) -->
3901		indent_expr(Expr),
3902		{(Rest=[] -> RealSep='' ; RealSep=Sep)},
3903		insert_atom(RealSep), % the threaded argument is a pair, not directly a string !
3904		indent_expr_l_sep(Rest,Sep).
3905		%indention_level(L) --> indention_level(L,L).
3906		increase_indentation_level --> indention_level(L,New), {New is L+1}.
3907		increase_indentation_level(N) --> indention_level(L,New), {New is L+N}.
3908		decrease_indentation_level --> indention_level(L,New), {New is L-1}.
3909		decrease_indentation_level(N) --> indention_level(L,New), {New is L-N}.
3910		indention_level(Old,New,(Old,S),(New,S)).
3911		indention_codes(Old,New,(Indent,Old),(Indent,New)).
3912		indent --> indent('').
3913		indent(M,(I,S),(I,T)) :- indent2(I,M,S,T).
3914		indent2(Level,Msg) -->
3915		"\n",do_indention(Level),ppatom(Msg).
3916
3917		insert_atom(Sep,(I,S),(I,T)) :- ppatom(Sep,S,T).
3918
3919		insertstr(M,(I,S),(I,T)) :- ppterm(M,S,T).
3920		insertcodes(M,(I,S),(I,T)) :- ppcodes(M,S,T).
3921
3922		do_indention(0,T,R) :- !, R=T.
3923		do_indention(N,[32|I],O) :-
3924		N>0,N2 is N-1, do_indention(N2,I,O).
3925
3926		optional_type(Typed,Expr) :- get_texpr_expr(Typed,E),!,Expr=E.
3927		optional_type(Expr,Expr).
3928
3929		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3930		% expressions and predicates
3931
3932		% pretty-type an expression in an indent-environment
3933		% currently, the indent level is just thrown away
3934		% TODO: pp_expr_indent dom( comprehension_set ) / union ( ...)
3935		pp_expr_indent(b(comprehension_set(Ids,Body),_,_)) -->
3936		{\+ eventb_translation_mode, % TODO: also print in Event-B mode:
3937		detect_lambda_comprehension(Ids,Body, FrontIDs,LambdaBody,ToExpr)},
3938		{add_normal_typing_predicates(FrontIDs,LambdaBody,TLambdaBody)},
3939		!,
3940		insertstr('%('), % to do: use lambda_symbol and improve layout below
3941		pp_expr_indent_l(FrontIDs),
3942		insertstr(') . ('),
3943		pred_over_lines(2,'@body',TLambdaBody),
3944		indent(' | '), increase_indentation_level(2),
3945		indent(''), pp_expr_indent(ToExpr), decrease_indentation_level(2),
3946		indent(')').
3947		pp_expr_indent(b(comprehension_set(Ids,Body),_,Info),(I,S),(I,T)) :-
3948		pp_comprehension_set5(Ids,Body,Info,_,special(_Kind),S,T),
3949		% throw away indent and check if a special pp rule is applicable
3950		!.
3951		pp_expr_indent(b(comprehension_set(Ids,Body),_,_)) -->
3952		!,
3953		insertstr('{'), pp_expr_indent_l(Ids),
3954		insertstr(' | '),
3955		pred_over_lines(2,'@body',Body),
3956		indent('}').
3957		pp_expr_indent(b(convert_bool(Body),_,_)) -->
3958		!,
3959		insertstr('bool('),
3960		pred_over_lines(2,'@bool',Body),
3961		indent(')').
3962		pp_expr_indent(b(if_then_else(Test,Then,Else),_,_)) -->
3963		!,
3964		insertstr('IF'),
3965		pred_over_lines(2,'@test',Test),
3966		indent('THEN'),increase_indentation_level(2),
3967		indent(''),pp_expr_indent(Then),decrease_indentation_level(2),
3968		indent('ELSE'),increase_indentation_level(2),
3969		indent(''),pp_expr_indent(Else),decrease_indentation_level(2),
3970		indent('END').
3971		pp_expr_indent(b(let_expression(Ids,Exprs,Body),_,_)) -->
3972		!,
3973		pp_let_expr_nested(Ids,Exprs,Body).
3974		% TODO: support a few more like dom/ran(comprehension_set) SIGMA, PI, \/ (union), ...
3975		pp_expr_indent(Expr,(I,S),(I,T)) :-
3976		%get_texpr_expr(Expr,F), functor(F,FF,NN), format(user_output,'Cannot indent: ~w/~w~n',[FF,NN]),
3977		pp_expr(Expr,_,_LimitReached,S,T). % throw away indent
3978
3979		can_indent_texpr(b(E,_,_)) :- can_indent_expr(E).
3980		can_indent_expr(comprehension_set(_,_)).
3981		can_indent_expr(convert_bool(_)).
3982		can_indent_expr(if_then_else(_,_,_)).
3983		can_indent_expr(let_expression(_,_,_)).
3984
3985		pp_expr_indent_l([E]) --> !, pp_expr_indent(E).
3986		pp_expr_indent_l(Exprs,(I,S),(I,T)) :-
3987		pp_expr_l(Exprs,_LR,S,T). % throw away indent
3988		pp_expr_m_indent(Expr,MinPrio,(I,S),(I,T)) :-
3989		pp_expr_m(Expr,MinPrio,_LimitReached,S,T).
3990		pp_atom_indent(A,(I,S),(I,T)) :- ppatom(A,S,T).
3991		pp_expr_ids_in_mode_indent(Ids,(I,S),(I,T)) :- pp_expr_ids_in_mode(Ids,_,S,T).
3992
3993
3994
3995
3996		is_boolean_value(b(B,boolean,_),BV) :- boolean_aux(B,BV).
3997		boolean_aux(boolean_true,pred_true).
3998		boolean_aux(boolean_false,pred_false).
3999		boolean_aux(value(V),BV) :- nonvar(V),!,BV=V.
4000
4001
4002		constants_in_mode(F,S) :-
4003		constants(F,S1), translate_in_mode(F,S1,S).
4004
4005		constants(pred_true,'TRUE').
4006		constants(pred_false,'FALSE').
4007		constants(boolean_true,'TRUE').
4008		constants(boolean_false,'FALSE').
4009		constants(max_int,'MAXINT').
4010		constants(min_int,'MININT').
4011		constants(empty_set,'{}').
4012		constants(bool_set,'BOOL').
4013		constants(float_set,'FLOAT').
4014		constants(real_set,'REAL').
4015		constants(string_set,'STRING').
4016		constants(empty_sequence,'[]').
4017		constants(event_b_identity,'id').
4018
4019		constants(truth,Res) :- eventb_translation_mode,!,Res=true.
4020		constants(truth,Res) :- animation_minor_mode(tla),!,Res='TRUE'.
4021		constants(truth,Res) :- atelierb_mode(_),!,Res='(TRUE:BOOL)'. % __truth; we could also do TRUE=TRUE
4022		constants(truth,'btrue').
4023		constants(falsity,Res) :- eventb_translation_mode,!,Res=false.
4024		constants(falsity,Res) :- animation_minor_mode(tla),!,Res='FALSE'.
4025		constants(falsity,Res) :- atelierb_mode(_),!,Res='(TRUE=FALSE)'.
4026		constants(falsity,'bfalse'). % __falsity
4027		constants(unknown_truth_value(Msg),Res) :- % special internal constant
4028		ajoin(['?(',Msg,')'],Res).
4029
4030		function_like_in_mode(F,S) :-
4031		function_like(F,S1),
4032		translate_in_mode(F,S1,S).
4033
4034		function_like(convert_bool,bool).
4035		function_like(convert_real,real). % cannot be used on its own: dom(real) is not accepted by Atelier-B
4036		function_like(convert_int_floor,floor). % ditto
4037		function_like(convert_int_ceiling,ceiling). % ditto
4038		function_like(successor,succ). % can also be used on its own; e.g., dom(succ)=INTEGER is ok
4039		function_like(predecessor,pred). % ditto
4040		function_like(max,max).
4041		function_like(max_real,max).
4042		function_like(min,min).
4043		function_like(min_real,min).
4044		function_like(card,card).
4045		function_like(pow_subset,'POW').
4046		function_like(pow1_subset,'POW1').
4047		function_like(fin_subset,'FIN').
4048		function_like(fin1_subset,'FIN1').
4049		function_like(identity,id).
4050		function_like(first_projection,prj1).
4051		function_like(first_of_pair,'prj1'). % used to be __first_of_pair, will be dealt with separately to generate parsable representation
4052		function_like(second_projection,prj2).
4053		function_like(second_of_pair,'prj2'). % used to be __second_of_pair, will be dealt with separately to generate parsable representation
4054		function_like(iteration,iterate).
4055		function_like(event_b_first_projection_v2,prj1).
4056		function_like(event_b_second_projection_v2,prj2).
4057		function_like(reflexive_closure,closure).
4058		function_like(closure,closure1).
4059		function_like(domain,dom).
4060		function_like(range,ran).
4061		function_like(seq,seq).
4062		function_like(seq1,seq1).
4063		function_like(iseq,iseq).
4064		function_like(iseq1,iseq1).
4065		function_like(perm,perm).
4066		function_like(size,size).
4067		function_like(first,first).
4068		function_like(last,last).
4069		function_like(front,front).
4070		function_like(tail,tail).
4071		function_like(rev,rev).
4072		function_like(general_concat,conc).
4073		function_like(general_union,union).
4074		function_like(general_intersection,inter).
4075		function_like(trans_function,fnc).
4076		function_like(trans_relation,rel).
4077		function_like(tree,tree).
4078		function_like(btree,btree).
4079		function_like(const,const).
4080		function_like(top,top).
4081		function_like(sons,sons).
4082		function_like(prefix,prefix).
4083		function_like(postfix,postfix).
4084		function_like(sizet,sizet).
4085		function_like(mirror,mirror).
4086		function_like(rank,rank).
4087		function_like(father,father).
4088		function_like(son,son).
4089		function_like(subtree,subtree).
4090		function_like(arity,arity).
4091		function_like(bin,bin).
4092		function_like(left,left).
4093		function_like(right,right).
4094		function_like(infix,infix).
4095
4096		function_like(rec,rec).
4097		function_like(struct,struct).
4098
4099		function_like(negation,not).
4100		function_like(bag_items,items).
4101
4102		function_like(finite,finite). % from Event-B, TO DO: if \+ eventb_translation_mode then print as S:FIN(S)
4103		function_like(witness,'@witness'). % from Event-B
4104
4105		function_like(floored_div,'FDIV') :- \+ animation_minor_mode(tla). % using external function
4106
4107		unary_prefix(unary_minus,'\x2212\',210) :- unicode_mode, eventb_translation_mode, !.
4108		unary_prefix(unary_minus,-,210).
4109		unary_prefix(unary_minus_real,-,210).
4110		unary_prefix(mu,'MU',210) :- animation_minor_mode(z).
4111
4112		unary_prefix_parentheses(compaction,'compaction').
4113		unary_prefix_parentheses(bag_items,'bag_items').
4114		unary_prefix_parentheses(mu,'MU') :-
4115		\+ animation_minor_mode(z). % write with () for external function
4116
4117		unary_postfix(reverse,'~',230). % relational inverse
4118		%unary_postfix(mu,'?',250). % TODO: comment in once new parser release made
4119
4120
4121		always_surround_by_parentheses(parallel_product).
4122		always_surround_by_parentheses(composition).
4123
4124		binary_infix_symbol(b(T,_,_),Symbol) :- functor(T,F,2), binary_infix_in_mode(F,Symbol,_,_).
4125
4126		% EXPR * EXPR --> EXPR
4127		binary_infix(composition,';',20,left).
4128		binary_infix(overwrite,'<+',160,left).
4129		binary_infix(direct_product,'><',160,left). % Rodin requires parentheses
4130		binary_infix(parallel_product,'||',20,left).
4131		binary_infix(concat,'^',160,left).
4132		binary_infix(relations,'<->',125,left).
4133		binary_infix(partial_function,'+->',125,left).
4134		binary_infix(total_function,'-->',125,left).
4135		binary_infix(partial_injection,'>+>',125,left).
4136		binary_infix(total_injection,'>->',125,left).
4137		binary_infix(partial_surjection,'+->>',125,left).
4138		binary_infix(total_surjection,Symbol,125,left) :-
4139		(eventb_translation_mode -> Symbol = '->>'; Symbol = '-->>').
4140		binary_infix(total_bijection,'>->>',125,left).
4141		binary_infix(partial_bijection,'>+>>',125,left).
4142		binary_infix(total_relation,'<<->',125,left). % only in Event-B
4143		binary_infix(surjection_relation,'<->>',125,left). % only in Event-B
4144		binary_infix(total_surjection_relation,'<<->>',125,left). % only in Event-B
4145		binary_infix(insert_front,'->',160,left).
4146		binary_infix(insert_tail,'<-',160,left).
4147		binary_infix(domain_restriction,'<|',160,left).
4148		binary_infix(domain_subtraction,'<<|',160,left).
4149		binary_infix(range_restriction,'|>',160,left).
4150		binary_infix(range_subtraction,'|>>',160,left).
4151		binary_infix(intersection,'/\\',160,left).
4152		binary_infix(union,'\\/',160,left).
4153		binary_infix(restrict_front,'/|\\',160,left).
4154		binary_infix(restrict_tail,'\\|/',160,left).
4155		binary_infix(couple,'|->',160,left).
4156		binary_infix(interval,'..',170,left).
4157		binary_infix(add,+,180,left).
4158		binary_infix(add_real,+,180,left).
4159		binary_infix(minus,-,180,left).
4160		binary_infix(minus_real,-,180,left).
4161		binary_infix(set_subtraction,'\\',180,left) :- eventb_translation_mode,!. % symbol is not allowed by Atelier-B
4162		binary_infix(set_subtraction,-,180,left).
4163		binary_infix(minus_or_set_subtract,-,180,left).
4164		binary_infix(multiplication,*,190,left).
4165		binary_infix(multiplication_real,*,190,left).
4166		binary_infix(cartesian_product,**,190,left) :- eventb_translation_mode,!.
4167		binary_infix(cartesian_product,*,190,left).
4168		binary_infix(mult_or_cart,*,190,left). % in case type checker not yet run
4169		binary_infix(div,/,190,left).
4170		binary_infix(div_real,/,190,left).
4171		binary_infix(floored_div,div,190,left) :- animation_minor_mode(tla).
4172		binary_infix(modulo,mod,190,left).
4173		binary_infix(power_of,**,200,right).
4174		binary_infix(power_of_real,**,200,right).
4175		binary_infix(typeof,oftype,120,right). % Event-B oftype operator; usually removed by btypechecker, technically has no associativity in our parser, but right associativity matches better
4176
4177		binary_infix(ring,'\x2218\',160,left). % our B Parser gives ring same priority as direct_product or overwrite
4178
4179		% PRED * PRED --> PRED
4180		binary_infix(implication,'=>',30,left).
4181		binary_infix(conjunct,'&',40,left).
4182		binary_infix(disjunct,or,40,left).
4183		binary_infix(equivalence,'<=>',Prio,left) :- % in Rodin this has the same priority as implication
4184		(eventb_translation_mode -> Prio=30 ; Prio=60).
4185
4186
4187		% EXPR * EXPR --> PRED
4188		binary_infix(equal,=,60,left).
4189		binary_infix(not_equal,'/=',160,left).
4190		binary_infix(less_equal,'<=',160,left).
4191		binary_infix(less,'<',160,left).
4192		binary_infix(less_equal_real,'<=',160,left).
4193		binary_infix(less_real,'<',160,left).
4194		binary_infix(greater_equal,'>=',160,left).
4195		binary_infix(greater,'>',160,left).
4196		binary_infix(member,':',60,left).
4197		binary_infix(not_member,'/:',160,left).
4198		binary_infix(subset,'<:',110,left).
4199		binary_infix(subset_strict,'<<:',110,left).
4200		binary_infix(not_subset,'/<:',110,left).
4201		binary_infix(not_subset_strict,'/<<:',110,left).
4202
4203		binary_infix(values_entry,'=',60,left).
4204
4205		% atelierb_mode(prover(_)): translation for AtelierB's PP/ML prover
4206		% atelierb_mode(native): translation to native B supported by AtelierB
4207		:- dynamic latex_mode/0, unicode_mode/0, atelierb_mode/1, force_eventb_rodin_mode/0.
4208
4209		%latex_mode.
4210		%unicode_mode.
4211		%force_eventb_rodin_mode. % Force Event-B output even if not in eventb minor mode
4212
4213		eventb_translation_mode :- animation_minor_mode(eventb),!.
4214		eventb_translation_mode :- animation_minor_mode(sequent_prover),!.
4215		eventb_translation_mode :- force_eventb_rodin_mode.
4216
4217		set_force_eventb_mode :- assertz(force_eventb_rodin_mode).
4218		unset_force_eventb_mode :-
4219		(retract(force_eventb_rodin_mode) -> true ; add_internal_error('Was not in forced Event-B mode: ',force_eventb_rodin_mode)).
4220
4221		set_unicode_mode :- assertz(unicode_mode).
4222		set_latex_mode :- assertz(latex_mode).
4223		unset_unicode_mode :-
4224		(retract(unicode_mode) -> true ; add_internal_error('Was not in Unicode mode: ',unset_unicode_mode)).
4225		unset_latex_mode :-
4226		(retract(latex_mode) -> true
4227		; add_internal_error('Was not in Latex mode: ',unset_latex_mode)).
4228
4229		set_atelierb_mode(Mode) :- asserta(atelierb_mode(Mode)).
4230		unset_atelierb_mode :-
4231		(retract(atelierb_mode(_)) -> true ; add_internal_error('Was not in Atelier-B mode: ',unset_atelierb_mode)).
4232
4233		get_translation_mode(M) :- unicode_mode, !, M=unicode.
4234		get_translation_mode(M) :- latex_mode, !, M=latex.
4235		get_translation_mode(M) :- atelierb_mode(native), !, M=atelierb.
4236		get_translation_mode(M) :- atelierb_mode(prover(pp)), !, M=atelierb_pp.
4237		get_translation_mode(M) :- atelierb_mode(prover(ml)), !, M=atelierb_ml.
4238		get_translation_mode(ascii).
4239
4240		% TO DO: provide better stack-based setting/unsetting of modes or use options parameter
4241		set_translation_mode(ascii) :- !, retractall(unicode_mode), retractall(latex_mode), retractall(atelierb_mode(_)).
4242		set_translation_mode(unicode) :- !, set_unicode_mode.
4243		set_translation_mode(latex) :- !, set_latex_mode.
4244		set_translation_mode(atelierb) :- !, set_atelierb_mode(native).
4245		set_translation_mode(atelierb_pp) :- !, set_atelierb_mode(prover(pp)). % translation for PP/ML prover
4246		set_translation_mode(atelierb_ml) :- !, set_atelierb_mode(prover(ml)).
4247		set_translation_mode(Mode) :- add_internal_error('Illegal mode:',set_translation_mode(Mode)).
4248
4249		unset_translation_mode(ascii) :- !.
4250		unset_translation_mode(unicode) :- !,unset_unicode_mode.
4251		unset_translation_mode(latex) :- !,unset_latex_mode.
4252		unset_translation_mode(atelierb) :- !,unset_atelierb_mode.
4253		unset_translation_mode(atelierb_pp) :- !,unset_atelierb_mode.
4254		unset_translation_mode(atelierb_ml) :- !,unset_atelierb_mode.
4255		unset_translation_mode(Mode) :- add_internal_error('Illegal mode:',unset_translation_mode(Mode)).
4256
4257		with_translation_mode(Mode, Call) :-
4258		get_translation_mode(OldMode),
4259		(OldMode == Mode -> Call ;
4260		set_translation_mode(ascii), % Clear all existing translation mode settings first
4261		set_translation_mode(Mode),
4262		call_cleanup(Call, set_translation_mode(OldMode))
4263		% FIXME This might not restore all translation modes fully!
4264		% For example, if both unicode_mode and latex_mode are set,
4265		% then with_translation_mode(ascii, ...) will only restore unicode_mode.
4266		% Not sure if this might cause problems for some code.
4267		).
4268
4269		% The language mode is currently linked to the animation minor mode,
4270		% so be careful when changing it!
4271		% TODO Allow overriding the language for translate without affecting the animation mode
4272
4273		get_language_mode(csp_and(Lang)) :-
4274		csp_with_bz_mode,
4275		!,
4276		(animation_minor_mode(Lang) -> true ; Lang = b).
4277		get_language_mode(Lang) :- animation_minor_mode(Lang), !.
4278		get_language_mode(Lang) :- animation_mode(Lang).
4279
4280		set_language_mode(csp_and(Lang)) :-
4281		!,
4282		set_animation_mode(csp_and_b),
4283		(Lang == b -> true ; set_animation_minor_mode(Lang)).
4284		set_language_mode(csp) :- !, set_animation_mode(csp).
4285		set_language_mode(xtl) :- !, set_animation_mode(xtl).
4286		set_language_mode(sequent_prover) :- !, set_animation_mode(xtl), set_animation_minor_mode(sequent_prover).
4287		set_language_mode(b) :- !, set_animation_mode(b).
4288		set_language_mode(Lang) :-
4289		set_animation_mode(b),
4290		set_animation_minor_mode(Lang).
4291
4292		with_language_mode(Lang, Call) :-
4293		get_language_mode(OldLang),
4294		(OldLang == Lang -> Call ;
4295		set_language_mode(Lang),
4296		call_cleanup(Call, set_language_mode(OldLang))
4297		% FIXME This might not restore all animation modes fully!
4298		% It's apparently possible to have multiple animation minor modes,
4299		% which get/set_language_mode doesn't handle.
4300		% (Are multiple animation minor modes actually used anywhere?)
4301		).
4302
4303		exists_symbol --> {latex_mode},!, "\\exists ".
4304		exists_symbol --> {unicode_mode},!, pp_colour_code(magenta),[8707],pp_colour_code(reset).
4305		exists_symbol --> pp_colour_code(blue),"#",pp_colour_code(reset).
4306		forall_symbol --> {latex_mode},!, "\\forall ".
4307		forall_symbol --> {unicode_mode},!, pp_colour_code(magenta),[8704],pp_colour_code(reset).
4308		forall_symbol --> pp_colour_code(blue),"!",pp_colour_code(reset).
4309		dot_symbol --> {latex_mode},!, "\\cdot ".
4310		dot_symbol --> {unicode_mode},!, [183]. %"·". % dot also used in Rodin
4311		dot_symbol --> ".".
4312		dot_bullet_symbol --> {latex_mode},!, "\\cdot ".
4313		dot_bullet_symbol --> [183]. %"·". % dot also used in Rodin
4314		set_brackets(X,Y) :- latex_mode,!,X='\\{', Y='\\}'.
4315		set_brackets('{','}').
4316		left_set_bracket --> {latex_mode},!, "\\{ ".
4317		left_set_bracket --> "{".
4318		right_set_bracket --> {latex_mode},!, "\\} ".
4319		right_set_bracket --> "}".
4320		maplet_symbol --> {latex_mode},!, "\\mapsto ".
4321		maplet_symbol --> {unicode_mode},!, [8614].
4322		maplet_symbol --> "|->". % also provide option to use colours? pp_colour_code(blue) ,...
4323
4324		lambda_symbol --> {unicode_mode},!, [955]. % '\x3BB\'
4325		lambda_symbol --> {latex_mode},!, "\\lambda ".
4326		lambda_symbol --> pp_colour_code(blue),"%",pp_colour_code(reset).
4327
4328		and_symbol --> {unicode_mode},!, [8743]. % ''\x2227\''
4329		and_symbol --> {latex_mode},!, "\\wedge ".
4330		and_symbol --> "&".
4331
4332		hash_card_symbol --> {latex_mode},!, "\\# ".
4333		hash_card_symbol --> "#".
4334		ldots --> {latex_mode},!, "\\ldots ".
4335		ldots --> "...".
4336
4337		empty_set_symbol --> {get_preference(translate_print_all_sequences,true)},!, pp_empty_sequence.
4338		empty_set_symbol --> {unicode_mode},!, [8709].
4339		empty_set_symbol --> {latex_mode},!, "\\emptyset ".
4340		empty_set_symbol --> "{}".
4341
4342		underscore_symbol --> {latex_mode},!, "\\_".
4343		underscore_symbol --> "_".
4344
4345		string_start_symbol --> {latex_mode},!, "\\textnormal{``".
4346		string_start_symbol --> pp_colour_code(blue), """".
4347		string_end_symbol --> {latex_mode},!, "''}".
4348		string_end_symbol --> pp_colour_code(reset), """".
4349
4350
4351		unary_postfix_in_mode(Op,Trans2,Prio) :-
4352		unary_postfix(Op,Trans,Prio), % write(op(Op,Trans)),nl,
4353		translate_in_mode(Op,Trans,Trans2).
4354
4355		binary_infix_in_mode(Op,Trans2,Prio,Assoc) :-
4356		binary_infix(Op,Trans,Prio,Assoc), % write(op(Op,Trans)),nl,
4357		translate_in_mode(Op,Trans,Trans2).
4358
4359		latex_integer_set_translation('NATURAL', '\\mathbb N '). % \nat in bsymb.sty
4360		latex_integer_set_translation('NATURAL1', '\\mathbb N_1 '). % \natn
4361		latex_integer_set_translation('INTEGER', '\\mathbb Z '). % \intg
4362		latex_integer_set_translation('REAL', '\\mathbb R '). % \intg
4363
4364		latex_translation(empty_set, '\\emptyset ').
4365		latex_translation(implication, '\\mathbin\\Rightarrow ').
4366		latex_translation(conjunct,'\\wedge ').
4367		latex_translation(disjunct,'\\vee ').
4368		latex_translation(equivalence,'\\mathbin\\Leftrightarrow ').
4369		latex_translation(negation,'\\neg ').
4370		latex_translation(not_equal,'\\neq ').
4371		latex_translation(less_equal,'\\leq ').
4372		latex_translation(less_equal_real,'\\leq ').
4373		latex_translation(greater_equal,'\\geq ').
4374		latex_translation(member,'\\in ').
4375		latex_translation(not_member,'\\not\\in ').
4376		latex_translation(subset,'\\subseteq ').
4377		latex_translation(subset_strict,'\\subset ').
4378		latex_translation(not_subset,'\\not\\subseteq ').
4379		latex_translation(not_subset_strict,'\\not\\subset ').
4380		latex_translation(union,'\\cup ').
4381		latex_translation(intersection,'\\cap ').
4382		latex_translation(couple,'\\mapsto ').
4383		latex_translation(cartesian_product,'\\times').
4384		latex_translation(rec,'\\mathit{rec}').
4385		latex_translation(struct,'\\mathit{struct}').
4386		latex_translation(convert_bool,'\\mathit{bool}').
4387		latex_translation(max,'\\mathit{max}').
4388		latex_translation(max_real,'\\mathit{max}').
4389		latex_translation(min,'\\mathit{min}').
4390		latex_translation(min_real,'\\mathit{min}').
4391		latex_translation(modulo,'\\mod ').
4392		latex_translation(card,'\\mathit{card}').
4393		latex_translation(successor,'\\mathit{succ}').
4394		latex_translation(predecessor,'\\mathit{pred}').
4395		latex_translation(domain,'\\mathit{dom}').
4396		latex_translation(range,'\\mathit{ran}').
4397		latex_translation(size,'\\mathit{size}').
4398		latex_translation(first,'\\mathit{first}').
4399		latex_translation(last,'\\mathit{last}').
4400		latex_translation(front,'\\mathit{front}').
4401		latex_translation(tail,'\\mathit{tail}').
4402		latex_translation(rev,'\\mathit{rev}').
4403		latex_translation(seq,'\\mathit{seq}').
4404		latex_translation(seq1,'\\mathit{seq}_{1}').
4405		latex_translation(perm,'\\mathit{perm}').
4406		latex_translation(fin_subset,'\\mathit{FIN}').
4407		latex_translation(fin1_subset,'\\mathit{FIN}_{1}').
4408		latex_translation(first_projection,'\\mathit{prj}_{1}').
4409		latex_translation(second_projection,'\\mathit{prj}_{2}').
4410		latex_translation(pow_subset,'\\mathbb P\\hbox{}'). % POW \pow would require bsymb.sty
4411		latex_translation(pow1_subset,'\\mathbb P_1'). % POW1 \pown would require bsymb.sty
4412		latex_translation(concat,'\\stackrel{\\frown}{~}'). % was '\\hat{~}').
4413		latex_translation(relations,'\\mathbin\\leftrightarrow'). % <->, \rel requires bsymb.sty
4414		latex_translation(total_relation,'\\mathbin{\\leftarrow\\mkern-14mu\\leftrightarrow}'). % <<-> \trel requires bsymb.sty
4415		latex_translation(total_surjection_relation,'\\mathbin{\\leftrightarrow\\mkern-14mu\\leftrightarrow}'). % <<->> \strel requires bsymb.sty
4416		latex_translation(surjection_relation,'\\mathbin{\\leftrightarrow\\mkern-14mu\\rightarrow}'). % <->> \srel requires bsymb.sty
4417		latex_translation(partial_function,'\\mathbin{\\mkern6mu\\mapstochar\\mkern-6mu\\rightarrow}'). % +-> \pfun requires bsymb.sty, but \mapstochar is not supported by Mathjax
4418		latex_translation(partial_injection,'\\mathbin{\\mkern9mu\\mapstochar\\mkern-9mu\\rightarrowtail}'). % >+> \pinj requires bsymb.sty
4419		latex_translation(partial_surjection,'\\mathbin{\\mkern6mu\\mapstochar\\mkern-6mu\\twoheadrightarrow}'). % >+> \psur requires bsymb.sty
4420		latex_translation(total_function,'\\mathbin\\rightarrow'). % --> \tfun would require bsymb.sty
4421		latex_translation(total_surjection,'\\mathbin\\twoheadrightarrow'). % -->> \tsur requires bsymb.sty
4422		latex_translation(total_injection,'\\mathbin\\rightarrowtail'). % >-> \tinj requires bsymb.sty
4423		latex_translation(total_bijection,'\\mathbin{\\rightarrowtail\\mkern-18mu\\twoheadrightarrow}'). % >->> \tbij requires bsymb.sty
4424		latex_translation(domain_restriction,'\\mathbin\\lhd'). % <| domres requires bsymb.sty
4425		latex_translation(range_restriction,'\\mathbin\\rhd'). % |> ranres requires bsymb.sty
4426		latex_translation(domain_subtraction,'\\mathbin{\\lhd\\mkern-14mu-}'). % <<| domsub requires bsymb.sty
4427		latex_translation(range_subtraction,'\\mathbin{\\rhd\\mkern-14mu-}'). % |>> ransub requires bsymb.sty
4428		latex_translation(overwrite,'\\mathbin{\\lhd\\mkern-9mu-}'). % <+ \ovl requires bsymb.sty
4429		latex_translation(ring,'\\circ '). % not tested
4430		latex_translation(general_sum,'\\Sigma ').
4431		latex_translation(general_product,'\\Pi ').
4432		latex_translation(lambda,'\\lambda ').
4433		latex_translation(quantified_union,'\\bigcup\\nolimits'). % \Union requires bsymb.sty
4434		latex_translation(quantified_intersection,'\\bigcap\\nolimits'). % \Inter requires bsymb.sty
4435		%latex_translation(truth,'\\top').
4436		%latex_translation(falsity,'\\bot').
4437		latex_translation(truth,'{\\color{olive} \\top}'). % requires \usepackage{xcolor} in Latex
4438		latex_translation(falsity,'{\\color{red} \\bot}').
4439		latex_translation(boolean_true,'{\\color{olive} \\mathit{TRUE}}').
4440		latex_translation(boolean_false,'{\\color{red} \\mathit{FALSE}}').
4441		latex_translation(pred_true,'{\\color{olive} \\mathit{TRUE}}').
4442		latex_translation(pred_false,'{\\color{red} \\mathit{FALSE}}').
4443		latex_translation(reverse,'^{-1}').
4444
4445		ascii_to_unicode(Ascii,Unicode) :-
4446		translate_prolog_constructor(BAst,Ascii), % will not backtrack
4447		unicode_translation(BAst,Unicode).
4448
4449
4450		% can be used to translate Latex shortcuts to B Unicode operators for editors
4451		latex_to_unicode(LatexShortcut,Unicode) :-
4452		latex_to_b_ast(LatexShortcut,BAst),
4453		unicode_translation(BAst,Unicode).
4454		latex_to_unicode(LatexShortcut,Unicode) :- % allow to use B AST names as well
4455		unicode_translation(LatexShortcut,Unicode).
4456		latex_to_unicode(LatexShortcut,Unicode) :-
4457		greek_symbol(LatexShortcut,Unicode).
4458
4459		get_latex_keywords(List) :-
4460		findall(Id,latex_to_unicode(Id,_),Ids),
4461		sort(Ids,List).
4462
4463		get_latex_keywords_with_backslash(BList) :-
4464		get_latex_keywords(List),
4465		maplist(atom_concat('\\'),List,BList).
4466
4467		latex_to_b_ast(and,conjunct).
4468		latex_to_b_ast(bcomp,ring). % bsymb: backwards composition
4469		latex_to_b_ast(bigcap,quantified_intersection).
4470		latex_to_b_ast(bigcup,quantified_union).
4471		latex_to_b_ast(cap,intersection).
4472		latex_to_b_ast(cart,cartesian_product).
4473		latex_to_b_ast(cprod,cartesian_product).
4474		latex_to_b_ast(cdot,dot_symbol).
4475		latex_to_b_ast(cup,union).
4476		latex_to_b_ast(dprod,direct_product).
4477		latex_to_b_ast(dres,domain_restriction).
4478		latex_to_b_ast(dsub,domain_subtraction).
4479		latex_to_b_ast(emptyset,empty_set).
4480		latex_to_b_ast(exp,power_of).
4481		%latex_to_b_ast(fcomp,composition). % bsymb: forwards composition
4482		latex_to_b_ast(geq,greater_equal).
4483		latex_to_b_ast(implies,implication).
4484		latex_to_b_ast(in,member).
4485		latex_to_b_ast(int,'INTEGER').
4486		latex_to_b_ast(intg,'INTEGER'). % from bsymb
4487		latex_to_b_ast(lambda,lambda).
4488		latex_to_b_ast(land,conjunct).
4489		latex_to_b_ast(leq,less_equal).
4490		latex_to_b_ast(leqv,equivalence).
4491		latex_to_b_ast(lhd,domain_restriction).
4492		latex_to_b_ast(limp,implication).
4493		latex_to_b_ast(lor,disjunct).
4494		latex_to_b_ast(lnot,negation).
4495		latex_to_b_ast(mapsto,couple).
4496		latex_to_b_ast(nat,'NATURAL').
4497		latex_to_b_ast(natn,'NATURAL1').
4498		latex_to_b_ast(neg,negation).
4499		latex_to_b_ast(neq,not_equal).
4500		latex_to_b_ast(nin,not_member).
4501		latex_to_b_ast(not,negation).
4502		latex_to_b_ast(nsubseteq,not_subset).
4503		latex_to_b_ast(nsubset,not_subset_strict).
4504		latex_to_b_ast(or,disjunct).
4505		%latex_to_b_ast(ovl,overwrite).
4506		latex_to_b_ast(pfun,partial_function).
4507		latex_to_b_ast(pinj,partial_injection).
4508		latex_to_b_ast(psur,partial_surjection).
4509		latex_to_b_ast(pow,pow_subset).
4510		latex_to_b_ast(pown,pow1_subset).
4511		latex_to_b_ast(pprod,parallel_product).
4512		latex_to_b_ast(qdot,dot_symbol).
4513		latex_to_b_ast(real,'REAL').
4514		latex_to_b_ast(rel,relations).
4515		latex_to_b_ast(rhd,range_restriction).
4516		latex_to_b_ast(rres,range_restriction).
4517		latex_to_b_ast(rsub,range_subtraction).
4518		latex_to_b_ast(srel,surjection_relation).
4519		latex_to_b_ast(subseteq,subset).
4520		latex_to_b_ast(subset,subset_strict).
4521		latex_to_b_ast(tbij,total_bijection).
4522		latex_to_b_ast(tfun,total_function).
4523		latex_to_b_ast(tinj,total_injection).
4524		latex_to_b_ast(trel,total_relation).
4525		latex_to_b_ast(tsrel,total_surjection_relation).
4526		latex_to_b_ast(tsur,total_surjection).
4527		latex_to_b_ast(upto,interval).
4528		latex_to_b_ast(vee,disjunct).
4529		latex_to_b_ast(wedge,conjunct).
4530		latex_to_b_ast('INT','INTEGER').
4531		latex_to_b_ast('NAT','NATURAL').
4532		latex_to_b_ast('N','NATURAL').
4533		latex_to_b_ast('Pi',general_product).
4534		latex_to_b_ast('POW',pow_subset).
4535		latex_to_b_ast('REAL','REAL').
4536		latex_to_b_ast('Rightarrow',implication).
4537		latex_to_b_ast('Sigma',general_sum).
4538		latex_to_b_ast('Leftrightarrow',equivalence).
4539		latex_to_b_ast('Inter',quantified_intersection).
4540		latex_to_b_ast('Union',quantified_union).
4541		latex_to_b_ast('Z','INTEGER').
4542
4543		unicode_translation(implication, '\x21D2\').
4544		unicode_translation(conjunct,'\x2227\').
4545		unicode_translation(disjunct,'\x2228\'). % \vee
4546		unicode_translation(negation,'\xAC\').
4547		unicode_translation(equivalence,'\x21D4\').
4548		unicode_translation(not_equal,'\x2260\').
4549		unicode_translation(less_equal,'\x2264\').
4550		unicode_translation(less_equal_real,'\x2264\').
4551		unicode_translation(greater_equal,'\x2265\').
4552		unicode_translation(member,'\x2208\').
4553		unicode_translation(not_member,'\x2209\').
4554		unicode_translation(subset,'\x2286\').
4555		unicode_translation(subset_strict,'\x2282\').
4556		unicode_translation(not_subset,'\x2288\').
4557		unicode_translation(not_subset_strict,'\x2284\').
4558		unicode_translation(supseteq,'\x2287\'). % ProB parser supports unicode symbol by reversing arguments
4559		unicode_translation(supset_strict,'\x2283\'). % ditto
4560		unicode_translation(not_supseteq,'\x2289\'). % ditto
4561		unicode_translation(not_supset_strict,'\x2285\'). % ditto
4562		unicode_translation(union,'\x222A\').
4563		unicode_translation(intersection,'\x2229\').
4564		unicode_translation(cartesian_product,'\xD7\'). % also 0x2217 in Camille or 0x2A2F (vector or cross product) in IDP
4565		unicode_translation(couple,'\x21A6\').
4566		unicode_translation(div,'\xF7\').
4567		unicode_translation(multiplication,'\x2217\') :- eventb_translation_mode. % Rodin asterisk operator
4568		unicode_translation(minus,'\x2212\') :- eventb_translation_mode. % Rodin minus
4569		unicode_translation(unary_minus,'\x2212\') :- eventb_translation_mode.
4570		unicode_translation(dot_symbol,'\xB7\'). % not a B AST operator, cf dot_symbol 183
4571		unicode_translation(floored_div,'\xF7\') :-
4572		animation_minor_mode(tla). % should we provide another Unicode character here for B?
4573		unicode_translation(power_of,'\x02C4\') :- \+ eventb_translation_mode. % version of ^, does not exist in Rodin ?!, upwards arrow x2191 used below for restrict front
4574		unicode_translation(power_of,'\x5E\') :- eventb_translation_mode.
4575		unicode_translation(power_of_real,'\x02C4\').
4576		unicode_translation(interval,'\x2025\').
4577		unicode_translation(domain_restriction,'\x25C1\').
4578		unicode_translation(domain_subtraction,'\x2A64\').
4579		unicode_translation(range_restriction,'\x25B7\').
4580		unicode_translation(range_subtraction,'\x2A65\').
4581		unicode_translation(relations,'\x2194\').
4582		unicode_translation(partial_function,'\x21F8\').
4583		unicode_translation(total_function,'\x2192\').
4584		unicode_translation(partial_injection,'\x2914\').
4585		unicode_translation(partial_surjection,'\x2900\').
4586		unicode_translation(total_injection,'\x21A3\').
4587		unicode_translation(total_surjection,'\x21A0\').
4588		unicode_translation(total_bijection,'\x2916\').
4589		unicode_translation('INTEGER','\x2124\').
4590		unicode_translation('NATURAL','\x2115\').
4591		unicode_translation('NATURAL1','\x2115\\x2081\') :- \+ eventb_translation_mode. % \x2081\ is subscript 1, not accepted by Rodin
4592		unicode_translation('NATURAL1','\x2115\\x31\') :- eventb_translation_mode. % N1
4593		unicode_translation('REAL','\x211D\'). % 8477 in decimal
4594		unicode_translation(real_set,'\x211D\').
4595		%unicode_translation(bool_set,'\x1D539\'). % conversion used by IDP, but creates SPIO_E_ENCODING_INVALID problem
4596		unicode_translation(pow_subset,'\x2119\').
4597		unicode_translation(pow1_subset,'\x2119\\x2081\') :- \+ eventb_translation_mode. % \x2081\ is subscript 1
4598		unicode_translation(pow1_subset,'\x2119\\x31\') :- eventb_translation_mode. % P1
4599		unicode_translation(lambda,'\x3BB\').
4600		unicode_translation(general_product,'\x220F\').
4601		unicode_translation(general_sum,'\x2211\').
4602		unicode_translation(quantified_union,'\x22C3\'). % 8899 in decimal
4603		unicode_translation(quantified_intersection,'\x22C2\'). % 8898 in decimal
4604		unicode_translation(empty_set,'\x2205\').
4605		unicode_translation(truth,'\x22A4\'). % 8868 in decimal
4606		unicode_translation(falsity,'\x22A5\'). % 8869 in decimal
4607		unicode_translation(direct_product,'\x2297\').
4608		unicode_translation(parallel_product,'\x2225\').
4609		unicode_translation(reverse,'\x207B\\xB9\') :- \+ eventb_translation_mode. % the one ¹ is ASCII 185, this symbol is not accepted by Rodin
4610		unicode_translation(reverse,'\x223c\') :- eventb_translation_mode. % tilde operator used by Rodin
4611		% unicode_translation(infinity,'\x221E\'). % 8734 in decimal
4612		unicode_translation(concat,'\x2312\'). % Arc character
4613		unicode_translation(insert_front,'\x21FE\').
4614		unicode_translation(insert_tail,'\x21FD\').
4615		unicode_translation(restrict_front,'\x2191\'). % up arrow
4616		unicode_translation(restrict_tail,'\x2192\').
4617		unicode_translation(forall, '\x2200\'). % usually forall_symbol used
4618		unicode_translation(exists, '\x2203\'). % usually exists_symbol used
4619		unicode_translation(eqeq,'\x225c\').
4620
4621		unicode_translation(total_relation,'\xE100\') :- force_eventb_rodin_mode. % use this custom symbol only in forced Rodin mode, cannot be displayed by most editors, but is important for BPR proof files
4622		unicode_translation(surjection_relation,'\xE101\') :- force_eventb_rodin_mode. % ditto
4623		unicode_translation(total_surjection_relation,'\xE102\') :- force_eventb_rodin_mode. % ditto
4624		unicode_translation(overwrite,'\xE103\') :- force_eventb_rodin_mode. % ditto, from kernel_lang_20.pdf
4625		unicode_translation(ring,'\x2218\'). % from Event-B
4626		unicode_translation(set_subtraction,'\x2216\'). % used by Rodin
4627		unicode_translation(typeof,'\x2982\'). % Event-B oftype operator
4628
4629		% see Chapter 3 of Atelier-B prover manual:
4630		%atelierb_pp_translation(E,PP,_) :- write(pp(PP,E)),nl,fail.
4631		atelierb_pp_translation(set_minus,pp,'_moinsE'). % is set_subtraction ??
4632		atelierb_pp_translation(cartesian_product,pp,'_multE').
4633		atelierb_pp_translation('INTEGER',_,'INTEGER').
4634		%atelierb_pp_translation('INT','(MININT..MAXINT)'). % does not seem necessary
4635		atelierb_pp_translation('NATURAL',_,'NATURAL').
4636		atelierb_pp_translation('NATURAL1',_,'(NATURAL - {0})').
4637		atelierb_pp_translation('NAT1',_,'(NAT - {0})').
4638		%atelierb_pp_translation('NAT','(0..MAXINT)'). % does not seem necessary
4639		%atelierb_pp_translation('NAT1','(1..MAXINT)'). % does not seem necessary
4640		atelierb_pp_translation(truth,_,btrue).
4641		atelierb_pp_translation(falsity,_,bfalse).
4642		atelierb_pp_translation(boolean_true,_,'TRUE').
4643		atelierb_pp_translation(boolean_false,_,'FALSE').
4644		atelierb_pp_translation(empty_sequence,_,'{}').
4645
4646
4647
4648		quantified_in_mode(F,S) :-
4649		quantified(F,S1), translate_in_mode(F,S1,S).
4650
4651		translate_in_mode(F,S1,Result) :-
4652	?	( unicode_mode, unicode_translation(F,S) -> true
4653		; latex_mode, latex_translation(F,S) -> true
4654		; atelierb_mode(prover(PPML)), atelierb_pp_translation(F,PPML,S) -> true
4655		; colour_translation(F,S1,S) -> true
4656		; S1=S),
4657		(colour_translation(F,S,Res) -> Result=Res ; Result=S).
4658
4659		:- use_module(tools_printing,[get_terminal_colour_code/2, no_color/0]).
4660		use_colour_codes :- \+ no_color,
4661		get_preference(pp_with_terminal_colour,true).
4662		colour_translation(F,S1,Result) :- use_colour_codes,
4663		colour_construct(F,Colour),!,
4664		get_terminal_colour_code(Colour,R1),
4665		get_terminal_colour_code(reset,R2),
4666		ajoin([R1,S1,R2],Result).
4667		colour_construct(pred_true,green).
4668		colour_construct(pred_false,red).
4669		colour_construct(boolean_true,green).
4670		colour_construct(boolean_false,red).
4671		colour_construct(truth,green).
4672		colour_construct(falsity,red).
4673		colour_construct(_,blue).
4674
4675		gen_term_color(Col) --> {use_colour_codes},!, {get_terminal_colour_code(Col,R1), atom_codes(R1,CC)},CC.
4676		gen_term_color(_) --> [].
4677
4678		% pretty print a colour code if colours are enabled:
4679		pp_colour_code(Colour) --> {use_colour_codes,get_terminal_colour_code(Colour,C), atom_codes(C,CC)},!,CC.
4680		pp_colour_code(_) --> [].
4681
4682
4683		quantified(general_sum,'SIGMA').
4684		quantified(general_product,'PI').
4685		quantified(quantified_union,'UNION').
4686		quantified(quantified_intersection,'INTER').
4687		quantified(lambda,X) :- atom_codes(X,[37]).
4688		quantified(forall,'!').
4689		quantified(exists,'#').
4690
4691
4692		translate_prolog_constructor(C,R) :- unary_prefix(C,R,_),!.
4693		translate_prolog_constructor(C,R) :- unary_postfix(C,R,_),!.
4694		translate_prolog_constructor(C,R) :- binary_infix_in_mode(C,R,_,_),!.
4695		translate_prolog_constructor(C,R) :- function_like_in_mode(C,R),!.
4696		translate_prolog_constructor(C,R) :- constants_in_mode(C,R),!.
4697		translate_prolog_constructor(C,R) :- quantified_in_mode(C,R),!.
4698
4699		% translate the Prolog constuctor of an AST node into a form for printing to the user
4700		translate_prolog_constructor_in_mode(Constructor,Result) :-
4701		unicode_mode,
4702		unicode_translation(Constructor,Unicode),!, Result=Unicode.
4703		translate_prolog_constructor_in_mode(Constructor,Result) :-
4704		latex_mode,
4705		latex_translation(Constructor,Latex),!, Result=Latex.
4706		translate_prolog_constructor_in_mode(C,R) :- translate_prolog_constructor(C,R).
4707
4708		translate_subst_or_bexpr_in_mode(Mode,TExpr,String) :-
4709		with_translation_mode(Mode, translate_subst_or_bexpr(TExpr,String)).
4710
4711
4712		translate_bexpression_to_unicode(TExpr,String) :-
4713		with_translation_mode(unicode, translate_bexpression(TExpr,String)).
4714
4715		translate_bexpression(TExpr,String) :-
4716		(pp_expr(TExpr,String) -> true
4717		; add_error(translate_bexpression,'Could not translate bexpression: ',TExpr),String='???').
4718
4719		translate_bexpression_to_codes(TExpr,Codes) :-
4720		reset_pp,
4721		pp_expr(TExpr,_,_LimitReached,Codes,[]).
4722
4723		pp_expr(TExpr,String) :-
4724		translate_bexpression_to_codes(TExpr,Codes),
4725		atom_codes_with_limit(String, Codes).
4726
4727		translate_bexpression_with_limit(T,S) :- translate_bexpression_with_limit(T,200,report_errors,S).
4728		translate_bexpression_with_limit(TExpr,Limit,String) :-
4729		translate_bexpression_with_limit(TExpr,Limit,report_errors,String).
4730		translate_bexpression_with_limit(TExpr,Limit,report_errors,String) :- compound(String),!,
4731		add_internal_error('Result is instantiated to a compound term:',
4732		translate_bexpression_with_limit(TExpr,Limit,report_errors,String)),fail.
4733		translate_bexpression_with_limit(TExpr,Limit,ReportErrors,String) :-
4734		(catch_call(pp_expr_with_limit(TExpr,Limit,String)) -> true
4735		; (ReportErrors=report_errors,
4736		add_error(translate_bexpression,'Could not translate bexpression: ',TExpr),String='???')).
4737
4738		pp_expr_with_limit(TExpr,Limit,String) :-
4739		set_up_limit_reached(Codes,Limit,LimitReached),
4740		reset_pp,
4741		pp_expr(TExpr,_,LimitReached,Codes,[]),
4742		atom_codes_with_limit(String, Limit, Codes).
4743
4744
4745
4746		% pretty-type an expression, if the expression has a priority >MinPrio, parenthesis
4747		% can be ommitted, if not the expression has to be put into parenthesis
4748		pp_expr_m(TExpr,MinPrio,LimitReached,S,Srest) :-
4749		add_outer_paren(Prio,MinPrio,S,Srest,X,Xrest), % use co-routine to instantiate S as soon as possible
4750		pp_expr(TExpr,Prio,LimitReached,X,Xrest).
4751
4752		:- block add_outer_paren(-,?,?,?,?,?).
4753		add_outer_paren(Prio,MinPrio,S,Srest,X,Xrest) :-
4754		( Prio > MinPrio -> % was >=, but problem with & / or with same priority or with non associative operators !
4755		S=X, Srest=Xrest
4756		;
4757		[Open] = "(", [Close] = ")",
4758		S = [Open|X], Xrest = [Close|Srest]).
4759		% warning: if prio not set we will have a pending co-routine and instantiation_error in atom_codes later
4760
4761		:- use_module(translate_keywords,[classical_b_keyword/1, translate_keyword_id/2]).
4762		translated_identifier('_zzzz_binary',R) :- !,
4763		(latex_mode -> R='z''''' ; R='z__'). % TO DO: could cause clash with user IDs
4764		translated_identifier('_zzzz_unary',R) :- !,
4765		(latex_mode -> R='z''' ; R='z_'). % TO DO: ditto
4766		translated_identifier('__RANGE_LAMBDA__',R) :- !,
4767		(latex_mode -> R='\\rho\'' ; unicode_mode -> R= '\x03c1\' % RHO
4768		; R = 'RANGE_LAMBDA__'). %ditto, could clash with user IDs !!
4769		% TO DO: do we need to treat _prj_arg1__, _prj_arg2__, _lambda_result_ here ?
4770		translated_identifier(ID,Result) :-
4771		latex_mode,!,
4772		my_greek_latex_escape_atom(ID,Greek,Res), %print_message(translate_latex(ID,Greek,Res)),
4773		(Greek=greek -> Result = Res ; ajoin(['\\mathit{',Res,'}'],Result)).
4774		translated_identifier(X,X).
4775
4776		pp_identifier(Atom) --> {id_requires_escaping(Atom), \+ eventb_translation_mode, \+ latex_mode}, !,
4777		({atelierb_mode(_)}
4778		-> pp_identifier_for_atelierb(Atom)
4779		; pp_backquoted_identifier(Atom)
4780		).
4781		pp_identifier(Atom) --> ppatom_opt_scramble(Atom).
4782
4783		% print atom using backquotes, we use same escaping rules as in a string
4784		% requires B parser version 2.9.30 or newer
4785		pp_backquoted_identifier(Atom) --> {atom_codes(Atom,Codes)}, pp_backquoted_id_codes(Codes,outer).
4786		pp_backquoted_id_codes(Codes,_) --> {append(Prefix,[0'. | Suffix],Codes), Suffix=[_|_]},
4787		!, % we need to split the id and quote each part separately; otherwise the parser will complain
4788		% see issue https://github.com/hhu-stups/prob-issues/issues/321
4789		% However, ids with dots are not accepted for constants and variables; so this does not solve all problems
4790		({id_codes_requires_escaping(Prefix)}
4791		-> "`", pp_codes_opt_scramble(Prefix), "`"
4792		; pp_codes_opt_scramble(Prefix)
4793		), ".",
4794		pp_backquoted_id_codes(Suffix,inner).
4795		pp_backquoted_id_codes(Codes,inner) --> % last part of an id with dots
4796		{\+ id_codes_requires_escaping(Codes)},
4797		!, pp_codes_opt_scramble(Codes).
4798		pp_backquoted_id_codes(Codes,_) --> "`", pp_codes_opt_scramble(Codes), "`".
4799
4800		id_codes_requires_escaping(Codes) :- atom_codes(PA,Codes),id_requires_escaping(PA).
4801		:- use_module(tools_strings,[is_simple_classical_b_identifier/1]).
4802		id_requires_escaping(ID) :- classical_b_keyword(ID).
4803		id_requires_escaping(ID) :- \+ is_simple_classical_b_identifier(ID).
4804
4805		pp_identifier_for_atelierb(Atom) -->
4806		{atom_codes(Atom,Codes),
4807		strip_illegal_id_codes(Codes,Change,Codes2),
4808		Change==true},!,
4809		{atom_codes(A2,Codes2)},
4810		ppatom_opt_scramble(A2).
4811		pp_identifier_for_atelierb(Atom) --> ppatom_opt_scramble(Atom).
4812
4813		% remove illegal codes in an identifier (probably EventB or Z)
4814		strip_illegal_id_codes([0'_ | T ],Change,[946 | TR]) :- !, Change=true, strip_illegal_id_codes(T,_,TR).
4815		strip_illegal_id_codes(Codes,Change,Res) :- strip_illegal_id_codes2(Codes,Change,Res).
4816
4817		strip_illegal_id_codes2([],_,[]).
4818		strip_illegal_id_codes2([H|T],Change,Res) :- strip_code(H,Res,TR),!, Change=true, strip_illegal_id_codes2(T,_,TR).
4819		strip_illegal_id_codes2([H|T],Change,[H|TR]) :- strip_illegal_id_codes2(T,Change,TR).
4820
4821		strip_code(46,[0'_, 0'_ |T],T). % replace dot . by two underscores
4822		strip_code(36,[946|T],T) :- T \= [48]. % replace dollar $ by beta unless it is $0 at the end
4823		strip_code(92,[950|T],T). % replace dollar by zeta; probably from Zed
4824		% TODO: add more symbols and ensure that the new codes do not exist
4825
4826
4827
4828		:- use_module(tools,[latex_escape_atom/2]).
4829
4830		greek_or_math_symbol(Symbol) :- greek_symbol(Symbol,_).
4831		% other Latex math symbols
4832		greek_or_math_symbol('varepsilon').
4833		greek_or_math_symbol('varphi').
4834		greek_or_math_symbol('varpi').
4835		greek_or_math_symbol('varrho').
4836		greek_or_math_symbol('varsigma').
4837		greek_or_math_symbol('vartheta').
4838		greek_or_math_symbol('vdash').
4839		greek_or_math_symbol('models').
4840
4841		greek_symbol('Alpha','\x0391\').
4842		greek_symbol('Beta','\x0392\').
4843		greek_symbol('Chi','\x03A7\').
4844		greek_symbol('Delta','\x0394\').
4845		greek_symbol('Epsilon','\x0395\').
4846		greek_symbol('Eta','\x0397\').
4847		greek_symbol('Gamma','\x0393\').
4848		greek_symbol('Iota','\x0399\').
4849		greek_symbol('Kappa','\x039A\').
4850		greek_symbol('Lambda','\x039B\').
4851		greek_symbol('Mu','\x039C\').
4852		greek_symbol('Nu','\x039D\').
4853		greek_symbol('Phi','\x03A6\').
4854		greek_symbol('Pi','\x03A0\').
4855		greek_symbol('Psi','\x03A8\').
4856		greek_symbol('Rho','\x03A1\').
4857		greek_symbol('Omega','\x03A9\').
4858		greek_symbol('Omicron','\x039F\').
4859		greek_symbol('Sigma','\x03A3\').
4860		greek_symbol('Theta','\x0398\').
4861		greek_symbol('Upsilon','\x03A5\').
4862		greek_symbol('Xi','\x039E\').
4863		greek_symbol('alpha','\x03B1\').
4864		greek_symbol('beta','\x03B2\').
4865		greek_symbol('delta','\x03B4\').
4866		greek_symbol('chi','\x03C7\').
4867		greek_symbol('epsilon','\x03B5\').
4868		greek_symbol('eta','\x03B7\').
4869		greek_symbol('gamma','\x03B3\').
4870		greek_symbol('iota','\x03B9\').
4871		greek_symbol('kappa','\x03BA\').
4872		greek_symbol('lambda','\x03BB\').
4873		greek_symbol('mu','\x03BC\').
4874		greek_symbol('nu','\x03BD\').
4875		greek_symbol('omega','\x03C9\').
4876		greek_symbol('omicron','\x03BF\').
4877		greek_symbol('pi','\x03C0\').
4878		greek_symbol('phi','\x03C6\').
4879		greek_symbol('psi','\x03C8\').
4880		greek_symbol('rho','\x03C1\').
4881		greek_symbol('sigma','\x03C3\').
4882		greek_symbol('tau','\x03C4\').
4883		greek_symbol('theta','\x03B8\').
4884		greek_symbol('upsilon','\x03C5\').
4885		greek_symbol('xi','\x03BE\').
4886		greek_symbol('zeta','\x03B6\').
4887
4888
4889		my_greek_latex_escape_atom(A,greek,Res) :-
4890		greek_or_math_symbol(A),get_preference(latex_pp_greek_ids,true),!,
4891		atom_concat('\\',A,Res).
4892		my_greek_latex_escape_atom(A,no_greek,EA) :- latex_escape_atom(A,EA).
4893
4894		% ppatom + scramble if BUGYLY is TRUE
4895		ppatom_opt_scramble(Name) --> {get_preference(bugly_pp_scrambling,true)},
4896		% {\+ bmachine:b_top_level_operation(Name)}, % comment in to not change name of B operations
4897		!,
4898		{bugly_scramble_id(Name,ScrName)},
4899		ppatom(ScrName).
4900		ppatom_opt_scramble(Name) -->
4901		{primes_to_unicode(Name, UnicodeName)},
4902		pp_atom_opt_latex(UnicodeName).
4903
4904		% Convert ASCII primes (apostrophes) in identifiers to Unicode primes
4905		% so they can be parsed by the classical B parser.
4906		primes_to_unicode(Name, UnicodeName) :-
4907		atom_codes(Name, Codes),
4908		phrase(primes_to_unicode(Codes), UCodes),
4909		atom_codes(UnicodeName, UCodes).
4910		primes_to_unicode([0'\'|T]) --> !,
4911		"\x2032\",
4912		primes_to_unicode(T).
4913		primes_to_unicode([C|T]) --> !,
4914		[C],
4915		primes_to_unicode(T).
4916		primes_to_unicode([]) --> "".
4917
4918		:- use_module(tools,[b_string_escape_codes/2]).
4919		:- use_module(tools_strings,[convert_atom_to_number/2]).
4920		% a version of ppatom which encodes/quotes symbols inside strings such as quotes "
4921		ppstring_opt_scramble(Name) --> {var(Name)},!,ppatom(Name).
4922		ppstring_opt_scramble(Name) --> {compound(Name)},!,
4923		{add_internal_error('Not an atom: ',ppstring_opt_scramble(Name,_,_))},
4924		"<<" ,ppterm(Name), ">>".
4925		ppstring_opt_scramble(Name) --> {get_preference(bugly_pp_scrambling,true)},!,
4926		pp_bugly_composed_string(Name).
4927		ppstring_opt_scramble(Name) --> {atom_codes(Name,Codes),b_string_escape_codes(Codes,EscCodes)},
4928		pp_codes_opt_latex(EscCodes).
4929
4930		% a version of ppstring_opt_scramble with codes list
4931		pp_codes_opt_scramble(Codes) --> {get_preference(bugly_pp_scrambling,true)},!,
4932		pp_bugly_composed_string_codes(Codes,[]).
4933		pp_codes_opt_scramble(Codes) --> {b_string_escape_codes(Codes,EscCodes)},
4934		pp_codes_opt_latex(EscCodes).
4935
4936		pp_bugly_composed_string(Name) --> {atom_codes(Name,Codes)},
4937		!, % we can decompose the string; scramble each string separately; TODO: provide option to define separators
4938		% idea is that if we have a string with spaces or other special separators we preserve the separators
4939		pp_bugly_composed_string_codes(Codes,[]).
4940
4941		pp_bugly_composed_string_codes([],Acc) --> {atom_codes(Atom,Acc)}, pp_bugly_string(Atom).
4942		pp_bugly_composed_string_codes(List,Acc) --> {decompose_string(List,Seps,T)},!,
4943		{reverse(Acc,Rev),atom_codes(Atom,Rev)}, pp_bugly_string(Atom),
4944		ppcodes(Seps),
4945		pp_bugly_composed_string_codes(T,[]).
4946		pp_bugly_composed_string_codes([H|T],Acc) --> pp_bugly_composed_string_codes(T,[H|Acc]).
4947
4948		decompose_string([Sep|T],[Sep],T) :- bugly_separator(Sep).
4949		% comment in and adapt for domain specific separators:
4950		%decompose_string(List,Seps,T) :- member(Seps,["LEU","DEF","BAL"]), append(Seps,T,List).
4951		%bugly_separator(10).
4952		%bugly_separator(13).
4953		bugly_separator(32).
4954		bugly_separator(0'-).
4955		bugly_separator(0'_).
4956		bugly_separator(0',).
4957		bugly_separator(0'.).
4958		bugly_separator(0';).
4959		bugly_separator(0':).
4960		bugly_separator(0'#).
4961		bugly_separator(0'[).
4962		bugly_separator(0']).
4963		bugly_separator(0'().
4964		bugly_separator(0')).
4965
4966		% scramble and pretty print individual strings or components of strings
4967		pp_bugly_string('') --> !, [].
4968		pp_bugly_string(Name) -->
4969		{convert_atom_to_number(Name,_)},!, % do not scramble numbers; we could check if LibraryStrings is available
4970		pp_atom_opt_latex(Name).
4971		pp_bugly_string(Name) -->
4972		{bugly_scramble_id(Name,ScrName)},
4973		ppatom(ScrName).
4974
4975		% ------------
4976
4977		pp_atom_opt_latex(Name) --> {latex_mode},!,
4978		{my_greek_latex_escape_atom(Name,_,EscName)},
4979		% should we add \mathrm{.} or \mathit{.}?
4980		ppatom(EscName).
4981		pp_atom_opt_latex(Name) --> ppatom(Name).
4982
4983		% a version of pp_atom_opt_latex working with codes
4984		pp_codes_opt_latex(Codes) --> {latex_mode},!,
4985		{atom_codes(Name,Codes),my_greek_latex_escape_atom(Name,_,EscName)},
4986		ppatom(EscName).
4987		pp_codes_opt_latex(Codes) --> ppcodes(Codes).
4988
4989		pp_atom_opt_latex_mathit(Name) --> {latex_mode},!,
4990		{latex_escape_atom(Name,EscName)},
4991		"\\mathit{",ppatom(EscName),"}".
4992		pp_atom_opt_latex_mathit(Name) --> ppatom(Name).
4993
4994		pp_atom_opt_mathit(EscName) --> {latex_mode},!,
4995		% we assume already escaped
4996		"\\mathit{",ppatom(EscName),"}".
4997		pp_atom_opt_mathit(Name) --> ppatom(Name).
4998
4999		pp_space --> {latex_mode},!, "\\ ".
5000		pp_space --> " ".
5001
5002		opt_scramble_id(ID,Res) :- get_preference(bugly_pp_scrambling,true),!,
5003		bugly_scramble_id(ID,Res).
5004		opt_scramble_id(ID,ID).
5005
5006		:- use_module(probsrc(gensym),[gensym/2]).
5007		:- dynamic bugly_scramble_id_cache/2.
5008		bugly_scramble_id(ID,Res) :- var(ID),!, add_internal_error('Illegal call: ',bugly_scramble_id(ID,Res)), ID=Res.
5009		bugly_scramble_id(ID,Res) :- bugly_scramble_id_cache(ID,ScrambledID),!,
5010		Res=ScrambledID.
5011		bugly_scramble_id(ID,Res) :- %write(gen_id(ID,Res)),nl,
5012		genbuglynr(Nr),
5013		gen_bugly_id(Nr,ScrambledID),
5014		assertz(bugly_scramble_id_cache(ID,ScrambledID)),
5015		%format(user_output,'BUGLY scramble ~w --> ~w~n',[ID,ScrambledID]),
5016		Res = ScrambledID.
5017
5018		gen_bugly_id_codes(Nr,[Char|TC]) :- Char is 97+ Nr mod 26,
5019		(Nr> 25 -> N1 is Nr // 26, gen_bugly_id_codes(N1,TC) ; TC=[]).
5020		gen_bugly_id(Nr,ScrambledID) :- gen_bugly_id_codes(Nr,Codes), atom_codes(ScrambledID,[97,97|Codes]).
5021		%gen_bugly_id(Nr,ScrambledID) :- ajoin(['aa',Nr],ScrambledID). % old version using aaNr
5022
5023		:- dynamic bugly_count/1.
5024		bugly_count(0).
5025		genbuglynr(Nr) :-
5026		retract(bugly_count(Nr)), N1 is Nr + 1,
5027		assertz(bugly_count(N1)).
5028
5029
5030		is_lambda_result_id(b(identifier(ID),_,_INFO),Suffix) :- % _INFO=[lambda_result], sometiems _INFO=[]
5031		is_lambda_result_name(ID,Suffix).
5032		is_lambda_result_name(LAMBDA_RESULT,Suffix) :- atomic(LAMBDA_RESULT),
5033		atom_codes(LAMBDA_RESULT,[95,108,97,109,98,100,97,95,114,101,115,117,108,116,95|Suffix]). % _lambda_result_
5034
5035		pp_expr(TE,P) --> %{write('OBSOLETE'),nl,nl},
5036		pp_expr(TE,P,_LimitReached).
5037
5038		pp_expr(TExpr,Prio,_) --> {var(TExpr)},!,"_",{Prio=500}.
5039		pp_expr(_,Prio,LimitReached) --> {LimitReached==limit_reached},!,"...",{Prio=500}.
5040		pp_expr(b(Expr,Type,Info),Prio,LimitReached) --> !,
5041		pp_expr0(Expr,Type,Info,Prio,LimitReached).
5042		pp_expr([H|T],10,LimitReached) --> !, % also allow pp_expr to be used for lists of expressions
5043		pp_expr_l([H|T],LimitReached).
5044		pp_expr(Expr,Prio,LimitReached) -->
5045		pp_expr1(Expr,any,[],Prio,LimitReached).
5046
5047		pp_expr0(identifier(ID),_Type,_Info,Prio,_LimitReached) --> {is_lambda_result_name(ID,Suffix)},!, {Prio=500},
5048		{append("LAMBDA_RESULT___",Suffix,ASCII), atom_codes(R,ASCII)}, ppatom(R).
5049		pp_expr0(Expr,_Type,Info,Prio,_LimitReached) -->
5050		{eventb_translation_mode},
5051		pp_theory_operator(Expr,Info,Prio),!.
5052		pp_expr0(Expr,Type,Info,Prio,LimitReached) -->
5053		{check_info(Expr,Type,Info)},
5054		pp_rodin_label(Expr,Info),
5055		(pp_expr1(Expr,Type,Info,Prio,LimitReached) -> {true}
5056		; {add_error(translate,'Could not translate:',Expr,Expr),fail}
5057		).
5058
5059		check_info(Expr,_,Info) :- var(Info), add_error(translate,'Illegal variable info field for expression: ', Expr),fail.
5060		check_info(_,_,_).
5061
5062		pp_theory_operator(general_sum(_,Membercheck,_),_Info,500) -->
5063		{get_texpr_expr(Membercheck,member(_,Arg))},
5064		ppatom('SUM('),pp_expr(Arg,_),ppatom(')').
5065		pp_theory_operator(general_product(_,Membercheck,_),_Info,500) -->
5066		{get_texpr_expr(Membercheck,member(_Couple,Arg))},
5067		ppatom('PRODUCT('),pp_expr(Arg,_),ppatom(')').
5068		pp_theory_operator(function(_,Arg),Info,500) -->
5069		{memberchk_in_info(theory_operator(O,N),Info),decouplise_expr(N,Arg,Args)},
5070		ppatom(O),"(",pp_expr_l_sep(Args,",",_LR),")".
5071		pp_theory_operator(member(Arg,_),Info,500) -->
5072		{memberchk_in_info(theory_operator(O,N),Info),decouplise_expr(N,Arg,Args)},
5073		ppatom(O),"(",pp_expr_l_sep(Args,",",_LR),")".
5074
5075		decouplise_expr(1,E,R) :- !,R=[E].
5076		decouplise_expr(N,E,R) :-
5077		get_texpr_expr(E,couple(A,B)),!,
5078		N2 is N-1,
5079		decouplise_expr(N2,A,R1),append(R1,[B],R).
5080		decouplise_expr(N,E,[E]) :-
5081		print_message(call_failed(decouplise_expr(N,E,_))),nl.
5082
5083		% do not print labels for identifiers (can happen in ANY); not accepted by B parser
5084		pp_rodin_label(identifier(_),_Infos) --> {!}, [].
5085		pp_rodin_label(_Expr,Infos) --> pp_rodin_label(Infos).
5086
5087		% will pretty print (first) rodin or pragma label
5088		pp_rodin_label(_Infos) --> {preference(translate_suppress_rodin_positions_flag,true),!}.
5089		pp_rodin_label(_Infos) --> {preference(bugly_pp_scrambling,true),!}.
5090		pp_rodin_label(Infos) --> {var(Infos)},!, "/* ILLEGAL VARIABLE INFO FIELD */".
5091		pp_rodin_label(Infos) --> {get_info_labels(Infos,Label)},!,
5092		pp_start_label_pragma,
5093		ppatoms_opt_latex(Label),
5094		pp_end_label_pragma.
5095		pp_rodin_label(Infos) --> {preference(pp_wd_infos,true)},!, pp_wd_info(Infos).
5096		pp_rodin_label(_Infos) --> [].
5097
5098		% print infos about well-definedness attached to AST node:
5099		pp_wd_info(Infos) --> {member(discharged_wd_po,Infos)},!, "/*D",
5100		({member(contains_wd_condition,Infos)} -> "-WD*/ " ; "*/ ").
5101		pp_wd_info(Infos) --> {member(contains_wd_condition,Infos)},!, "/*WD*/ ".
5102		pp_wd_info(_Infos) --> [].
5103
5104		pp_start_label_pragma -->
5105		{(atelierb_mode(prover(_))
5106		; get_preference(translate_print_typing_infos,true))}, % proxy for parseable;
5107		% set by translate_bvalue_to_parseable_classicalb; important for parsertests with labels
5108		!,
5109		"/*@label ".
5110		pp_start_label_pragma --> "/* @". % shorter version, for viewing in UI
5111		pp_end_label_pragma --> " */ ".
5112
5113		ppatoms([]) --> !, [].
5114		ppatoms([ID|T]) --> !,ppatom(ID), " ", ppatoms(T).
5115		ppatoms(X) --> {add_error(ppatoms,'Not a list of atoms: ',ppatoms(X))}.
5116
5117		ppatoms_opt_latex([]) --> !, [].
5118		ppatoms_opt_latex([ID]) --> !,pp_atom_opt_latex(ID).
5119		ppatoms_opt_latex([ID|T]) --> !,pp_atom_opt_latex(ID), " ", ppatoms_opt_latex(T).
5120		ppatoms_opt_latex(X) --> {add_error(ppatoms_opt_latex,'Not a list of atoms: ',ppatoms_opt_latex(X))}.
5121
5122		%:- use_module(bsyntaxtree,[is_set_type/2]).
5123		:- load_files(library(system), [when(compile_time), imports([environ/2])]).
5124		pp_expr1(Expr,_,_,Prio,_) --> {var(Expr)},!,"_",{Prio=500}.
5125		pp_expr1(event_b_comprehension_set(Ids,E,P),Type,_Info,Prio,LimitReached) -->
5126		{\+ eventb_translation_mode, b_ast_cleanup:rewrite_event_b_comprehension_set(Ids,E,P,Type, NewExpression)},!,
5127		pp_expr(NewExpression,Prio,LimitReached).
5128		pp_expr1(union(b(event_b_identity,Type,_), b(closure(Rel),Type,_)),_,Info,500,LimitReached) -->
5129		/* closure(Rel) = id \/ closure1(Rel) */
5130	?	{member_in_info(was(reflexive_closure),Info)},!,
5131		"closure(",pp_expr(Rel,_,LimitReached),")".
5132		pp_expr1(comprehension_set([_],_),_,Info,500,_LimitReached) -->
5133		{memberchk_in_info(freetype(P),Info),!},ppatom(P).
5134		% used instead of constants(Expr,Symbol) case below:
5135		pp_expr1(greater_equal(A,Y),Type,Info,Prio,LimitReached) --> % x:NATURAL was rewritten to x>=0, see test 499, 498
5136		{memberchk_in_info(was(member(A,B)),Info), get_integer(Y,_)},
5137		pp_expr1(member(A,B),Type,Info,Prio,LimitReached).
5138		pp_expr1(comprehension_set([TID],b(B,_,_)),Type,Info,Prio,LimitReached) -->
5139		{memberchk_in_info(was(integer_set(S)),Info)},
5140		{S='INTEGER' -> B=truth
5141		; get_texpr_id(TID,ID),
5142		B=greater_equal(TID2,Y), get_integer(Y,I),
5143		get_texpr_id(TID2,ID),
5144		(I=0 -> S='NATURAL' ; I=1,S='NATURAL1')}, % TO DO: check bounds
5145		!,
5146		pp_expr1(integer_set(S),Type,Info,Prio,LimitReached).
5147		pp_expr1(interval(b(A,_,_),B),Type,Info,Prio,LimitReached) -->
5148		{memberchk_in_info(was(integer_set(S)),Info)},
5149		{B=b(max_int,integer,_)}, % TO DO ? allow value(int(Mx))
5150		{A=min_int -> S='INT' ; A=integer(0) -> S='NAT' ; A=integer(1),S='NAT1'},
5151		!,
5152		pp_expr1(integer_set(S),Type,Info,Prio,LimitReached).
5153		pp_expr1(falsity,_,Info,Prio,LimitReached) --> {memberchk_in_info(was(Pred),Info)},!,
5154		({(unicode_mode ; latex_mode)}
5155		-> {translate_in_mode(falsity,'falsity',Symbol)},
5156		ppatom(Symbol),
5157		({get_preference(pp_propositional_logic_mode,true)} -> {true}
5158		; " ", enter_comment, " ", pp_expr2(Pred,Prio,LimitReached), " ", exit_comment)
5159		; enter_comment, " falsity ",exit_comment, " ",
5160		pp_expr2(Pred,Prio,LimitReached)). % Pred is not wrapped
5161		pp_expr1(truth,_,Info,Prio,LimitReached) --> {memberchk_in_info(was(Pred),Info)},!,
5162		({(unicode_mode ; latex_mode)}
5163		-> {translate_in_mode(truth,'truth',Symbol)},
5164		ppatom(Symbol),
5165		({get_preference(pp_propositional_logic_mode,true)} -> {true}
5166		; " ",enter_comment, " ", pp_expr2(Pred,Prio,LimitReached), " ", exit_comment)
5167		; enter_comment, " truth ", exit_comment, " ",
5168		pp_expr2(Pred,Prio,LimitReached)). % Pred is not wrapped
5169		% TO DO: do this for other expressions as well; but then we have to ensure that ast_cleanup generates complete was(_) infos
5170		% :- load_files(library(system), [when(compile_time), imports([environ/2])]). % directive moved above to avoid Spider warning
5171		pp_expr1(event_b_identity,Type,_Info,500,_LimitReached) -->
5172		{\+ eventb_translation_mode}, %{atelierb_mode(prover(_)},
5173		{is_set_type(Type,couple(ElType,ElType))},
5174		!,
5175		"id(", {pretty_normalized_type(ElType,S)},ppatom(S), ")".
5176		pp_expr1(typeset,SType,_Info,500,_LimitReached) --> % normally removed by ast_cleanup
5177		{is_set_type(SType,Type)},
5178		!,
5179		({normalized_type_requires_outer_paren(Type)} -> "(" ; ""),
5180		{pretty_normalized_type(Type,S)},ppatom(S),
5181		({normalized_type_requires_outer_paren(Type)} -> ")" ; "").
5182		:- if(environ(prob_safe_mode,true)).
5183		pp_expr1(exists(Parameters,_),_,Info,_Prio,_LimitReached) -->
5184		{\+ member_in_info(used_ids(_),Info),
5185		add_error(translate,'Missing used_ids Info for exists: ',Parameters:Info),fail}.
5186		%pp_expr1(exists(Ids,P1),_,Info,250) --> !, { member_in_info(used_ids(Used),Info)},
5187		% exists_symbol,pp_expr_ids_in_mode(Ids,LimitReached),
5188		% {add_normal_typing_predicates(Ids,P1,P)},
5189		% " /* Used = ", ppterm(Used), " */ ",
5190		% ".",pp_expr_m(P,221).
5191		:- endif.
5192		pp_expr1(Expr,Type,Info,Prio,LimitReached) --> {member_in_info(sharing(ID,Count,_,_),Info),number(Count),Count>1},!,
5193		"( ",enter_comment," CSE ",ppnumber(ID), ":#", ppnumber(Count),
5194		({member_in_info(negated_cse,Info)} -> " (neg) " ; " "),
5195		({member_in_info(contains_wd_condition,Info)} -> " (wd) " ; " "),
5196		exit_comment, " ",
5197		{delete(Info,sharing(_,_,_,_),Info2)},
5198		pp_expr1(Expr,Type,Info2,Prio,LimitReached), ")".
5199		%pp_expr1(Expr,_,Info,Prio) --> {member_in_info(contains_wd_condition,Info)},!,
5200		% "( /* (wd) */ ", pp_expr2(Expr,Prio), ")".
5201		% pp_expr1(Expr,subst,_Info,Prio) --> !, translate_subst2(Expr,Prio). % TO DO: also allow substitutions here
5202		pp_expr1(value(V),Type,_,Prio,LimitReached) --> !,
5203		{(nonvar(V),V=closure(_,_,_) -> Prio=300 ; Prio=500)}, pp_value_with_type(V,Type,LimitReached).
5204		pp_expr1(comprehension_set(Ids,P1),_,Info,500,LimitReached) --> !,
5205		pp_comprehension_set(Ids,P1,Info,LimitReached).
5206		%pp_expr1(Expr,_,Info,Prio,LimitReached) --> {pp_is_important_info_field(Expr,Info,_)},
5207		% !, pp_important_infos(Expr,Info), pp_expr2(Expr,Prio,LimitReached).
5208		pp_expr1(first_of_pair(X),_,Info,500,LimitReached) --> {was_eventb_destructor(Info,X,Op,Arg)},!,
5209		ppatom(Op), "(",pp_expr(Arg,_,LimitReached), ")".
5210		pp_expr1(second_of_pair(X),_,Info,500,LimitReached) --> {was_eventb_destructor(Info,X,Op,Arg)},!,
5211		ppatom(Op), "(",pp_expr(Arg,_,LimitReached), ")".
5212		%pp_expr1(let_expression(_Ids,Exprs,_P),_Type,Info,500,LimitReached) -->
5213		% % pretty print direct definition operator calls, which get translated using create_z_let
5214		% % However: the lets can get removed; in which case the translated direct definition will be pretty printed
5215		% % also: what if the body of the let has been modified ??
5216		% {member(was(extended_expr(DirectDefOp)),Info),
5217		% bmachine_eventb:stored_operator_direct_definition(DirectDefOp,_Proj,_Theory,Parameters,_Def,_WD,_TypeParas,_Kind),
5218		% %length(Exprs,Arity),,length(Parameters,Arity1), write(found_dd(DirectDefOp,Arity1,Arity2,Proj,Theory)),nl,
5219		% same_length(Parameters,ActualParas), %same_length(TypeParameters,TP),
5220		% append(ActualParas,_TP,Exprs)
5221		% },
5222		% !,
5223		% ppatom(DirectDefOp),
5224		% pp_expr_wrap_l('(',ActualParas,')',LimitReached).
5225		pp_expr1(Expr,_,_Info,Prio,LimitReached) --> pp_expr2(Expr,Prio,LimitReached).
5226
5227		was_eventb_destructor(Info,X,Op,Arg) :- eventb_translation_mode,
5228		member(was(extended_expr(Op)),Info),peel_projections(X,Arg).
5229		is_projection(first_of_pair(A),A).
5230		is_projection(second_of_pair(A),A).
5231		% peel projections constructed for Event-B destructor operator
5232		peel_projections(b(A,_,_),R) :-
5233		(is_projection(A,RA) -> peel_projections(RA,R)
5234		; A = freetype_destructor(_,_,R)).
5235
5236
5237		:- public pp_important_infos/4. % debugging utility
5238		pp_important_infos(Expr,Info) -->
5239		{findall(PPI,pp_is_important_info_field(Expr,Info,PPI),PPInfos), PPInfos \= []},
5240		" ", enter_comment, ppterm(PPInfos), exit_comment, " ".
5241		pp_is_important_info_field(_,Infos,'DO_NOT_ENUMERATE'(X)) :- member(prob_annotation('DO_NOT_ENUMERATE'(X)),Infos).
5242		pp_is_important_info_field(exists(_,_),Infos,'LIFT') :- member(allow_to_lift_exists,Infos).
5243		pp_is_important_info_field(exists(_,_),Infos,used_ids(Used)) :- member(used_ids(Used),Infos).
5244		pp_is_important_info_field(exists(_,_),Infos,'(wd)') :- member(contains_wd_condition,Infos).
5245
5246
5247		pp_expr2(Expr,_,_LimitReached) --> {var(Expr)},!,"_".
5248		pp_expr2(_,_,LimitReached) --> {LimitReached==limit_reached},!,"...".
5249
5250		pp_expr2(atom_string(V),500,_) --> !,pp_atom_opt_latex_mathit(V). % hardwired_atom
5251		pp_expr2(global_set(V),500,_) --> !, pp_identifier(V).
5252		pp_expr2(freetype_set(V),500,_) --> !,{pretty_freetype(V,P)},ppatom_opt_scramble(P).
5253		pp_expr2(lazy_lookup_expr(I),500,_) --> !, pp_identifier(I).
5254		pp_expr2(lazy_lookup_pred(I),500,_) --> !, pp_identifier(I).
5255		pp_expr2(identifier(I),500,_) --> !,
5256		{( I=op(Id) -> true; I=Id)},
5257		( {atomic(Id)} -> ({translated_identifier(Id,TId)},
5258		({latex_mode} -> ppatom(TId) ; pp_identifier(TId)))
5259		;
5260		"'",ppterm(Id), "'").
5261		pp_expr2(integer(N),500,_) --> !, ppnumber(N).
5262		pp_expr2(real(N),500,_) --> !, ppatom(N).
5263		pp_expr2(integer_set(S),500,_) --> !,
5264		{integer_set_mapping(S,T)},ppatom(T).
5265		pp_expr2(string(S),500,_) --> !, string_start_symbol, ppstring_opt_scramble(S), string_end_symbol.
5266		pp_expr2(set_extension(Ext),500,LimitReached) --> !, {set_brackets(L,R)},
5267		pp_expr_wrap_l(L,Ext,R,LimitReached).
5268		pp_expr2(sequence_extension(Ext),500,LimitReached) --> !,
5269		pp_begin_sequence,
5270		({get_preference(translate_print_cs_style_sequences,true)} -> pp_expr_l_sep(Ext,"",LimitReached)
5271		; pp_expr_l_sep(Ext,",",LimitReached)),
5272		pp_end_sequence.
5273		pp_expr2(assign(LHS,RHS),10,LimitReached) --> !,
5274		pp_expr_wrap_l(',',LHS,'',LimitReached), ":=", pp_expr_wrap_l(',',RHS,'',LimitReached).
5275		pp_expr2(assign_single_id(LHS,RHS),10,LimitReached) --> !, pp_expr2(assign([LHS],[RHS]),10,LimitReached).
5276		pp_expr2(parallel(RHS),10,LimitReached) --> !,
5277		pp_expr_wrap_l('||',RHS,'',LimitReached).
5278		pp_expr2(sequence(RHS),10,LimitReached) --> !,
5279		pp_expr_wrap_l(';',RHS,'',LimitReached).
5280		pp_expr2(event_b_comprehension_set(Ids,E,P1),500,LimitReached) --> !, % normally conversion above should trigger; this is if we call pp_expr for untyped expressions
5281		pp_event_b_comprehension_set(Ids,E,P1,LimitReached).
5282		pp_expr2(recursive_let(Id,S),500,LimitReached) --> !,
5283		({eventb_translation_mode} -> "" % otherwise we get strange characters in Rodin
5284		; enter_comment," recursive ID ", pp_expr(Id,_,LimitReached), " ", exit_comment),
5285		pp_expr(S,_,LimitReached).
5286		pp_expr2(image(A,B),300,LimitReached) --> !,
5287		pp_expr_m(A,249,LimitReached),"[", % was 0; but we may have to bracket A; e.g., f <| {2} [{2}] is not ok; 250 is priority of lambda
5288		pp_expr_m(B,0,LimitReached),"]". % was 500, now set to 0: we never need an outer pair of () !?
5289		pp_expr2(function(A,B),300,LimitReached) --> !,
5290		pp_expr_m(A,249,LimitReached), % was 0; but we may have to bracket A; e.g., f <| {2} (2) is not ok; 250 is priority of lambda
5291		pp_function_left_bracket,
5292		pp_expr_m(B,0,LimitReached), % was 500, now set to 0: we never need an outer pair of () !?
5293		pp_function_right_bracket.
5294		pp_expr2(definition(A,B),300,LimitReached) --> !, % definition call; usually inlined,...
5295		ppatom(A),
5296		pp_function_left_bracket,
5297		pp_expr_l_sep(B,",",LimitReached),
5298		pp_function_right_bracket.
5299		pp_expr2(operation_call_in_expr(A,B),300,LimitReached) --> !,
5300		pp_expr_m(A,249,LimitReached),
5301		pp_function_left_bracket,
5302		pp_expr_l_sep(B,",",LimitReached),
5303		pp_function_right_bracket.
5304		pp_expr2(enumerated_set_def(GS,ListEls),200,LimitReached) --> !, % for pretty printing enumerate set defs
5305		{reverse(ListEls,RLE)}, /* they have been inserted in inverse order */
5306		pp_identifier(GS), "=", pp_expr_wrap_l('{',RLE,'}',LimitReached).
5307		pp_expr2(forall(Ids,D1,P),Prio,LimitReached) --> !,
5308		({eventb_translation_mode} -> {Prio=60} ; {Prio=250}), % in Rodin forall/exists cannot be mixed with &, or, <=>, ...
5309		({eventb_translation_mode} -> "(" ; ""), % always put brackets around the forall in Rodin
5310		forall_symbol,pp_expr_ids_in_mode(Ids,LimitReached),
5311		{add_normal_typing_predicates(Ids,D1,D)},
5312		dot_symbol,pp_expr_m(b(implication(D,P),pred,[]),221,LimitReached),
5313		({eventb_translation_mode} -> ")" ; "").
5314		pp_expr2(exists(Ids,P1),Prio,LimitReached) --> !,
5315		({eventb_translation_mode} -> {Prio=60} ; {Prio=250}), % exists has Prio 250, but dot has 220
5316		({eventb_translation_mode} -> "(" ; ""), % always put brackets around the exists in Rodin
5317		exists_symbol,pp_expr_ids_in_mode(Ids,LimitReached),
5318		{add_normal_typing_predicates(Ids,P1,P)},
5319		dot_symbol,
5320		({eventb_translation_mode} -> {MinPrio=29} ; {MinPrio=500}),
5321		% used to be 221, but #x.x>7 or #x.not(...) are not parsed by Atelier-B or ProB, x.x and x.not are parsed as composed identifiers
5322		% In Event-B ∃y·y>x ∧ (y=x+1 ∨ y=x+2) is valid and requires no outer parenthesis (if not on the left side of another predicate!)
5323		pp_expr_m(P,MinPrio,LimitReached),
5324		({eventb_translation_mode} -> ")" ; "").
5325		pp_expr2(record_field(R,I),250,LimitReached) --> !,
5326		pp_expr_m(R,251,LimitReached),"'",pp_identifier(I).
5327		pp_expr2(rec(Fields),500,LimitReached) --> !,
5328		{function_like_in_mode(rec,Symbol)},
5329		ppatom(Symbol), "(",pp_expr_fields(Fields,LimitReached),")".
5330		pp_expr2(struct(Rec),500,LimitReached) -->
5331		{get_texpr_expr(Rec,rec(Fields)),Val=false ; get_texpr_expr(Rec,value(rec(Fields)))},!,
5332		{function_like_in_mode(struct,Symbol)},
5333		ppatom(Symbol), "(",
5334		({Val==false} -> pp_expr_fields(Fields,LimitReached)
5335		; pp_value_l(Fields,',',LimitReached)),
5336		")".
5337		pp_expr2(freetype_case(_FT,L,Expr),Prio,LimitReached) --> !,
5338		%{Prio=500}, pp_freetype_term('__is_ft_case',FT,L,Expr,LimitReached).
5339		% we now pretty-print it as Expr : ran(L) assuming there is a constant L generated for every case
5340		{FTCons = b(identifier(L),any,[]), RanFTCons = b(range(FTCons),any,[])},
5341		pp_expr(b(member(Expr,RanFTCons),pred,[]),Prio,LimitReached).
5342		pp_expr2(freetype_constructor(_FT,Case,Expr),Prio,LimitReached) --> !,
5343		{FTCons = b(identifier(Case),any,[])},
5344		pp_expr(b(function(FTCons,Expr),any,[]),Prio,LimitReached).
5345		% ppatom_opt_scramble(Case),ppatom('('),pp_expr(Expr,_,LimitReached),ppatom(')').
5346		pp_expr2(freetype_destructor(_FT,Case,Expr),Prio,LimitReached) --> !,
5347		% pretty print it as: Case~(Expr)
5348		{FTCons = b(identifier(Case),any,[]), Destr = b(reverse(FTCons),any,[])},
5349		pp_expr(b(function(Destr,Expr),any,[]),Prio,LimitReached).
5350		% ({unicode_mode}
5351		% -> {unicode_translation(reverse,PowMinus1Symbol)},
5352		% ppatom(Case),ppatom(PowMinus1Symbol), % Note: we do not print the freetype's name FT
5353		% "(",pp_expr_m(Expr,0,LimitReached),")"
5354		% ; pp_freetype_term('__ft~',FT,Case,Expr,LimitReached) % TODO: maybe find better print
5355		% ).
5356		pp_expr2(let_predicate(Ids,Exprs,P),1,LimitReached) --> !,
5357		pp_expr_let_exists(Ids,Exprs,P,LimitReached). % instead of pp_expr_let
5358		pp_expr2(let_expression(Ids,Exprs,P),1,LimitReached) --> !,
5359		pp_expr_let(Ids,Exprs,P,LimitReached).
5360		pp_expr2(let_expression_global(Ids,Exprs,P),1,LimitReached) --> !, " /", "* global *", "/ ",
5361		pp_expr_let(Ids,Exprs,P,LimitReached).
5362		pp_expr2(lazy_let_pred(Id,Expr,P),Pr,LimitReached) --> !, pp_expr2(lazy_let_expr(Id,Expr,P),Pr,LimitReached).
5363		pp_expr2(lazy_let_subst(Id,Expr,P),Pr,LimitReached) --> !, pp_expr2(lazy_let_expr(Id,Expr,P),Pr,LimitReached).
5364		pp_expr2(lazy_let_expr(Id,Expr,P),1,LimitReached) --> !,
5365		pp_expr_let([Id],[Expr],P,LimitReached).
5366		pp_expr2(norm_conjunct(Cond,[]),1,LimitReached) --> !, % norm_conjunct: flattened version generated by b_interpreter_check,...
5367		"( ",pp_expr(Cond,_,LimitReached), ")".
5368		pp_expr2(norm_conjunct(Cond,[H|T]),1,LimitReached) --> !,
5369		"( ",pp_expr(Cond,_,LimitReached), ") ", and_symbol, " (", pp_expr2(norm_conjunct(H,T),_,LimitReached), ")".
5370		pp_expr2(assertion_expression(Cond,Msg,Expr),1,LimitReached) --> !,
5371		" ASSERT_EXPR (",
5372		pp_expr_m(b(convert_bool(Cond),pred,[]),30,LimitReached), ",",
5373		pp_expr_m(string(Msg),30,LimitReached), ",",
5374		pp_expr_m(Expr,30,LimitReached),
5375		" )".
5376		%pp_expr2(assertion_expression(Cond,_Msg,Expr),1) --> !,
5377		% "__ASSERT ",pp_expr_m(Cond,30),
5378		% " IN ", pp_expr_m(Expr,30).
5379		pp_expr2(partition(S,Elems),500,LimitReached) -->
5380		{eventb_translation_mode ;
5381		\+ atelierb_mode(_), length(Elems,Len), Len>50 % we need to print a quadratic number of disjoints
5382		},!,
5383		"partition(",pp_expr(S,_,LimitReached),
5384		({Elems=[]} -> ")" ; pp_expr_wrap_l(',',Elems,')',LimitReached)).
5385		pp_expr2(partition(S,Elems),500,LimitReached) --> !,
5386		"(",pp_expr(S,_,LimitReached), " = ",
5387		({Elems=[]} -> "{})"
5388		; pp_expr_l_sep(Elems,"\\/",LimitReached), pp_all_disjoint(Elems,LimitReached),")").
5389		pp_expr2(finite(S),Prio,LimitReached) --> {\+ eventb_translation_mode}, %{atelierb_mode(_)},
5390		!,
5391		pp_expr2(member(S,b(fin_subset(S),set(any),[])),Prio,LimitReached).
5392		pp_expr2(if_then_else(If,Then,Else),1,LimitReached) --> {animation_minor_mode(z)},!,
5393		"\\IF ",pp_expr_m(If,30,LimitReached),
5394		" \\THEN ",pp_expr_m(Then,30,LimitReached),
5395		" \\ELSE ",pp_expr_m(Else,30,LimitReached).
5396		%pp_expr2(if_then_else(If,Then,Else),1) --> {unicode_mode},!,
5397		% "if ",pp_expr_m(If,30), " then ",pp_expr_m(Then,30), " else ",pp_expr_m(Else,30).
5398		pp_expr2(if_then_else(If,Then,Else),Prio,LimitReached) --> {atelierb_mode(_)},!,
5399		% print IF-THEN-ELSE using a translation that Atelier-B can understand:
5400		{rewrite_if_then_else_expr_to_b(if_then_else(If,Then,Else), NExpr),
5401		get_texpr_type(Then,Type),
5402		NAst = b(NExpr,Type,[])},
5403		% construct {d,x| If => x=Then & not(if) => x=Else}(TRUE)
5404		pp_expr(NAst,Prio,LimitReached).
5405		pp_expr2(if_then_else(If,Then,Else),1,LimitReached) --> !,
5406		pp_atom_opt_mathit('IF'),pp_space, % "IF ",
5407		pp_expr_m(If,30,LimitReached),
5408		pp_space, pp_atom_opt_mathit('THEN'),pp_space, %" THEN ",
5409		pp_expr_m(Then,30,LimitReached),
5410		pp_space, pp_atom_opt_mathit('ELSE'),pp_space, %" ELSE ",
5411		pp_expr_m(Else,30,LimitReached),
5412		pp_space, pp_atom_opt_mathit('END'). %" END"
5413		pp_expr2(kodkod(Id,Identifiers),300,LimitReached) --> !,
5414		"KODKOD_CALL(",ppnumber(Id),": ",pp_expr_ids(Identifiers,LimitReached),")".
5415		pp_expr2(Expr,500,_) -->
5416		{constants_in_mode(Expr,Symbol)},!,ppatom(Symbol).
5417		pp_expr2(equal(A,B),Prio,LimitReached) -->
5418		{get_preference(pp_propositional_logic_mode,true), % a mode for printing propositional logic formuli
5419		is_boolean_value(B,BV),
5420		get_texpr_id(A,_)},!,
5421		({BV=pred_true} -> pp_expr(A,Prio,LimitReached)
5422		; pp_expr2(negation(b(equal(A,b(boolean_true,boolean,[])),pred,[])),Prio,LimitReached)).
5423		pp_expr2(Expr,Prio,LimitReached) -->
5424		{functor(Expr,F,1),
5425		unary_prefix(F,Symbol,Prio),!,
5426		arg(1,Expr,Arg),APrio is Prio+1},
5427		ppatom(Symbol),
5428		({F=unary_minus, eventb_translation_mode} -> "" ; " "), % no space between unary minus and integer literal in Event-B
5429		pp_expr_m(Arg,APrio,LimitReached).
5430		pp_expr2(Expr,500,LimitReached) -->
5431		{functor(Expr,F,1),
5432		unary_prefix_parentheses(F,Symbol),!,
5433		arg(1,Expr,Arg)},
5434		pp_atom_opt_latex(Symbol), "(", pp_expr(Arg,_,LimitReached), ")".
5435		pp_expr2(Expr,Prio,LimitReached) -->
5436		{functor(Expr,F,1),
5437		unary_postfix_in_mode(F,Symbol,Prio),!,
5438		arg(1,Expr,Arg),APrio is Prio+1},
5439		pp_expr_m(Arg,APrio,LimitReached),ppatom(Symbol).
5440		pp_expr2(power_of(Left,Right),Prio,LimitReached) --> {latex_mode},!, % special case, as we need to put {} around RHS
5441		{Prio=200, LPrio is Prio+1, RPrio = Prio},
5442		pp_expr_m(Left,LPrio,LimitReached),
5443		"^{",
5444		pp_expr_m(Right,RPrio,LimitReached),
5445		"}".
5446		pp_expr2(power_of_real(Left,Right),Prio,LimitReached) --> !,
5447		({get_texpr_expr(Right,convert_real(RI))}
5448		-> pp_expr2(power_of(Left,RI),Prio,LimitReached) % the Atelier-B power_of expects integer exponent
5449		; pp_external_call('RPOW',[Left,Right],expression,Prio,LimitReached)
5450		).
5451		pp_expr2(Expr,OPrio,LimitReached) -->
5452		{functor(Expr,F,2),
5453		binary_infix_in_mode(F,Symbol,Prio,Ass),!,
5454		arg(1,Expr,Left),
5455		arg(2,Expr,Right),
5456		( Ass = left, binary_infix_symbol(Left,Symbol) -> LPrio is Prio-1, RPrio is Prio+1
5457		; Ass = right, binary_infix_symbol(Right,Symbol) -> LPrio is Prio+1, RPrio is Prio-1
5458		; LPrio is Prio+1, RPrio is Prio+1)},
5459		% Note: Prio+1 is actually not necessary, Prio would be sufficient, as pp_expr_m uses a strict comparison <
5460		({always_surround_by_parentheses(F)} -> "(",{OPrio=1000} ; {OPrio=Prio}),
5461		pp_expr_m(Left,LPrio,LimitReached),
5462		" ", ppatom(Symbol), " ",
5463		pp_expr_m(Right,RPrio,LimitReached),
5464		({always_surround_by_parentheses(F)} -> ")" ; []).
5465		pp_expr2(first_of_pair(X),500,LimitReached) --> {get_texpr_type(X,couple(From,To))},!,
5466		"prj1(", % TO DO: Latex version
5467		({\+ atelierb_mode(_)} % eventb_translation_mode
5468		-> "" % no need to print types in Event-B or with new parser;
5469		% TODO: also with new parser no longer required; only print in Atelier-B mode
5470		; {pretty_normalized_type(From,FromT),
5471		pretty_normalized_type(To,ToT)},
5472		pp_atom_opt_latex(FromT), ",", pp_atom_opt_latex(ToT),
5473		")("
5474		),
5475		pp_expr(X,_,LimitReached),")".
5476		pp_expr2(second_of_pair(X),500,LimitReached) --> {get_texpr_type(X,couple(From,To))},!,
5477		"prj2(", % TO DO: Latex version
5478		({\+ atelierb_mode(_)} -> "" % no need to print types in Event-B or with new parser
5479		; {pretty_normalized_type(From,FromT),
5480		pretty_normalized_type(To,ToT)},
5481		pp_atom_opt_latex(FromT), ",", pp_atom_opt_latex(ToT),
5482		")("
5483		),
5484		pp_expr(X,_,LimitReached),")".
5485		pp_expr2(Call,Prio,LimitReached) --> {external_call(Call,Kind,Symbol,Args)},!,
5486		pp_external_call(Symbol,Args,Kind,Prio,LimitReached).
5487		pp_expr2(card(A),500,LimitReached) --> {latex_mode, get_preference(latex_pp_greek_ids,true)},!,
5488		"|",pp_expr_m(A,0,LimitReached),"|".
5489		pp_expr2(Expr,500,LimitReached) -->
5490		{functor(Expr,F,_),
5491		function_like_in_mode(F,Symbol),!,
5492		Expr =.. [F|Args]},
5493		ppatom(Symbol),
5494		({Args=[]}
5495		-> "" % some operators like pred and succ do not expect arguments
5496		; pp_expr_wrap_l('(',Args,')',LimitReached)).
5497		pp_expr2(Expr,250,LimitReached) -->
5498		{functor(Expr,F,3),
5499		quantified_in_mode(F,Symbol),
5500		Expr =.. [F,Ids,P1,E],
5501		!,
5502		add_normal_typing_predicates(Ids,P1,P)},
5503		ppatom(Symbol),pp_expr_ids(Ids,LimitReached),".(",
5504		pp_expr_m(P,11,LimitReached),pp_such_that_bar(E),
5505		pp_expr_m(E,11,LimitReached),")".
5506		pp_expr2(Expr,Prio,LimitReached) -->
5507		{functor(Expr,F,N),
5508		(debug_mode(on)
5509		-> format('**** Unknown functor ~w/~w in pp_expr2~n expression: ~w~n',[F,N,Expr])
5510		; format('**** Unknown functor ~w/~w in pp_expr2~n',[F,N])
5511		),
5512		%add_internal_error('Unknown Expression: ',pp_expr2(Expr,Prio)),
5513		Prio=20},
5514		ppterm_with_limit_reached(Expr,LimitReached).
5515
5516		:- use_module(external_function_declarations,[synonym_for_external_predicate/2]).
5517
5518		pp_external_call('MEMOIZE_STORED_FUNCTION',[TID],_,500,LimitReached) -->
5519		{get_integer(TID,ID),memoization:get_registered_function_name(ID,Name)},!,
5520		pp_expr_m(atom_string(Name),20,LimitReached),
5521		" /*@memo ", pp_expr_m(TID,20,LimitReached), "*/".
5522		pp_external_call('STRING_LENGTH',[Arg],_,Prio,LimitReached) -->
5523		{get_preference(allow_sequence_operators_on_strings,true)},!,
5524		pp_expr2(size(Arg),Prio,LimitReached).
5525		pp_external_call('STRING_APPEND',[Arg1,Arg2],_,Prio,LimitReached) -->
5526		{get_preference(allow_sequence_operators_on_strings,true)},!,
5527		pp_expr2(concat(Arg1,Arg2),Prio,LimitReached).
5528		pp_external_call('STRING_CONC',[Arg1],_,Prio,LimitReached) -->
5529		{get_preference(allow_sequence_operators_on_strings,true)},!,
5530		pp_expr2(general_concat(Arg1),Prio,LimitReached).
5531		% we could also pretty-print RMUL, ...
5532		pp_external_call(PRED,Args,pred,Prio,LimitReached) -->
5533		{get_preference(translate_ids_to_parseable_format,true),
5534		synonym_for_external_predicate(PRED,FUNC)},
5535		!, % print external predicate as function, as parser can only parse the latter without access to DEFINITIONS
5536		pp_expr2(equal(b(external_function_call(FUNC,Args),boolean,[]),
5537		b(boolean_true,boolean,[])),Prio,LimitReached).
5538		pp_external_call(Symbol,Args,_,Prio,LimitReached) -->
5539		({invisible_external_pred(Symbol)}
5540		-> pp_expr2(truth,Prio,LimitReached),
5541		" /* ",pp_expr_m(atom_string(Symbol),20,LimitReached),pp_expr_wrap_l('(',Args,') */',LimitReached)
5542		; {Prio=500},pp_expr_m(atom_string(Symbol),20,LimitReached),
5543		pp_expr_wrap_l('(',Args,')',LimitReached) % pp_expr_wrap_l('/*EXT:*/(',Args,')')
5544		).
5545
5546		invisible_external_pred('LEQ_SYM').
5547		invisible_external_pred('LEQ_SYM_BREAK'). % just for symmetry breaking foralls,...
5548		external_call(external_function_call(Symbol,Args),expression,Symbol,Args).
5549		external_call(external_pred_call(Symbol,Args),pred,Symbol,Args).
5550		external_call(external_subst_call(Symbol,Args),subst,Symbol,Args).
5551
5552		pp_all_disjoint([H1,H2],LimitReached) --> !, " ",and_symbol," ", pp_disjoint(H1,H2,LimitReached).
5553		pp_all_disjoint([H1|T],LimitReached) --> pp_all_disjoint_aux(T,H1,LimitReached), pp_all_disjoint(T,LimitReached).
5554		pp_all_disjoint([],_) --> "".
5555
5556		pp_all_disjoint_aux([],_,_) --> "".
5557		pp_all_disjoint_aux([H2|T],H1,LimitReached) --> " ",and_symbol," ",
5558		pp_disjoint(H1,H2,LimitReached), pp_all_disjoint_aux(T,H1,LimitReached).
5559
5560		pp_disjoint(H1,H2,LimitReached) --> pp_expr(H1,_), "/\\", pp_expr(H2,_,LimitReached), " = {}".
5561
5562
5563		% given a list of predicates and an ID either extract ID:Set and return Set or return its type as string
5564		select_membership([],TID,[],atom_string(TS)) :- % atom_string used as wrapper for pp_expr2
5565		get_texpr_type(TID,Type), pretty_type(Type,TS).
5566		select_membership([Pred|Rest],TID,Rest,Set) :-
5567		Pred = b(member(TID2,Set),pred,_),
5568		same_id(TID2,TID,_),!.
5569		select_membership([Pred|Rest],TID,Rest,Set) :-
5570		Pred = b(equal(TID2,EqValue),pred,_),
5571		same_id(TID2,TID,_),!, get_texpr_type(TID,Type),
5572		Set = b(set_extension([EqValue]),set(Type),[]).
5573		select_membership([Pred|T],TID,[Pred|Rest],Set) :-
5574		select_membership(T,TID,Rest,Set).
5575
5576		% pretty print prj1/prj2
5577		pp_prj12(Prj,Set1,Set2,LimitReached) -->
5578		ppatom(Prj),"(",pp_expr(Set1,_,LimitReached),",",pp_expr(Set2,_),")".
5579
5580		%:- use_module(bsyntaxtree,[is_a_disjunct/3, get_integer/2]).
5581
5582		pp_comprehension_set(Ids,P1,Info,LimitReached) -->
5583		pp_comprehension_set5(Ids,P1,Info,LimitReached,_).
5584
5585		% the extra argument of pp_comprehension_set5 indicates whether a special(Rule) was applied or not
5586		%pp_comprehension_set(IDs,Body,Info,LimitReached,_) --> {write(pp(IDs,Body,Info)),nl,fail}.
5587		pp_comprehension_set5([TID1,TID2,TID3],Body,_Info,LimitReached,special(Proj)) -->
5588		/* This comprehension set was a projection function (prj1/prj2) */
5589		% %(z_,z__).(z__ : NATURAL|z_) -> prj1(INTEGER,NATURAL)
5590		{get_texpr_id(TID1,ID1), % sometimes _zzzz_unary or _prj_arg1__
5591		get_texpr_id(TID2,ID2), % sometimes _zzzz_binary or _prj_arg2__
5592		get_texpr_id(TID3,LambdaID),
5593	?	get_lambda_equality(Body,LambdaID,RestBody,ResultExpr),
5594		get_texpr_id(ResultExpr,ResultID),
5595		(ResultID = ID1 -> Proj = prj1 ; ResultID = ID2, Proj = prj2),
5596		flatten_conjunctions(RestBody,Rest1),
5597		select_membership(Rest1,TID1,Rest2,Set1), % will extract full type if no membership there
5598		select_membership(Rest2,TID2,[],Set2)}, % ditto
5599		!,
5600		pp_prj12(Proj,Set1,Set2,LimitReached).
5601		pp_comprehension_set5([ID1|T],Body,Info,LimitReached,special(disjunct)) --> {is_a_disjunct(Body,B1,B2),
5602		get_last(T,ID1,_FrontIDs,LastID),
5603		is_lambda_result_id(LastID,_Suffix)},!, % we seem to have the union of two lambda expressions
5604		"(", pp_comprehension_set([ID1|T],B1,Info,LimitReached),
5605		" \\/ ", pp_comprehension_set([ID1|T],B2,Info,LimitReached), ")".
5606		pp_comprehension_set5(Paras,Body,_,_,special(pred)) --> % '_lambda_result_'
5607		{is_pred_compset(Paras,Body)},
5608		!,
5609		"pred".
5610		pp_comprehension_set5(Paras,Body,_,_,special(succ)) --> % '_lambda_result_'
5611		{is_succ_compset(Paras,Body)},
5612		!,
5613		"succ".
5614		pp_comprehension_set5(Paras,Body,Info,LimitReached,special(lambda)) -->
5615		{detect_lambda_comprehension(Paras,Body, FrontIDs,LambdaBody,ToExpr)},
5616		!,
5617		{add_normal_typing_predicates(FrontIDs,LambdaBody,TLambdaBody)},
5618		({eventb_translation_mode} -> "(" ; ""), % put brackets around the lambda in Rodin
5619		pp_annotations(Info,Body),
5620		lambda_symbol, % "%"
5621		pp_lambda_identifiers(FrontIDs,LimitReached),
5622		".",
5623		({eventb_translation_mode} -> {IPrio=30} ; {IPrio=11}, "("), % In Rodin it is not ok to write (P|E)
5624		pp_expr_m(TLambdaBody,IPrio,LimitReached), % Check 11 against prio of . and |
5625		pp_such_that_bar(ToExpr),
5626		pp_expr_m(ToExpr,IPrio,LimitReached),
5627		")".
5628		pp_comprehension_set5(TIds,Body,Info,LimitReached,special(event_b_comprehension_set)) -->
5629		% detect Event-B style set comprehensions and use bullet • or Event-B notation such as {x·x ∈ 1 ‥ 3|x * 10}
5630		% gets translated to {`__comp_result__`|∃x·(x ∈ 1 ‥ 3 ∧ `__comp_result__` = x * 10)}
5631	?	{is_eventb_comprehension_set(TIds,Body,Info,Ids,P1,EXPR), \+ atelierb_mode(_)},!, % print rewritten version for AtelierB
5632		pp_annotations(Info,P1),
5633		left_set_bracket,
5634		pp_expr_l(Ids,LimitReached), % here we must separate with , not with |-> via pp_expr_l_pair_in_mode !
5635		{add_normal_typing_predicates(Ids,P1,P)},
5636		dot_bullet_symbol,
5637		pp_expr_m(P,11,LimitReached),
5638		pp_such_that_bar(P),
5639		pp_expr_m(EXPR,11,LimitReached),
5640		right_set_bracket.
5641		pp_comprehension_set5(Ids,P1,_Info,LimitReached,normal) --> {atelierb_mode(prover(ml))},!,
5642		"SET(",
5643		pp_expr_l_pair_in_mode(Ids,LimitReached),
5644		").(",
5645		{add_normal_typing_predicates(Ids,P1,P)},
5646		pp_expr_m(P,11,LimitReached),
5647		")".
5648		pp_comprehension_set5(Ids,P1,Info,LimitReached,normal) -->
5649		pp_annotations(Info,P1),
5650		left_set_bracket,
5651		pp_expr_l_pair_in_mode(Ids,LimitReached),
5652		{add_normal_typing_predicates(Ids,P1,P)},
5653		pp_such_that_bar(P),
5654		pp_expr_m(P,11,LimitReached),
5655		right_set_bracket.
5656
5657
5658		detect_lambda_comprehension([ID1|T],Body, FrontIDs,LambdaBody,ToExpr) :-
5659		get_last(T,ID1,FrontIDs,LastID),
5660		FrontIDs=[_|_], % at least one identifier for the lambda
5661		is_lambda_result_id(LastID,Suffix),
5662		% nl, write(lambda(Body,T,ID1)),nl,
5663		(is_an_equality(Body,From,ToExpr) -> LambdaBody = b(truth,pred,[])
5664		; is_a_conjunct(Body,LambdaBody,Equality),
5665		is_an_equality(Equality,From,ToExpr)),
5666		is_lambda_result_id(From,Suffix).
5667
5668		pp_annotations(V,_) --> {var(V), format('Illegal variable info field in pp_annotations: ~w~n',[V])},!,
5669		"/* ILLEGAL VARIABLE INFO FIELD */".
5670	?	pp_annotations(INFO,_) --> {member(prob_annotation('SYMBOLIC'),INFO)},!,
5671		"/*@symbolic*/ ".
5672	?	pp_annotations(_,b(_,_,INFO)) --> {nonvar(INFO),member(prob_annotation('SYMBOLIC'),INFO)},!,
5673		"/*@symbolic*/ ".
5674		% TO DO: maybe also print other annotations like memoize, recursive ?
5675		pp_annotations(_,_) --> "".
5676
5677		% in Event-B style: { x,y . P | E }
5678		pp_event_b_comprehension_set(Ids,E,P1,LimitReached) -->
5679		left_set_bracket,pp_expr_l(Ids,LimitReached), % use comma separated list; maplet is not accepted by Rodin
5680		{add_normal_typing_predicates(Ids,P1,P)},
5681		dot_symbol,pp_expr_m(P,11,LimitReached),
5682		pp_such_that_bar(P),pp_expr_m(E,11,LimitReached),right_set_bracket.
5683
5684		pp_lambda_identifiers([H1,H2|T],LimitReached) --> {\+ eventb_translation_mode},!,
5685		"(",pp_expr_l([H1,H2|T],LimitReached),")".
5686		pp_lambda_identifiers(L,LimitReached) --> pp_expr_l_pair_in_mode(L,LimitReached).
5687
5688		pp_such_that_bar(_) --> {latex_mode},!, "\\mid ".
5689		pp_such_that_bar(_) --> {unicode_mode},!, "\x2223\". % used by Rodin
5690		pp_such_that_bar(b(unary_minus(_),_,_)) --> !, " | ". % otherwise AtelierB complains about illegal token |-
5691		pp_such_that_bar(b(unary_minus_real(_),_,_)) --> !, " | ". % otherwise AtelierB complains about illegal token |-
5692		pp_such_that_bar(_Next) --> "|".
5693		pp_such_that_bar --> {latex_mode},!, "\\mid ".
5694		pp_such_that_bar --> {unicode_mode},!, "\x2223\".
5695		pp_such_that_bar --> "|".
5696
5697		is_an_equality(b(equal(A,B),_,_),A,B).
5698
5699		integer_set_mapping(A,B) :- integer_set_mapping(A,_,B).
5700	?	integer_set_mapping(A,integer_set,B) :- unicode_mode, unicode_translation(A,B),!.
5701		integer_set_mapping(A,integer_set,B) :- latex_mode, latex_integer_set_translation(A,B),!.
5702		integer_set_mapping(A,integer_set,B) :- atelierb_mode(prover(PPML)),
5703		atelierb_pp_translation(A,PPML,B),!.
5704		integer_set_mapping(A,integer_set,B) :-
5705		eventb_translation_mode, eventb_integer_mapping(A,B),!.
5706		integer_set_mapping(ISet,user_set,Res) :- atomic(ISet),!,Res=ISet.
5707		integer_set_mapping(_ISet,unknown_set,'integer_set(??)').
5708
5709		eventb_integer_mapping('INTEGER','INT').
5710		eventb_integer_mapping('NATURAL','NAT').
5711		eventb_integer_mapping('NATURAL1','NAT1').
5712
5713		real_set_mapping(A,B) :- unicode_mode, unicode_translation(A,B),!.
5714		real_set_mapping(X,X). % TO DO: unicode_mode,...
5715
5716		:- dynamic comment_level/1.
5717		reset_pp :- retractall(comment_level(_)).
5718		enter_comment --> {retract(comment_level(N))},!, "(*", {N1 is N+1, assertz(comment_level(N1))}.
5719		enter_comment --> "/*", {assertz(comment_level(1))}.
5720		exit_comment --> {retract(comment_level(N))},!,
5721		({N>1} -> "*)", {N1 is N-1, assertz(comment_level(N1))} ; "*/").
5722		exit_comment --> "*/", {add_internal_error('Unmatched closing comment:',exit_comment)}.
5723		% TO DO: ensure reset_pp is called when starting to pretty print, in case timeout occurs in previous pretty prints
5724
5725		%get_last([b(identifier(_lambda_result_10),set(couple(integer,set(couple(integer,integer)))),[])],b(identifier(i),integer,[]),[b(identifier(i),integer,[])],b(identifier(_lambda_result_10),set(couple(integer,set(couple(integer,integer)))),[]))
5726
5727		get_last([],Last,[],Last).
5728		get_last([H2|T],H1,[H1|LT],Last) :- get_last(T,H2,LT,Last).
5729
5730		pp_expr_wrap_l(Pre,Expr,Post,LimitReached) -->
5731		ppatom(Pre),pp_expr_l(Expr,LimitReached),ppatom(Post).
5732		%pp_freetype_term(Term,FT,L,Expr,LimitReached) -->
5733		% {pretty_freetype(FT,P)},
5734		% ppatom(Term),"(",ppatom_opt_scramble(P),",",
5735		% ppatom(L),",",pp_expr_m(Expr,500,LimitReached),")".
5736
5737		% print a list of expressions, seperated by commas
5738		pp_expr_l_pair_in_mode(List,LimitReached) --> {eventb_translation_mode},!,
5739		{maplet_symbol(MapletStr,[])},
5740		pp_expr_l_sep(List,MapletStr,LimitReached).
5741		pp_expr_l_pair_in_mode(List,LimitReached) --> pp_expr_l_sep(List,",",LimitReached).
5742		pp_expr_l(List,LimitReached) --> pp_expr_l_sep(List,",",LimitReached).
5743
5744		pp_expr_l_sep([Expr],_,LimitReached) --> !,
5745		pp_expr_m(Expr,0,LimitReached).
5746		pp_expr_l_sep(List,Sep,LimitReached) --> pp_expr_l2(List,Sep,LimitReached).
5747		pp_expr_l2([],_Sep,_) --> !.
5748		pp_expr_l2([Expr|Rest],Sep,LimitReached) -->
5749		{get_sep_prio(Sep,Prio)},
5750		pp_expr_m(Expr,Prio,LimitReached),
5751		pp_expr_l3(Rest,Sep,LimitReached).
5752		pp_expr_l3([],_Sep,_) --> !.
5753		pp_expr_l3(Rest,Sep,LimitReached) -->
5754		Sep,pp_expr_l2(Rest,Sep,LimitReached).
5755
5756		get_sep_prio(",",Prio) :- !, Prio=116. % Prio of , is 115
5757		get_sep_prio("\\/",Prio) :- !, Prio=161.
5758		get_sep_prio("/\\",Prio) :- !, Prio=161.
5759		get_sep_prio("|->",Prio) :- !, Prio=161.
5760		get_sep_prio([8614],Prio) :- !, Prio=161.
5761		%
5762		get_sep_prio(_,161).
5763
5764		% print the fields of a record
5765		pp_expr_fields([field(Name,Expr)],LimitReached) --> !,
5766		pp_identifier(Name),":",pp_expr_m(Expr,120,LimitReached).
5767		pp_expr_fields(Fields,LimitReached) -->
5768		pp_expr_fields2(Fields,LimitReached).
5769		pp_expr_fields2([],_) --> !.
5770		pp_expr_fields2([field(Name,Expr)|Rest],LimitReached) -->
5771		pp_identifier(Name),":",
5772		pp_expr_m(Expr,116,LimitReached),
5773		pp_expr_fields3(Rest,LimitReached).
5774		pp_expr_fields3([],_) --> !.
5775		pp_expr_fields3(Rest,LimitReached) -->
5776		",",pp_expr_fields2(Rest,LimitReached).
5777
5778		% TO DO: test more fully; identifiers seem to be wrapped in brackets
5779		pp_expr_let_exists(Ids,Exprs,P,LimitReached) -->
5780		exists_symbol,
5781		({eventb_translation_mode} -> % otherwise we get strange characters in Rodin, no (.) allowed in Rodin
5782		pp_expr_ids_in_mode(Ids,LimitReached),
5783		".("
5784		; " /* LET */ (",
5785		pp_expr_l_pair_in_mode(Ids,LimitReached),
5786		").("
5787		),
5788		pp_expr_let_pred_exprs(Ids,Exprs,LimitReached),
5789		({is_truth(P)} -> ""
5790		; " ",and_symbol," ", pp_expr_m(P,40,LimitReached)),
5791		")".
5792
5793		pp_expr_let_pred_exprs([],[],_) --> !.
5794		pp_expr_let_pred_exprs([Id|Irest],[Expr|Erest],LimitReached) -->
5795		" ",pp_expr_let_id(Id,LimitReached),
5796		"=",pp_expr_m(Expr,400,LimitReached),
5797		( {Irest=[]} -> [] ; " ", and_symbol),
5798		pp_expr_let_pred_exprs(Irest,Erest,LimitReached).
5799
5800		% print a LET expression
5801		pp_expr_let(_Ids,Exprs,P,LimitReached) -->
5802		{eventb_translation_mode,
5803		P=b(_,_,I), member(was(extended_expr(Op)),I)},!, % let was created by direct_definition for a theory operator call
5804		ppatom(Op),
5805		pp_function_left_bracket,
5806		pp_expr_l_sep(Exprs,",",LimitReached),
5807		%pp_expr_let_pred_exprs(Ids,Exprs,LimitReached) % write entire predicate with parameter names
5808		pp_function_right_bracket.
5809		pp_expr_let(Ids,Exprs,P,LimitReached) -->
5810		"LET ", pp_expr_ids_no_parentheses(Ids,LimitReached),
5811		" BE ", pp_expr_let_pred_exprs(Ids,Exprs,LimitReached),
5812		" IN ",pp_expr_m(P,5,LimitReached),
5813		" END".
5814
5815		pp_expr_let_id(ID,LimitReached) --> {atomic(ID),!, write(unwrapped_let_id(ID)),nl},
5816		pp_expr_m(identifier(ID),500,LimitReached).
5817		pp_expr_let_id(ID,LimitReached) --> pp_expr_m(ID,499,LimitReached).
5818
5819		% print a list of identifiers
5820		pp_expr_ids_in_mode([],_) --> !.
5821		pp_expr_ids_in_mode(Ids,LimitReached) --> {eventb_translation_mode ; Ids=[_]},!,
5822		pp_expr_l(Ids,LimitReached). % no (.) allowed in Event-B; not necessary in B if only one id
5823		pp_expr_ids_in_mode(Ids,LimitReached) --> "(",pp_expr_l(Ids,LimitReached),")".
5824
5825		pp_expr_ids([],_) --> !.
5826		pp_expr_ids(Ids,LimitReached) -->
5827		% ( {Ids=[Id]} -> pp_expr_m(Id,221)
5828		% ;
5829		"(",pp_expr_l(Ids,LimitReached),")".
5830
5831		pp_expr_ids_no_parentheses(Ids,LimitReached) --> pp_expr_l(Ids,LimitReached).
5832
5833
5834		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5835		% pretty print types for error messages
5836
5837		%:- use_module(probsrc(typing_tools), [normalize_type/2]).
5838		% replace seq(.) types before pretty printing:
5839		pretty_normalized_type(Type,String) :- typing_tools:normalize_type(Type,NT),!,
5840		pretty_type(NT,String).
5841		pretty_normalized_type(Type,String) :-
5842		add_internal_error('Cannot normalize type:',pretty_normalized_type(Type,String)),
5843		pretty_type(Type,String).
5844
5845		% for pp_expr: do we potentially have to add parentheses
5846		normalized_type_requires_outer_paren(couple(_,_)).
5847		% all other types are either identifiers or use prefix notation (POW(.), seq(.), struct(.))
5848
5849		pretty_type(Type,String) :-
5850		pretty_type_l([Type],[String]).
5851
5852		pretty_type_l(Types,Strings) :-
5853		extract_vartype_names(Types,N),
5854		pretty_type2_l(Types,N,Strings).
5855		pretty_type2_l([],_,[]).
5856		pretty_type2_l([T|TRest],Names,[S|SRest]) :-
5857		pretty_type2(T,Names,noparen,S),
5858		pretty_type2_l(TRest,Names,SRest).
5859
5860		extract_vartype_names(Types,names(Variables,Names)) :-
5861		term_variables(Types,Variables),
5862		name_variables(Variables,1,Names).
5863
5864		pretty_type2(X,names(Vars,Names),_,Name) :- var(X),!,exact_member_lookup(X,Name,Vars,Names).
5865		pretty_type2(any,_,_,'?').
5866		pretty_type2(set(T),N,_,Text) :- nonvar(T),T=couple(A,B),!,
5867		pretty_type2(A,N,paren,AT), pretty_type2(B,N,paren,BT),
5868		binary_infix_in_mode(relations,Symbol,_,_), % <->
5869		ajoin(['(',AT,Symbol,BT,')'],Text).
5870		pretty_type2(set(T),N,_,Text) :-
5871		pretty_type2(T,N,noparen,TT), function_like_in_mode(pow_subset,POW),
5872		ajoin([POW,'(',TT,')'],Text).
5873		pretty_type2(seq(T),N,_,Text) :-
5874		pretty_type2(T,N,noparen,TT), ajoin(['seq(',TT,')'],Text).
5875		pretty_type2(couple(A,B),N,Paren,Text) :-
5876		pretty_type2(A,N,paren,AT),pretty_type2(B,N,paren,BT),
5877		binary_infix_in_mode(cartesian_product,Cart,_,_),
5878		ajoin([AT,Cart,BT],Prod),
5879		( Paren == noparen ->
5880		Text = Prod
5881		;
5882		ajoin(['(',Prod,')'],Text)).
5883		pretty_type2(string,_,_,'STRING').
5884		pretty_type2(integer,_,_,Atom) :- integer_set_mapping('INTEGER',Atom).
5885		pretty_type2(real,_,_,Atom) :- real_set_mapping('REAL',Atom).
5886		pretty_type2(boolean,_,_,'BOOL').
5887		pretty_type2(global(G_Id),_,_,A) :- opt_scramble_id(G_Id,G), ajoin([G],A).
5888		pretty_type2(freetype(Id),N,_,A) :- pretty_freetype2(Id,N,A).
5889		pretty_type2(pred,_,_,predicate).
5890		pretty_type2(subst,_,_,substitution).
5891		pretty_type2(constant(List),_,_,A) :-
5892		(var(List) -> ['{??VAR??...}'] % should not happen
5893		; ajoin_with_sep(List,',',P), ajoin(['{',P,'}'],A)).
5894		pretty_type2(record(Fields),N,_,Text) :-
5895		pretty_type_fields(Fields,N,FText),
5896		ajoin(['struct(',FText,')'],Text).
5897		pretty_type2(op(Params,Results),N,_,Text) :-
5898		pretty_type_l(Params,N,PText),
5899		( nonvar(Results),Results=[] ->
5900		ajoin(['operation(',PText,')'],Text)
5901		;
5902		pretty_type_l(Results,N,RText),
5903		ajoin([RText,'<--operation(',PText,')'],Text) ).
5904		pretty_type2(definition(DefType,_,_),_,_,DefType).
5905		pretty_type2(witness,_,_,witness).
5906		pretty_type2([],_,_,'[]') :- add_error(pretty_type,'Illegal list in type:','[]').
5907		pretty_type2([H|T],_,_,'[_]') :- add_error(pretty_type,'Illegal list in type:',[H|T]).
5908		pretty_type2(b(E,T,I),_,_,'?') :- add_error(pretty_type,'Illegal b/3 term in type:',b(E,T,I)).
5909
5910		pretty_type_l(L,_,'...') :- var(L),!.
5911		pretty_type_l([],_,'') :- !.
5912		pretty_type_l([E|Rest],N,Text) :-
5913		pretty_type2(E,N,noparen,EText),
5914		( nonvar(Rest),Rest=[] ->
5915		EText=Text
5916		;
5917		pretty_type_l(Rest,N,RText),
5918		ajoin([EText,',',RText],Text)).
5919
5920		pretty_type_fields(L,_,'...') :- var(L),!.
5921		pretty_type_fields([],_,'') :- !.
5922		pretty_type_fields([field(Name,Type)|FRest],N,Text) :- !,
5923		pretty_type2(Type,N,noparen,TText),
5924		ptf_seperator(FRest,Sep),
5925		pretty_type_fields(FRest,N,RestText),
5926		opt_scramble_id(Name,ScrName),
5927		ajoin([ScrName,':',TText,Sep,RestText],Text).
5928		pretty_type_fields(Err,N,Text) :-
5929		add_internal_error('Illegal field type: ',pretty_type_fields(Err,N,Text)), Text='??'.
5930		ptf_seperator(L,', ') :- var(L),!.
5931		ptf_seperator([],'') :- !.
5932		ptf_seperator(_,', ').
5933
5934		pretty_freetype(Id,A) :-
5935		extract_vartype_names(Id,N),
5936		pretty_freetype2(Id,N,A).
5937		pretty_freetype2(Id,_,A) :- var(Id),!,A='_'.
5938		pretty_freetype2(Id,_,A) :- atomic(Id),!,Id=A.
5939		pretty_freetype2(Id,N,A) :-
5940		Id=..[Name|TypeArgs],
5941		pretty_type2_l(TypeArgs,N,PArgs),
5942		ajoin_with_sep(PArgs,',',P),
5943		ajoin([Name,'(',P,')'],A).
5944
5945		name_variables([],_,[]).
5946		name_variables([_|VRest],Index,[Name|NRest]) :-
5947		(nth1(Index,"ABCDEFGHIJKLMNOPQRSTUVWXYZ",C) -> SName = [C] ; number_codes(Index,SName)),
5948		append("_",SName,CName),atom_codes(Name,CName),
5949		Next is Index+1,
5950		name_variables(VRest,Next,NRest).
5951
5952		ppatom(Var) --> {var(Var)},!, ppatom('$VARIABLE').
5953		ppatom(Cmp) --> {compound(Cmp)},!, ppatom('$COMPOUND_TERM').
5954		ppatom(Atom) --> {safe_atom_codes(Atom,Codes)}, ppcodes(Codes).
5955
5956		ppnumber(Number) --> {var(Number)},!,pp_clpfd_variable(Number).
5957		ppnumber(inf) --> !,"inf".
5958		ppnumber(minus_inf) --> !,"minus_inf".
5959		ppnumber(Number) --> {number(Number),number_codes(Number,Codes)},!, ppcodes(Codes).
5960		ppnumber(Number) --> {add_internal_error('Not a number: ',ppnumber(Number,_,_))}, "<<" ,ppterm(Number), ">>".
5961
5962		pp_numberedvar(N) --> "_",ppnumber(N),"_".
5963
5964		pp_clpfd_variable(X) --> "?:",{fd_dom(X,Dom)},write_to_codes(Dom), pp_frozen_info(X).
5965
5966		pp_frozen_info(_X) --> {get_preference(translate_print_frozen_infos,false)},!,[].
5967		pp_frozen_info(X) -->
5968		":(",{frozen(X,Goal)},
5969		write_goal_with_max_depth(Goal),
5970		")".
5971
5972		write_goal_with_max_depth((A,B)) --> !, "(",write_goal_with_max_depth(A),
5973		", ", write_goal_with_max_depth(B), ")".
5974		write_goal_with_max_depth(Term) --> write_with_max_depth(3,Term).
5975
5976		write_with_max_depth(Depth,Term,S1,S2) :- write_term_to_codes(Term,S1,S2,[max_depth(Depth)]).
5977
5978		ppterm(Term) --> write_to_codes(Term).
5979
5980		ppcodes([],S,S).
5981		ppcodes([C|Rest],[C|In],Out) :- ppcodes(Rest,In,Out).
5982
5983		ppterm_with_limit_reached(Term,LimitReached) -->
5984		{write_to_codes(Term,Codes,[])}, ppcodes_with_limit_reached(Codes,LimitReached).
5985
5986		ppcodes_with_limit_reached([C|Rest],LimitReached,[C|In],Out) :- var(LimitReached), !,
5987		ppcodes_with_limit_reached(Rest,LimitReached,In,Out).
5988		ppcodes_with_limit_reached(_,_LimitReached,S,S).
5989
5990		% for debugging:
5991		:- public b_portray_hook/1.
5992		b_portray_hook(X) :-
5993		nonvar(X),
5994		(is_texpr(X), ground(X) -> write('{# '),print_bexpr_or_subst(X),write(' #}')
5995		; X=avl_set(_), ground(X) -> write('{#avl '), print_bvalue(X), write(')}')
5996		; X=wfx(WF0,_,WFE,Info) -> format('wfx(~w,$mutable,~w,~w)',[WF0,WFE,Info]) % to do: short summary of prios & call stack
5997		).
5998
5999		install_b_portray_hook :- % register portray hook mainly for the Prolog debugger
6000		assertz(( user:portray(X) :- translate:b_portray_hook(X) )).
6001		remove_b_portray_hook :-
6002		retractall( user:portray(_) ).
6003
6004
6005		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6006		% Pretty-print of Event-B models as classical B
6007
6008		translate_eventb_to_classicalb(EBMachine,AddInfo,Rep) :-
6009		( conversion_check(EBMachine) ->
6010		convert_eventb_classicalb(EBMachine,CBMachine),
6011		call_cleanup(( set_animation_mode(b), % clear minor mode "eventb"
6012		translate_machine(CBMachine,Rep,AddInfo),!),
6013		set_animation_minor_mode(eventb))
6014		; \+ animation_minor_mode(eventb) -> add_error(translate,'Conversion only applicable to Event-B models')
6015		;
6016		add_error_and_fail(translate,'Conversion not applicable, check if you limited the number of abstract level to 0')
6017		).
6018
6019		convert_eventb_classicalb(EBMachine,CBMachine) :-
6020		select_section(operation_bodies,In,Out,EBMachine,CBMachine1),
6021		maplist(convert_eventop,In,Out),
6022		select_section(initialisation,IIn,IOut,CBMachine1,CBMachine),
6023		convert_event(IIn,[],IOut).
6024		convert_eventop(EBOp,CBOp) :-
6025		get_texpr_expr(EBOp,operation(Id,[],Args,EBBody)),
6026		get_texpr_info(EBOp,Info),
6027		convert_event(EBBody,Args,CBBody),
6028		% Remove the arguments
6029		create_texpr(operation(Id,[],[],CBBody),op([],[]),Info,CBOp).
6030		convert_event(TEvent,Parameters,TSubstitution) :-
6031		get_texpr_expr(TEvent,rlevent(_Id,_Section,_Status,_Parameters,Guard,_Theorems,Actions,_VariableWitnesses,_ParameterWitnesses,_Ums,_Refined)),
6032		in_parallel(Actions,PAction),
6033		convert_event2(Parameters,Guard,PAction,TSubstitution).
6034		convert_event2([],Guard,Action,Action) :-
6035		is_truth(Guard),!.
6036		convert_event2([],Guard,Action,Select) :-
6037		!,create_texpr(select([When]),subst,[],Select),
6038		create_texpr(select_when(Guard,Action),subst,[],When).
6039		convert_event2(Parameters,Guard,Action,Any) :-
6040		create_texpr(any(Parameters,Guard,Action),subst,[],Any).
6041		in_parallel([],Skip) :- !,create_texpr(skip,subst,[],Skip).
6042		in_parallel([A],A) :- !.
6043		in_parallel(Actions,Parallel) :- create_texpr(parallel(Actions),subst,[],Parallel).
6044
6045		conversion_check(Machine) :-
6046		animation_mode(b),
6047		animation_minor_mode(eventb),
6048		get_section(initialisation,Machine,Init),
6049		get_texpr_expr(Init,rlevent(_Id,_Sec,_St,_Par,_Grd,_Thms,_Act,_VW,_PW,_Ums,[])).
6050
6051		% ------------------------------------------------------------
6052
6053		% divide a B typed expression into columns for CSV export or Table viewing of its values
6054		get_bexpression_column_template(b(couple(A,B),_,_),(AVal,BVal),ColHeaders,Columns) :- !,
6055		get_bexpression_column_template(A,AVal,AHeaders,AColumns),
6056		get_bexpression_column_template(B,BVal,BHeaders,BColumns),
6057		append(AHeaders,BHeaders,ColHeaders),
6058		append(AColumns,BColumns,Columns).
6059		get_bexpression_column_template(TypedExpr,Value,[ColHeader],[Value]) :-
6060		translate:translate_bexpression_with_limit(TypedExpr,100,ColHeader).
6061
6062
6063		% a version of member that creates an error when info list not instantiated
6064		member_in_info(X,T) :- var(T),!, add_internal_error('Illegal info field:', member_in_info(X,T)),fail.
6065		member_in_info(X,[X|_]).
6066	?	member_in_info(X,[_|T]) :- member_in_info(X,T).
6067
6068		memberchk_in_info(X,T) :- var(T),!, add_internal_error('Illegal info field:', memberchk_in_info(X,T)),fail.
6069		memberchk_in_info(X,[X|_]) :- !.
6070		memberchk_in_info(X,[_|T]) :- memberchk_in_info(X,T).
6071
6072		%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6073
6074		:- use_module(library(clpfd)).
6075
6076		% print also partially instantiated variables with CLP(FD) Info
6077		print_value_variable(X) :- var(X), !, write(X).
6078		print_value_variable(int(X)) :- write('int('), print_clpfd_variable(X), write(')').
6079		print_value_variable(fd(X,T)) :- write('fd('), print_clpfd_variable(X), write(','), write(T),write(')').
6080		print_value_variable(X) :- write(X).
6081
6082		print_clpfd_variable(X) :- var(X),!,write(X), write(':'), fd_dom(X,Dom), write(Dom), print_frozen_info(X).
6083		print_clpfd_variable(X) :- write(X).
6084
6085		%print_clpfd_variables([]).
6086		%print_clpfd_variables([H|T]) :- write('CLPFD: '),print_clpfd_variable(H), nl, print_clpfd_variables(T).
6087
6088
6089		:- public l_print_frozen_info/1.
6090		l_print_frozen_info([]).
6091		l_print_frozen_info([H|T]) :- write(H), write(' '),
6092		(var(H) -> print_frozen_info(H) ;
6093		H=fd_var(V,_) -> print_frozen_info(V) ; true), l_print_frozen_info(T).
6094
6095		print_frozen_info(X) :- frozen(X,Goal), print_frozen_goal(Goal).
6096		print_frozen_goal((A,B)) :- !, print_frozen_goal(A), write(','), print_frozen_goal(B).
6097		print_frozen_goal(prolog:trig_nondif(_A,_B,R,_S)) :- !, frozen(R,G2), print_frozen_goal2(G2).
6098		print_frozen_goal(G) :- print_frozen_goal2(G).
6099		print_frozen_goal2(V) :- var(V),!, write(V).
6100		print_frozen_goal2(true) :- !.
6101		print_frozen_goal2((A,B)) :- !, print_frozen_goal2(A), write(','), print_frozen_goal2(B).
6102		print_frozen_goal2(G) :- write(' :: '), tools_printing:print_term_summary(G).
6103
6104
6105		/* Event-B operators */
6106		translate_eventb_operators([]) --> !.
6107		translate_eventb_operators([Name-Call|Rest]) -->
6108		translate_eventb_operator(Call,Name),
6109		translate_eventb_operators(Rest).
6110
6111		translate_eventb_operator(Module:Call,Name) -->
6112		insertcodes("\n "),
6113		indention_codes(In,Out),
6114		{Call =.. [Functor|Args],
6115		translate_eventb_operator2(Functor,Args,Module,Call,Name,In,Out)}.
6116
6117
6118		translate_eventb_operator2(direct_definition,[Args,_RawWD,RawBody,TypeParas|_],_Module,_Call,Name) -->
6119		pp_eventb_direct_definition_header(Name,Args),!,
6120		ppcodes(" direct_definition ["),
6121		pp_eventb_operator_args(TypeParas),
6122		ppcodes("] "),
6123		{translate_in_mode(eqeq,'==',EqEqStr)}, ppatom(EqEqStr),
6124		ppcodes(" "),
6125		pp_raw_formula(RawBody). % TO DO: use indentation
6126		translate_eventb_operator2(axiomatic_definition,[Tag|_],_Module,_Call,Name) --> !,
6127		ppterm(Name),
6128		ppcodes(": Operator implemented by axiomatic definition using "),
6129		ppatom(Tag).
6130		translate_eventb_operator2(Functor,_,Module,_Call,Name) -->
6131		ppterm(Name),
6132		ppcodes(": Operator implemented by "),
6133		ppatom(Module),ppcodes(":"),ppatom(Functor).
6134
6135		% example direct definition:
6136		%direct_definition([argument(curM,integer_set(none)),argument(curH,integer_set(none))],truth(none),add(none,identifier(none,curM),multiplication(none,identifier(none,curH),integer(none,60))),[])
6137
6138		pp_eventb_direct_definition_header(Name,Args) -->
6139		ppterm(Name), ppcodes("("),
6140		pp_eventb_operator_args(Args), ppcodes(")").
6141
6142		translate_eventb_direct_definition_header(Name,Args,ResAtom) :-
6143		(pp_eventb_direct_definition_header(Name,Args,C,[])
6144		-> atom_codes(ResAtom,C) ; ResAtom='<<UNABLE TO PRETTY-PRINT OPERATOR HEADER>>').
6145		translate_eventb_direct_definition_body(RawBody,ResAtom) :-
6146		(pp_raw_formula(RawBody,C,[]) -> atom_codes(ResAtom,C) ; ResAtom='<<UNABLE TO PRETTY-PRINT OPERATOR BODY>>').
6147
6148		pp_raw_formula(RawExpr) --> {transform_raw(RawExpr,TExpr)},!, pp_expr(TExpr,_,_LR).
6149		pp_raw_formula(_) --> ppcodes("<<UNABLE TO PRETTY-PRINT>>").
6150
6151
6152		pp_eventb_operator_args([]) --> [].
6153		pp_eventb_operator_args([Arg]) --> !, pp_argument(Arg).
6154		pp_eventb_operator_args([Arg|T]) --> pp_argument(Arg), ppcodes(","),
6155		pp_eventb_operator_args(T).
6156		pp_argument(argument(ID,_RawType)) --> !, ppatom(ID).
6157		pp_argument(identifier(_,ID)) --> !, "<",ppatom(ID),">".
6158		pp_argument(Atom) --> ppatom(Atom).
6159
6160		% ---------------------------------------
6161
6162		% translate a predicate into B machine for manipulation
6163		translate_predicate_into_machine(Pred,MchName,ResultAtom) :-
6164		with_language_mode(b, translate_predicate_into_machine_aux(Pred,MchName,ResultAtom)). % clear minor mode "eventb"
6165		translate_predicate_into_machine_aux(Pred,MchName,ResultAtom) :-
6166		get_global_identifiers(Ignored,ignore_promoted_constants),
6167		find_typed_identifier_uses(Pred, Ignored, TUsedIds),
6168		get_texpr_ids(TUsedIds,UsedIds),
6169		add_typing_predicates(TUsedIds,Pred,TPred),
6170		set_print_type_infos(all,CHNG),
6171		call_pp_with_no_limit_and_parseable(pred_over_lines(2,_Lbl,TPred,(0,CPrettyPred),(_,[]))), % split predicate into one conjunct per line
6172		atom_codes(PrettyPred,CPrettyPred),
6173		reset_print_type_infos(CHNG),
6174		convert_and_ajoin_ids_line_break(UsedIds,AllIds,10),
6175		bmachine:get_full_b_machine(Name,BMachine),
6176		include(relevant_section,BMachine,RelevantSections),
6177		% TO DO: we could filter out enumerate/deferred sets not occuring in Pred
6178		translate_section_list(RelevantSections,SetsParas),
6179		atom_codes(ASP,SetsParas),
6180		pp_identifier(MchName,CMchName,[]), atom_codes(EMchName,CMchName),
6181		ajoin(['MACHINE ', EMchName, ' /* generated from ',Name,' */\n',ASP,'CONSTANTS\n ',AllIds,'\nPROPERTIES',PrettyPred,'\nEND\n'],ResultAtom).
6182
6183		relevant_section(deferred_sets/_).
6184		relevant_section(enumerated_elements/_).
6185		relevant_section(parameters/_).
6186
6187		:- use_module(library(system),[ datime/1]).
6188		:- use_module(specfile,[currently_opened_file/1]).
6189		:- use_module(probsrc(version), [format_prob_version/1]).
6190		% print a Proof Obligation aka Sequent as a B machine
6191		% Rodin disprover can print this to tmp/ProB_Rodin_PO_SelectedHyps.mch
6192		nested_print_sequent_as_classicalb(Stream,HypsList,Goal,AllHypsList,MchName,ProofInfos) :-
6193		set_suppress_rodin_positions(false,Chng), % ensure we print Rodin labels if available
6194		call_cleanup(nested_print_sequent_as_classicalb_aux(Stream,HypsList,Goal,AllHypsList,MchName,ProofInfos),
6195		reset_suppress_rodin_positions(Chng)).
6196
6197		% convert identifier by adding backquote if necessary for unicode, reserved keywords, ...
6198		convert_id(b(identifier(ID),_,_),CAtom) :- !, convert_id(ID,CAtom).
6199		convert_id(Atom,CAtom) :- atom(Atom),!,pp_identifier(Atom,Codes,[]), atom_codes(CAtom,Codes).
6200		convert_id(E,CAtom) :- add_internal_error('Illegal id: ',E), CAtom = '?'.
6201		convert_and_ajoin_ids(UsedIds,AllIdsWithCommas) :-
6202		maplist(convert_id,UsedIds,ConvUsedIds),
6203		ajoin_with_sep(ConvUsedIds,', ',AllIdsWithCommas).
6204		convert_and_ajoin_ids_line_break(UsedIds,AllIdsWithLineBreak,Threshold) :-
6205		(length(UsedIds,Len), Len>Threshold -> Sep=',\n ' ; Sep=', ' ),
6206		maplist(convert_id,UsedIds,ConvUsedIds),
6207		ajoin_with_sep(ConvUsedIds,Sep,AllIdsWithLineBreak).
6208
6209		nested_print_sequent_as_classicalb_aux(Stream,HypsList,Goal,AllHypsList,MchName,ProofInfos) :-
6210		conjunct_predicates(HypsList,HypsPred),
6211		conjunct_predicates([Goal|HypsList],Pred),
6212		get_global_identifiers(Ignored,ignore_promoted_constants), % the sets section below will not print the promoted enumerated set constants, they may also not be valid for the selected hyps only
6213		find_typed_identifier_uses(Pred, Ignored, TUsedIds),
6214		get_texpr_ids(TUsedIds,UsedIds),
6215		convert_and_ajoin_ids(UsedIds,AllIds),
6216		bmachine:get_full_b_machine(_Name,BMachine),
6217		include(relevant_section,BMachine,RelevantSections),
6218		% TO DO: we could filter out enumerate/deferred sets not occuring in Pred
6219		translate_section_list(RelevantSections,SetsParas),
6220		set_print_type_infos(all,CHNG),
6221		datime(datime(Yr,Mon,Day,Hr,Min,_Sec)),
6222		format(Stream,'MACHINE ~w~n /* Exported: ~w/~w/~w ~w:~w */~n',[MchName,Day,Mon,Yr,Hr,Min]),
6223		(currently_opened_file(File), bmachine:b_machine_name(Name)
6224		-> format(Stream,' /* Origin: ~w : ~w */~n',[Name,File]) ; true),
6225		write(Stream,' /* '),format_prob_version(Stream), format(Stream,' */~n',[]),
6226		format(Stream,' /* Use static asssertion checking to look for counter examples: */~n',[]),
6227		format(Stream,' /* - probcli -cbc_assertions ProB_Rodin_PO_SelectedHyps.mch */~n',[]),
6228		format(Stream,' /* - in ProB2-UI: Verifications View -> Symbolic Tab -> Static Assertion Checking */~n',[]),
6229		maplist(format_proof_infos(Stream),ProofInfos),
6230		format(Stream,'~sCONSTANTS~n ~w~nPROPERTIES /* Selected Hypotheses: */~n',[SetsParas,AllIds]),
6231		add_typing_predicates(TUsedIds,HypsPred,HypsT),
6232		current_output(OldStream),
6233		set_output(Stream),
6234		nested_print_bexpr_as_classicalb2(HypsT,s(0)), % TODO: pass stream to this predicate
6235		format(Stream,'~nASSERTIONS /* Proof Goal: */~n',[]),
6236		nested_print_bexpr_as_classicalb2(Goal,s(0)), % TODO: pass stream to this predicate
6237		(AllHypsList = [] -> true
6238		; sort(AllHypsList,SAL), sort(HypsList,SL),
6239		ord_subtract(SAL,SL,RemainingHypsList), % TODO: we could preserve order
6240		conjunct_predicates(RemainingHypsList,AllHypsPred),
6241		find_typed_identifier_uses(AllHypsPred, Ignored, TAllUsedIds),
6242		get_texpr_ids(TAllUsedIds,AllUsedIds),
6243		ord_subtract(AllUsedIds,UsedIds,NewIds), % compute new ids not used in selected hyps and goal
6244		(NewIds = []
6245		-> format(Stream,'OPERATIONS~n CheckRemainingHypotheses = SELECT~n',[])
6246		; ajoin_with_sep(NewIds,', ',NIdLst),
6247		format(Stream,'OPERATIONS~n CheckRemainingHypotheses(~w) = SELECT~n',[NIdLst])
6248		),
6249		add_typing_predicates(TAllUsedIds,AllHypsPred,AllHypsT),
6250		nested_print_bexpr_as_classicalb2(AllHypsT,s(0)), % TODO: pass stream to this predicate
6251		format(Stream,' THEN skip~n END /* CheckRemainingHypotheses */~n',[])
6252		),
6253		set_output(OldStream),
6254		reset_print_type_infos(CHNG),
6255		format(Stream,'DEFINITIONS~n SET_PREF_DISPROVER_MODE == TRUE~n ; SET_PREF_TRY_FIND_ABORT == FALSE~n',[]),
6256		format(Stream,' ; SET_PREF_ALLOW_REALS == FALSE~n',[]),
6257		% The Rodin DisproverCommand.java usually enables CHR;
6258		% TODO: we could also look for options(List) in ProofInfos and check use_chr_solver/true in List, ...
6259		(get_preference(use_clpfd_solver,false) -> format(Stream,' ; SET_PREF_CHR == FALSE~n',[]) ; true),
6260		(get_preference(use_chr_solver,true) -> format(Stream,' ; SET_PREF_CHR == TRUE~n',[]) ; true),
6261		(get_preference(use_smt_mode,true) -> format(Stream,' ; SET_PREF_SMT == TRUE~n',[]) ; true),
6262		(get_preference(use_common_subexpression_elimination,true) -> format(Stream,' ; SET_PREF_CSE == TRUE~n',[]) ; true),
6263		(get_preference(smt_supported_interpreter,true) -> format(Stream,' ; SET_PREF_SMT_SUPPORTED_INTERPRETER == TRUE~n',[]) ; true),
6264		format(Stream,'END~n',[]).
6265
6266		format_proof_infos(_,Var) :- var(Var),!.
6267		format_proof_infos(Stream,disprover_result(Prover,Hyps,Result)) :- nonvar(Result),functor(Result,FR,_),!,
6268		format(Stream,' /* ProB Disprover ~w result on ~w : ~w */~n',[Prover,Hyps,FR]).
6269		format_proof_infos(Stream,E) :- format(Stream,' /* ~w */~n',[E]).
6270
6271
6272		% ---------------------------------------
6273
6274
6275		% show non obvious functors
6276		get_texpr_top_level_symbol(TExpr,Symbol,2,infix) :-
6277		translate:binary_infix_symbol(TExpr,Symbol),!.
6278		get_texpr_top_level_symbol(b(E,_,_),Symbol,1,postfix) :-
6279		functor(E,F,1), translate:unary_postfix_in_mode(F,Symbol,_),!.
6280		get_texpr_top_level_symbol(b(E,_,_),Symbol,3,prefix) :-
6281		functor(E,F,Arity), (Arity=3 ; Arity=2), % 2 for exists
6282		quantified_in_mode(F,Symbol),!.
6283		get_texpr_top_level_symbol(b(E,_,_),Symbol,N,prefix) :-
6284		functor(E,F,N),
6285		function_like_in_mode(F,Symbol).
6286
6287		% ---------------
6288
6289		% feedback to user about values
6290		translate_bvalue_kind([],Res) :- !, Res='EMPTY-Set'.
6291		translate_bvalue_kind([_|_],Res) :- !, Res='LIST-Set'.
6292		translate_bvalue_kind(avl_set(A),Res) :- !, avl_size(A,Size), ajoin(['AVL-Set:',Size],Res).
6293		translate_bvalue_kind(int(_),Res) :- !, Res = 'INTEGER'.
6294		translate_bvalue_kind(term(floating(_)),Res) :- !, Res = 'FLOAT'.
6295		translate_bvalue_kind(string(_),Res) :- !, Res = 'STRING'.
6296		translate_bvalue_kind(pred_true,Res) :- !, Res = 'TRUE'.
6297		translate_bvalue_kind(pred_false,Res) :- !, Res = 'FALSE'.
6298		translate_bvalue_kind(fd(_,T),Res) :- !, Res = T.
6299		translate_bvalue_kind((_,_),Res) :- !, Res = 'PAIR'.
6300		translate_bvalue_kind(rec(_),Res) :- !, Res = 'RECORD'.
6301		translate_bvalue_kind(freeval(Freetype,_Case,_),Res) :- !, Res = Freetype.
6302		translate_bvalue_kind(CL,Res) :- custom_explicit_sets:is_interval_closure(CL,_,_),!, Res= 'INTERVAL'.
6303		translate_bvalue_kind(CL,Res) :- custom_explicit_sets:is_infinite_explicit_set(CL),!, Res= 'INFINITE-Set'.
6304		translate_bvalue_kind(closure(_,_,_),Res) :- !, Res= 'SYMBOLIC-Set'.
6305
6306
6307		% ---------------------------------------
6308
6309		:- use_module(tools_printing,[better_write_canonical_to_codes/3]).
6310		pp_xtl_value(Value) --> better_write_canonical_to_codes(Value).
6311
6312		translate_xtl_value(Value,Output) :-
6313		pp_xtl_value(Value,Codes,[]),
6314		atom_codes_with_limit(Output,Codes).