| 1 | | % (c) 2009-2025 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(bsyntaxtree, |
| 6 | | [is_texpr/1, % checks if the given argument is a typed expression |
| 7 | | |
| 8 | | get_texpr_expr/2, % get the expression part of a typed expression |
| 9 | | get_texpr_type/2, % get the type of a typed expression |
| 10 | | get_texpr_info/2, % get the list of information of a typed expression |
| 11 | | get_texpr_id/2, % get the id of a typed identifier, fails if it's not an identifier |
| 12 | | def_get_texpr_id/2, % same as above, but raises error if arg1 is not an identifier |
| 13 | | def_get_texpr_ids/2, % maplist of the above, i.e., translate a typed id list into a plain list of id names |
| 14 | | create_typed_id/3, % create a typed identifier |
| 15 | | create_typed_ids/3, % create a list of typed identifiers from list of names and types |
| 16 | | same_id/3, % true if two typed identifiers have the same id |
| 17 | | same_ids/2, % true if two lists of typed identifiers have the same ids |
| 18 | | same_ids_and_types/2, % also check types |
| 19 | | split_names_and_types/3, % split list of typed ids into ids and types |
| 20 | | get_texpr_exprs/2, % list variant of the above |
| 21 | | get_texpr_types/2, % list variant of the above |
| 22 | | get_texpr_infos/2, % list variant of the above |
| 23 | | get_texpr_ids/2, % list variant of the above |
| 24 | | get_texpr_pos/2, % get the position of a typed expression |
| 25 | | get_texpr_pos_infos/2, % the a list containing the position infos, sublist of get_texpr_infos |
| 26 | | extract_pos_infos/2, % get the position info sub list of an info list |
| 27 | | copy_pos_infos/3, % copy position infos from one typed expression to another |
| 28 | | delete_pos_info/2, % delete position info from an info list |
| 29 | | propagate_pos_info_if_useful/3, % propagate position info from second list if useful |
| 30 | | merge_info/3, % merge two information lists as well as possible |
| 31 | | update_infos/3, % provide updates to an existing info list |
| 32 | | get_info_pos/2, % get the position directly from info field |
| 33 | | contains_info_pos/1, % true if info field contains position infos |
| 34 | | |
| 35 | | same_texpr/2, % check if two typed expressions are equal modulo Info fields |
| 36 | | different_texpr_values/2, % check if two type expressions are WD and definitely denote different values |
| 37 | | |
| 38 | | create_texpr/4, % creates a typed expression by giving expression, type and infos |
| 39 | | add_texpr_infos/3, % adds some more information to a typed expression at front |
| 40 | | add_texpr_info_if_new/3, % adds one info field to typed B expression info list at front if it is new |
| 41 | | add_texpr_infos_if_new/3, % ditto but list of infos can be added |
| 42 | | add_info_if_new/3, % adds to info list |
| 43 | | add_infos_if_new/3, % same for list of info items |
| 44 | | safe_create_texpr/3, % a version of create_texpr which extracts wd-info from sub-expressionssafe_create_texpr |
| 45 | | safe_create_texpr/4, |
| 46 | | texpr_contains_wd_condition/1, |
| 47 | | sub_expression_contains_wd_condition/1, % utility to check if sub-expression contains wd condition |
| 48 | | |
| 49 | | get_rodin_name/2, get_rodin_model_name/2, |
| 50 | | is_rodin_label_info/1, |
| 51 | | get_texpr_label/2, get_texpr_labels/2, |
| 52 | | get_info_labels/2, select_info_labels/3, |
| 53 | | add_labels_to_texpr/3, |
| 54 | | get_texpr_description/2, % get @desc pragma for typed expression |
| 55 | | add_texpr_description/3, % add an additional description by hand |
| 56 | | info_has_ignore_pragma/1, % check if an info list has an ignore pragma |
| 57 | | predicate_has_ignore_pragma/1, % ditto for the info list of a predicate |
| 58 | | always_well_defined/1, always_well_defined_or_disprover_mode/1, |
| 59 | | always_well_defined_or_wd_reorderings_allowed/1, |
| 60 | | always_well_defined_or_wd_improvements_allowed/1, |
| 61 | | finite_wd_set_value/1, finite_set_or_disprover_mode/1, |
| 62 | | is_truth/1, is_falsity/1, |
| 63 | | conjunct_predicates/2, |
| 64 | | conjunct_predicates_with_pos_info/3, conjunct_predicates_with_pos_info/2, |
| 65 | | is_a_conjunct/3, is_a_conjunct_without_label/3, decompose_conjunct/3, |
| 66 | | is_a_disjunct/3, is_an_implication/3, is_an_equivalence/3, is_a_negation/2, |
| 67 | | conjunction_to_list/2, |
| 68 | | conjunction_to_list_with_rodin_labels/2, % a variation which propagates labels down to conjuncts |
| 69 | | member_in_conjunction/2, select_member_in_conjunction/3, |
| 70 | | flatten_conjunctions/2, |
| 71 | | size_of_conjunction/2, |
| 72 | | member_in_conjunction_cse/3, |
| 73 | | disjunct_predicates/2, |
| 74 | | disjunct_predicates_with_pos_info/3, |
| 75 | | disjunction_to_list/2, |
| 76 | | is_a_disjunct_or_implication/4, |
| 77 | | is_a_conjunct_or_neg_disj/3, |
| 78 | | |
| 79 | | predicate_components/2, % split a predicate into components which use distinct identifiers |
| 80 | | predicate_components_in_scope/3, % ditto with an optional list of local variables |
| 81 | | predicate_components_with_restriction/4, |
| 82 | | predicate_identifiers/2, predicate_identifiers_in_scope/3, |
| 83 | | |
| 84 | | project_predicate_on_identifiers/5, |
| 85 | | |
| 86 | | find_identifier_uses_top_level/2, % not including global sets and constants |
| 87 | | find_identifier_uses/3, find_identifier_uses_if_necessary/3, |
| 88 | | find_identifier_uses_l/3, |
| 89 | | find_typed_identifier_uses/3, |
| 90 | | find_typed_identifier_uses/2, % not including global sets and constants |
| 91 | | find_typed_identifier_uses_l/3, |
| 92 | | find_identifier_uses_for_quantifier_body/3, |
| 93 | | get_global_identifiers/1, get_global_identifiers/2, |
| 94 | | occurs_in_expr/2, some_id_occurs_in_expr/2, |
| 95 | | single_usage_identifier/3, |
| 96 | | update_used_ids/3, |
| 97 | | check_computed_used_ids/2, |
| 98 | | |
| 99 | | create_exists/3, create_or_merge_exists/3, |
| 100 | | create_exists_or_let_predicate/3, |
| 101 | | create_exists_opt_liftable/3, |
| 102 | | create_exists_opt/3, create_exists_opt/4, create_exists_opt/5, |
| 103 | | not_generated_exists_paras/1, |
| 104 | | create_forall/3, |
| 105 | | create_negation/2, is_negation_of/2, get_negated_operator_expr/2, |
| 106 | | create_implication/3, |
| 107 | | create_equivalence/3, |
| 108 | | is_equality/3, |
| 109 | | create_equality/3, split_equality/3, get_texpr_couple/3, |
| 110 | | create_couple/3, create_couple/2, nested_couple_to_list/2, |
| 111 | | create_comprehension_set/4, |
| 112 | | is_eventb_comprehension_set/4, is_eventb_comprehension_set/6, |
| 113 | | singleton_set_extension/2, |
| 114 | | is_membership/3, is_membership_or_equality/3, |
| 115 | | get_lambda_equality/4, |
| 116 | | is_pow_subset/2, is_pow1_subset/2, |
| 117 | | |
| 118 | | detect_global_predicates/4, |
| 119 | | |
| 120 | | definitely_not_empty_set/1, definitely_empty_set/1, definitely_not_empty_finite_value/1, |
| 121 | | get_integer/2, |
| 122 | | get_interval/3, |
| 123 | | |
| 124 | | replace_id_by_expr/4, |
| 125 | | replace_id_by_expr_with_count/5, % also count number of replacements |
| 126 | | replace_ids_by_exprs/4, |
| 127 | | remove_used_id_from_info/3, % remove an id from used_id info field if it exists |
| 128 | | remove_used_ids_from_info/3, % remove list of ids (order of args different !) |
| 129 | | |
| 130 | | rename_bt/3, % a simplified version of replace_ids_by_exprs, which assumes target of renamings are variables |
| 131 | | rename_bt_l/3, |
| 132 | | remove_bt/4, |
| 133 | | syntaxtransformation/5, |
| 134 | | syntaxtransformation_det/5, % faster, non-backtracking version |
| 135 | | syntaxtransformation_for_renaming/5, |
| 136 | | |
| 137 | | map_over_bexpr/2, map_over_typed_bexpr/2, map_over_typed_bexpr/3, |
| 138 | | map_over_typed_bexpr_with_names/2, |
| 139 | | map_over_bexpr_top_down_acc/3, map_over_typed_bexpr_top_down_acc/3, |
| 140 | | reduce_over_bexpr/4, |
| 141 | | transform_bexpr/3, % transform a typed B expression bottom-up |
| 142 | | transform_bexpr_with_scoping/3, % ditto, but we also provide info about local ids |
| 143 | | transform_bexpr_td_with_scoping/3, % top-down with scoping |
| 144 | | transform_bexpr_with_bup_accs/5, transform_bexpr_with_acc/5, |
| 145 | | non_det_transform_bexpr_with_acc/5, % can be used to generate several transformed expressions |
| 146 | | uses_implementable_integers/1, |
| 147 | | min_max_integer_value_used/3, min_max_integer_value_used/5, |
| 148 | | syntaxtraversion/6, |
| 149 | | safe_syntaxelement/5, |
| 150 | | safe_syntaxelement_det/5, % a deterministic, non-backtracking version |
| 151 | | is_subst_syntaxelement/1, |
| 152 | | is_syntax_constant/1, |
| 153 | | |
| 154 | | expand_all_lets/2, |
| 155 | | |
| 156 | | remove_all_infos/2, extract_info/2, extract_info/3, extract_info_wo_used_ids/2, |
| 157 | | bsyntax_pattern/2, |
| 158 | | |
| 159 | | remove_all_infos_and_ground/2, |
| 160 | | |
| 161 | | check_if_typed_predicate/1, |
| 162 | | check_if_typed_expression/1, |
| 163 | | check_if_typed_substitution/1, |
| 164 | | |
| 165 | | strip_and_norm_ast/2, |
| 166 | | same_norm_texpr/2, |
| 167 | | get_texpr_functor/3, |
| 168 | | |
| 169 | | is_set_type/2, get_set_type/2, get_texpr_set_type/2, |
| 170 | | is_just_type/1, is_just_type/2, |
| 171 | | |
| 172 | | create_recursive_compset/6, |
| 173 | | unique_typed_id/3, |
| 174 | | mark_bexpr_as_symbolic/2, |
| 175 | | |
| 176 | | identifier_sub_ast/3, exchange_ast_position/5, |
| 177 | | |
| 178 | | has_declared_identifier/2, add_declaration_for_identifier/3, |
| 179 | | check_ast/1, check_ast/2, |
| 180 | | repair_used_ids/3, |
| 181 | | print_ast/1, |
| 182 | | rewrite_if_then_else_expr_to_b/2, |
| 183 | | normalise_bexpr_for_ml/2 |
| 184 | | ]). |
| 185 | | |
| 186 | | % meta_predicate annotations should appear before loading any code: |
| 187 | | |
| 188 | | :- meta_predicate map_over_full_bexpr_no_fail(1,?). |
| 189 | | |
| 190 | | :- meta_predicate map_over_bexpr(1,?). |
| 191 | | :- meta_predicate map_over_typed_bexpr(1,?). |
| 192 | | :- meta_predicate map_over_typed_bexpr(2,?,?). |
| 193 | | :- meta_predicate map_over_bexpr_top_down_acc(3,?,?). |
| 194 | | :- meta_predicate map_over_typed_bexpr_top_down_acc(3,?,?). |
| 195 | | |
| 196 | | :- meta_predicate reduce_over_bexpr(3,?,?,?). |
| 197 | | :- meta_predicate transform_bexpr(2,?,?). |
| 198 | | :- meta_predicate l_transform_bexpr(?,2,?). |
| 199 | | :- meta_predicate transform_bexpr_with_scoping(3,?,?). |
| 200 | | :- meta_predicate transform_bexpr_td_with_scoping(3,?,?). |
| 201 | | :- meta_predicate transform_bexpr_with_scoping2(3,?,?,?). |
| 202 | | :- meta_predicate l_transform_bexpr_with_scoping(?,3,?,?). |
| 203 | | :- meta_predicate transform_bexpr_with_bup_accs(4,?,?,?,?). |
| 204 | | :- meta_predicate l_transform_bexpr_with_bup_accs(?,4,?,?,?). |
| 205 | | :- meta_predicate transform_bexpr_with_acc(4,?,?,?,?). |
| 206 | | :- meta_predicate l_transform_bexpr_with_acc(?,4,?,?,?). |
| 207 | | :- meta_predicate non_det_transform_bexpr_with_acc(4,?,?,?,?). |
| 208 | | :- meta_predicate l_nd_transform_bexpr_with_acc(?,4,?,?,?). |
| 209 | | |
| 210 | | % ----------- |
| 211 | | |
| 212 | | |
| 213 | | :- use_module(tools). |
| 214 | | |
| 215 | | :- use_module(module_information,[module_info/2]). |
| 216 | | :- module_info(group,typechecker). |
| 217 | | :- module_info(description,'This module provides operations on the type-checked AST.'). |
| 218 | | |
| 219 | | :- use_module(library(lists)). |
| 220 | | :- use_module(library(ordsets)). |
| 221 | | :- use_module(library(avl)). |
| 222 | | :- use_module(library(terms)). |
| 223 | | |
| 224 | | :- use_module(self_check). |
| 225 | | :- use_module(error_manager). |
| 226 | | :- use_module(translate,[print_bexpr/1,translate_bexpression/2]). |
| 227 | | :- use_module(gensym,[gensym/2]). |
| 228 | | :- use_module(preferences,[get_preference/2,preference/2]). |
| 229 | | :- use_module(debug,[debug_mode/1,debug_format/3]). |
| 230 | | |
| 231 | | :- use_module(typing_tools,[is_finite_type_in_context/2,normalize_type/2]). |
| 232 | | :- use_module(tools_lists,[convlist_max/4]). |
| 233 | | |
| 234 | | :- set_prolog_flag(double_quotes, codes). |
| 235 | | |
| 236 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 237 | | % basic access to enriched syntax tree |
| 238 | | |
| 239 | | is_texpr(b(_,_,_)). |
| 240 | | |
| 241 | | get_texpr_expr(b(Name,_,_),R) :- !,R=Name. |
| 242 | | get_texpr_expr(E,_) :- add_error_fail(get_texpr_expr,'B Expression not properly wrapped: ',E). |
| 243 | | |
| 244 | | get_texpr_type(b(_,Type,_),R) :- !, R=Type. |
| 245 | | get_texpr_type(E,_) :- add_error_fail(get_texpr_type,'B Expression not properly wrapped: ',E). |
| 246 | | get_texpr_info(b(_,_,Info),R) :- !, R=Info. |
| 247 | | get_texpr_info(E,_) :- add_error_fail(get_texpr_info,'B Expression not properly wrapped: ',E). |
| 248 | | |
| 249 | | %! get_texpr_id(+Texpr,-Id) |
| 250 | | get_texpr_id(b(N,_,_),Id) :- !, N=identifier(Id). |
| 251 | | get_texpr_id(E,_) :- add_error_fail(get_texpr_id,'B Expression not properly wrapped: ',E). |
| 252 | | /* same as above: but must succeed */ |
| 253 | | def_get_texpr_id(b(identifier(Id),_,_),R) :- !,R=Id. |
| 254 | | def_get_texpr_id(b(E,_,_),_) :- !, |
| 255 | | add_error_fail(def_get_texpr_id,'Could not extract identifier from typed expression: ',E). |
| 256 | | def_get_texpr_id(ID,_) :- add_error_fail(def_get_texpr_id,'Could not extract identifier, not properly wrapped: ',ID). |
| 257 | | |
| 258 | | % translate a list of ids with the b/3 wrapper into a plain id list; throw error if not an identifier |
| 259 | | % used to also be called get_texpr_id_names |
| 260 | | def_get_texpr_ids(L,Ids) :- maplist(def_get_texpr_id,L,Ids). |
| 261 | | |
| 262 | | create_typed_id(IDName,Type,b(identifier(IDName),Type,[])). |
| 263 | | |
| 264 | | create_typed_ids([],[],[]). |
| 265 | | create_typed_ids([ID|TI],[Type|TT],[TID| TRes]) :- |
| 266 | | create_typed_id(ID,Type,TID), |
| 267 | | create_typed_ids(TI,TT,TRes). |
| 268 | | |
| 269 | | same_id(X,Y,ID) :- get_texpr_id(X,ID), get_texpr_id(Y,ID). |
| 270 | | |
| 271 | | same_ids([],[]). |
| 272 | | same_ids([X|Xs],[Y|Ys]) :- same_id(X,Y,_), same_ids(Xs,Ys). |
| 273 | | |
| 274 | | % check if two lists of identifiers have the same name and types |
| 275 | | same_ids_and_types([],[]). |
| 276 | | same_ids_and_types([b(identifier(Id),T1,_)|Xs],[b(identifier(Id),T2,_)|Ys]) :- unify_types_strict(T1,T2), |
| 277 | | same_ids_and_types(Xs,Ys). |
| 278 | | |
| 279 | | % split a list of typed identifiers into atomic ids and types |
| 280 | | split_names_and_types([],N,T) :- !, N=[], T=[]. |
| 281 | | split_names_and_types([Identifier|IdRest],[Name|NRest],[Type|TRest]) :- !, |
| 282 | | def_get_texpr_id(Identifier,Name), |
| 283 | | get_texpr_type(Identifier,Type), |
| 284 | | split_names_and_types(IdRest,NRest,TRest). |
| 285 | | split_names_and_types(TIDS,N,R) :- |
| 286 | | add_internal_error('Illegal call to:',split_names_and_types(TIDS,N,R)),fail. |
| 287 | | |
| 288 | | |
| 289 | | |
| 290 | | % check if two wrapped expressions are equal (modulo associated Info, e.g. source loc info) |
| 291 | | same_texpr(b(E1,Type,_),b(E2,Type,_)) :- % should we do a == check first ?? probably not as it may traverse the entire structure (see email exchange with SICStus 28.1.2015) |
| 292 | | same_functor(E1,E2), |
| 293 | | safe_syntaxelement_det(E1,Subs1,_Names1,_List1,Constant), |
| 294 | | safe_syntaxelement_det(E2,Subs2,_Names2,_List2,Constant2), |
| 295 | | Constant==Constant2, % in case we have values with variables inside ! |
| 296 | | same_sub_expressions(Subs1,Subs2). |
| 297 | | |
| 298 | | same_sub_expressions([],[]). |
| 299 | | same_sub_expressions([H1|T1],[H2|T2]) :- same_texpr(H1,H2), same_sub_expressions(T1,T2). |
| 300 | | |
| 301 | | % check if two wrapped expressions definitely denote a different value (and are well-defined) |
| 302 | | % only detects certain cases ! |
| 303 | | different_texpr_values(b(E1,Type,I1),b(E2,Type,I2)) :- |
| 304 | | different_value(E1,E2,CheckWD), |
| 305 | | (CheckWD=false -> true |
| 306 | | ; always_well_defined_or_wd_improvements_allowed(b(E1,Type,I1)), |
| 307 | | always_well_defined_or_wd_improvements_allowed(b(E2,Type,I2))). |
| 308 | | different_value(boolean_false,boolean_true,false) :- !. |
| 309 | | different_value(boolean_true,boolean_false,false) :- !. |
| 310 | | different_value(integer(X),IY,false) :- get_integer_aux(IY,Y),!, X\=Y. |
| 311 | | different_value(string(X),string(Y),false) :- !, X\=Y. |
| 312 | | different_value(value(VX),Y,false) :- !, different_val_from(VX,Y). |
| 313 | | different_value(empty_set,S,check_wd) :- !, non_empty_set(S). |
| 314 | | different_value(S,empty_set,check_wd) :- !, non_empty_set(S). |
| 315 | | % should we compare two set_extensions ? couples ? records ? reals? |
| 316 | | |
| 317 | | different_val_from(Var,_) :- var(Var),!,fail. |
| 318 | | different_val_from(int(X),IY) :- integer(X), get_integer_aux(IY,Y), X\=Y. |
| 319 | | different_val_from(fd(X,Gs),value(FY)) :- nonvar(X), nonvar(FY), FY=fd(Y,Gs), nonvar(Y), X\=Y. |
| 320 | | different_val_from(pred_false,boolean_true). |
| 321 | | different_val_from(pred_false,value(BY)) :- BY==pred_true. |
| 322 | | different_val_from(pred_true,boolean_false). |
| 323 | | different_val_from(pred_true,value(BY)) :- BY==pred_false. |
| 324 | | different_val_from(string(X),string(Y)) :- !, X\=Y. |
| 325 | | different_val_from(string(X),value(VY)) :- nonvar(VY), VY=string(Y), nonvar(Y), !, X\=Y. |
| 326 | | different_val_from(avl_set(node(_,_,_,_,_)),empty_set). |
| 327 | | |
| 328 | | non_empty_set(set_extension([_|_])). |
| 329 | | non_empty_set(sequence_extension([_|_])). |
| 330 | | |
| 331 | | |
| 332 | | get_texpr_exprs([],[]). |
| 333 | | get_texpr_exprs([E|Rest],[N|NRest]) :- get_texpr_expr(E,N),get_texpr_exprs(Rest,NRest). |
| 334 | | get_texpr_exprs(b(E,_,_),Res) :- add_internal_error('Illegal call:',get_texpr_infos(b(E,_,_),Res)), Res=[E]. |
| 335 | | get_texpr_types([],[]). |
| 336 | | get_texpr_types([E|Rest],[T|TRest]) :- get_texpr_type(E,T),get_texpr_types(Rest,TRest). |
| 337 | | get_texpr_types(b(_,T,_),Res) :- add_internal_error('Illegal call:',get_texpr_infos(b(_,T,_),Res)), Res=[T]. |
| 338 | | get_texpr_infos([],[]). |
| 339 | | get_texpr_infos([E|Rest],[I|IRest]) :- get_texpr_info(E,I),get_texpr_infos(Rest,IRest). |
| 340 | | get_texpr_infos(b(_,_,I),Res) :- add_internal_error('Illegal call:',get_texpr_infos(b(_,_,I),Res)), Res=[I]. |
| 341 | | get_texpr_ids([],[]). |
| 342 | | get_texpr_ids([E|Rest],[I|IRest]) :- get_texpr_id(E,I),get_texpr_ids(Rest,IRest). |
| 343 | | |
| 344 | | get_texpr_pos(TExpr,Pos) :- |
| 345 | | get_texpr_info(TExpr,Infos), |
| 346 | ? | ( member(nodeid(Pos1),Infos) -> !,Pos=Pos1 |
| 347 | | ; Pos = none). |
| 348 | | |
| 349 | | get_texpr_pos_infos(b(_,_,Infos),PosInfos) :- extract_pos_infos(Infos,PosInfos). |
| 350 | | |
| 351 | | % similar to get_texpr_pos, but returns sub-list of infos relating to position |
| 352 | | extract_pos_infos(Infos,InfoRes) :- |
| 353 | ? | ( member(nodeid(Pos1),Infos) -> !,InfoRes=[nodeid(Pos1)] |
| 354 | | ; InfoRes = []). |
| 355 | | |
| 356 | | % copy position info from first arg to second argument |
| 357 | | copy_pos_infos(b(_,_,Infos1),Arg2,Res) :- |
| 358 | | member(nodeid(Pos1),Infos1),!, |
| 359 | | Arg2 = b(E,T,Infos2), Res = b(E,T,Infos3), |
| 360 | | delete_pos_info(Infos2,Infos2d), |
| 361 | | Infos3 = [nodeid(Pos1)|Infos2d]. |
| 362 | | copy_pos_infos(_,TE,TE). |
| 363 | | |
| 364 | | delete_pos_info(Infos1,Infos2) :- |
| 365 | ? | select(nodeid(_),Infos1,D),!, Infos2=D. |
| 366 | | %delete(Infos1,nodeid(_),Infos2). |
| 367 | | delete_pos_info(I,I). |
| 368 | | |
| 369 | | % propagate position info from second list to first one if it has better position info |
| 370 | | propagate_pos_info_if_useful(Infos,AuxInfos,NewInfos) :- |
| 371 | | member(nodeid(Pos2),AuxInfos), |
| 372 | | \+ derived_pos(Pos2),!, % potentially useful position info to propagate |
| 373 | ? | (select(nodeid(Pos1),Infos,Infos2) |
| 374 | | -> (derived_pos(Pos1) |
| 375 | | -> NewInfos = [nodeid(Pos2)|Infos2] % we have better position info now |
| 376 | | ; NewInfos = Infos % we already have a position info |
| 377 | | ) |
| 378 | | ; NewInfos = [nodeid(Pos2)|Infos] |
| 379 | | ). |
| 380 | | propagate_pos_info_if_useful(Infos,_,Infos). |
| 381 | | |
| 382 | | % derived position; not precise instrinsic label at top-level |
| 383 | | derived_pos(rodin_derived_context_pos(_,_,_)). |
| 384 | | |
| 385 | | |
| 386 | | get_info_pos(Infos,Pos) :- (member(nodeid(Pos1),Infos) -> Pos=Pos1 ; Pos=none). |
| 387 | | contains_info_pos(Infos) :- (member(nodeid(NI),Infos) -> NI \= none). |
| 388 | | |
| 389 | | create_texpr(Expr,Type,Info,b(Expr,Type,Info)). |
| 390 | | |
| 391 | | add_texpr_infos(b(Expr,Type,Old),Infos,b(Expr,Type,New)) :- !, |
| 392 | | append(Infos,Old,New). |
| 393 | | add_texpr_infos(Other,Infos,Res) :- |
| 394 | | add_internal_error('Illegal call, not BExpr:',add_texpr_infos(Other,Infos,Res)),fail. |
| 395 | | |
| 396 | | add_texpr_info_if_new(b(Expr,Type,Old),Info,b(Expr,Type,New)) :- !, |
| 397 | | add_info_if_new(Old,Info,New). |
| 398 | | add_texpr_info_if_new(Other,Infos,Res) :- |
| 399 | | add_internal_error('Illegal call, not BExpr:',add_texpr_info_if_new(Other,Infos,Res)),fail. |
| 400 | | % add multiple infos: |
| 401 | | add_texpr_infos_if_new(b(Expr,Type,Old),Infos,b(Expr,Type,New)) :- |
| 402 | | add_infos_if_new(Infos,Old,New). |
| 403 | | |
| 404 | | % add to info list: |
| 405 | | add_info_if_new(Old,Info,New) :- |
| 406 | | (member(Info,Old) -> New=Old ; New = [Info|Old]). |
| 407 | | |
| 408 | | add_infos_if_new([]) --> []. |
| 409 | | add_infos_if_new([Info|T]) --> add_info(Info), add_infos_if_new(T). |
| 410 | | add_info(Info,Old,New) :- |
| 411 | ? | (member(Info,Old) -> New=Old ; New = [Info|Old]). |
| 412 | | |
| 413 | | |
| 414 | | % try and extract the Rodin name of a predicate or expression |
| 415 | | get_rodin_name(Expression,Name) :- get_texpr_pos(Expression,rodinpos(Name,_)), Name \= []. |
| 416 | | get_rodin_name(Expression,Name) :- get_texpr_pos(Expression,rodinpos(_Model,Name,_)), Name \= []. % new rodinpos |
| 417 | | |
| 418 | | get_rodin_model_name(Expression,Model) :- |
| 419 | | get_texpr_pos(Expression,rodinpos(Model,Name,_)), Name \= []. % new rodinpos |
| 420 | | % Note: only precise position label, not rodin_derived_context_pos |
| 421 | | |
| 422 | | % try and extract the Rodin name or label pragma of a predicate or expression |
| 423 | | get_texpr_labels(TExpr,Label) :- |
| 424 | | get_texpr_info(TExpr,Infos), |
| 425 | ? | member(I,Infos), info_label(I,Label). |
| 426 | | get_info_labels(Infos,LabelList) :- |
| 427 | ? | member(I,Infos), info_label(I,LabelList). |
| 428 | | select_info_labels(LabelList,Infos,Rest) :- |
| 429 | | select(I,Infos,Rest), info_label(I,LabelList). |
| 430 | | info_label(nodeid(NodeID),[Name]) :- nodeid_info_label(NodeID,Name). |
| 431 | | info_label(label(LabelList),LabelList). |
| 432 | | |
| 433 | | nodeid_info_label(rodinpos(Name,_),Name) :- Name \= []. |
| 434 | | nodeid_info_label(rodinpos(Model,Name,_),FullName) :- Name \= [], % new rodinpos |
| 435 | | ajoin([Model,':',Name], FullName). % TO DO: if only one level; don't do this |
| 436 | | % TODO: provide separate way to access this derived information: |
| 437 | | %nodeid_info_label(rodin_derived_context_pos(Model,Context,Label),FullName) :- |
| 438 | | % ajoin([Model,'.',Context,':',Label], FullName). |
| 439 | | |
| 440 | | |
| 441 | | add_labels_to_texpr(E,[],R) :- !, R=E. % no labels to add |
| 442 | | add_labels_to_texpr(b(E,T,I),Labels,b(E,T,NewI)) :- |
| 443 | | (select(label(OldList),I,Rest) |
| 444 | | -> append(Labels,OldList,NewList), NewI=[label(NewList)|Rest] |
| 445 | | % TO DO: what if we have Rodin labels |
| 446 | | ; NewI = [label(Labels)|I] |
| 447 | | ). |
| 448 | | |
| 449 | | get_texpr_label(TExpr,Label) :- get_texpr_labels(TExpr,Labels), member(Label,Labels). |
| 450 | | |
| 451 | | get_texpr_description(TExpr,Description) :- |
| 452 | | get_texpr_info(TExpr,Infos), |
| 453 | | memberchk(description(Description),Infos). |
| 454 | | |
| 455 | | add_texpr_description(b(E,T,I),Description,b(E,T,[description(Description)|I])) :- |
| 456 | | (atom(Description) -> true ; |
| 457 | | add_error(add_texpr_description,'Non-atomic description:',Description)). |
| 458 | | |
| 459 | | % check if an info list has an ignore pragma |
| 460 | | info_has_ignore_pragma(Infos) :- |
| 461 | | member(description('prob-ignore'),Infos). |
| 462 | | % detect_prob_ignore ast_cleanup rule also generates this description annotation |
| 463 | | |
| 464 | | predicate_has_ignore_pragma(b(_E,pred,I)) :- |
| 465 | | %add_message(check_prob_ignore,'Pred: ',b(_E,pred,I),I), |
| 466 | | info_has_ignore_pragma(I). |
| 467 | | |
| 468 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 469 | | |
| 470 | | :- assert_must_succeed( (E = "1/2", |
| 471 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 472 | | Type==integer, Err==none, always_well_defined(ET) ) ). |
| 473 | | :- assert_must_succeed( (E = "3 mod 2", |
| 474 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 475 | | Type==integer, Err==none, always_well_defined(ET) ) ). |
| 476 | | :- assert_must_succeed( (E = "1/0", |
| 477 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 478 | | Type==integer, Err==none, \+ always_well_defined(ET) ) ). |
| 479 | | :- assert_must_succeed( (E = "2*(3 mod card({}))", |
| 480 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 481 | | Type==integer, Err==none, \+ always_well_defined(ET) ) ). |
| 482 | | :- assert_must_succeed( (E = "1/(2+1-3)", |
| 483 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 484 | | Type==integer, Err==none, \+ always_well_defined(ET) ) ). |
| 485 | | :- assert_must_succeed( (E = "max({1,2,3,0})", |
| 486 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 487 | | Type==integer, Err==none, always_well_defined(ET) ) ). |
| 488 | | :- assert_must_succeed( (E = "min({1,2,3,0})", |
| 489 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 490 | | Type==integer, Err==none, always_well_defined(ET) ) ). |
| 491 | | :- assert_must_succeed( (E = "min({1,2,3,0}-(0..4))", |
| 492 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 493 | | Type==integer, Err==none, \+ always_well_defined(ET) ) ). |
| 494 | | :- assert_must_succeed( (E = "2+max({1,2,3, 1/0})", |
| 495 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 496 | | Type==integer, Err==none,\+ always_well_defined(ET) ) ). |
| 497 | | :- assert_must_succeed( (E = "2-card({1,2,3})", |
| 498 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 499 | | Type==integer, Err==none, always_well_defined(ET) ) ). |
| 500 | | :- assert_must_succeed( (E = "2-card({1,2,3, 1/0})", |
| 501 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 502 | | Type==integer, Err==none,\+ always_well_defined(ET) ) ). |
| 503 | | :- assert_must_succeed( (E = "bool(2-size([1,2,3, 1/0])=3)", |
| 504 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 505 | | Type==boolean, Err==none, \+ always_well_defined(ET) ) ). |
| 506 | | :- assert_must_succeed( (E = "bool(2-size([1,2,3, 1/2, 3 mod 2, 3**2])=size([]))", |
| 507 | | bmachine:b_parse_machine_expression_from_codes(E,ET,Type,false,Err), |
| 508 | | Type==boolean, Err==none, always_well_defined(ET) ) ). |
| 509 | | |
| 510 | | always_well_defined_or_wd_reorderings_allowed(BE) :- % allow re-ordering to improve Left-to-right WD |
| 511 | | (preferences:preference(disprover_mode,true) -> true % we can assume all calls are well-defined |
| 512 | | ; preferences:preference(allow_improving_wd_mode,true) -> true |
| 513 | | ; preferences:preference(data_validation_mode,true) -> true |
| 514 | | ; always_well_defined_or_discharged(BE)). |
| 515 | | always_well_defined_or_wd_improvements_allowed(BE) :- % allow to remove useless calls which could be non-WD |
| 516 | | % example #x(x = f(...)) -> btrue or f[{}] --> {} |
| 517 | | always_well_defined_or_wd_reorderings_allowed(BE). % we currently use the same definition |
| 518 | | always_well_defined_or_disprover_mode(BE) :- |
| 519 | | (preferences:preference(disprover_mode,true) -> true % we can assume all calls are well-defined |
| 520 | | ; always_well_defined_or_discharged(BE)). |
| 521 | | |
| 522 | | always_well_defined_or_discharged(b(E,_,Infos)) :- !, |
| 523 | | (nonmember(contains_wd_condition,Infos) -> true |
| 524 | | ; always_wd(E) -> true % some special rules |
| 525 | | ; member(discharged_wd_po,Infos) -> true |
| 526 | | %; nl, functor(E,F,N), F \= function, print(non_wd(F,N)),nl,nl,fail |
| 527 | | ). |
| 528 | | always_well_defined_or_discharged(E) :- |
| 529 | | add_error_fail(always_well_defined,'Illegal call: ',always_well_defined_or_discharged(E)). |
| 530 | | |
| 531 | | % should ensure that there is no failure and no error raised |
| 532 | | always_well_defined(b(E,_,Infos)) :- !, |
| 533 | | (nonmember(contains_wd_condition,Infos) -> true |
| 534 | | ; always_wd(E) -> true % some special rules |
| 535 | | %; nl, functor(E,F,N), F \= function, print(non_wd(F,N)),nl,nl,fail |
| 536 | | ). |
| 537 | | always_well_defined(E) :- add_error_fail(always_well_defined,'Illegal call: ',always_well_defined(E)). |
| 538 | | |
| 539 | | |
| 540 | | :- assert_must_succeed( always_wd(div( b(integer(2),integer,[]), b(integer(2),integer,[]) )) ). |
| 541 | | :- assert_must_fail( always_wd(div( b(integer(2),integer,[]), b(integer(0),integer,[]) )) ). |
| 542 | | :- assert_must_succeed( always_wd(modulo( b(integer(2),integer,[]), b(integer(2),integer,[]) )) ). |
| 543 | | :- assert_must_fail( always_wd(modulo( b(integer(2),integer,[]), b(integer(0),integer,[]) )) ). |
| 544 | | :- assert_must_fail( always_wd(modulo( b(integer(2),integer,[]), b(integer(-2),integer,[]) )) ). |
| 545 | | :- assert_must_fail( always_wd(modulo( b(integer(-1),integer,[]), b(integer(2),integer,[]) )) ). |
| 546 | | :- assert_must_succeed( always_wd(power_of( b(integer(2),integer,[]), b(integer(3),integer,[]) )) ). |
| 547 | | :- assert_must_succeed( always_wd(power_of( b(integer(2),integer,[]), b(integer(0),integer,[]) )) ). |
| 548 | | :- assert_must_fail( always_wd(power_of( b(integer(2),integer,[]), b(integer(-1),integer,[]) )) ). |
| 549 | | |
| 550 | | % catch cases where the construct is currently so instantiated that we can determine that it is well-defined |
| 551 | | % can happen e.g. during closure compilation |
| 552 | | :- use_module(custom_explicit_sets,[check_unique_in_domain_of_avlset/2]). |
| 553 | | :- use_module(kernel_tools,[ground_value/1]). |
| 554 | | always_wd(power_of(X,Y)) :- get_integer(Y,Val), Val>=0, |
| 555 | | (eventb_mode -> get_integer(X,ValX), ValX >=0 |
| 556 | | ; always_well_defined(X)). |
| 557 | | always_wd(div(X,Y)) :- get_integer(Y,Val), Val\=0, always_well_defined(X). |
| 558 | | always_wd(modulo(X,Y)) :- get_integer(Y,Val), Val>0, % Z Live allows negative numbers here it seems, cf modulo2 |
| 559 | | (z_or_tla_minor_mode -> true % in Z, TLA we can have negative numbers here |
| 560 | | ; get_integer(X,ValX), ValX>=0). |
| 561 | | always_wd(function(X,Y)) :- nonvar(X), |
| 562 | | X= b(value(AVLSET),_,_), nonvar(AVLSET), AVLSET=avl_set(AVL), |
| 563 | | always_wd_avl_function(AVL,Y). |
| 564 | | always_wd(min(X)) :- non_empty_finite_wd_set_value(X). |
| 565 | | always_wd(max(X)) :- non_empty_finite_wd_set_value(X). |
| 566 | | always_wd(card(X)) :- finite_wd_set_value(X). |
| 567 | | always_wd(size(X)) :- finite_wd_seq_value(X). |
| 568 | | always_wd(first(X)) :- non_empty_wd_seq_value(X). |
| 569 | | always_wd(front(X)) :- non_empty_wd_seq_value(X). |
| 570 | | always_wd(last(X)) :- non_empty_wd_seq_value(X). |
| 571 | | always_wd(tail(X)) :- non_empty_wd_seq_value(X). % TO DO: add restrict_front, restrict_tail ? |
| 572 | | always_wd(general_intersection(X)) :- non_empty_finite_wd_set_value(X). |
| 573 | | always_wd(value(_)). % we have already computed the value and will raise WD error; to be 100 % safe we could restrict this to ground values |
| 574 | | % other candidates: size(_), first(_) last(_) tail(_) front(_) restrict_front(_,_) restrict_tail(_,_) rel_iterate(_,_) |
| 575 | | always_wd(typeset). |
| 576 | | % operators that are always wd on their own: |
| 577 | | always_wd(record_field(RecEx,FieldName)) :- ground(FieldName), |
| 578 | | always_well_defined(RecEx). |
| 579 | | always_wd(unary_minus(A)) :- always_well_defined(A). |
| 580 | | always_wd(unary_minus_real(A)) :- always_well_defined(A). |
| 581 | | always_wd(first_of_pair(A)) :- always_well_defined(A). |
| 582 | | always_wd(add(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 583 | | always_wd(add_real(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 584 | | always_wd(minus(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 585 | | always_wd(minus_real(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 586 | | always_wd(multiplication(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 587 | | always_wd(multiplication_real(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 588 | | always_wd(equal(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 589 | | always_wd(not_equal(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 590 | | always_wd(less_equal(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 591 | | always_wd(less_equal_real(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 592 | | always_wd(greater_equal(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 593 | | always_wd(less(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 594 | | always_wd(less_real(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 595 | | always_wd(greater(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 596 | | always_wd(couple(A,B)) :- always_well_defined(A),always_well_defined(B). |
| 597 | | % TO DO: add more/all other operators ? |
| 598 | | |
| 599 | | always_wd_avl_function(AVL,Y) :- nonvar(Y), Y= b(value(Val),_,_), |
| 600 | | ground_value(Val), !, |
| 601 | | % Warning: this does not check that the whole AVL is a function; just this particular lookup is ok |
| 602 | | check_unique_in_domain_of_avlset(Val,AVL). % ,print(ok),nl. |
| 603 | | always_wd_avl_function(AVL,Y) :- always_well_defined(Y), |
| 604 | | custom_explicit_sets:quick_definitely_maximal_total_function_avl(AVL). |
| 605 | | |
| 606 | | % non empty set with WD elements |
| 607 | | non_empty_finite_wd_set_value(b(E,_,_)) :- non_empty_fin_wd_set2(E). |
| 608 | | non_empty_fin_wd_set2(bool_set). |
| 609 | | non_empty_fin_wd_set2(value(X)) :- definitely_not_empty_finite_value(X). |
| 610 | | non_empty_fin_wd_set2(set_extension(S)) :- l_always_well_defined(S). % the set_extension could contain wd_errors !! |
| 611 | | non_empty_fin_wd_set2(sequence_extension(S)) :- l_always_well_defined(S). % ditto |
| 612 | | non_empty_fin_wd_set2(interval(A,B)) :- get_integer(A,IA), get_integer(B,IB), IA =< IB. |
| 613 | | % see not_empty_set_aux |
| 614 | | definitely_not_empty_finite_value(X) :- var(X),!,fail. |
| 615 | | definitely_not_empty_finite_value(avl_set(_)). |
| 616 | | definitely_not_empty_finite_value([_|_]). |
| 617 | | definitely_not_empty_finite_value(closure(P,T,B)) :- |
| 618 | | custom_explicit_sets:is_interval_closure(P,T,B,LOW,UP), integer(LOW),integer(UP), LOW =< UP. |
| 619 | | % TODO: pow_subset of finite values |
| 620 | | |
| 621 | | non_empty_wd_seq_value(b(E,_,_)) :- non_empty_seq2(E). |
| 622 | | non_empty_seq2(value(X)) :- definitely_not_empty_seq(X). |
| 623 | | non_empty_seq2(sequence_extension(S)) :- l_always_well_defined(S), S=[_|_]. |
| 624 | | |
| 625 | | definitely_not_empty_seq(X) :- var(X),!,fail. |
| 626 | | definitely_not_empty_seq(avl_set(A)) :- custom_explicit_sets:is_avl_sequence(A). |
| 627 | | definitely_not_empty_seq([El1|T]) :- T==[],nonvar(El1), El1=(IDX,_), IDX==int(1). % TO DO: add more cases ? |
| 628 | | |
| 629 | | |
| 630 | | finite_set_or_disprover_mode(Set) :- |
| 631 | | (preferences:preference(disprover_mode,true) -> true % we can assume all calls are well-defined |
| 632 | | ; finite_wd_set_value(Set)). |
| 633 | | |
| 634 | | :- use_module(typing_tools,[is_provably_finite_type/1]). |
| 635 | | % we could also use is_finite_type_in_context to allow deferred sets to be counted as finite |
| 636 | | finite_wd_set_value(b(E,T,_)) :- !, (finite_set2(E) -> true ; is_provably_finite_type(T)). |
| 637 | | finite_wd_set_value(E) :- add_internal_error('Not a BExpr: ',E),fail. |
| 638 | | finite_set2(empty_set). |
| 639 | | finite_set2(empty_sequence). |
| 640 | | finite_set2(value(X)) :- X==[] -> true ; definitely_not_empty_finite_value(X). |
| 641 | | finite_set2(set_extension(S)) :- l_always_well_defined(S). % the set_extension could contain wd_errors !! |
| 642 | | finite_set2(sequence_extension(S)) :- l_always_well_defined(S). % ditto |
| 643 | | |
| 644 | | finite_wd_seq_value(b(E,_,_)) :- finite_seq2(E). |
| 645 | | finite_seq2(empty_set). |
| 646 | | finite_seq2(empty_sequence). |
| 647 | | finite_seq2(value(X)) :- finite_seq_value(X). |
| 648 | | finite_seq2(sequence_extension(S)) :- l_always_well_defined(S). |
| 649 | | |
| 650 | | finite_seq_value(X) :- var(X),!,fail. |
| 651 | | finite_seq_value([]). |
| 652 | | finite_seq_value(avl_set(A)) :- custom_explicit_sets:is_avl_sequence(A). |
| 653 | | % it could be expensive to check if non empty list is a B sequence ?? |
| 654 | | |
| 655 | | l_always_well_defined([]). |
| 656 | | l_always_well_defined([H|T]) :- always_well_defined(H), l_always_well_defined(T). |
| 657 | | |
| 658 | | is_truth(b(F,pred,_)) :- is_truth_aux(F). |
| 659 | | is_truth_aux(truth). |
| 660 | | is_truth_aux(value(V)) :- V==pred_true. % can occur in CSE mode |
| 661 | | |
| 662 | | is_falsity(b(F,pred,_)) :- is_falsity_aux(F). |
| 663 | | is_falsity_aux(falsity). |
| 664 | | is_falsity_aux(value(V)) :- V==pred_false. % can occur in CSE mode |
| 665 | | |
| 666 | | % conjunction of a list of predicates |
| 667 | | % NOTE: bsyntaxtree:conjunct_predicates([P1,P2,P3],R). --> generates R = b(conjunct(b(conjunct(P1,P2),pred,[]),P3),pred,[]) |
| 668 | | conjunct_predicates(V,R) :- var(V),!, add_internal_error('Variable conjunction list: ',conjunct_predicates(V,R)),fail. |
| 669 | | conjunct_predicates([],b(truth,pred,[])). |
| 670 | | conjunct_predicates([P|Rest],Result) :- conjunct2(Rest,P,Result). |
| 671 | | conjunct2([],P,P). |
| 672 | | conjunct2([Q|Rest],P,Result) :- conjunct3(P,Q,R), conjunct2(Rest,R,Result). |
| 673 | | conjunct3(b(truth,_,_),P,P) :- !. |
| 674 | | conjunct3(P,b(truth,_,_),P) :- !. |
| 675 | | conjunct3(A,B,b(conjunct(A,B),pred,NewInfo)) :- extract_info(A,B,NewInfo). |
| 676 | | |
| 677 | | % disjunction of a list of predicates |
| 678 | | disjunct_predicates([],b(falsity,pred,[])). |
| 679 | | disjunct_predicates([P|Rest],Result) :- disjunct2(Rest,P,Result). |
| 680 | | disjunct2([],P,P). |
| 681 | | disjunct2([Q|Rest],P,Result) :- disjunct3(P,Q,R), disjunct2(Rest,R,Result). |
| 682 | | disjunct3(b(falsity,_,_),P,R) :- !, R=P. |
| 683 | | disjunct3(b(truth,T,I),_,R) :- !, R=b(truth,T,I). |
| 684 | | disjunct3(P,b(falsity,_,_),R) :- !, R=P. |
| 685 | | disjunct3(_,b(truth,T,I),R) :- !, R=b(truth,T,I). |
| 686 | | disjunct3(A,B,b(disjunct(A,B),pred,NewInfo)) :- extract_info(A,B,NewInfo). |
| 687 | | |
| 688 | | % conjunct two predicates and try and construct position information |
| 689 | | conjunct_predicates_with_pos_info(A,B,AB) :- is_truth(B),!, AB=A. |
| 690 | | conjunct_predicates_with_pos_info(A,B,AB) :- is_truth(A),!, AB=B. |
| 691 | | conjunct_predicates_with_pos_info(A,B,AB) :- |
| 692 | | conjunct_predicates([A,B],AB0), % this may contain position info if B is truth; hence we do check above |
| 693 | | (try_get_merged_position_info(A,B,ABI) |
| 694 | | -> add_texpr_infos(AB0,[ABI],AB) %,print(abi(ABI)),nl |
| 695 | | ; AB=AB0). |
| 696 | | |
| 697 | | % disjunct two predicates and try and construct position information |
| 698 | | disjunct_predicates_with_pos_info(A,B,AB) :- |
| 699 | | disjunct_predicates([A,B],AB0), |
| 700 | | (try_get_merged_position_info(A,B,ABI) |
| 701 | | -> add_texpr_infos(AB0,[ABI],AB) %,print(abi(ABI)),nl |
| 702 | | ; AB=AB0). |
| 703 | | |
| 704 | | try_get_merged_position_info(b(_,_,I1),b(_,_,I2),PosInfo) :- |
| 705 | | (try_get_merged_position_info_aux(I1,I2,MergedInfo) -> PosInfo = MergedInfo |
| 706 | ? | ; get_non_label_posinfo(Pos1,I1) -> PosInfo=nodeid(Pos1) |
| 707 | ? | ; get_non_label_posinfo(Pos2,I2) -> PosInfo=nodeid(Pos2) |
| 708 | | ). |
| 709 | | try_get_merged_position_info_aux(I1,I2,nodeid(pos(C,Filenumber,Srow,Scol,Erow,Ecol))) :- |
| 710 | | member(nodeid(pos(C1,Filenumber,Srow1,Scol1,Erow1,Ecol1)),I1), |
| 711 | | (number(C1),number(Srow1),number(Scol1),number(Erow1),number(Ecol1) |
| 712 | | -> true ; add_internal_error('Info field 1 not yet instantiated: ',try_get_merged_position_info(I1)),fail), |
| 713 | | !, |
| 714 | | member(nodeid(pos(C2,Filenumber,Srow2,Scol2,Erow2,Ecol2)),I2), |
| 715 | | (number(C2),number(Srow2),number(Scol2),number(Erow2),number(Ecol2) |
| 716 | | -> true ; add_internal_error('Info field 2 not yet instantiated: ',try_get_merged_position_info(I2)),fail), |
| 717 | | !, |
| 718 | | % merge position info if in same file |
| 719 | | (C1 =< C2 -> C=C1, Srow=Srow1,Scol=Scol1 ; C=C2, Srow=Srow2,Scol=Scol2), |
| 720 | | ((Erow1 > Erow2 ; Erow1=Erow2, Ecol1 >= Ecol2) |
| 721 | | -> Erow =Erow1, Ecol=Ecol1 |
| 722 | | ; Erow =Erow2, Ecol=Ecol2). |
| 723 | | |
| 724 | | % get position info which is not a label; label info should not be propagated to outer conjuncts/disjuncts/... |
| 725 | ? | get_non_label_posinfo(Pos,Infos) :- member(nodeid(Pos),Infos), |
| 726 | | \+ functor(Pos,rodinpos,_). |
| 727 | | |
| 728 | ? | get_texpr_non_label_posinfo(b(_,_,Infos),nodeid(Pos)) :- get_non_label_posinfo(Pos,Infos). |
| 729 | | |
| 730 | | % conjunct list of predicates and try and construct position information |
| 731 | | conjunct_predicates_with_pos_info([H|T],Res) :- is_truth(H),!, |
| 732 | | (T=[] -> Res = H ; conjunct_predicates_with_pos_info(T,Res)). |
| 733 | | conjunct_predicates_with_pos_info([H|T],Res) :- |
| 734 | | last_non_truth(T,none,Last), % the truth elements will be removed and are not relevant; get last relevant predicate |
| 735 | | Last \= none, |
| 736 | | try_get_merged_position_info(H,Last,MergedPosInfo), % try and merge position of first and last element |
| 737 | | !, |
| 738 | | conjunct_predicates([H|T],Res0), |
| 739 | | add_texpr_infos(Res0,[MergedPosInfo],Res). % Res0 should have no nodeid field |
| 740 | | conjunct_predicates_with_pos_info(L,Res) :- conjunct_predicates(L,Res). |
| 741 | | |
| 742 | | :- assert_must_succeed((bsyntaxtree:last_non_truth([a,b,c],none,L),L==c)). |
| 743 | | :- assert_must_succeed((bsyntaxtree:last_non_truth([a,b,c,b(truth,pred,[])],none,L),L==c)). |
| 744 | | |
| 745 | | % get last non-truth element and filter out all truth elements |
| 746 | | last_non_truth([],Acc,Acc). |
| 747 | | last_non_truth([H|T],NonTruth,Last) :- is_truth(H),!, last_non_truth(T,NonTruth,Last). |
| 748 | | last_non_truth([H|T],_,Last) :- last_non_truth(T,H,Last). |
| 749 | | |
| 750 | | |
| 751 | | texpr_contains_wd_condition(b(_,_,Info)) :- !, memberchk(contains_wd_condition,Info). |
| 752 | | texpr_contains_wd_condition(E) :- add_internal_error('Not a texpr: ',texpr_contains_wd_condition(E)). |
| 753 | | |
| 754 | | % a version of create_texpr which collects automatically important infos from sub-expressions |
| 755 | | safe_create_texpr(Expr,Type,b(Expr,Type,Info)) :- % |
| 756 | ? | (sub_expression_contains_wd_condition(Expr) -> Info = [contains_wd_condition] ; Info=[]). |
| 757 | | |
| 758 | | safe_create_texpr(Expr,Type,Info,b(Expr,Type,FullInfo)) :- % |
| 759 | ? | ((sub_expression_contains_wd_condition(Expr), nonmember(contains_wd_condition, Info)) -> FullInfo = [contains_wd_condition|Info] ; FullInfo=Info). |
| 760 | | |
| 761 | ? | sub_expression_contains_wd_condition(Expr) :- sub_expression_contains_wd_condition(Expr,_). |
| 762 | | sub_expression_contains_wd_condition(Expr,Sub) :- |
| 763 | | safe_syntaxelement_det(Expr,Subs,_Names,_L,_C), |
| 764 | ? | member(b(Sub,_,Infos),Subs), |
| 765 | | (var(Infos) |
| 766 | | -> add_internal_error('Typed expression not sufficiently instantiated (variable Infos): ',sub_expression_contains_wd_condition(Expr)), |
| 767 | | fail |
| 768 | | ; memberchk(contains_wd_condition,Infos)). |
| 769 | | |
| 770 | | % provide updated infos (e.g., reads(...)) and remove any old info fields with same functor |
| 771 | | update_infos([],Infos,Infos). |
| 772 | | update_infos([Update|T],OldInfos,NewInfos) :- |
| 773 | | functor(Update,F,N), |
| 774 | | functor(Old,F,N), |
| 775 | | delete(OldInfos,Old,OldInfos1), |
| 776 | | update_infos(T,[Update|OldInfos1],NewInfos). |
| 777 | | |
| 778 | | % merge two info lists and try to reconcile position information: |
| 779 | | merge_info(Info1,Info2,Res) :- |
| 780 | | merge_imp_info2(Info2,Info1,NewInfo), |
| 781 | | (try_get_merged_position_info_aux(Info1,Info2,NewPos) |
| 782 | | -> delete_pos_info(NewInfo,NI2), |
| 783 | | Res = [NewPos|NI2] |
| 784 | | ; Res = NewInfo). |
| 785 | | |
| 786 | | % extract important info but without used_ids: |
| 787 | | extract_info_wo_used_ids(b(_,_,Info1),Info) :- |
| 788 | | extract_pos_infos(Info1,PosInfos), |
| 789 | | extract_just_important_info_aux(Info1,[],I1), |
| 790 | | append(PosInfos,I1,Info). |
| 791 | | extract_info_wo_used_ids_and_pos(b(_,_,Info1),b(_,_,Info2),Info) :- |
| 792 | | extract_just_important_info_aux(Info1,[],I1), |
| 793 | | extract_just_important_info_aux(Info2,I1,Info). |
| 794 | | |
| 795 | | % extract important info from one sub-expression: |
| 796 | | extract_info(b(_,_,Info1),NewInfo) :- |
| 797 | | extract_imp_info1(Info1,I1),!, NewInfo = I1. |
| 798 | | extract_info(A,R) :- |
| 799 | | add_internal_error('Could not extract info: ',extract_info(A,R)), |
| 800 | | R=[]. |
| 801 | | % extract imortant info fields from two (sub-)expressions |
| 802 | | extract_info(b(_,_,Info1),b(_,_,Info2),NewInfo) :- |
| 803 | ? | merge_imp_info2(Info1,Info2,II),!, NewInfo = II. |
| 804 | | %:- use_module(library(ordsets),[ord_intersection/3]). |
| 805 | | % ord_intersection(Info1,Info2,NewInfo),!. |
| 806 | | % TO DO: should we merge nodeid position information !? |
| 807 | | extract_info(A,B,R) :- add_internal_error('Could not extract info: ',extract_info(A,B,R)), |
| 808 | | R=[]. |
| 809 | | |
| 810 | | % extract important info and used_ids |
| 811 | | extract_imp_info1([],[]). |
| 812 | | extract_imp_info1([H|T],Res) :- |
| 813 | | ((important_info(H); H=used_ids(_)) -> Res=[H|ET], extract_imp_info1(T,ET) |
| 814 | | ; extract_imp_info1(T,Res) |
| 815 | | ). |
| 816 | | |
| 817 | | % extract and merge important info and try to merge used_ids from two info lists |
| 818 | | merge_imp_info2(Info1,Info2,ResInfos) :- |
| 819 | | extract_imp_info1(Info1,I1), |
| 820 | ? | extract_imp_info1(Info2,I2), |
| 821 | | merge_aux(I1,I2,ResInfos). |
| 822 | | |
| 823 | | merge_aux([],I2,Res) :- !, delete(I2,used_ids(_),Res). % used_ids not valid for new construct |
| 824 | | merge_aux(I1,[],Res) :- !, delete(I1,used_ids(_),Res). % ditto |
| 825 | | merge_aux(I1,I2,ResInfos) :- |
| 826 | ? | (select(used_ids(Ids1),I1,II1) |
| 827 | ? | -> (select(used_ids(Ids2),I2,II2) |
| 828 | | -> ord_union(Ids1,Ids2,Ids3), |
| 829 | | append(II1,[used_ids(Ids3)|II2],II) |
| 830 | | ; append(II1,I2,II) |
| 831 | | ) |
| 832 | | ; delete(I2,used_ids(_),II2), |
| 833 | | append(I1,II2,II) |
| 834 | | ), |
| 835 | | sort(II,ResInfos). % TO DO: sort sublists ? and use ord_union? |
| 836 | | |
| 837 | | important_info(contains_wd_condition). |
| 838 | | important_info(prob_annotation(_)). |
| 839 | | important_info(allow_to_lift_exists). |
| 840 | | important_info(removed_typing). |
| 841 | | %important_info(lambda_result(_)). % should probably not be copied |
| 842 | | |
| 843 | | % variation of above which does not extract and merge used_ids: |
| 844 | | extract_just_important_info_aux([],Acc,Acc). |
| 845 | | extract_just_important_info_aux([H|T],Acc,Res) :- |
| 846 | ? | (important_info(H), \+ member(H,Acc) -> extract_just_important_info_aux(T,[H|Acc],Res) |
| 847 | | ; extract_just_important_info_aux(T,Acc,Res)). |
| 848 | | |
| 849 | | |
| 850 | | is_a_conjunct(b(conjunct(A,B),pred,_),A,B). |
| 851 | | % use is_a_conjunct_without_label if you want to avoid decomposing conjunction associated with a single label |
| 852 | | is_a_conjunct_without_label(b(conjunct(A,B),pred,I),A,B) :- \+ get_info_labels(I,_). |
| 853 | | % use decompose conjunct if you want to propagate labels down to the conjuncts |
| 854 | | decompose_conjunct(b(conjunct(A,B),pred,I),ResA,ResB) :- |
| 855 | | (get_info_labels(I,Labels) |
| 856 | | -> add_labels_to_texpr(A,Labels,ResA), add_labels_to_texpr(B,Labels,ResB) |
| 857 | | ; ResA=A, ResB=B). |
| 858 | | |
| 859 | | size_of_conjunction(C,Size) :- size_of_conjunction(C,0,Size). |
| 860 | | size_of_conjunction(C,Acc,Res) :- is_a_conjunct(C,A,B),!, |
| 861 | | size_of_conjunction(B,Acc,A1), |
| 862 | | size_of_conjunction(A,A1,Res). |
| 863 | | size_of_conjunction(_,Acc,Size) :- Size is Acc+1. |
| 864 | | |
| 865 | | conjunction_to_list(C,L) :- var(C),!, |
| 866 | | add_error_fail(conjunction_to_list,'Internal error: var :',conjunction_to_list(C,L)). |
| 867 | | conjunction_to_list(C,List) :- |
| 868 | | conjunction_to_list2(C,List,[]). |
| 869 | | conjunction_to_list2(X,I,O) :- X=b(E,_,_), |
| 870 | | (E=conjunct(LHS,RHS) -> conjunction_to_list2(LHS,I,Inter), |
| 871 | | conjunction_to_list2(RHS,Inter,O) |
| 872 | | ; E = truth -> I=O |
| 873 | | ; I = [X|O]). |
| 874 | | |
| 875 | | % a variation of conjunction_to_list which propagates Rodin and pragma label infos down |
| 876 | | % important for proof info; maybe we should only propagate Rodin labels ? |
| 877 | | conjunction_to_list_with_rodin_labels(C,L) :- var(C),!, |
| 878 | | add_error_fail(conjunction_to_list,'Internal error: var :',conjunction_to_list_with_rodin_labels(C,L)). |
| 879 | | conjunction_to_list_with_rodin_labels(C,List) :- |
| 880 | | conjunction_to_list_with_labels2(C,List,[]). |
| 881 | | conjunction_to_list_with_labels2(b(conjunct(A,B),pred,Infos),I,O) :- !, |
| 882 | | copy_rodin_label(Infos,A,B,LHS,RHS), |
| 883 | | conjunction_to_list_with_labels2(LHS,I,Inter), |
| 884 | | conjunction_to_list_with_labels2(RHS,Inter,O). |
| 885 | | conjunction_to_list_with_labels2(X,I,O) :- X=b(E,_,_), |
| 886 | | ( E = truth -> I=O |
| 887 | | ; I = [X|O]). |
| 888 | | |
| 889 | | |
| 890 | ? | copy_rodin_label(Infos,A,B,NewA,NewB) :- member(Pos,Infos), is_rodin_label_info(Pos),!, |
| 891 | | add_rodin_label_info(A,Pos,NewA), |
| 892 | | add_rodin_label_info(B,Pos,NewB). |
| 893 | | copy_rodin_label(_,A,B,A,B). |
| 894 | | |
| 895 | | add_rodin_label_info(b(E,T,I),Pos,b(E,T,I2)) :- |
| 896 | | (member(Pos,I), is_rodin_label_info(Pos) -> I2=I |
| 897 | | ; I2 = [Pos|I]). |
| 898 | | |
| 899 | | is_rodin_label_info(nodeid(Pos)) :- functor(Pos,rodinpos,_). |
| 900 | | |
| 901 | | |
| 902 | | flatten_conjunctions(List,FlattenedList) :- flatten_conj_aux(List,FlattenedList,[]). |
| 903 | | flatten_conj_aux([]) --> !, []. |
| 904 | | flatten_conj_aux([H|T]) --> !, flatten_conj_aux(H),flatten_conj_aux(T). |
| 905 | | flatten_conj_aux(C) --> {is_a_conjunct(C,LHS,RHS)}, |
| 906 | | !, |
| 907 | | flatten_conj_aux(LHS), flatten_conj_aux(RHS). |
| 908 | | flatten_conj_aux(Truth) --> {is_truth(Truth)},!,[]. |
| 909 | | flatten_conj_aux(C) --> [C]. |
| 910 | | |
| 911 | | member_in_conjunction(M,Conj) :- is_a_conjunct(Conj,LHS,RHS),!, |
| 912 | ? | (member_in_conjunction(M,LHS) ; member_in_conjunction(M,RHS)). |
| 913 | | member_in_conjunction(M,M). |
| 914 | | |
| 915 | | % a version of member_in_conjunction which can deal with lazy_let_pred : |
| 916 | | % member_in_conjunction_cse(FullConjunctWithLets,InnerConjunctNotALet, Conjunction) |
| 917 | | member_in_conjunction_cse(M,InnerConj,Conj) :- is_a_conjunct(Conj,LHS,RHS),!, |
| 918 | | (member_in_conjunction_cse(M,InnerConj,LHS) ; member_in_conjunction_cse(M,InnerConj,RHS)). |
| 919 | | member_in_conjunction_cse(Conj,InnerConj,b(lazy_let_pred(ID,Share,Body),pred,Info)) :- |
| 920 | | Conj = b(lazy_let_pred(ID,Share,BConj),pred,Info),!, |
| 921 | | member_in_conjunction_cse(BConj,InnerConj,Body). |
| 922 | | member_in_conjunction_cse(M,M,M). |
| 923 | | |
| 924 | | % not terribly efficient way to select and remove a conjunct from a predicate |
| 925 | | select_member_in_conjunction(M,Conj,Rest) :- is_a_conjunct(Conj,LHS,RHS),!, |
| 926 | ? | (select_member_in_conjunction(M,LHS,RL), conjunct_predicates([RL,RHS],Rest) |
| 927 | | ; select_member_in_conjunction(M,RHS,RR), conjunct_predicates([LHS,RR],Rest)). |
| 928 | | select_member_in_conjunction(M,M,b(truth,pred,[])). |
| 929 | | |
| 930 | | is_a_disjunct(b(disjunct(A,B),pred,_),A,B). |
| 931 | | is_a_negation(b(negation(A),pred,_),A). |
| 932 | | |
| 933 | | disjunction_to_list(C,L) :- var(C),!, |
| 934 | | add_error_fail(disjunction_to_list,'Internal error: var :',disjunction_to_list(C,L)). |
| 935 | | disjunction_to_list(C,List) :- |
| 936 | | disjunction_to_list2(C,List,[]). |
| 937 | | disjunction_to_list2(C,I,O) :- is_a_disjunct(C,LHS,RHS),!, |
| 938 | | disjunction_to_list2(LHS,I,Inter), |
| 939 | | disjunction_to_list2(RHS,Inter,O). |
| 940 | | disjunction_to_list2(X,[X|R],R). |
| 941 | | |
| 942 | | is_an_implication(b(implication(A,B),pred,_),A,B). |
| 943 | | |
| 944 | | is_an_equivalence(b(equivalence(A,B),pred,_),A,B). |
| 945 | | |
| 946 | | |
| 947 | | is_a_disjunct_or_implication(b(DI,pred,_),Type,A,B) :- is_a_disj_or_impl_aux(DI,Type,A,B). |
| 948 | | is_a_disj_or_impl_aux(disjunct(A,B),'disjunction',A,B). |
| 949 | | is_a_disj_or_impl_aux(implication(A,B),'implication',NA,B) :- |
| 950 | | create_negation(A,NA). |
| 951 | | is_a_disj_or_impl_aux(negation(b(conjunct(A,B),pred,_)),'negated conjunction',NA,NB) :- |
| 952 | | create_negation(A,NA),create_negation(B,NB). |
| 953 | | |
| 954 | | % a more liberal version of is_a_conjunct/2 which also detects negated disjunctions/implications |
| 955 | | is_a_conjunct_or_neg_disj(b(DI,pred,I),A,B) :- is_conjunct_aux(DI,I,A,B). |
| 956 | | |
| 957 | | is_conjunct_aux(conjunct(LHS,RHS),_,LHS,RHS). |
| 958 | | is_conjunct_aux(negation(DISJ),_,NegLHS,NegRHS) :- |
| 959 | | is_a_disjunct_or_implication(DISJ,_Type,LHS,RHS), |
| 960 | | create_negation(LHS,NegLHS), |
| 961 | | create_negation(RHS,NegRHS). |
| 962 | | is_conjunct_aux(equal(TA,TB),I,b(equal(TA1,TB1),pred,I),b(equal(TA2,TB2),pred,I)) :- |
| 963 | | % split TA1|->TA2 = TB1|->TB2, cf, split_equality/3; useful for enumeration order analysis |
| 964 | | get_texpr_couple(TA,TA1,TA2), |
| 965 | | get_texpr_couple(TB,TB1,TB2). |
| 966 | | % print('Splitting equality in is_a_conjunct_or_neg_disj: '), translate:print_bexpr(b(equal(TA,TB),pred,I)),nl. |
| 967 | | |
| 968 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 969 | | % remove all info fields by fresh variables |
| 970 | | % typically the result will be unified with AST terms which contain full info fields |
| 971 | | remove_all_infos(TExpr,TNExpr) :- |
| 972 | | var(TExpr),!,TExpr=TNExpr. |
| 973 | | % in contrast to remove_all_infos_and_ground we provide no special treatment of values with closures here; |
| 974 | | % there could be a problem if we unify with a free variable as value |
| 975 | | remove_all_infos(TExpr,TNExpr) :- |
| 976 | | get_texpr_expr(TExpr,Expr), |
| 977 | | get_texpr_type(TExpr,Type), |
| 978 | ? | syntaxtransformation(Expr,Subs,_,NSubs,NExpr), |
| 979 | | create_texpr(NExpr,Type,_,TNExpr), |
| 980 | ? | maplist(remove_all_infos,Subs,NSubs). |
| 981 | | |
| 982 | | % replace all info fields |
| 983 | | remove_all_infos_and_ground(TExpr,TNExpr) :- |
| 984 | | var(TExpr),!,TExpr=TNExpr. |
| 985 | | remove_all_infos_and_ground(b(value(Value),Type,_),TNExpr) :- |
| 986 | | % special case for closure(_,_,_) since it is not covered by syntraxtransformation/5 |
| 987 | | % most useful for intervals |
| 988 | | !, |
| 989 | | remove_all_infos_from_bvalue(Value,NValue), |
| 990 | | TNExpr = b(value(NValue),Type,[]). |
| 991 | | remove_all_infos_and_ground(TExpr,TNExpr) :- |
| 992 | | get_texpr_expr(TExpr,Expr), |
| 993 | | get_texpr_type(TExpr,Type), |
| 994 | | syntaxtransformation(Expr,Subs,_,NSubs,NExpr), |
| 995 | | create_texpr(NExpr,Type,[],TNExpr), |
| 996 | | maplist(remove_all_infos_and_ground,Subs,NSubs). |
| 997 | | |
| 998 | | remove_all_infos_from_bvalue(Var,Res) :- var(Var),!, Res=Var. |
| 999 | | remove_all_infos_from_bvalue((A,B),(RA,RB)) :- !, |
| 1000 | | remove_all_infos_from_bvalue(A,RA), |
| 1001 | | remove_all_infos_from_bvalue(B,RB). |
| 1002 | | remove_all_infos_from_bvalue(closure(P,T,Body),Res) :- !, |
| 1003 | | remove_all_infos_and_ground(Body,RBody), |
| 1004 | | Res = closure(P,T,RBody). |
| 1005 | | % TODO: we could provide more cases like records, sets as lists, freetype values |
| 1006 | | remove_all_infos_from_bvalue(Val,Val). |
| 1007 | | |
| 1008 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1009 | | |
| 1010 | | % a version of create_exists_opt which also detects top-level disjunctions |
| 1011 | | % and marks the exists as generated and as allow_to_lift_exists |
| 1012 | | create_exists_opt_liftable(Ids,b(disjunct(A,B),pred,Info1),NewPred) :- !, |
| 1013 | | create_exists_opt_liftable(Ids,A,PA), |
| 1014 | | create_exists_opt_liftable(Ids,B,PB), |
| 1015 | | disjunct_predicates_with_pos_info(PA,PB,b(NP,pred,Info2)), |
| 1016 | | NewPred=b(NP,pred,NewInfo), |
| 1017 | | extract_just_important_info_aux(Info1,Info2,NewInfo). % copy symbolic or other relevant info |
| 1018 | | create_exists_opt_liftable(Ids,Pred,NewPred) :- conjunction_to_list(Pred,L), |
| 1019 | | create_exists_opt(Ids,L,[allow_to_lift_exists],NewPred,_Modified). |
| 1020 | | |
| 1021 | | % create_exists_opt(TIds,Preds,NewPred) |
| 1022 | | % creating an existential quantification with some optimisations. |
| 1023 | | % TIds: The typed identifiers that are quantified |
| 1024 | | % Preds: A list of predicates |
| 1025 | | % NewPred: The (optimised) quantified expression |
| 1026 | | % Basically two optimisations are performed: |
| 1027 | | % - identifiers that are not used at all are removed from the quantifier |
| 1028 | | % - predicates that do not use one of the quantified identifiers are moved |
| 1029 | | % outside the quantification, resulting in a predicate of the form "P & #x.Q(x)" |
| 1030 | | |
| 1031 | | create_exists_opt(TIds,Preds,NewPred) :- |
| 1032 | | create_exists_opt(TIds,Preds,[],NewPred,_). |
| 1033 | | |
| 1034 | | create_exists_opt(TIds,Preds,NewPred,Modified) :- |
| 1035 | | create_exists_opt(TIds,Preds,[],NewPred,Modified). |
| 1036 | | |
| 1037 | | create_exists_opt([],Preds,_,NewPred,Modified) :- !, Modified = false, |
| 1038 | | conjunct_predicates(Preds,NewPred). |
| 1039 | | create_exists_opt(TIds,Preds,AdditionalInfos,Res,Mod) :- |
| 1040 | | get_texpr_ids(TIds,UnsortedIds), sort(UnsortedIds,Ids), |
| 1041 | | (create_exists_opt1(TIds,Ids,Preds,AdditionalInfos,NewPred2,Modified) -> Res = NewPred2, Mod=Modified |
| 1042 | | ; add_internal_error('Call failed:',create_exists_opt(TIds,Preds,AdditionalInfos,_,_)),fail). |
| 1043 | | %create_exists_opt1(TIds,_,Preds,AdditionalInfos,NewPred,Modified) :- preference(data_validation_mode,true), |
| 1044 | | % % do not lift predicates outside of existential quantifiers and change order; see rule_avec_DV.mch ClearSy example (N_ITERa_avec_DV_sans_DV) and test 1945 |
| 1045 | | create_exists_opt1(TIds,Ids,Preds,AdditionalInfos,NewPred2,Modified) :- |
| 1046 | | create_exists_opt2(Preds,first,Ids,[],Inner,Outer,UsedIds), |
| 1047 | | % Inner: quantified part, Outer: part which does not have to be quantified |
| 1048 | | ( Inner = [] -> AllPreds=Outer % no exists needed |
| 1049 | | ; % Inner = [_|_] -> |
| 1050 | | create_filtered_exists(TIds,UsedIds,Inner,AdditionalInfos,Exists,IModified), |
| 1051 | | append(Outer,[Exists],AllPreds) |
| 1052 | | ), |
| 1053 | | (Outer=[_|_] -> Modified=true % TO DO: check if TIds=UsedTIds |
| 1054 | | ; IModified==true -> Modified=true |
| 1055 | | ; UsedIds == Ids -> Modified= false |
| 1056 | | ; Modified=true), |
| 1057 | | conjunct_predicates(AllPreds,NewPred2). |
| 1058 | | |
| 1059 | | % create an exists for the used Ids only |
| 1060 | | create_filtered_exists(TIds,UsedIds,Inner,AdditionalInfos,Exists,_) :- |
| 1061 | | ceo_filter_used_ids(TIds,UsedIds,UsedTIds), % filter out unused variables |
| 1062 | | conjunct_predicates_with_pos_info(Inner,I), % we could store used_ids info |
| 1063 | | create_exists_detect_tautology_aux(UsedTIds,I,AdditionalInfos,Exists). |
| 1064 | | % remove_typing also added in create_exists_detect_tautology_aux |
| 1065 | | |
| 1066 | | |
| 1067 | | % return Inner: predicates inside quantifier and Outer: predicates that can be moved out of the quantifier |
| 1068 | | create_exists_opt2([],_,_Ids,UsedIds,[],[],UsedIds) :- !. |
| 1069 | | create_exists_opt2([Pred|Prest],First,Ids,UsedIdsIn,Inner,Outer,UsedIdsOut) :- !, |
| 1070 | | find_identifier_uses_if_necessary(Pred, [], LocalUses), % TODO: add used_ids(LocalUses) to Pred |
| 1071 | | ord_intersection(Ids,LocalUses,ExistsIdsUsed), |
| 1072 | | ( ExistsIdsUsed = [], % Pred uses none of the quantified ids: we can move it out |
| 1073 | | (First==first -> true |
| 1074 | | ; preference(data_validation_mode,false), % see test 1945; step 39 in trace replay |
| 1075 | | always_well_defined_or_disprover_mode(Pred) % TODO: we should probably also check this ! |
| 1076 | | ) |
| 1077 | | -> |
| 1078 | | Inner = Irest, |
| 1079 | | Outer = [Pred|Orest], % move Pred out of existential quantifier as it does not depend on quantified variables |
| 1080 | | % format('MOVED out of #(~w): ',[Ids]),translate:print_bexpr(Pred), format(' Uses ~w [~w]~n',[LocalUses,ExistsIdsUsed]), |
| 1081 | | create_exists_opt2(Prest,first,Ids,UsedIdsIn,Irest,Orest,UsedIdsOut) |
| 1082 | | ; |
| 1083 | | update_used_ids(Pred,LocalUses,Pred2), |
| 1084 | | Inner = [Pred2|Irest], |
| 1085 | | Outer = Orest, |
| 1086 | | ord_union(UsedIdsIn,ExistsIdsUsed,Urest), |
| 1087 | | create_exists_opt2(Prest,not_first_anymore,Ids,Urest,Irest,Orest,UsedIdsOut) |
| 1088 | | ). |
| 1089 | | create_exists_opt2(Pred,First,Ids,UsedIdsIn,Inner,Outer,UsedIdsOut) :- |
| 1090 | | add_error(create_exists_opt,'Expecting predicate list: ',Pred), |
| 1091 | | create_exists_opt2([Pred],First,Ids,UsedIdsIn,Inner,Outer,UsedIdsOut). |
| 1092 | | |
| 1093 | | % construct exists optimized: keep only used TIds |
| 1094 | | ceo_filter_used_ids([],_UsedIds,[]). |
| 1095 | | ceo_filter_used_ids([TId|Irest],UsedIds,Filtered) :- |
| 1096 | | get_texpr_id(TId,Id), |
| 1097 | | ( ord_member(Id,UsedIds) -> Filtered = [TId|Frest] % id used: keep it |
| 1098 | | ; Filtered = Frest), |
| 1099 | | ceo_filter_used_ids(Irest,UsedIds,Frest). |
| 1100 | | |
| 1101 | | % a version of create_exists which also detects x=E and x:E, x>E, not(x>E) tautologies |
| 1102 | | % we could replace this by a more generic prover |
| 1103 | | create_exists_detect_tautology_aux([TID],b(member(LHS,RHS),pred,_),_,Truth) :- |
| 1104 | | get_texpr_id(LHS,ID), get_texpr_id(TID,ID), |
| 1105 | | definitely_not_empty_set(RHS), |
| 1106 | | always_well_defined_or_disprover_mode(RHS), |
| 1107 | | !, % replace #x.(x:RHS) by TRUTH |
| 1108 | | debug_format(19,'Detected tautology exists membership over ~w~n',[ID]), |
| 1109 | | Truth=b(truth,pred,[]). |
| 1110 | | create_exists_detect_tautology_aux([TID],b(Pred,_,_),_,Truth) :- |
| 1111 | | is_comparison(Pred,pos_neg(pos,TID),L,R), get_texpr_id(TID,ID), |
| 1112 | | ((LHS,RHS)=(L,R) ; (LHS,RHS)=(R,L)), |
| 1113 | | get_texpr_id(LHS,ID), |
| 1114 | | \+ occurs_in_expr(ID,RHS), |
| 1115 | | always_well_defined_or_disprover_mode(RHS), |
| 1116 | | !, % replace #x.(x COMP E) by TRUTH |
| 1117 | | debug_format(19,'Detected tautology comparison over ~w~n',[ID]), |
| 1118 | | Truth=b(truth,pred,[]). |
| 1119 | | %create_exists_detect_tautology_aux(Ids,b(disjunct(A,B),pred,Info1),AdditionalInfos,NewPred) :- !, |
| 1120 | | % create_exists(Ids,A,PA), create_exists(Ids,B,PB), |
| 1121 | | % disjunct_predicates_with_pos_info(PA,PB,b(NP,pred,Info2)), |
| 1122 | | % NewPred=b(NP,pred,NewInfo), |
| 1123 | | % extract_just_important_info_aux(Info1,Info2,NewInfo). % copy symbolic or other relevant info |
| 1124 | | create_exists_detect_tautology_aux(Ids,Pred,AdditionalInfos,NewPred2) :- |
| 1125 | | create_exists_or_let_predicate(Ids,Pred,NewPred), |
| 1126 | | add_texpr_infos_if_new(NewPred,[removed_typing|AdditionalInfos],NewPred2). |
| 1127 | | % removed_typing to avoid spurious exists_body_warning, see test 1681, 625 |
| 1128 | | |
| 1129 | | |
| 1130 | | is_eventb_comprehension_set(b(comprehension_set(TopIds,Body),_,Info),Ids,PRED,EXPR) :- |
| 1131 | | is_eventb_comprehension_set(TopIds,Body,Info,Ids,PRED,EXPR). |
| 1132 | | is_eventb_comprehension_set([TID1],Body,Info,Ids,PRED,EXPR) :- |
| 1133 | | Body = b(exists(Ids,InnerBody),pred,_), |
| 1134 | | conjunction_to_list(InnerBody,Inner), |
| 1135 | | append(Inner1,[b(equal(TID2,EXPR),pred,EqInfo)],Inner), |
| 1136 | ? | (member(was(event_b_comprehension_set),Info) -> true ; |
| 1137 | ? | member(prob_annotation('LAMBDA-EQUALITY'),EqInfo) % relevant for TLA2B |
| 1138 | | ), |
| 1139 | | same_id(TID1,TID2,_), |
| 1140 | | conjunct_predicates(Inner1,PRED), |
| 1141 | | % we check that TID1 is not being used in P1 and not just rely on was(event_b_comprehension_set) |
| 1142 | | not_occurs_in_expr(PRED,TID1). |
| 1143 | | |
| 1144 | | % ------------------- |
| 1145 | | |
| 1146 | | is_equal(b(equal(LHS,RHS),pred,_),A,B) :- |
| 1147 | | ((A,B)=(LHS,RHS) ; (A,B)=(RHS,LHS)). |
| 1148 | | |
| 1149 | | :- use_module(typing_tools,[type_has_at_least_two_elements/1]). |
| 1150 | | is_comparison(greater(A,B),_,A,B). |
| 1151 | | is_comparison(less(A,B),_,A,B). |
| 1152 | | is_comparison(greater_equal(A,B),_,A,B). |
| 1153 | | is_comparison(less_equal(A,B),_,A,B). |
| 1154 | | is_comparison(equal(A,B),pos_neg(P,TID),A,B) :- |
| 1155 | | % for neg: we need to make sure there is more than one value in the type (otherwise we cannot make equal false) |
| 1156 | | % for pos: assuming the RHS expression above is well-defined there must be at least one element; no need to check non_empty_type(Type) |
| 1157 | | (P=pos -> true ; get_texpr_type(TID,Type),type_has_at_least_two_elements(Type)). |
| 1158 | | is_comparison(not_equal(A,B),pos_neg(P,TID),A,B) :- % ditto but with pos and neg reversed |
| 1159 | | (P=neg -> true ; get_texpr_type(TID,Type),type_has_at_least_two_elements(Type)). |
| 1160 | | is_comparison(negation(b(Comp,pred,_)),PosNeg,A,B) :- negate(PosNeg,P2), |
| 1161 | | is_comparison(Comp,P2,A,B). |
| 1162 | | negate(pos_neg(pos,T),pos_neg(neg,T)). |
| 1163 | | negate(pos_neg(neg,T),pos_neg(pos,T)). |
| 1164 | | |
| 1165 | | |
| 1166 | | |
| 1167 | | % is true if a predicate Pred can be split into two parts: |
| 1168 | | % Outer which does not depend on LocalIds (can be lifted out) and Inner which does |
| 1169 | | detect_global_predicates(LocalIds,Pred,Outer,Inner) :- |
| 1170 | | get_texpr_ids(LocalIds,UnsortedIds), sort(UnsortedIds,Ids), |
| 1171 | | conjunction_to_list(Pred,Preds), |
| 1172 | | split_predicate_local_global(Preds,Ids,OuterL,InnerL), |
| 1173 | | OuterL \= [], |
| 1174 | | conjunct_predicates(OuterL,Outer), |
| 1175 | | conjunct_predicates(InnerL,Inner). |
| 1176 | | split_predicate_local_global([],_Ids,[],[]). |
| 1177 | | split_predicate_local_global([P|Ps],Ids,Outer,Inner) :- |
| 1178 | | (is_local_predicate(Ids,P) |
| 1179 | | -> Inner = [P|Is], split_predicate_local_global(Ps,Ids,Outer,Is) |
| 1180 | | ; Outer = [P|Os], split_predicate_local_global(Ps,Ids,Os,Inner)). |
| 1181 | | is_local_predicate(Ids,Pred) :- |
| 1182 | | find_identifier_uses_if_necessary(Pred, [], LocalUses), |
| 1183 | | ord_intersect(Ids,LocalUses). |
| 1184 | | |
| 1185 | | %:- use_module(b_global_sets,[b_global_set/1]). |
| 1186 | | definitely_not_empty_set(b(SET,T,_)) :- not_empty_set_aux(SET,T). |
| 1187 | | not_empty_set_aux(bool_set,_). |
| 1188 | | not_empty_set_aux(integer_set(_),_). |
| 1189 | | not_empty_set_aux(float_set,_). |
| 1190 | | not_empty_set_aux(real_set,_). |
| 1191 | | not_empty_set_aux(string_set,_). |
| 1192 | | not_empty_set_aux(set_extension(X),_) :- dif(X,[]). |
| 1193 | | not_empty_set_aux(sequence_extension(X),_) :- dif(X,[]). |
| 1194 | | not_empty_set_aux(pow_subset(_),_). % always contains at least the empty set |
| 1195 | | not_empty_set_aux(fin_subset(_),_). % ditto |
| 1196 | | not_empty_set_aux(seq(_),_). % ditto |
| 1197 | | not_empty_set_aux(iseq(_),_). % ditto |
| 1198 | | not_empty_set_aux(pow1_subset(A),_) :- definitely_not_empty_set(A). |
| 1199 | | not_empty_set_aux(fin1_subset(A),_) :- definitely_not_empty_set(A). |
| 1200 | | not_empty_set_aux(seq1(A),_) :- definitely_not_empty_set(A). |
| 1201 | | not_empty_set_aux(iseq1(A),_) :- definitely_not_empty_set(A). |
| 1202 | | not_empty_set_aux(cartesian_product(A,B),_) :- definitely_not_empty_set(A), definitely_not_empty_set(B). |
| 1203 | | not_empty_set_aux(partial_function(_A,_B),_). % always contains at least the empty set |
| 1204 | | not_empty_set_aux(partial_injection(_A,_B),_). % ditto |
| 1205 | | not_empty_set_aux(relations(_A,_B),_). % ditto |
| 1206 | | not_empty_set_aux(total_function(A,B),_) :- |
| 1207 | | (definitely_not_empty_set(B) -> true |
| 1208 | | ; definitely_empty_set(A)). % if A is empty, then the set of total functions is {{}} |
| 1209 | | not_empty_set_aux(union(A,B),_) :- (definitely_not_empty_set(A) -> true ; definitely_not_empty_set(B)). |
| 1210 | | not_empty_set_aux(overwrite(A,B),_) :- (definitely_not_empty_set(A) -> true ; definitely_not_empty_set(B)). |
| 1211 | | % TODO: add a few more function rules |
| 1212 | | not_empty_set_aux(value(S),_) :- not_empty_value(S). |
| 1213 | | %not_empty_set_aux(identifier(X),set(global(X))) :- bmachine:b_get_machine_set(X). % what if we have a local variable ? ENSURE THAT WE DO NOT ALLOW identifier X to stand for global set X; see ExistentialGlobalSetIDTest in Tester % also: b_global_set not yet computed when ast_cleanup runs on startup ! |
| 1214 | | % TO DO: determine which identifier(X) refer to global set names |
| 1215 | | not_empty_set_aux(interval(A,B),_) :- get_integer(A,IA), get_integer(B,IB), IA =< IB. |
| 1216 | | |
| 1217 | | :- use_module(b_global_sets,[b_non_empty_global_set/1]). |
| 1218 | | :- use_module(kernel_freetypes,[is_non_empty_freetype/1]). |
| 1219 | | not_empty_value(S) :- var(S),!,fail. |
| 1220 | | not_empty_value(avl_set(_)). |
| 1221 | | not_empty_value([_|_]). |
| 1222 | | not_empty_value(global_set(G)) :- b_non_empty_global_set(G). % always true |
| 1223 | | not_empty_value(freetype(G)) :- is_non_empty_freetype(G). % always true |
| 1224 | | not_empty_value(closure(P,T,B)) :- |
| 1225 | | custom_explicit_sets:is_interval_closure(P,T,B,LOW,UP), integer(LOW),integer(UP), LOW =< UP. |
| 1226 | | %TODO: more closures; see also definitely_not_empty_finite_value |
| 1227 | | |
| 1228 | | definitely_empty_set(b(ES,_,_)) :- is_empty_set_aux(ES). |
| 1229 | | is_empty_set_aux(empty_set). |
| 1230 | | is_empty_set_aux(empty_sequence). |
| 1231 | | is_empty_set_aux(domain(D)) :- definitely_empty_set(D). |
| 1232 | | is_empty_set_aux(range(D)) :- definitely_empty_set(D). |
| 1233 | | is_empty_set_aux(domain_subtraction(_,Rel)) :- definitely_empty_set(Rel). |
| 1234 | | is_empty_set_aux(domain_restriction(Dom,Rel)) :- (definitely_empty_set(Dom) -> true ; definitely_empty_set(Rel)). |
| 1235 | | is_empty_set_aux(range_restriction(Rel,Ran)) :- (definitely_empty_set(Ran) -> true ; definitely_empty_set(Rel)). |
| 1236 | | is_empty_set_aux(range_subtraction(Rel,_)) :- definitely_empty_set(Rel). |
| 1237 | | is_empty_set_aux(interval(A,B)) :- get_integer(A,IA), get_integer(B,IB), IA > IB. |
| 1238 | | is_empty_set_aux(intersection(A,B)) :- (definitely_empty_set(A) -> true ; definitely_empty_set(B)). |
| 1239 | | is_empty_set_aux(set_subtraction(A,_)) :- definitely_empty_set(A). |
| 1240 | | is_empty_set_aux(union(A,B)) :- definitely_empty_set(A), definitely_empty_set(B). |
| 1241 | | is_empty_set_aux(overwrite(A,B)) :- definitely_empty_set(A), definitely_empty_set(B). |
| 1242 | | is_empty_set_aux(value(V)) :- V==[]. |
| 1243 | | |
| 1244 | | |
| 1245 | | get_integer(b(B,_,_),I) :- get_integer_aux(B,I). |
| 1246 | | get_integer_aux(integer(I),I). |
| 1247 | | get_integer_aux(value(V),I) :- get_integer_value(V,I). |
| 1248 | | get_integer_value(V,I) :- nonvar(V),V=int(I), integer(I). |
| 1249 | | |
| 1250 | | |
| 1251 | | |
| 1252 | | :- use_module(probsrc(custom_explicit_sets),[avl_is_interval/3]). |
| 1253 | | get_interval(b(I,set(integer),_),Low,Up) :- |
| 1254 | | is_interval_aux(I,Low,Up). |
| 1255 | | is_interval_aux(interval(Low,Up),Low,Up). |
| 1256 | | is_interval_aux(value(CS),Low,Up) :- nonvar(CS), CS=avl_set(AVL), % occurs in Leftpad_i.imp |
| 1257 | | Low = b(integer(LI),integer,[]), Up = b(integer(UI),integer,[]), |
| 1258 | | avl_is_interval(AVL,LI,UI). |
| 1259 | | is_interval_aux(set_extension(List),Low,Up) :- print(l(List)),nl, |
| 1260 | | sort(List,SList), |
| 1261 | | SList = [Low|Rest], get_integer(Low,LI), |
| 1262 | | last(SList,Up), get_integer(Up,UI), |
| 1263 | | length(List,Len), |
| 1264 | | Len is UI-LI+1, |
| 1265 | | maplist(get_integer,Rest,_). |
| 1266 | | |
| 1267 | | % a simple let-detection |
| 1268 | | create_exists_or_let_predicate([H|T],b(conjunct(LHS,RHS),pred,I),NewPred) :- get_texpr_id(H,ID), |
| 1269 | ? | is_equal(LHS,TID,IDEXPR), % TO DO: should we do a more complicated check here ? exist technique useful for SLOT-24 codespeed test |
| 1270 | | get_texpr_id(TID,ID), \+ occurs_in_expr(ID,IDEXPR), |
| 1271 | | maplist(not_occurs_in_expr(IDEXPR),T), |
| 1272 | | !, |
| 1273 | | NewPred = b(let_predicate([TID],[IDEXPR],Body),pred,I), |
| 1274 | | %print('LET: '),translate:print_bexpr(NewPred),nl, |
| 1275 | | create_exists_or_let_predicate(T,RHS,Body). |
| 1276 | | create_exists_or_let_predicate(Ids,Pred,NewPred) :- create_exists(Ids,Pred,NewPred). |
| 1277 | | |
| 1278 | | not_occurs_in_expr(IDEXPR,TID) :- get_texpr_id(TID,ID), \+ occurs_in_expr(ID,IDEXPR). |
| 1279 | | |
| 1280 | | create_exists([],Pred,NewPred) :- !,Pred=NewPred. |
| 1281 | | create_exists(Ids,Pred,NewPred) :- |
| 1282 | | find_identifier_uses_for_quantifier_body(Ids,Pred, Used), |
| 1283 | | extract_info_wo_used_ids(Pred,NewImportantInfo), |
| 1284 | | create_texpr(exists(Ids,Pred),pred,[used_ids(Used)|NewImportantInfo],NewPred). |
| 1285 | | |
| 1286 | | % a version of create_exists which can merge with an already present exists if possible |
| 1287 | | % possibly more expensive as identfiers used are recomputed for the moment (TODO: reuse used_ids and subtract) |
| 1288 | | create_or_merge_exists(IDs, Condition, Exists):- |
| 1289 | | get_texpr_expr(Condition,exists(InnerVars,InnerCond)),!, |
| 1290 | | % fuse two exists together |
| 1291 | | append(IDs,InnerVars,Vars), |
| 1292 | | create_or_merge_exists(Vars,InnerCond,Exists). |
| 1293 | | create_or_merge_exists(IDs, Condition, Exists):- |
| 1294 | | create_exists(IDs,Condition,Exists). |
| 1295 | | |
| 1296 | | % see create_unsimplified_exists |
| 1297 | | not_generated_exists_paras([b(_,_,Infos)|_]) :- nonmember(generated_exists_parameter,Infos). |
| 1298 | | |
| 1299 | | |
| 1300 | | create_forall([],Pred,NewPred) :- !,Pred=NewPred. |
| 1301 | | create_forall(Ids,Pred,NewPred) :- |
| 1302 | | find_identifier_uses_for_quantifier_body(Ids,Pred, Used), |
| 1303 | | split_forall_body(Pred,LHS,RHS), |
| 1304 | | extract_info_wo_used_ids_and_pos(LHS,RHS,NewImportantInfo), |
| 1305 | | create_texpr(forall(Ids,LHS,RHS),pred,[used_ids(Used)|NewImportantInfo],NewPred). |
| 1306 | | split_forall_body(b(implication(LHS,RHS),_,_),LHS,RHS) :- !. |
| 1307 | | split_forall_body(RHS,b(truth,pred,[]),RHS). |
| 1308 | | |
| 1309 | | create_implication(b(truth,pred,_),P,Res) :- !, Res=P. |
| 1310 | | create_implication(b(falsity,pred,_),P,Res) :- !, create_negation(P,Res). |
| 1311 | | create_implication(Lhs,Rhs,b(implication(Lhs,Rhs),pred,NewInfo)) :- |
| 1312 | | extract_info(Lhs,Rhs,NewInfo). |
| 1313 | | |
| 1314 | | create_equivalence(Lhs,Rhs, b(equivalence(Lhs,Rhs),pred,NewInfo)) :- |
| 1315 | | extract_info(Lhs,Rhs,NewInfo). |
| 1316 | | |
| 1317 | | create_negation(b(P,pred,I),Res) :- create_negation_aux(P,I,R),!,Res=R. |
| 1318 | | create_negation(Pred,b(negation(Pred),pred,NewInfo)) :- |
| 1319 | | extract_info(Pred,Infos), |
| 1320 | ? | (get_texpr_non_label_posinfo(Pred,Pos) -> NewInfo = [Pos|Infos] ; NewInfo=Infos). |
| 1321 | | |
| 1322 | | create_negation_aux(truth,I,R) :- !, R=b(falsity,pred,I). |
| 1323 | | create_negation_aux(falsity,I,R) :- !, R=b(truth,pred,I). |
| 1324 | | create_negation_aux(negation(Pred),_,R) :- R=Pred. % not(not(P)) = P |
| 1325 | | %create_negation_aux(equal(A,B),I,R) :- !, R=b(not_equal(A,B),pred,I). |
| 1326 | | %create_negation_aux(not_equal(A,B),I,R) :- !, R=b(equal(A,B),pred,I). |
| 1327 | | % we could add some rules about negating member <-> not_member, ... but be careful with effects on is_negation_of |
| 1328 | | |
| 1329 | | % check if something is the negation of something else (quite stupid at the moment) |
| 1330 | | % used, e.g., to detect IF-THEN-ELSE constructs in b_ast_cleanup |
| 1331 | | is_negation_of(P,NP) :- |
| 1332 | | create_negation(P,NotP), % works both with not(A),A or A,not(A) |
| 1333 | | same_texpr(NotP,NP). |
| 1334 | | is_negation_of(b(P,pred,_),b(NP,pred,_)) :- is_negation_aux(P,NP). |
| 1335 | | |
| 1336 | | is_negation_aux(equal(A,B),NP) :- is_negation_of_equality(NP,A,B). |
| 1337 | | is_negation_aux(not_equal(A,B),NP) :- is_negation_of_disequality(NP,A,B). |
| 1338 | | is_negation_aux(subset(XA,SA),not_subset(XB,SB)) :- same_texpr(XA,XB), same_texpr(SA,SB). |
| 1339 | | is_negation_aux(not_subset(XA,SA),subset(XB,SB)) :- same_texpr(XA,XB), same_texpr(SA,SB). |
| 1340 | | is_negation_aux(subset_strict(XA,SA),not_subset_strict(XB,SB)) :- same_texpr(XA,XB), same_texpr(SA,SB). |
| 1341 | | is_negation_aux(not_subset_strict(XA,SA),subset_strict(XB,SB)) :- same_texpr(XA,XB), same_texpr(SA,SB). |
| 1342 | | is_negation_aux(member(XA,SA),not_member(XB,SB)) :- same_texpr(XA,XB), same_texpr(SA,SB). |
| 1343 | | is_negation_aux(not_member(XA,SA),member(XB,SB)) :- same_texpr(XA,XB), same_texpr(SA,SB). |
| 1344 | | is_negation_aux(less(A,B),greater_equal(AA,BB)) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1345 | | is_negation_aux(less(A,B),less_equal(BB,AA)) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1346 | | is_negation_aux(less_equal(B,A),less(AA,BB)) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1347 | | is_negation_aux(less_equal(A,B),greater(AA,BB)) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1348 | | is_negation_aux(greater_equal(A,B),NP) :- is_negation_aux(less_equal(B,A),NP). |
| 1349 | | is_negation_aux(greater(A,B),NP) :- is_negation_aux(less(B,A),NP). |
| 1350 | | is_negation_aux(less_equal_real(B,A),less_real(AA,BB)) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1351 | | is_negation_aux(less_real(B,A),less_equal_real(AA,BB)) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1352 | | is_negation_aux(negation(A),negation(B)) :- is_negation_of(A,B). |
| 1353 | | is_negation_aux(truth,falsity). |
| 1354 | | is_negation_aux(falsity,truth). |
| 1355 | | % TO DO: detect more ?? x < y <=> not ( x > y-1 ) |
| 1356 | | |
| 1357 | | is_negation_of_equality(not_equal(AA,BB),A,B) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1358 | | is_negation_of_equality(equal(AA,BB),A,B) :- same_texpr(A,AA), neg_value(BB,B). |
| 1359 | | |
| 1360 | | neg_value(b(boolean_true,_,_),b(boolean_false,_,_)). |
| 1361 | | neg_value(b(boolean_false,_,_),b(boolean_true,_,_)). |
| 1362 | | |
| 1363 | | is_negation_of_disequality(equal(AA,BB),A,B) :- same_texpr(A,AA), same_texpr(B,BB). |
| 1364 | | is_negation_of_disequality(not_equal(AA,BB),A,B) :- same_texpr(A,AA), neg_value(BB,B). |
| 1365 | | |
| 1366 | | |
| 1367 | | % another version which is simpler can can be used to get the negation of some operators |
| 1368 | | |
| 1369 | | get_negated_operator_expr(b(E,pred,_),Res) :- negate_expr_aux(E,Res). |
| 1370 | | negate_expr_aux(falsity,truth). |
| 1371 | | negate_expr_aux(truth,falsity). |
| 1372 | | negate_expr_aux(member(X,S),not_member(X,S)). |
| 1373 | | negate_expr_aux(not_member(X,S),member(X,S)). |
| 1374 | | negate_expr_aux(subset(X,S),not_subset(X,S)). |
| 1375 | | negate_expr_aux(not_subset(X,S),subset(X,S)). |
| 1376 | | negate_expr_aux(subset_strict(X,S),not_subset_strict(X,S)). |
| 1377 | | negate_expr_aux(not_subset_strict(X,S),subset_strict(X,S)). |
| 1378 | | negate_expr_aux(equal(X,S),not_equal(X,S)). |
| 1379 | | negate_expr_aux(not_equal(X,S),equal(X,S)). |
| 1380 | | negate_expr_aux(less(X,S),greater_equal(X,S)). |
| 1381 | | negate_expr_aux(greater_equal(X,S),less(X,S)). |
| 1382 | | negate_expr_aux(less_equal(X,S),greater(X,S)). |
| 1383 | | negate_expr_aux(greater(X,S),less_equal(X,S)). |
| 1384 | | negate_expr_aux(less_equal_real(X,S),less_real(S,X)). |
| 1385 | | negate_expr_aux(less_real(X,S),less_equal_real(S,X)). |
| 1386 | | % TO DO: negation() |
| 1387 | | |
| 1388 | | |
| 1389 | | % a liberal version for finding equalities |
| 1390 | | is_equality(TP,TA,TB) :- get_texpr_expr(TP,P), is_equality_aux(P,TA,TB). |
| 1391 | | |
| 1392 | | is_equality_aux(Var,TA,TB) :- var(Var),!, add_internal_error('Illegal call: ', is_equality_aux(Var,TA,TB)),fail. |
| 1393 | | is_equality_aux(equal(TA,TB),TA,TB). |
| 1394 | | is_equality_aux(not_equal(TA,TB),NTA,NTB) :- |
| 1395 | | (negate_boolean_value(TB,NTB) -> NTA=TA |
| 1396 | | ; NTB=TB, negate_boolean_value(TA,NTA)). % TA /= TRUE ---> TA = FALSE |
| 1397 | | is_equality_aux(partition(TA,[TB]),TA,TB). |
| 1398 | | is_equality_aux(member(TA,TSet),TA,TB) :- singleton_set_extension(TSet,TB). % TA:{TB} |
| 1399 | | is_equality_aux(negation(TExpr),TA,TB) :- get_negated_operator_expr(TExpr,NT), is_equality_aux(NT,TA,TB). |
| 1400 | | |
| 1401 | | negate_boolean_value(b(B,T,I),b(NB,T,I)) :- neg_bool_aux(B,NB). |
| 1402 | | neg_bool_aux(boolean_true,boolean_false). |
| 1403 | | neg_bool_aux(boolean_false,boolean_true). |
| 1404 | | % TODO: should we also detect value(pred_true), .... |
| 1405 | | |
| 1406 | | singleton_set_extension(b(SONE,Type,_),El) :- singleton_set_extension_aux(SONE,Type,El). |
| 1407 | | singleton_set_extension_aux(set_extension([El]),_,El). |
| 1408 | | singleton_set_extension_aux(value(Set),set(Type),b(value(El),Type,[])) :- custom_explicit_sets:singleton_set(Set,El). |
| 1409 | | singleton_set_extension_aux(sequence_extension([El]),_,Couple) :- |
| 1410 | | ONE = b(integer(1),integer,[]), |
| 1411 | | create_couple(ONE,El,Couple). |
| 1412 | | |
| 1413 | | |
| 1414 | | % detect various forms of membership: |
| 1415 | | is_membership(b(Expr,pred,_),TID,Set) :- is_membership_aux(Expr,TID,Set). |
| 1416 | | is_membership_aux(member(TID,Set),TID,Set). |
| 1417 | | is_membership_aux(subset(SONE,Set),TID,Set) :- singleton_set_extension(SONE,TID). % {TID} <: Set |
| 1418 | | |
| 1419 | | % detect even more forms of membership: |
| 1420 | | is_membership_or_equality(b(Expr,pred,_),TID,Set) :- |
| 1421 | | (is_membership_aux(Expr,TID,Set) -> true ; is_mem_eq_aux(Expr,TID,Set)). |
| 1422 | | |
| 1423 | | is_mem_eq_aux(equal(TID,VAL),TID,Set) :- % x=VAL <==> x:{VAL} |
| 1424 | | get_texpr_type(VAL,Type), |
| 1425 | | safe_create_texpr(set_extension([VAL]),set(Type),Set). |
| 1426 | | |
| 1427 | | % extract a lambda equality from a body; we suppose the equality is the last conjunct |
| 1428 | | get_lambda_equality(b(equal(TID,ResultExpr),pred,_),ID,[],ResultExpr) :- get_texpr_id(TID,ID). |
| 1429 | | get_lambda_equality(b(conjunct(LHS,RHS),pred,_),ID,[LHS|T],ResultExpr) :- |
| 1430 | ? | get_lambda_equality(RHS,ID,T,ResultExpr). |
| 1431 | | |
| 1432 | | % --------------------------------- |
| 1433 | | |
| 1434 | | is_pow_subset(B,Set) :- |
| 1435 | | ( B = b(pow_subset(Set),_,_) |
| 1436 | | ; B = b(fin_subset(Set),_,_), |
| 1437 | | finite_wd_set_value(Set) |
| 1438 | | ). |
| 1439 | | is_pow1_subset(B,Set) :- |
| 1440 | | ( B = b(pow1_subset(Set),_,_) |
| 1441 | | ; B = b(fin1_subset(Set),_,_), |
| 1442 | | finite_wd_set_value(Set) |
| 1443 | | ). |
| 1444 | | |
| 1445 | | % --------------------------------- |
| 1446 | | |
| 1447 | | get_texpr_couple(b(couple(TA1,TA2),_,_),TA1,TA2). |
| 1448 | | |
| 1449 | | % detect TA1|->TA2 = TB1|->TB2 and split into two |
| 1450 | | split_equality(b(equal(TA,TB),pred,I),b(equal(TA1,TB1),pred,I),b(equal(TA2,TB2),pred,I)) :- |
| 1451 | | get_texpr_couple(TA,TA1,TA2), |
| 1452 | | get_texpr_couple(TB,TB1,TB2). |
| 1453 | | |
| 1454 | | create_equality(b(_,TA,_),b(_,TB,_),_) :- TA \= TB, \+ unify_types_strict(TA,TB),!, |
| 1455 | | add_internal_error('Creating equality with incompatible types:',equal(TA,TB)),fail. |
| 1456 | | create_equality(A,B,Equality) :- |
| 1457 | | safe_create_texpr(equal(A,B),pred,Equality). |
| 1458 | | |
| 1459 | | create_couple(A,B,b(couple(A,B),couple(TA,TB),Infos)) :- |
| 1460 | | get_texpr_type(A,TA), get_texpr_type(B,TB), |
| 1461 | | extract_info(A,B,Infos). |
| 1462 | | |
| 1463 | | % couplise_list for typed expression list |
| 1464 | | create_couple([A],Couple) :- !,A=Couple. |
| 1465 | | create_couple([A,B|Rest],Couple) :- |
| 1466 | | create_couple(A,B,Couple1), |
| 1467 | | create_couple([Couple1|Rest],Couple). |
| 1468 | | |
| 1469 | | % derive typing from Ids |
| 1470 | | create_comprehension_set(Ids,Pred,Info,CompSet) :- |
| 1471 | | get_texpr_types(Ids,Types), |
| 1472 | | couplise_list(Types,ElementType), |
| 1473 | | create_texpr(comprehension_set(Ids,Pred),set(ElementType),Info,CompSet). |
| 1474 | | |
| 1475 | | |
| 1476 | | :- assert_must_succeed(bsyntaxtree:nested_couple_to_list(b(couple(b(couple(a,b),x,[]),c),xx,[]),[a,b,c])). |
| 1477 | | :- assert_must_succeed(bsyntaxtree:nested_couple_to_list(b(couple(a,c),x,[]),[a,c])). |
| 1478 | | :- assert_must_succeed(bsyntaxtree:nested_couple_to_list(b(couple(a,b(couple(b,c),x,[])),xx,[]),[a,b(couple(b,c),x,[])])). |
| 1479 | | nested_couple_to_list(NC,L) :- nested_couple_to_list_dcg(NC,L,[]). |
| 1480 | | nested_couple_to_list_dcg(b(couple(A,B),_,_)) --> !, |
| 1481 | | nested_couple_to_list_dcg(A), [B]. |
| 1482 | | nested_couple_to_list_dcg(E) --> [E]. |
| 1483 | | |
| 1484 | | % -------------------------------------- |
| 1485 | | |
| 1486 | | |
| 1487 | | % check if identifier(s) occur in typed expressions |
| 1488 | | |
| 1489 | | occurs_in_expr(ID,TExpr) :- var(ID),!, |
| 1490 | | add_internal_error('Variable id: ',occurs_in_expr(ID,TExpr)),fail. |
| 1491 | | occurs_in_expr(ID,TExpr) :- ID=b(_,_,_),!, add_internal_error('Non-atomic identifier: ',occurs_in_expr(ID,TExpr)),fail. |
| 1492 | | occurs_in_expr(ID,TExpr) :- ID=[_|_],!, |
| 1493 | | add_internal_error('List instead of identifier: ',occurs_in_expr(ID,TExpr)),fail. |
| 1494 | | occurs_in_expr(ID,TExpr) :- occurs_in_expr1(TExpr,ID). |
| 1495 | | |
| 1496 | | % treat a few common operators here; possibly avoid traversing whole term if we find ID in a sub-tree |
| 1497 | | occurs_in_expr1(TExpr,ID) :- TExpr = b(Expr,_,_),!, |
| 1498 | | occurs_in_expr2(Expr,TExpr,ID). |
| 1499 | | occurs_in_expr1(TExpr,ID) :- add_internal_error('Illegal typed expression:',occurs_in_expr1(TExpr,ID)). |
| 1500 | | |
| 1501 | | occurs_in_expr2(add(A,B),_,ID) :- !, |
| 1502 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1503 | | occurs_in_expr2(conjunct(A,B),_,ID) :- !, |
| 1504 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1505 | | occurs_in_expr2(couple(A,B),_,ID) :- !, |
| 1506 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1507 | | occurs_in_expr2(member(A,B),_,ID) :- !, |
| 1508 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1509 | | occurs_in_expr2(equal(A,B),_,ID) :- !, |
| 1510 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1511 | | occurs_in_expr2(function(A,B),_,ID) :- !, |
| 1512 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1513 | | occurs_in_expr2(image(A,B),_,ID) :- !, |
| 1514 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1515 | | occurs_in_expr2(intersection(A,B),_,ID) :- !, |
| 1516 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1517 | | occurs_in_expr2(interval(A,B),_,ID) :- !, |
| 1518 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1519 | | occurs_in_expr2(not_equal(A,B),_,ID) :- !, |
| 1520 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1521 | | occurs_in_expr2(assertion_expression(A,_Msg,B),_,ID) :- !, |
| 1522 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID)). |
| 1523 | | occurs_in_expr2(domain(A),_,ID) :- !, occurs_in_expr1(A,ID). |
| 1524 | | occurs_in_expr2(range(A),_,ID) :- !, occurs_in_expr1(A,ID). |
| 1525 | | occurs_in_expr2(record_field(A,_FieldName),_,ID) :- !, occurs_in_expr1(A,ID). |
| 1526 | | occurs_in_expr2(identifier(ID1),_,ID) :- !, |
| 1527 | | ID1 = ID. |
| 1528 | | occurs_in_expr2(integer(_),_,_ID) :- !,fail. |
| 1529 | | occurs_in_expr2(string(_),_,_ID) :- !,fail. |
| 1530 | | occurs_in_expr2(value(_),_,_ID) :- !,fail. |
| 1531 | | occurs_in_expr2(truth,_,_ID) :- !,fail. |
| 1532 | | occurs_in_expr2(if_then_else(A,B,C),_,ID) :- !, |
| 1533 | | (occurs_in_expr1(A,ID) -> true ; occurs_in_expr1(B,ID) -> true ; occurs_in_expr1(C,ID)). |
| 1534 | | occurs_in_expr2(rec(Fields),_,ID) :- !, |
| 1535 | | l_field_occurs_in_expr1(Fields,ID). |
| 1536 | | occurs_in_expr2(set_extension(Elements),_,ID) :- !, |
| 1537 | | l_occurs_in_expr1(Elements,ID). |
| 1538 | | occurs_in_expr2(sequence_extension(Elements),_,ID) :- !, |
| 1539 | | l_occurs_in_expr1(Elements,ID). |
| 1540 | | occurs_in_expr2(Expr,_,ID) :- |
| 1541 | | syntaxelement(Expr,List,[], [], [], _), % no bound quantifiers; TO DO: treat bound quantifiers |
| 1542 | | !, |
| 1543 | | l_occurs_in_expr1(List,ID). |
| 1544 | | occurs_in_expr2(_E,TExpr,ID) :- |
| 1545 | | %functor(_E,F,N), print(occurs_in_expr2(F,N,ID)),nl, |
| 1546 | | (find_identifier_uses_if_necessary(TExpr,[],Used) |
| 1547 | | -> %check_sorted(Used), |
| 1548 | | %add_message(bsyntaxtree,'Occurs check: ',ID:Used,TExpr), translate:nested_print_bexpr(TExpr),nl, |
| 1549 | | ord_member(ID,Used) |
| 1550 | | ; add_failed_call_error(find_identifier_uses(TExpr,[],_)),fail). |
| 1551 | | % TO DO: optimize so that we only look for ID; we don't have to keep track of other IDs |
| 1552 | | |
| 1553 | | l_occurs_in_expr1([H|T],ID) :- !, |
| 1554 | | (occurs_in_expr1(H,ID) -> true ; l_occurs_in_expr1(T,ID)). |
| 1555 | | l_occurs_in_expr1(L,ID) :- L \= [], |
| 1556 | | add_internal_error('Illegal typed expression list:',l_occurs_in_expr1(L,ID)). |
| 1557 | | l_field_occurs_in_expr1([field(_,H)|T],ID) :- !, |
| 1558 | | (occurs_in_expr1(H,ID) -> true ; l_field_occurs_in_expr1(T,ID)). |
| 1559 | | l_field_occurs_in_expr1(L,ID) :- L \= [], |
| 1560 | | add_internal_error('Illegal record field list:',l_field_occurs_in_expr1(L,ID)). |
| 1561 | | |
| 1562 | | %check_sorted(List) :- sort(List,SL), (SL \= List -> add_internal_error('Not sorted:',List) ; true). |
| 1563 | | |
| 1564 | | some_id_occurs_in_expr([H|T],TExpr) :- (var(H) ; \+ atomic(H) ; var(T) ; T=[H2|_], H2 @< H), |
| 1565 | | add_internal_error('Must be (sorted) atomic identifiers: ',some_id_occurs_in_expr([H|T],TExpr)), |
| 1566 | | fail. |
| 1567 | | some_id_occurs_in_expr([Id],TExpr) :- !, % use version without complete find_identifier_uses |
| 1568 | | occurs_in_expr(Id,TExpr). |
| 1569 | | some_id_occurs_in_expr(SortedIDs,TExpr) :- |
| 1570 | | find_identifier_uses_if_necessary(TExpr,[],Used), |
| 1571 | | list_to_ord_set(Used,UsedSorted), |
| 1572 | | ord_intersect(UsedSorted,SortedIDs). |
| 1573 | | |
| 1574 | | % ----------------------------- |
| 1575 | | |
| 1576 | | % find used identifiers in typed expressions |
| 1577 | | |
| 1578 | | % a special version for quantifier bodies, attempting to reuse used_ids info |
| 1579 | | find_identifier_uses_for_quantifier_body(TIds,Body,Res) :- |
| 1580 | | get_texpr_ids(TIds,Ids), |
| 1581 | | list_to_ord_set(Ids,Ignore), |
| 1582 | | find_identifier_uses_if_necessary(Body,Ignore,Res). |
| 1583 | | |
| 1584 | | % only run find_identifier_uses if necessary because no used_ids Info field present |
| 1585 | | % TO DO: we could consider using used_ids within find_typed_identifier_uses: drawback: we would need to store types |
| 1586 | | find_identifier_uses_if_necessary(Expr,Ignore,Res) :- |
| 1587 | | get_texpr_info(Expr,I), |
| 1588 | ? | member(used_ids(UIds),I),!, %print('+'),nl, |
| 1589 | | find_with_reuse(Expr,UIds,Ignore,Res). |
| 1590 | | find_identifier_uses_if_necessary(Expr,Ignore,Res) :- find_identifier_uses(Expr,Ignore,Res). |
| 1591 | | |
| 1592 | | find_with_reuse(Expr,UIds,Ignore,Res) :- preference(prob_safe_mode,true), |
| 1593 | | !, |
| 1594 | | (is_ordset(Ignore) -> true ; add_internal_error('Not ordset: ',Ignore)), |
| 1595 | | (is_ordset(UIds) -> true ; add_internal_error('Not ordset: ',UIds)), |
| 1596 | | ord_subtract(UIds,Ignore,Res0), |
| 1597 | | find_identifier_uses(Expr,Ignore,Res1), |
| 1598 | | (Res1=Res0 -> true |
| 1599 | | ; ord_subtract(Res1,Res0,Miss), % missing |
| 1600 | | ord_subtract(Res0,Res1,Res01), % too much |
| 1601 | | (Miss=[] -> add_message(find_identifier_uses_if_necessary,'Suboptimal used_ids: ',Res01,Expr) |
| 1602 | | ; add_internal_error('Incorrect used_ids:',used_ids(missing(Miss),toomuch(Res01),usedids(UIds), |
| 1603 | | ignore(Ignore),real(Res1))), |
| 1604 | | translate:print_bexpr(Expr),nl |
| 1605 | | ) |
| 1606 | | ), |
| 1607 | | Res=Res1. |
| 1608 | | find_with_reuse(_,UIds,Ignore,Res) :- |
| 1609 | | %(is_ordset(Ignore) -> true ; add_internal_error('Not ordset: ',Ignore)), |
| 1610 | | ord_subtract(UIds,Ignore,Res). |
| 1611 | | |
| 1612 | | |
| 1613 | | find_identifier_uses_top_level(TExpr,Ids) :- |
| 1614 | | % get_global_identifiers(Ignored), % ignore all global sets and global constants; |
| 1615 | | % hence find_identifier_uses_top_level/2 usually should only be called for top level expressions |
| 1616 | | Ignored = [], % much more efficient to exclude afterwards for long lists of Ignored ids |
| 1617 | | find_identifier_uses(TExpr,Ignored,Ids0), |
| 1618 | | exclude_global_identifiers(Ids0,Ids). |
| 1619 | | |
| 1620 | | :- use_module(tools,[safe_sort/3]). |
| 1621 | | find_identifier_uses(TExpr,Ignored,Ids) :- |
| 1622 | | %tools_printing:print_term_summary(find_identifier_uses(TExpr,Ignored,Ids)),nl, |
| 1623 | | check_is_texpr(TExpr,find_identifier_uses), |
| 1624 | | (find_typed_identifier_uses(TExpr,Ignored,TIds) |
| 1625 | | -> get_texpr_ids(TIds,RIds), |
| 1626 | | % in case of type errors, or when type checking is not yet complete, we can have multiple entries of the same identifier with different types ! |
| 1627 | | sort(RIds,Ids) % was remove_dups, but remove_dups just calls sort; TODO: implement get_sorted_texpr_ids |
| 1628 | | ; add_internal_error('Call failed:',find_typed_identifier_uses(TExpr,Ignored,_)), |
| 1629 | | Ids=[] |
| 1630 | | ). |
| 1631 | | find_identifier_uses_l(TExprs,Ignored,Ids) :- |
| 1632 | | find_typed_identifier_uses_l(TExprs,Ignored,TIds), |
| 1633 | | get_texpr_ids(TIds,RIds), |
| 1634 | | sort(RIds,Ids). % see above |
| 1635 | | |
| 1636 | | check_is_texpr(X,Context) :- |
| 1637 | | (get_texpr_expr(X,_) -> true ; add_internal_error('Expected TExpr: ', check_is_texpr(X,Context))). |
| 1638 | | |
| 1639 | | find_typed_identifier_uses(TExpr,Ids) :- |
| 1640 | | % get_global_identifiers(Ignored), % ignore all global sets and global constants; hence find_typed_identifier_uses/2 usually should only be called for top level expressions |
| 1641 | | Ignored = [], |
| 1642 | | find_typed_identifier_uses(TExpr,Ignored,Ids0), |
| 1643 | | exclude_global_identifiers(Ids0,Ids). |
| 1644 | | |
| 1645 | | find_typed_identifier_uses(TExpr,Ignored,Ids) :- var(TExpr),!, |
| 1646 | | add_internal_error('Variable typed expression: ', find_typed_identifier_uses(TExpr,Ignored,Ids)), |
| 1647 | | Ids = []. |
| 1648 | | find_typed_identifier_uses(TExpr,Ignored,Ids) :- |
| 1649 | | find_typed_identifier_uses_l([TExpr],Ignored,Ids). |
| 1650 | | |
| 1651 | | find_typed_identifier_uses2(TExpr,Ignored,Ids,Rest) :- |
| 1652 | | get_texpr_expr(TExpr,Expr), |
| 1653 | | safe_syntaxelement_det(Expr,Subs,TNames,_,_), % QSubs=[], |
| 1654 | | ( uses_an_identifier(Expr,Id,TExpr,Ignored) -> |
| 1655 | | ( ord_member(Id,Ignored) -> Ids=Rest |
| 1656 | | ; |
| 1657 | | get_texpr_type(TExpr,Type), |
| 1658 | | normalize_type(Type,NType), % replace seq by set; |
| 1659 | | % warning: when type-check not yet complete we have variables here |
| 1660 | | create_texpr(identifier(Id),NType,[],TId), |
| 1661 | | %print(adding(Id,NType,Ignored)),nl, |
| 1662 | | Ids = [TId|Rest] |
| 1663 | | ) |
| 1664 | | % ; (Expr = becomes_such(TIds,_)), nl,print(uses_primes(Expr)),nl,fail |
| 1665 | | ; indirectly_uses_identifiers(Expr,Ignored,IndirectIds) -> |
| 1666 | | add_typed_ids(IndirectIds,Ids,Rest2), |
| 1667 | | find_typed_identifier_uses2_l(Subs,Ignored,Rest2,Rest) |
| 1668 | | ; TNames = [] -> find_typed_identifier_uses2_l(Subs,Ignored,Ids,Rest) |
| 1669 | | ; |
| 1670 | | %find_typed_identifier_uses2_l(QSubs,Ignored,Ids,Ids2), % useless here as QSubs=[] |
| 1671 | | get_texpr_ids(TNames,Names), |
| 1672 | | list_to_ord_set(Names,SNames), ord_union(SNames,Ignored,Ignored2), |
| 1673 | | find_typed_identifier_uses2_l(Subs,Ignored2,Ids,Rest)). |
| 1674 | | find_typed_identifier_uses2_l([],_) --> !, []. |
| 1675 | | find_typed_identifier_uses2_l([Expr|Rest],Ignored) --> !, |
| 1676 | | find_typed_identifier_uses2(Expr,Ignored), |
| 1677 | | find_typed_identifier_uses2_l(Rest,Ignored). |
| 1678 | | find_typed_identifier_uses2_l(E,Ignored) --> |
| 1679 | | {add_internal_error('Illegal arguments (not a list):',find_typed_identifier_uses2_l(E,Ignored)),fail}. |
| 1680 | | |
| 1681 | | %Note: above we do not remap uses of Id$0 to Id in becomes_such; |
| 1682 | | % this is done in find_read_vars_for_becomes_such in b_read_write_info |
| 1683 | | |
| 1684 | | |
| 1685 | | uses_an_identifier(Expr,Id) :- uses_an_identifier(Expr,Id,none,[]). |
| 1686 | | |
| 1687 | | uses_an_identifier(identifier(Id),Id,_,_). |
| 1688 | | uses_an_identifier(lazy_lookup_pred(Id),Id,_,_). |
| 1689 | | uses_an_identifier(lazy_lookup_expr(Id),Id,_,_). |
| 1690 | | uses_an_identifier(value(_),Id,b(_,_,Info),Ignored) :- Ignored \= [], |
| 1691 | ? | member(was_identifier(Id),Info), |
| 1692 | | member('$examine_value_was_identifier_info',Ignored),!. |
| 1693 | | |
| 1694 | | % uses multiple ids and we also need to inspect subs (operation call arguments) |
| 1695 | | indirectly_uses_identifiers(operation_call_in_expr(Operation,_),Ignored,IndirectIds) :- |
| 1696 | | get_texpr_info(Operation,Info), |
| 1697 | | (memberchk(reads(Vars),Info) |
| 1698 | | -> (var(Vars) % can happen during initial computation of read_write info for recursive operation calls in expr |
| 1699 | | -> add_message(bsyntaxtree,'Operation reads info not yet computed (probably recursive call): ',Operation,Info), |
| 1700 | | fail % Assume this is a direct recursive call which adds no used ids, |
| 1701 | | % case happens in test 1960 for recursive call to Fact; TODO: more robust solution or disallow recursion |
| 1702 | | ; true) |
| 1703 | | ; add_warning(bsyntaxtree,'Operation call contains no read infos:',Operation,Info),fail), |
| 1704 | | ord_subtract(Vars,Ignored,IndirectIds), |
| 1705 | | IndirectIds \= []. |
| 1706 | | %indirectly_uses_identifiers(external_pred_call(FunName,_),Ignored,IndirectIds) :- |
| 1707 | | % expects_state(FunName), TODO: check for which external functions/predicates we need to add ids |
| 1708 | | |
| 1709 | | |
| 1710 | | % this is to convert untyped ids in operation call reads infos to typed ids |
| 1711 | | add_typed_ids([]) --> []. |
| 1712 | | add_typed_ids([Id|T]) --> {var_cst_type(Id,Type)},!, |
| 1713 | | {create_texpr(identifier(Id),Type,[],TId)}, [TId], add_typed_ids(T). |
| 1714 | | add_typed_ids([Id|T]) --> {debug_println(19,ignoring_used_id(Id))}, add_typed_ids(T). |
| 1715 | | |
| 1716 | | :- use_module(bmachine,[bmachine_is_precompiled/0, b_is_variable/2,b_is_constant/2]). |
| 1717 | | var_cst_type(Name,Type) :- bmachine_is_precompiled,!, |
| 1718 | | (b_is_variable(Name,Type) ; b_is_constant(Name,Type)),!. |
| 1719 | | var_cst_type(_,any). % TODO: provide a better solution; maybe only allow untyped find_identifier_uses ?? |
| 1720 | | |
| 1721 | | % ------------- |
| 1722 | | |
| 1723 | | find_typed_identifier_uses_l(TExprs,Ignored,Ids) :- |
| 1724 | | check_atomic_ids(Ignored), |
| 1725 | | list_to_ord_set(Ignored,SIgnored), |
| 1726 | | find_typed_identifier_uses2_l(TExprs,SIgnored,Unsorted,[]),!, |
| 1727 | | safe_sort(find_typed_identifier_uses,Unsorted,Ids), |
| 1728 | | (preference(prob_safe_mode,true) -> check_typed_ids(Ids) ; true). |
| 1729 | | find_typed_identifier_uses_l(TExprs,Ignored,Ids) :- |
| 1730 | | add_internal_error('Call failed:',find_typed_identifier_uses_l(TExprs,Ignored,Ids)), |
| 1731 | | fail. |
| 1732 | | |
| 1733 | | check_typed_ids([]) :- !. |
| 1734 | | check_typed_ids([b(identifier(ID),T,_)|Tail]) :- !, check_ids3(Tail,ID,T). |
| 1735 | | check_typed_ids(Other) :- add_internal_error('Unexpected typed id list:',check_typed_ids(Other)). |
| 1736 | | |
| 1737 | | |
| 1738 | | check_atomic_ids([]) :- !. |
| 1739 | | check_atomic_ids([Id|_]) :- atomic(Id),!. |
| 1740 | | check_atomic_ids(Other) :- add_internal_error('Expected atomic id list:',check_atomic_ids(Other)). |
| 1741 | | |
| 1742 | | |
| 1743 | | check_ids3([],_,_) :- !. |
| 1744 | | check_ids3([b(identifier(ID),T,_)|Tail],ID1,T1) :- !, |
| 1745 | | (ID=ID1 -> add_internal_error('Identifier appears multiple times with types:',id(ID,T1,T)) ; true), |
| 1746 | | check_ids3(Tail,ID,T). |
| 1747 | | check_ids3(Other,ID1,T1) :- add_internal_error('Unexpected typed id list:',check_ids3(Other,ID1,T1)). |
| 1748 | | |
| 1749 | | |
| 1750 | | update_used_ids(b(Pred,T,OInfo),UsedIds,b(Pred,T,[used_ids(UsedIds)|NInfo])) :- |
| 1751 | | delete(OInfo,used_ids(_),NInfo). |
| 1752 | | |
| 1753 | | % check if some pre-computed used ids are valid wrt find_typed_identifier_uses |
| 1754 | | check_computed_used_ids(TExpr,CompUsedIds) :- |
| 1755 | | find_identifier_uses(TExpr,[],RealUsedIds), |
| 1756 | | (RealUsedIds=CompUsedIds -> print(ok(CompUsedIds)),nl |
| 1757 | | ; add_error(range,'Unexpected used ids:',CompUsedIds,TExpr), |
| 1758 | | format('Real: ~w~nComp: ~w~n',[RealUsedIds,CompUsedIds]),trace |
| 1759 | | ). |
| 1760 | | |
| 1761 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1762 | | % break predicate into components with disjunct identifiers |
| 1763 | | % Pred: a predicate |
| 1764 | | % Components: a list of terms component/2 where the first argument |
| 1765 | | % is a predicate, the second is the set of used identifiers |
| 1766 | | predicate_components(Pred,Res) :- predicate_components_in_scope(Pred,[],Res). |
| 1767 | | predicate_components_in_scope(Pred,LocalVars,Res) :- |
| 1768 | | predicate_components_with_restriction(Pred,LocalVars,all,Res). |
| 1769 | | |
| 1770 | | predicate_components_with_restriction(Pred,LocalVars,RestrictionList,Res) :- |
| 1771 | | conjunction_to_list(Pred,Preds), |
| 1772 | | l_predicate_identifiers(Preds,LocalVars,PredIds), |
| 1773 | | (RestrictionList=all -> R=all ; list_to_ord_set(RestrictionList,R)), |
| 1774 | | try_find_and_remove_equalities(PredIds,PredIds2), |
| 1775 | | % print(find_components(R)),nl,nl, |
| 1776 | | %%(member(pred(P,Ids,X),PredIds2), nl,print(pred(Ids,X)),nl,translate:print_bexpr(P),nl,fail ; true), |
| 1777 | | find_components(PredIds2,R,Components), |
| 1778 | | !, |
| 1779 | | %maplist(print_component,Components), |
| 1780 | | Components=Res. |
| 1781 | | predicate_components_with_restriction(Pred,_,_,[component(Pred,[])]) :- |
| 1782 | | add_internal_error('predicate_components failed: ',predicate_components_with_restriction(Pred,_,_,_)). |
| 1783 | | |
| 1784 | | % print_component(component(Pred,Ids)) :- format('Component over ~w :~n',[Ids]), translate:print_bexpr(Pred),nl. |
| 1785 | | |
| 1786 | | % get the list of used identifiers for each predicate |
| 1787 | | l_predicate_identifiers([],_LocalVars,[]). |
| 1788 | | l_predicate_identifiers([Pred|PRest],LocalVars,[pred(Pred,Ids,_Selected)|IRest]) :- |
| 1789 | | predicate_identifiers_in_scope(Pred,LocalVars,Ids), % Do not ignore local variables; used instead of enumerate set elements |
| 1790 | | l_predicate_identifiers(PRest,LocalVars,IRest). |
| 1791 | | |
| 1792 | | |
| 1793 | | try_find_and_remove_equalities(PredAndIds,PredAndIds2) :- |
| 1794 | | preferences:get_preference(partition_predicates_inline_equalities,true), |
| 1795 | | \+ preferences:get_preference(use_solver_on_load,kodkod), |
| 1796 | ? | find_and_remove_equalities(PredAndIds,RR), |
| 1797 | | !, PredAndIds2=RR. |
| 1798 | | try_find_and_remove_equalities(Ps,Ps). |
| 1799 | | |
| 1800 | | :- use_module(debug,[debug_println/2]). |
| 1801 | | % find and apply obvious equalities so that they do not interfere with partitioning into components |
| 1802 | | % example: c = 1 & f: 1..c --> A & g: 1..c --> B |
| 1803 | | % TO DO: preprocess and do one pass to detect potential equalities |
| 1804 | | find_and_remove_equalities([],[]). |
| 1805 | | find_and_remove_equalities(List,[pred(P,PIds,Sel)|FT]) :- |
| 1806 | ? | select(pred(P,PIds,Sel),List,Rest), |
| 1807 | | %PIds = [Id], |
| 1808 | | identifier_equality(P,Id,Value), |
| 1809 | | %(value_which_can_be_replaced(Value) -> true ; nl,print('Not replaced: '),translate:print_bexpr(Value),nl,fail), |
| 1810 | | (get_texpr_id(Value,Id2) |
| 1811 | | -> Id2 \= Id %,print(inline_id(Id,Id2)),nl |
| 1812 | | % Note: this inlining does *not* help with partitioning; but does help ProB detect common predicates/expressions |
| 1813 | | ; PIds=[Id],value_which_can_be_replaced(Value)), |
| 1814 | | debug_println(9,replace_simple_equality(Id,PIds)), |
| 1815 | ? | maplist(apply_to_pred(Id,Value),Rest,RT), |
| 1816 | | !, |
| 1817 | ? | find_and_remove_equalities(RT,FT). |
| 1818 | | % TO DO: detect equalityes x = EXPR, where EXPR does not contain x and where x occurs in no other predicate |
| 1819 | | % we can then annotate x as not to enumerate |
| 1820 | | find_and_remove_equalities(R,R). |
| 1821 | | |
| 1822 | | identifier_equality(b(equal(LHS,RHS),_,_),Id,EqTerm) :- |
| 1823 | | (get_texpr_id(LHS,Id) -> EqTerm = RHS |
| 1824 | | ; get_texpr_id(RHS,Id) -> EqTerm = LHS). |
| 1825 | | % TO DO: should we detect other equalities? |
| 1826 | | |
| 1827 | | value_which_can_be_replaced(b(E,T,_)) :- value_which_can_be_replaced2(E,T). |
| 1828 | | %(value_which_can_be_replaced2(E,T) -> true ; print(not_val(E)),nl,fail). |
| 1829 | | value_which_can_be_replaced2(value(_),_). |
| 1830 | | value_which_can_be_replaced2(integer(_),_). |
| 1831 | | %value_which_can_be_replaced2(identifier(I),global(G)) :- b_global_constant(G), id_not_used_anywhere(I). |
| 1832 | | value_which_can_be_replaced2(integer_set(_),_). |
| 1833 | | value_which_can_be_replaced2(unary_minus(A),_) :- value_which_can_be_replaced(A). |
| 1834 | | value_which_can_be_replaced2(add(A,B),_) :- value_which_can_be_replaced(A), value_which_can_be_replaced(B). |
| 1835 | | % we could compute the value |
| 1836 | | value_which_can_be_replaced2(minus(A,B),_) :- value_which_can_be_replaced(A), value_which_can_be_replaced(B). |
| 1837 | | value_which_can_be_replaced2(multiplication(A,B),_) :- value_which_can_be_replaced(A), value_which_can_be_replaced(B). |
| 1838 | | value_which_can_be_replaced2(div(A,B),_) :- |
| 1839 | | get_integer(B,IB), IB \= 0, |
| 1840 | | value_which_can_be_replaced(A). |
| 1841 | | value_which_can_be_replaced2(floored_div(A,B),T) :- value_which_can_be_replaced2(div(A,B),T). |
| 1842 | | % should we add: with WD check: division, modulo, .... ? see also simple2 in b_ast_cleanup |
| 1843 | | value_which_can_be_replaced2(max_int,_). |
| 1844 | | value_which_can_be_replaced2(min_int,_). |
| 1845 | | value_which_can_be_replaced2(float_set,_). |
| 1846 | | value_which_can_be_replaced2(real(_),_). |
| 1847 | | value_which_can_be_replaced2(real_set,_). |
| 1848 | | value_which_can_be_replaced2(string(_),_). |
| 1849 | | value_which_can_be_replaced2(string_set,_). |
| 1850 | | value_which_can_be_replaced2(boolean_true,_). |
| 1851 | | value_which_can_be_replaced2(boolean_false,_). |
| 1852 | | value_which_can_be_replaced2(bool_set,_). |
| 1853 | | value_which_can_be_replaced2(empty_set,_). |
| 1854 | | value_which_can_be_replaced2(empty_sequence,_). |
| 1855 | | value_which_can_be_replaced2(couple(A,B),_) :- value_which_can_be_replaced(A), value_which_can_be_replaced(B). |
| 1856 | | value_which_can_be_replaced2(interval(A,B),_) :- value_which_can_be_replaced(A), value_which_can_be_replaced(B). |
| 1857 | | value_which_can_be_replaced2(set_extension(L),_) :- maplist(value_which_can_be_replaced,L). |
| 1858 | | value_which_can_be_replaced2(sequence_extension(L),_) :- maplist(value_which_can_be_replaced,L). |
| 1859 | | value_which_can_be_replaced2(cartesian_product(A,B),_) :- % typing equations, like t_float = INTEGER*NATURAL1 |
| 1860 | | simple_value_set(A), simple_value_set(B). |
| 1861 | | value_which_can_be_replaced2(pow_subset(A),_) :- simple_value_set(A). |
| 1862 | | %value_which_can_be_replaced2(identifier(_),_). % TO DO: check that this is not the LHS identifier which we replace !! |
| 1863 | | % identifiers can also be replaced: we check above that the only identifier in the predicate is the equality identifier |
| 1864 | | % TO DO: enable this but then we need to fix replace_id_by_expr2 to updated the used_ids info ! + we can have scoping issues !?; see test 1358 |
| 1865 | | |
| 1866 | | % TO DO: also allow inlining of prj1/prj2 of simple_value_set: |
| 1867 | | % not_val(comprehension_set([b(identifier(_zzzz_unary),integer,[generated(first)]),b(identifier(_zzzz_binary),integer,[generated(first)]),b(identifier(_lambda_result_),integer,[lambda_result])],b(equal(b(identifier(_lambda_result_),integer,[lambda_result]),b(identifier(_zzzz_unary),integer,[generated(first)])),pred,[prob_annotation(LAMBDA),lambda_result]))) |
| 1868 | | % not_val(comprehension_set([b(identifier(_zzzz_unary),integer,[generated(second)]),b(identifier(_zzzz_binary),integer,[generated(second)]),b(identifier(_lambda_result_),integer,[lambda_result])],b(equal(b(identifier(_lambda_result_),integer,[lambda_result]),b(identifier(_zzzz_binary),integer,[generated(second)])),pred,[prob_annotation(LAMBDA),lambda_result]))) |
| 1869 | | |
| 1870 | | % TO DO: maybe check if it is an infinite type which cannot be evaluated anyway |
| 1871 | | simple_value_set(b(E,_,_)) :- simple_value_set2(E). |
| 1872 | | %simple_value_set2(bool_set). % Warning: we could have a finite construct which gets evaluated multiple times |
| 1873 | | simple_value_set2(string_set). |
| 1874 | | simple_value_set2(integer_set(_)). |
| 1875 | | simple_value_set2(float_set). |
| 1876 | | simple_value_set2(real_set). |
| 1877 | | simple_value_set2(cartesian_product(A,B)) :- simple_value_set(A), simple_value_set(B). |
| 1878 | | simple_value_set2(pow_subset(A)) :- simple_value_set(A). |
| 1879 | | % POW, records struct(_) set ? |
| 1880 | | |
| 1881 | | % apply a substiution of ID/Expr on a pred(EXPR,VarList,X) term |
| 1882 | | % Expr must either be a variable or contain no variables at all |
| 1883 | | apply_to_pred(ID,Expr,pred(E1,PIds1,X),pred(E2,PIds3,X)) :- |
| 1884 | ? | (select(ID,PIds1,PIds2) |
| 1885 | ? | -> replace_id_by_expr(E1,ID,Expr,E2), %,print(applied(ID)),nl,translate:print_bexpr(E2),nl |
| 1886 | | % TO DO: replace_id_by_expr does not seem to update used_ids info !! check_used_ids_info fails for test 1358 if we allow identifiers inside Expr |
| 1887 | | (get_texpr_id(Expr,NewID) |
| 1888 | | -> ord_add_element(PIds2,NewID,PIds3) |
| 1889 | | ; PIds3 = PIds2) |
| 1890 | | %, format('Apply ~w -> ~w : ',[ID,NewID]),translate:print_bexpr(E2),nl |
| 1891 | | ; E1=E2,PIds1=PIds3). |
| 1892 | | |
| 1893 | | |
| 1894 | | % project a predicate : keep only those Predicates that are directly or |
| 1895 | | % indirectly relevant for Ids; FullIds are all identifiers used by ProjectedPredicate |
| 1896 | | project_predicate_on_identifiers(Pred,Ids,ProjectedPredicate,FullIds, RestList) :- |
| 1897 | | (debug_mode(on) |
| 1898 | | -> print('project: '),print_bexpr(Pred),nl, print(' on : '), print(Ids),nl |
| 1899 | | ; true), |
| 1900 | | conjunction_to_list(Pred,Preds), |
| 1901 | | l_predicate_identifiers(Preds,[],PredIds), % TO DO: allow LocalVariables to be passed |
| 1902 | | % print(predids(PredIds)),nl, |
| 1903 | | try_find_and_remove_equalities(PredIds,PredIds2), |
| 1904 | | extract_all_predicates(Ids,all,Ids,PredIds2,ProjectedPredicates, RestList,FullIds), |
| 1905 | | conjunct_predicates(ProjectedPredicates,ProjectedPredicate), |
| 1906 | | (debug_mode(on) |
| 1907 | | -> print('*result: '),print_bexpr(ProjectedPredicate),nl, |
| 1908 | | print(' on : '), print(FullIds),nl |
| 1909 | | ; true). |
| 1910 | | |
| 1911 | | %print_preds([]). |
| 1912 | | %print_preds([pred(P,_IDs,_)|T]) :- translate:print_bexpr(P), nl, print(' '), print_preds(T). |
| 1913 | | |
| 1914 | | :- use_module(b_global_sets,[b_get_global_constants/1, b_get_enumerated_set_constants/1, |
| 1915 | | b_get_global_sets/1, exclude_global_identifiers/2, exclude_global_identifiers/3]). |
| 1916 | | predicate_identifiers(Pred,Ids) :- predicate_identifiers_in_scope(Pred,[],Ids). |
| 1917 | | predicate_identifiers_in_scope(Pred,LocalVariables,Ids) :- |
| 1918 | | %get_global_identifiers(IS), |
| 1919 | | list_to_ord_set(LocalVariables,LV), |
| 1920 | | %ord_subtract(IS,LV,Ignore2), % Do not ignore any local variable; it will be used instead of enumerate set element |
| 1921 | | find_identifier_uses_if_necessary(Pred,[],Ids1), % Ignore enumerated set names |
| 1922 | | exclude_global_identifiers(Ids1,LV,Ids2), |
| 1923 | | list_to_ord_set(Ids2,Ids). |
| 1924 | | |
| 1925 | | % see also b_global_constant_or_set_identifier and exclude_global_identifiers |
| 1926 | | get_global_identifiers(IDs) :- get_global_identifiers(IDs,all). |
| 1927 | | % get global set and constant identifiers which you usually want to exclude for find_identifier_uses |
| 1928 | | get_global_identifiers(IDs,Option) :- |
| 1929 | | (Option=ignore_promoted_constants |
| 1930 | | % do not include those constants that have been automatically promoted as enumerated set elements |
| 1931 | | -> b_get_enumerated_set_constants(EnumeratedSetCsts) |
| 1932 | | ; b_get_global_constants(EnumeratedSetCsts) |
| 1933 | | ), |
| 1934 | | % b_global_sets:b_get_global_enumerated_sets(GSets), % is there a reason to exclude deferred sets ??; cardinality inference,... are all done before partitioning ? |
| 1935 | | b_get_global_sets(GSets), |
| 1936 | | append(GSets,EnumeratedSetCsts,GE), |
| 1937 | | list_to_ord_set(GE,IDs). |
| 1938 | | |
| 1939 | | % find_components(ListOf_pred, Restrict, Out:ListOfComponents) |
| 1940 | | % role of Restrict: all if we do normal partition or List of VariableIDs on which we restrict our attention to (for Existential quantifier construction) |
| 1941 | | find_components([],_,[]). |
| 1942 | | find_components([pred(P,PIds,true)|PRest],Restrict,[component(Pred,Ids)|CRest]) :- |
| 1943 | | % find all predicates which are using identifiers occuring in PIds |
| 1944 | | % (and additionally those which use common identifiers ) |
| 1945 | | ord_restrict(Restrict,PIds,InterIDs), |
| 1946 | | %format('Treating predicate with ids ~w; restr. intersect = ~w~n',[PIds,InterIDs]), |
| 1947 | | ( InterIDs =[] -> |
| 1948 | | % we simply copy this predicate into a single component; not with the scope of Restricted IDs |
| 1949 | | % print(skip(PIds,P)),nl, % |
| 1950 | | Pred=P, Ids=PIds, PRest=Rest |
| 1951 | | ; |
| 1952 | | extract_all_predicates(InterIDs,Restrict,PIds,PRest,Preds,Rest,Ids), |
| 1953 | | %length([P|Preds],Len), format('Detected component with ~w conjuncts over ~w~n',[Len,Ids]), |
| 1954 | | conjunct_predicates_with_pos_info([P|Preds],Pred) |
| 1955 | | ), |
| 1956 | | find_components(Rest,Restrict,CRest). |
| 1957 | | extract_all_predicates([],_,_,Preds,Found,Rest,[]) :- !, % selecting done at end: keep same order of conjuncts |
| 1958 | | select_predicates(Preds,Found,Rest). |
| 1959 | | extract_all_predicates(Ids,Restrict,OldIds,Preds,Found,Rest,ResultIds) :- |
| 1960 | | % search for all predicates that directly use one of the |
| 1961 | | % identifiers in "Ids" |
| 1962 | | select_all_using_preds(Preds,Ids,FoundIds), |
| 1963 | | ord_subtract(FoundIds,OldIds,NewIds), |
| 1964 | | ord_restrict(Restrict,NewIds,NewIdsToExtract), |
| 1965 | | ord_union(OldIds,FoundIds,OldIds2), |
| 1966 | | % now recursively do this which the new identifiers that we have found |
| 1967 | | extract_all_predicates(NewIdsToExtract,Restrict,OldIds2,Preds,Found,Rest,RestIds), |
| 1968 | | ord_union([Ids,NewIds,RestIds],ResultIds). |
| 1969 | | |
| 1970 | | % mark all predicates which intersect with ComponentIds and compute new ids to be added to the component |
| 1971 | | select_all_using_preds([],_,[]). |
| 1972 | | select_all_using_preds([pred(_P,PIds,Selected)|PRest],ComponentIds,NewFoundIds) :- |
| 1973 | | ( (Selected==true ; ord_disjoint(PIds,ComponentIds)) -> |
| 1974 | | NewFoundIds1 = [] |
| 1975 | | ; % we select the predicate for the component |
| 1976 | | ord_subtract(PIds,ComponentIds,NewFoundIds1), |
| 1977 | | Selected=true |
| 1978 | | ), |
| 1979 | | select_all_using_preds(PRest,ComponentIds,NewFoundIds2), |
| 1980 | | ord_union(NewFoundIds1,NewFoundIds2,NewFoundIds). |
| 1981 | | |
| 1982 | | % ord_intersection with special case for all term |
| 1983 | | ord_restrict(all,Ids,Res) :- !, Res=Ids. |
| 1984 | | ord_restrict(Restrict,Ids,Res) :- ord_intersection(Ids,Restrict,Res). |
| 1985 | | |
| 1986 | | select_predicates(Predicates,FoundPreds,OtherPreds) :- |
| 1987 | | split_list(is_selected_predicate,Predicates,FoundPredIds,OtherPreds), |
| 1988 | | maplist(extract_found_predicate,FoundPredIds,FoundPreds). |
| 1989 | | is_selected_predicate(pred(_P,_PIds,Selected)) :- ground(Selected). |
| 1990 | | extract_found_predicate(pred(P,_PIds,_Selected),P). |
| 1991 | | |
| 1992 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1993 | | % replace (simultaneously) multiple identifiers by expressions |
| 1994 | | % this could be used to replace the predicate replace_id_by_expr by mapping everything in a |
| 1995 | | % singleton list. however, that would involve list operations instead of unifications |
| 1996 | | parse_pred(Codes,TExpr) :- %format('Parsing ~s~n',[Codes]), |
| 1997 | | bmachine:b_parse_machine_predicate_from_codes_open(no_quantifier,Codes,[],[],TExpr). |
| 1998 | | parse_expr(Codes,TExpr) :- bmachine:b_parse_machine_expression_from_codes(Codes,[],TExpr,_Type,true,_Error). |
| 1999 | | test_result(1,b(equal(b(comprehension_set([b(identifier(__FRESH____),integer,_)], |
| 2000 | | b(greater(b(identifier(__FRESH____2),integer,_),b(identifier(x),integer,_)),pred,_)),set(integer),_), |
| 2001 | | b(empty_set,set(integer),_)),pred,_)). |
| 2002 | | |
| 2003 | | :- assert_must_succeed((bsyntaxtree:parse_pred("{x|x:INTEGER & x>y}={}",T1), replace_ids_by_exprs(T1,[],[],T1))). |
| 2004 | | :- assert_must_succeed((bsyntaxtree:parse_pred("{x|x:INTEGER & x>y}={}",T1), bsyntaxtree:parse_expr("100",T2), |
| 2005 | | replace_ids_by_exprs(T1,[y],[T2],R),bsyntaxtree:parse_pred("{x|x>100}={}",T3),same_texpr(R,T3) )). |
| 2006 | | :- assert_must_succeed((bsyntaxtree:parse_pred("{x|x:INTEGER & x>y}={}",T1), |
| 2007 | | replace_ids_by_exprs(T1,[y],[b(identifier(x),integer,[])],R), |
| 2008 | | bsyntaxtree:test_result(1,R),bsyntaxtree:parse_pred("{x|x:INTEGER & x>x}={}",T3),\+ same_texpr(R,T3) )). |
| 2009 | | :- assert_must_succeed((bsyntaxtree:parse_pred("{x,y|x:INTEGER & y:INTEGER & x>v & y>w}={}",T1), |
| 2010 | | replace_ids_by_exprs(T1,[v,w],[b(identifier(w),integer,[]),b(identifier(v),integer,[])],R), |
| 2011 | | bsyntaxtree:parse_pred("{x,y|x:INTEGER & y:INTEGER & x>w & y>v}={}",T3), same_texpr(R,T3) )). |
| 2012 | | :- assert_must_succeed((gensym:reset_gensym, bsyntaxtree:parse_pred("{x,y|x:INTEGER & y:INTEGER & x>v & y>w}={}",T1), |
| 2013 | | replace_ids_by_exprs(T1,[v,w],[b(identifier(w),integer,[]),b(identifier(x),integer,[])],R), |
| 2014 | | translate:translate_bexpression(R,TR), |
| 2015 | | TR = '{`__FRESH____1`,y|`__FRESH____1` > w & y > x} = {}')). %'{__FRESH____1,y|(__FRESH____1 : INTEGER & y : INTEGER) & (__FRESH____1 > w & y > x)} = {}' )). |
| 2016 | | |
| 2017 | | replace_ids_by_exprs(TExpr,[TId],[Inserted],Replaced) :- !, % better, more robust and efficient version |
| 2018 | | check_ids([TId],[Id]), |
| 2019 | | replace_id_by_expr(TExpr,Id,Inserted,Replaced). |
| 2020 | | replace_ids_by_exprs(TExpr,[],[],Replaced) :- !, Replaced=TExpr. % Nothing to do |
| 2021 | | replace_ids_by_exprs(TExpr,Ids,Exprs,Replaced) :- |
| 2022 | | check_ids(Ids,Ids2), % convert to atomic identifiers |
| 2023 | | find_identifier_uses_l(Exprs,[],ExprsUsedIds), |
| 2024 | | sort(ExprsUsedIds,SExprsUsedIds), |
| 2025 | | generate_rename_list(Ids2,Exprs,RenameList), |
| 2026 | | %print(replace(RenameList,SExprsUsedIds)),nl, |
| 2027 | | replace_ids_by_exprs2(RenameList,SExprsUsedIds,TExpr,Replaced,_). %, nl,print(done),nl. |
| 2028 | | % a version of replace_ids_by_exprs2 for maplist: |
| 2029 | | %replace_ids_by_exprs1(RenameList,SExprsUsedIds,TExpr,Replaced) :- |
| 2030 | | % replace_ids_by_exprs2(RenameList,SExprsUsedIds,TExpr,Replaced,_). %, print('Rep: '), translate:print_bexpr(Replaced),nl. |
| 2031 | | |
| 2032 | | generate_rename_list([],[],[]). |
| 2033 | | generate_rename_list([ID1|T],[Expr1|TE],[rename(ID1,Expr1)|RT]) :- generate_rename_list(T,TE,RT). |
| 2034 | | |
| 2035 | | check_ids([],[]). |
| 2036 | | check_ids([H|T],[ID|IT]) :- (atomic(H) -> ID=H ; def_get_texpr_id(H,ID)), check_ids(T,IT). |
| 2037 | | replace_ids_by_exprs2(RenameList,ExprsUsedIds,TExpr,Replaced,WDC) :- |
| 2038 | | remove_bt(TExpr,Expr,NewExpr,TNewExpr), |
| 2039 | | ( Expr = identifier(Id), member(rename(Id,Inserted),RenameList) -> |
| 2040 | | Replaced = Inserted, |
| 2041 | | get_texpr_info(Inserted,Infos), |
| 2042 | | (memberchk(contains_wd_condition,Infos) |
| 2043 | | -> WDC = true ; WDC = false) % WDC = true means we have added a wd-condition where previously there was none |
| 2044 | | ; contains_no_ids(Expr) -> Replaced=TExpr, WDC=false |
| 2045 | | ; |
| 2046 | | syntaxtransformation_det(Expr,Subs1,Names,NSubs,NewExpr), |
| 2047 | | find_variable_clashes(Names,ExprsUsedIds,RenameNames), % check for variable caputure |
| 2048 | | (RenameNames = [] |
| 2049 | | -> Subs = Subs1 % no variable capture occured |
| 2050 | | ; %format('*** VARIABLE CAPTURE : ~w~n~n',[RenameNames]), |
| 2051 | | rename_bt_l(Subs1,RenameNames,Subs) % replace affected names by fresh ids in sub arguments (will also change list of quantified variables itself) |
| 2052 | | ), |
| 2053 | | %l_replace_ids_by_exprs2(QSubs,RenameList,ExprsUsedIds,NQSubs,WDC1), % QSubs are like RHS of let expression, where Names are not in scope |
| 2054 | | remove_hidden_names(Names,RenameList,UpdatedRenameList), |
| 2055 | | ( UpdatedRenameList = [] -> % all Ids are now hidden for the inner expressions |
| 2056 | | NSubs=Subs, WDC=false |
| 2057 | | ; |
| 2058 | | l_replace_ids_by_exprs2(Subs,UpdatedRenameList,ExprsUsedIds,NSubs,WDC) |
| 2059 | | ), |
| 2060 | | TNewExpr = b(E1,T1,Info1), |
| 2061 | | rename_update_used_ids_info(RenameList,Info1,Info2), |
| 2062 | | add_wd_if_needed(WDC,b(E1,T1,Info2),Replaced) |
| 2063 | | ). |
| 2064 | | |
| 2065 | | contains_no_ids(integer(_)). |
| 2066 | | contains_no_ids(string(_)). |
| 2067 | | contains_no_ids(value(_)). |
| 2068 | | |
| 2069 | | |
| 2070 | | % check if we have to rename any quantified variable to avoid variable capture of RHS of renamings |
| 2071 | | % example, suppose we rename x/y+1 and we enter {y|y>x} we have to generate {fresh|fresh>y+1} and *not* {y|y>y+1} |
| 2072 | | find_variable_clashes([],_,[]). |
| 2073 | | find_variable_clashes([Name|Names],ExprsUsedIds,[rename(ID,FRESHID)|Renaming] ) :- |
| 2074 | | def_get_texpr_id(Name,ID), |
| 2075 | | ord_member(ID,ExprsUsedIds), % the quantified name is also introduced by the renaming |
| 2076 | | !, |
| 2077 | | gensym('__FRESH__',FRESHID), |
| 2078 | | find_variable_clashes(Names,ExprsUsedIds,Renaming). |
| 2079 | | find_variable_clashes([_|Names],ExprsUsedIds,Renaming) :- |
| 2080 | | find_variable_clashes(Names,ExprsUsedIds,Renaming). |
| 2081 | | |
| 2082 | | |
| 2083 | | l_replace_ids_by_exprs2([],_,_,[],false). |
| 2084 | | l_replace_ids_by_exprs2([H|T],UpdatedRenameList,ExprsUsedIds,[IH|IT],WDC) :- |
| 2085 | | replace_ids_by_exprs2(UpdatedRenameList,ExprsUsedIds,H,IH,WDC1), |
| 2086 | | l_replace_ids_by_exprs2(T,UpdatedRenameList,ExprsUsedIds,IT,WDC2), |
| 2087 | | and_wdc(WDC1,WDC2,WDC). |
| 2088 | | |
| 2089 | | % remove any identifiers that are now "invisible" because they are masked by quantified names |
| 2090 | | % e.g., when we enter #x.(P) then a renaming of x will be "hidden" inside P |
| 2091 | | remove_hidden_names([],RenameList,RenameList). |
| 2092 | | remove_hidden_names([Name|Names],RenameList,NewRenameList) :- |
| 2093 | | def_get_texpr_id(Name,ID), |
| 2094 | | delete(RenameList,rename(ID,_),RenameList1), |
| 2095 | | !, % only one rename should exist |
| 2096 | | %print(del(ID,RenameList1)),nl, |
| 2097 | | remove_hidden_names(Names,RenameList1,NewRenameList). |
| 2098 | | |
| 2099 | | find_rhs_ids(rename(Id,TExpr),rename_ids(Id,InsUsedIds)) :- find_identifier_uses(TExpr,[],InsUsedIds). |
| 2100 | | |
| 2101 | | % apply a rename list to the used_ids,... information fields |
| 2102 | | % this is more tricky than applying a single identifier, as we first have to deleted all ids |
| 2103 | | % and remember which ones were deleted, and only then insert the corresponding ids |
| 2104 | | % e.g., we could have a RenameList = [rename(p,q),rename(q,p)] ; see test 1776 M1_Internal_v3.mch |
| 2105 | | rename_update_used_ids_info(RenameList,IIn,IOut) :- |
| 2106 | | l_find_rhs_ids(RenameList,RenameList2), |
| 2107 | | %maplist(apply_rename_list(RenameList2),IIn,IOut). |
| 2108 | | l_apply_rename_list(IIn,RenameList2,IOut). |
| 2109 | | |
| 2110 | | l_find_rhs_ids([],[]). |
| 2111 | | l_find_rhs_ids([R1|T],[NR1|NTR]) :- |
| 2112 | | find_rhs_ids(R1,NR1), |
| 2113 | | l_find_rhs_ids(T,NTR). |
| 2114 | | |
| 2115 | | l_apply_rename_list([],_,[]). |
| 2116 | | l_apply_rename_list([Info1|T],RenameList2,[NewInfo1|NTI]) :- |
| 2117 | | apply_rename_list(RenameList2,Info1,NewInfo1), |
| 2118 | | l_apply_rename_list(T,RenameList2,NTI). |
| 2119 | | |
| 2120 | | apply_rename_list(RenameList,I,NI) :- |
| 2121 | | apply_rename_list2(I,RenameList,NI). |
| 2122 | | apply_rename_list2(used_ids(IDS),RenameList,used_ids(NewIDS)) :- !, apply_rename_list_to_ids(RenameList,IDS,[],NewIDS). |
| 2123 | | apply_rename_list2(reads(IDS),RenameList,reads(NewIDS)) :- !, apply_rename_list_to_ids(RenameList,IDS,[],NewIDS). |
| 2124 | | apply_rename_list2(modifies(IDS),RenameList,modifies(NewIDS)) :- !, apply_rename_list_to_ids(RenameList,IDS,[],NewIDS). |
| 2125 | | apply_rename_list2(Info,_,Info). |
| 2126 | | |
| 2127 | | % apply a rename list to a sorted list of ids |
| 2128 | | apply_rename_list_to_ids([],Acc,ToInsert,Res) :- ord_union(Acc,ToInsert,Res). |
| 2129 | | apply_rename_list_to_ids([rename_ids(Id,NewIds)|T],Acc,ToInsert,Res) :- |
| 2130 | | (ord_delete_existing_element(Acc,Id,Acc2) % the Id occurs and is deleted |
| 2131 | | -> ord_union(NewIds,ToInsert,ToInsert2), |
| 2132 | | apply_rename_list_to_ids(T,Acc2,ToInsert2,Res) |
| 2133 | | ; apply_rename_list_to_ids(T,Acc,ToInsert,Res)). |
| 2134 | | |
| 2135 | | ord_delete_existing_element(List,El,ResList) :- % ord_del_element also succeeds if El is not in the list ! |
| 2136 | | ord_intersection([El],List,[El],ResList). |
| 2137 | | % ----------------------- |
| 2138 | | % remove an Identifier from used_ids Info field if it exists |
| 2139 | | remove_used_id_from_info(I,ID_to_remove,NI) :- |
| 2140 | | update_used_ids_info(I,ID_to_remove,[],NI). |
| 2141 | | |
| 2142 | | remove_used_ids_from_info([],I,I). |
| 2143 | | remove_used_ids_from_info([ID_to_remove|T],I,NI) :- remove_used_id_from_info(I,ID_to_remove,I2), |
| 2144 | | remove_used_ids_from_info(T,I2,NI). |
| 2145 | | |
| 2146 | | % remove a single Identifier from used_ids Info field if it exists and insert sorted list of ids instead |
| 2147 | | % a simpler version of rename_update_used_ids_info for a single identifier |
| 2148 | | update_used_ids_info([],_,_,[]). |
| 2149 | | update_used_ids_info([InfoField|T],ID_to_remove,IDsInserted,[NewInfoField|NT]) :- |
| 2150 | | (update_id_from_info_field(ID_to_remove,IDsInserted,InfoField,R) |
| 2151 | | -> NewInfoField=R |
| 2152 | | ; NewInfoField=InfoField), |
| 2153 | | update_used_ids_info(T,ID_to_remove,IDsInserted,NT). |
| 2154 | | |
| 2155 | | update_id_from_info_field(ID_to_remove,IDsInserted,I,NI) :- |
| 2156 | | update_id_from_info_field2(I,ID_to_remove,IDsInserted,NI). |
| 2157 | | update_id_from_info_field2(used_ids(IDS),ID,IDsInserted,used_ids(NewIDS)) :- update_id(IDS,ID,IDsInserted,NewIDS). |
| 2158 | | update_id_from_info_field2(reads(IDS),ID,IDsInserted,reads(NewIDS)) :- update_id(IDS,ID,IDsInserted,NewIDS). |
| 2159 | | update_id_from_info_field2(modifies(IDS),ID,IDsInserted,modifies(NewIDS)) :- update_id(IDS,ID,IDsInserted,NewIDS). |
| 2160 | | |
| 2161 | | update_id(IDS,ID_to_remove,IDsInserted,NewIDS) :- |
| 2162 | | ord_delete_existing_element(IDS,ID_to_remove,IDS2), % the Id occurs and is deleted |
| 2163 | | ord_union(IDsInserted,IDS2,NewIDS). |
| 2164 | | %if ord_del_element fails we do not add IDsInserted: we assume the used_ids info is correct and ID_to_remove does not occur ! |
| 2165 | | % We could use this info to avoid traversing subtree ! |
| 2166 | | % print(projecting_away_unknown_id(ID_to_remove,IDS)),nl, |
| 2167 | | |
| 2168 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2169 | | |
| 2170 | | :- assert_must_succeed((gensym:reset_gensym, bsyntaxtree:exists_ast(A), replace_id_by_expr(A,y,b(identifier(x),integer,[]),RA),translate:translate_bexpression(RA,TR), |
| 2171 | | TR = 'r = {`__FRESH____1`|`__FRESH____1` : 1 .. x & `__FRESH____1` mod 2 = 1}' )). |
| 2172 | | :- assert_must_succeed((bsyntaxtree:parse_pred("{x|x:INTEGER & x>y}={}",T1), |
| 2173 | | replace_id_by_expr(T1,y,b(identifier(x),integer,[]),R), |
| 2174 | | bsyntaxtree:test_result(1,R),bsyntaxtree:parse_pred("{x|x:INTEGER & x>x}={}",T3), |
| 2175 | | \+ same_texpr(R,T3) )). |
| 2176 | | :- assert_must_succeed((bsyntaxtree:parse_pred("{x|x:INTEGER & x>y}={}",T1), bsyntaxtree:parse_expr("100",T2), |
| 2177 | | replace_id_by_expr(T1,y,T2,R),bsyntaxtree:parse_pred("{x|x>100}={}",T3),same_texpr(R,T3) )). |
| 2178 | | |
| 2179 | | % replace an identifier Id by an expression Inserted |
| 2180 | | replace_id_by_expr(TExpr,Id,Inserted,Replaced) :- |
| 2181 | ? | replace_id_by_expr_with_count(TExpr,Id,Inserted,Replaced,_). |
| 2182 | | |
| 2183 | | replace_id_by_expr_with_count(TExpr,Id,Inserted,Replaced,NrReplacements) :- \+ atomic(Id),!, |
| 2184 | | add_internal_error('Id not atomic: ',replace_id_by_expr(TExpr,Id,Inserted,Replaced)), |
| 2185 | | Replaced = TExpr, NrReplacements=0. |
| 2186 | | replace_id_by_expr_with_count(TExpr,Id,Inserted,Replaced,NrReplacements) :- |
| 2187 | | %find_all_relevant_quantified_vars(Id,TExpr,QVars), |
| 2188 | | find_identifier_uses(Inserted,[],SInsUsedIds), % SInsUsedIds is sorted |
| 2189 | ? | replace_id_by_expr2(Id,Inserted,SInsUsedIds,TExpr,Replaced,_WDC,0,NrReplacements). |
| 2190 | | |
| 2191 | | replace_id_by_expr2(Id,Inserted,InsUsedIds,TExpr,Replaced,WDC,InR,OutR) :- |
| 2192 | | remove_bt(TExpr,Expr,NewExpr,TNewExpr), |
| 2193 | | ( Expr = identifier(Id) -> % TODO: count number of replacements |
| 2194 | | Replaced = Inserted, |
| 2195 | | OutR is InR+1, |
| 2196 | | get_texpr_info(Inserted,Infos), |
| 2197 | | (memberchk(contains_wd_condition,Infos) |
| 2198 | | -> WDC = true ; WDC = false) % WDC = true means we have added a wd-condition where previously there was none |
| 2199 | | ; contains_no_ids(Expr) -> Replaced=TExpr, WDC=false, OutR=InR |
| 2200 | | ; |
| 2201 | ? | syntaxtransformation_det(Expr,Subs,Names,NSubs,NewExpr), |
| 2202 | | get_texpr_id(TId,Id), |
| 2203 | | ( memberchk(TId,Names) -> % the Id is now hidden for the inner expressions |
| 2204 | | NSubs=Subs, WDC=false, OutR = InR |
| 2205 | | ; (InsUsedIds \= [], |
| 2206 | | get_texpr_ids(Names,Ns),sort(Ns,SNs), |
| 2207 | | ord_intersection(SNs,InsUsedIds,Captured), |
| 2208 | | Captured \= [] %, print(inter(SNs,InsUsedIds,Captured)),nl |
| 2209 | | ) |
| 2210 | | % The Names introduced clash with variables used in the Inserted expression |
| 2211 | | -> findall(rename(X,FRESHID),(member(X,Captured),gensym:gensym('__FRESH__',FRESHID)),RenameList), |
| 2212 | | %print(rename(RenameList)),nl, |
| 2213 | | rename_bt_l(Subs,RenameList,RenSubs), |
| 2214 | | l_replace_id_by_expr2(RenSubs,Id,Inserted,InsUsedIds,NSubs,WDC,InR,OutR) |
| 2215 | | ; |
| 2216 | ? | l_replace_id_by_expr2(Subs,Id,Inserted,InsUsedIds,NSubs,WDC,InR,OutR) |
| 2217 | | ), |
| 2218 | | TNewExpr = b(E1,T1,Info1), |
| 2219 | | update_used_ids_info(Info1,Id,InsUsedIds,Info2), |
| 2220 | | %(E1 = exists(P,_) -> print(exists(P,Id,Info1,Info2)),nl ; true), |
| 2221 | | add_wd_if_needed(WDC,b(E1,T1,Info2),Replaced) |
| 2222 | | ). |
| 2223 | | |
| 2224 | | l_replace_id_by_expr2([],_,_,_,[],false,R,R). |
| 2225 | | l_replace_id_by_expr2([H|T],Id,Inserted,InsUsedIds,[IH|IT],WDC,InR,OutR) :- |
| 2226 | ? | replace_id_by_expr2(Id,Inserted,InsUsedIds,H,IH,WDC1,InR,InR2), |
| 2227 | ? | l_replace_id_by_expr2(T,Id,Inserted,InsUsedIds,IT,WDC2,InR2,OutR), |
| 2228 | | and_wdc(WDC1,WDC2,WDC). |
| 2229 | | |
| 2230 | | % conjunct wd condition added flag |
| 2231 | | and_wdc(true,_,R) :- !,R=true. |
| 2232 | | and_wdc(_,true,R) :- !, R=true. |
| 2233 | | and_wdc(_,_,false). |
| 2234 | | |
| 2235 | | % add contains_wd_condition if a change occured during replacement of id by expression |
| 2236 | | add_wd_if_needed(true,b(E,T,Infos),Replaced) :- |
| 2237 | | nonmember(contains_wd_condition,Infos), |
| 2238 | | !, |
| 2239 | | Replaced = b(E,T,[contains_wd_condition|Infos]). |
| 2240 | | add_wd_if_needed(_,T,T). |
| 2241 | | |
| 2242 | | |
| 2243 | | |
| 2244 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2245 | | |
| 2246 | | |
| 2247 | | % syntaxtransformation_fixed/7 is the same as syntaxtransformation/5 with the exception |
| 2248 | | % that we distinguish between subexpressions that have the newly introduced identifiers (Names) |
| 2249 | | % in scope (OSubs) and those who don't (OExprs). The only expressions where the latter case is relevant |
| 2250 | | % are let_expression and let_predicate. |
| 2251 | | % TODO: This is a quick'n dirty fix for only some cases. |
| 2252 | | % NO LONGER REQUIRED: let_expression and let_predicate now obey another semantic, not the Z semantics anymore |
| 2253 | | %syntaxtransformation_fixed(OExpr,OExprs,OSubs,Names,NExprs,NSubs,NExpr) :- |
| 2254 | | %syntaxtransformation_fixed(Expr,[],Subs,Names,[],NSubs,NExpr) :- |
| 2255 | | % syntaxtransformation_det(Expr,Subs,Names,NSubs,NExpr). |
| 2256 | | |
| 2257 | | |
| 2258 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2259 | | % rename identifier |
| 2260 | | |
| 2261 | | % r = {x|x : 1..y & x mod 2 = 1} |
| 2262 | | exists_ast(AST) :- AST = |
| 2263 | | b(equal(b(identifier(r),set(integer),[nodeid(none)]), |
| 2264 | | b(comprehension_set([b(identifier(x),integer,[nodeid(none)])], |
| 2265 | | b(conjunct(b(member(b(identifier(x),integer,[nodeid(none)]), |
| 2266 | | b(interval(b(integer(1),integer,[nodeid(none)]),b(identifier(y),integer,[nodeid(none)])), |
| 2267 | | set(integer),[nodeid(none)])),pred,[nodeid(none)]), |
| 2268 | | b(equal(b(modulo(b(identifier(x),integer,[nodeid(none)]), |
| 2269 | | b(integer(2),integer,[nodeid(none)])),integer,[contains_wd_condition,nodeid(none)]), |
| 2270 | | b(integer(1),integer,[nodeid(none)])),pred, |
| 2271 | | [contains_wd_condition,nodeid(none)])),pred,[contains_wd_condition,nodeid(none)])), |
| 2272 | | set(integer),[contains_wd_condition,nodeid(none)])), |
| 2273 | | pred,[contains_wd_condition,nodeid(none)]). |
| 2274 | | |
| 2275 | | :- assert_must_succeed((bsyntaxtree:exists_ast(A), rename_bt(A,[rename(x,xx)],RA), RA==A )). |
| 2276 | | :- assert_must_succeed((bsyntaxtree:exists_ast(A), rename_bt(A,[rename(r,v)],RA), |
| 2277 | | translate:translate_bexpression(RA,TR), TR='v = {x|x : 1 .. y & x mod 2 = 1}' )). |
| 2278 | | :- assert_must_succeed((gensym:reset_gensym, bsyntaxtree:exists_ast(A), rename_bt(A,[rename(y,x)],RA), RA \= A, |
| 2279 | | translate:translate_bexpression(RA,TR), |
| 2280 | | TR = 'r = {`__FRESH____1`|`__FRESH____1` : 1 .. x & `__FRESH____1` mod 2 = 1}' )). |
| 2281 | | |
| 2282 | | % a simplified version of replace_ids_by_exprs, which assumes target of renamings are variables |
| 2283 | | rename_bt(Expr,[],Res) :- !,Res=Expr. |
| 2284 | | rename_bt(OExpr,Renamings,NExpr) :- |
| 2285 | | create_texpr(Old,Type,OInfo,OExpr), |
| 2286 | | create_texpr(New,Type,NInfo,NExpr), |
| 2287 | | rename_in_infos(OInfo,Renamings,NInfo), |
| 2288 | ? | rename_bt2(Old,Renamings,New). |
| 2289 | | rename_bt2(identifier(Old),Renamings,identifier(New)) :- |
| 2290 | | !, rename_id(Old,Renamings,New). |
| 2291 | | rename_bt2(lazy_lookup_expr(Old),Renamings,lazy_lookup_expr(New)) :- |
| 2292 | | !, rename_id(Old,Renamings,New). |
| 2293 | | rename_bt2(lazy_lookup_pred(Old),Renamings,lazy_lookup_pred(New)) :- |
| 2294 | | !, rename_id(Old,Renamings,New). |
| 2295 | | rename_bt2(OExpr,Renamings,NExpr) :- |
| 2296 | ? | syntaxtransformation_for_renaming(OExpr,Subs,TNames,NSubs,NExpr), |
| 2297 | | get_texpr_exprs(TNames,Names), |
| 2298 | | remove_renamings(Names,Renamings,NRenamings), |
| 2299 | ? | rename_bt_l(Subs,NRenamings,NSubs). |
| 2300 | | rename_bt_l([],_,[]). |
| 2301 | | rename_bt_l([Old|ORest],Renamings,[New|NRest]) :- |
| 2302 | ? | rename_bt(Old,Renamings,New), |
| 2303 | ? | rename_bt_l(ORest,Renamings,NRest). |
| 2304 | | |
| 2305 | | % syntaxtransformation rule for operation_call_in_expr does not show Id field in sub expressions |
| 2306 | | % (to avoid issues with find_identifier_uses, see below) |
| 2307 | | % so here we explicitly also rename the operation name if required, relevant for bmachine_construction, test 2504 |
| 2308 | | % TODO: avoid this special case and fix find_identifier_uses instead |
| 2309 | | syntaxtransformation_for_renaming(operation_call_in_expr(ID,Subs1),Subs,TNames,NSubs,NExpr) :- !, |
| 2310 | | NExpr = operation_call_in_expr(NID,NSubs1), |
| 2311 | | Subs = [ID|Subs1], |
| 2312 | | NSubs = [NID|NSubs1], TNames = []. |
| 2313 | | syntaxtransformation_for_renaming(OExpr,Subs,TNames,NSubs,NExpr) :- |
| 2314 | ? | syntaxtransformation(OExpr,Subs,TNames,NSubs,NExpr). |
| 2315 | | |
| 2316 | | remove_renamings([],Renamings,Renamings). |
| 2317 | | remove_renamings([identifier(Name)|Rest],Old,New) :- |
| 2318 | | ( select(rename(Name,_),Old,Inter1) -> true % Name no longer visible to renaming |
| 2319 | | ; Old = Inter1), |
| 2320 | | (member(rename(_OldName,Name),Inter1) -> |
| 2321 | | gensym('__FRESH__',FRESHID), |
| 2322 | | %print(variable_capture_in_rename(Name,from(OldName),FRESHID)),nl, |
| 2323 | | Inter2 = [rename(Name,FRESHID)|Inter1] |
| 2324 | | ; Inter2 = Inter1), |
| 2325 | | remove_renamings(Rest,Inter2,New). |
| 2326 | | |
| 2327 | | rename_in_infos(Old,Renamings,New) :- |
| 2328 | | ( has_info_to_rename(Old) -> |
| 2329 | | maplist(rename_in_infos2(Renamings),Old,New) |
| 2330 | | ; |
| 2331 | | Old = New). |
| 2332 | | rename_in_infos2(Renamings,OInfo,NInfo) :- |
| 2333 | | ( infos_to_rename(OInfo,OIds,SortedNIds,NInfo) -> |
| 2334 | | rename_ids(OIds,Renamings,NIds), |
| 2335 | | sort(NIds,SortedNIds) |
| 2336 | | ; |
| 2337 | | OInfo = NInfo). |
| 2338 | | |
| 2339 | | rename_ids([],_,[]). |
| 2340 | | rename_ids([OId|Orest],Renamings,[NId|Nrest]) :- |
| 2341 | | rename_id(OId,Renamings,NId), |
| 2342 | | rename_ids(Orest,Renamings,Nrest). |
| 2343 | | rename_id(Old,Renamings,New) :- |
| 2344 | | ( memberchk(rename(Old,New),Renamings) -> true % we could use ord_member if we sort ! |
| 2345 | | ; Old=New). |
| 2346 | | |
| 2347 | | has_info_to_rename(Infos) :- |
| 2348 | ? | member(I,Infos),infos_to_rename(I,_,_,_),!. |
| 2349 | | |
| 2350 | | infos_to_rename(modifies(O),O,N,modifies(N)). |
| 2351 | | infos_to_rename(reads(O),O,N,reads(N)). |
| 2352 | | infos_to_rename(non_det_modifies(O),O,N,non_det_modifies(N)). |
| 2353 | | infos_to_rename(modifies_locals(O),O,N,modifies_locals(N)). |
| 2354 | | infos_to_rename(reads_locals(O),O,N,reads_locals(N)). |
| 2355 | | infos_to_rename(used_ids(O),O,N,used_ids(N)). |
| 2356 | | %infos_to_rename(lambda_result(O),[O],[N],lambda_result(N)). % whould we no longer assume that we have lambda result, as predicate has possibly changed!? |
| 2357 | | |
| 2358 | | |
| 2359 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2360 | | % remove type information for transformations |
| 2361 | | |
| 2362 | | remove_bt(b(Expr,Type,Infos),Expr,NExpr,b(NExpr,Type,Infos)). |
| 2363 | | |
| 2364 | | remove_bt_and_used_ids(b(OldExpr,T,Infos),OldExpr,NewExpr,b(NewExpr,T,NewInfos)) :- |
| 2365 | | delete(Infos,used_ids(_),NewInfos). % invalidate used_ids info |
| 2366 | | |
| 2367 | | %remove_bt_l([],[],[],[]). |
| 2368 | | %remove_bt_l([OT|OTRest],[O|ORest],[N|NRest],[NT|NTRest]) :- |
| 2369 | | % remove_bt(OT,O,N,NT), |
| 2370 | | % remove_bt_l(OTRest,ORest,NRest,NTRest). |
| 2371 | | |
| 2372 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2373 | | % traversations |
| 2374 | | % Takes a predicate or expression or substitution and extracts: |
| 2375 | | % the expression itself Expr, its type Type, the syntaxnode information Infos |
| 2376 | | % + the subexpressions as a list Subs and the local identifiers declared |
| 2377 | | syntaxtraversion(b(Expr,Type,Infos),Expr,Type,Infos,Subs,Names) :- !, |
| 2378 | | safe_syntaxelement(Expr,Subs,Names,_,_). |
| 2379 | | syntaxtraversion(IExpr,Expr,Type,Infos,Subs,Names) :- |
| 2380 | | add_internal_error('Not properly wrapped', syntaxtraversion(IExpr,Expr,Type,Infos,Subs,Names)), |
| 2381 | | fail. |
| 2382 | | |
| 2383 | | |
| 2384 | | map_over_full_bexpr_no_fail(P,BExpr) :- |
| 2385 | | syntaxtraversion(BExpr,Expr,_,_,Subs,_TNames), |
| 2386 | | call(P,Expr), % the predicate should not fail |
| 2387 | | (Subs=[] -> true ; maplist(map_over_full_bexpr_no_fail(P),Subs)). |
| 2388 | | |
| 2389 | | map_over_bexpr(P,BExpr) :- |
| 2390 | | syntaxtraversion(BExpr,Expr,_,_,Subs,_TNames), |
| 2391 | | (call(P,Expr) % should probably fail so that by backtrack we recurse |
| 2392 | | ; |
| 2393 | ? | member(Sub,Subs), map_over_bexpr(P,Sub) |
| 2394 | | ). |
| 2395 | | % same as above but gets typed expressions: |
| 2396 | | map_over_typed_bexpr(P,BExpr) :- |
| 2397 | | syntaxtraversion(BExpr,_Expr,_,_,Subs,_TNames), |
| 2398 | | (call(P,BExpr) |
| 2399 | | ; |
| 2400 | ? | member(Sub,Subs), map_over_typed_bexpr(P,Sub) |
| 2401 | | ). |
| 2402 | | % same as above but returns value: |
| 2403 | | map_over_typed_bexpr(P,BExpr,Result) :- |
| 2404 | | syntaxtraversion(BExpr,_Expr,_,_,Subs,_TNames), |
| 2405 | | (call(P,BExpr,Result) |
| 2406 | | ; |
| 2407 | ? | member(Sub,Subs), map_over_typed_bexpr(P,Sub,Result) |
| 2408 | | ). |
| 2409 | | % this one gets TNames (locally introduced variables as parameter) |
| 2410 | | map_over_typed_bexpr_with_names(P,BExpr) :- |
| 2411 | | syntaxtraversion(BExpr,_Expr,_,_,Subs,TNames), |
| 2412 | | (call(P,BExpr,TNames) |
| 2413 | | ; |
| 2414 | | member(Sub,Subs), map_over_typed_bexpr_with_names(P,Sub) |
| 2415 | | ). |
| 2416 | | |
| 2417 | | % same as map_over_expr but provides an accumulator passed top-down to children; needs to be used by failure driven loop |
| 2418 | | |
| 2419 | | map_over_bexpr_top_down_acc(P,BExpr,TDAcc) :- |
| 2420 | | syntaxtraversion(BExpr,Expr,_,_,Subs,_TNames), |
| 2421 | | (call(P,Expr,TDAcc,NewAcc) |
| 2422 | | -> member(Sub,Subs), map_over_bexpr_top_down_acc(P,Sub,NewAcc) |
| 2423 | | ; member(Sub,Subs), map_over_bexpr_top_down_acc(P,Sub,TDAcc) |
| 2424 | | ). |
| 2425 | | % now a version which gets the typed predicate as argument |
| 2426 | | |
| 2427 | | map_over_typed_bexpr_top_down_acc(P,BExpr,TDAcc) :- |
| 2428 | | syntaxtraversion(BExpr,_Expr,_,_,Subs,_TNames), |
| 2429 | | (call(P,BExpr,TDAcc,NewAcc) |
| 2430 | | -> member(Sub,Subs), map_over_typed_bexpr_top_down_acc(P,Sub,NewAcc) |
| 2431 | | ; member(Sub,Subs), map_over_typed_bexpr_top_down_acc(P,Sub,TDAcc) |
| 2432 | | ). |
| 2433 | | |
| 2434 | | % predicate P has 3 arguments: (Expr,ValueSoFar,NewValue) |
| 2435 | | reduce_over_bexpr(P,BExpr,InitialValue,ResultValue) :- |
| 2436 | | syntaxtraversion(BExpr,Expr,_,_,Subs,_TNames), |
| 2437 | | call(P,Expr,InitialValue,I1), % print(reduce(P,Expr,InitialValue,I1)),nl, |
| 2438 | | scanlist(reduce_over_bexpr(P),Subs,I1,ResultValue). |
| 2439 | | |
| 2440 | | % apply a predicate over a syntax tree (bottom-up) |
| 2441 | | |
| 2442 | | transform_bexpr(Pred,b(Expr,Type,Info),NewBExpr) :- !, |
| 2443 | ? | syntaxtransformation(Expr,Subs,_Names,NSubs,NewExpr1), |
| 2444 | ? | l_transform_bexpr(Subs,Pred,NSubs), |
| 2445 | | (call(Pred,b(NewExpr1,Type,Info),NewBExpr) -> true ; NewBExpr = b(NewExpr1,Type,Info)). |
| 2446 | | transform_bexpr(Pred,Expr,NewBExpr) :- |
| 2447 | | add_internal_error('Expression not properly wrapped:',transform_bexpr(Pred,Expr,NewBExpr)), |
| 2448 | | fail. |
| 2449 | | |
| 2450 | | l_transform_bexpr([],_,[]). |
| 2451 | | l_transform_bexpr([SubH|T],Pred,[TSubH|TT]) :- |
| 2452 | ? | transform_bexpr(Pred,SubH,TSubH), |
| 2453 | ? | l_transform_bexpr(T,Pred,TT). |
| 2454 | | |
| 2455 | | % apply a predicate over a syntax tree (bottom-up), and provide scoping info about local ids |
| 2456 | | |
| 2457 | | transform_bexpr_with_scoping(Pred,BExpr,NewBExpr) :- |
| 2458 | | transform_bexpr_with_scoping2(Pred,BExpr,NewBExpr,[]). |
| 2459 | | transform_bexpr_with_scoping2(Pred,b(Expr,Type,Info),NewBExpr,LocalIds) :- |
| 2460 | | syntaxtransformation(Expr,Subs,Names,NSubs,NewExpr1), |
| 2461 | | get_texpr_ids(Names,QuantifiedNewIds), list_to_ord_set(QuantifiedNewIds,SQuantifiedNewIds), |
| 2462 | | ord_union(LocalIds,SQuantifiedNewIds,NewLocalIds), |
| 2463 | | l_transform_bexpr_with_scoping(Subs,Pred,NSubs,NewLocalIds), |
| 2464 | | (call(Pred,b(NewExpr1,Type,Info),NewBExpr,LocalIds) -> true ; NewBExpr = b(NewExpr1,Type,Info)). |
| 2465 | | |
| 2466 | | l_transform_bexpr_with_scoping([],_,[],_). |
| 2467 | | l_transform_bexpr_with_scoping([SubH|T],Pred,[TSubH|TT],LocalIds) :- |
| 2468 | | transform_bexpr_with_scoping2(Pred,SubH,TSubH,LocalIds), |
| 2469 | | l_transform_bexpr_with_scoping(T,Pred,TT,LocalIds). |
| 2470 | | |
| 2471 | | % transform a predicate top-down with scoping infos |
| 2472 | | % if Pred succeeds the top-down traversal stops |
| 2473 | | transform_bexpr_td_with_scoping(Pred,BExpr,NewBExpr) :- |
| 2474 | ? | transform_bexpr_td_with_scoping2(Pred,BExpr,NewBExpr,[]). |
| 2475 | | transform_bexpr_td_with_scoping2(Pred,b(Expr,Type,Info),b(NewExpr1,Type,Info),LocalIds) :- |
| 2476 | ? | (call(Pred,Expr,NewExpr1,LocalIds) |
| 2477 | | -> true |
| 2478 | ? | ; syntaxtransformation(Expr,Subs,Names,NSubs,NewExpr1), |
| 2479 | | get_texpr_ids(Names,QuantifiedNewIds), list_to_ord_set(QuantifiedNewIds,SQuantifiedNewIds), |
| 2480 | | ord_union(LocalIds,SQuantifiedNewIds,NewLocalIds), |
| 2481 | ? | l_transform_bexpr_td_with_scoping(Subs,Pred,NSubs,NewLocalIds) |
| 2482 | | ). |
| 2483 | | |
| 2484 | | l_transform_bexpr_td_with_scoping([],_,[],_). |
| 2485 | | l_transform_bexpr_td_with_scoping([SubH|T],Pred,[TSubH|TT],LocalIds) :- |
| 2486 | ? | transform_bexpr_td_with_scoping2(Pred,SubH,TSubH,LocalIds), |
| 2487 | ? | l_transform_bexpr_td_with_scoping(T,Pred,TT,LocalIds). |
| 2488 | | |
| 2489 | | |
| 2490 | | % apply a predicate over a syntax tree (bottom-up) with Accumulator result |
| 2491 | | % Accumulator is constructed bottom up; Pred receives *all* accumulators of sub expressions |
| 2492 | | |
| 2493 | | transform_bexpr_with_bup_accs(Pred,b(Expr,Type,Info),NewBExpr,EmptyAcc,Acc) :- |
| 2494 | | syntaxtransformation(Expr,Subs,_Names,NSubs,NewExpr1), |
| 2495 | | l_transform_bexpr_with_bup_accs(Subs,Pred,NSubs,EmptyAcc,SubAccs), |
| 2496 | | (call(Pred,b(NewExpr1,Type,Info),NewBExpr,SubAccs,Acc) -> true |
| 2497 | | ; NewBExpr = b(NewExpr1,Type,Info), Acc = EmptyAcc). |
| 2498 | | |
| 2499 | | l_transform_bexpr_with_bup_accs([],_,[],_,[]). |
| 2500 | | l_transform_bexpr_with_bup_accs([SubH|T],Pred,[TSubH|TT],EmptyAcc,[Acc1|RestAcc]) :- |
| 2501 | | transform_bexpr_with_bup_accs(Pred,SubH,TSubH,EmptyAcc,Acc1), |
| 2502 | | l_transform_bexpr_with_bup_accs(T,Pred,TT,EmptyAcc,RestAcc). |
| 2503 | | |
| 2504 | | % apply a predicate over a syntax tree (bottom-up) with Accumulator result |
| 2505 | | % a single Accumulator is passed along |
| 2506 | | |
| 2507 | | transform_bexpr_with_acc(_Pred,E,NewBExpr,InAcc,Acc) :- var(E),!, |
| 2508 | | NewBExpr=E, Acc=InAcc. |
| 2509 | | transform_bexpr_with_acc(Pred,b(Expr,Type,Info),NewBExpr,InAcc,Acc) :- |
| 2510 | | syntaxtransformation(Expr,Subs,_Names,NSubs,NewExpr1), |
| 2511 | | l_transform_bexpr_with_acc(Subs,Pred,NSubs,InAcc,SubAcc), |
| 2512 | | (call(Pred,b(NewExpr1,Type,Info),NewBExpr,SubAcc,Acc) -> true |
| 2513 | | ; NewBExpr = b(NewExpr1,Type,Info), Acc = SubAcc). |
| 2514 | | |
| 2515 | | l_transform_bexpr_with_acc([],_,[],Acc,Acc). |
| 2516 | | l_transform_bexpr_with_acc([SubH|T],Pred,[TSubH|TT],InAcc,ResAcc) :- |
| 2517 | | transform_bexpr_with_acc(Pred,SubH,TSubH,InAcc,Acc1), |
| 2518 | | l_transform_bexpr_with_acc(T,Pred,TT,Acc1,ResAcc). |
| 2519 | | |
| 2520 | | % a non-deterministic version of this |
| 2521 | | non_det_transform_bexpr_with_acc(_Pred,E,NewBExpr,InAcc,Acc) :- var(E),!, |
| 2522 | | NewBExpr=E, Acc=InAcc. |
| 2523 | | non_det_transform_bexpr_with_acc(Pred,b(Expr,Type,Info),NewBExpr,InAcc,Acc) :- |
| 2524 | | syntaxtransformation(Expr,Subs,_Names,NSubs,NewExpr1), |
| 2525 | | l_nd_transform_bexpr_with_acc(Subs,Pred,NSubs,InAcc,SubAcc), |
| 2526 | | if(call(Pred,b(NewExpr1,Type,Info),NewBExpr,SubAcc,Acc), |
| 2527 | | true, |
| 2528 | | (NewBExpr = b(NewExpr1,Type,Info), Acc = SubAcc)). |
| 2529 | | |
| 2530 | | l_nd_transform_bexpr_with_acc([],_,[],Acc,Acc). |
| 2531 | | l_nd_transform_bexpr_with_acc([SubH|T],Pred,[TSubH|TT],InAcc,ResAcc) :- |
| 2532 | | non_det_transform_bexpr_with_acc(Pred,SubH,TSubH,InAcc,Acc1), |
| 2533 | | l_nd_transform_bexpr_with_acc(T,Pred,TT,Acc1,ResAcc). |
| 2534 | | |
| 2535 | | |
| 2536 | | % ------------------------- |
| 2537 | | |
| 2538 | | min_max_integer_value_used(BExpr,Min,Max) :- |
| 2539 | | min_max_integer_value_used(BExpr,none,none,Min,Max). |
| 2540 | | min_max_integer_value_used(BExpr,IMin,IMax,Min,Max) :- |
| 2541 | | reduce_over_bexpr(min_max_aux,BExpr,minmax(IMin,IMax),minmax(Min,Max)). |
| 2542 | | |
| 2543 | | min_max_aux(sequence_extension(L),minmax(Min,Max),minmax(NMin,NMax)) :- !, |
| 2544 | | length(L,Len), % we use implicitly numbers from 1..Len |
| 2545 | | (number(Min),1>Min -> NMin=Min ; NMin=1), |
| 2546 | | (number(Max),Len<Max -> NMax=Max ; NMax=Len). |
| 2547 | | min_max_aux(integer(N),minmax(Min,Max),minmax(NMin,NMax)) :- !, |
| 2548 | | (number(Min),N>Min -> NMin=Min ; NMin=N), |
| 2549 | | (number(Max),N<Max -> NMax=Max ; NMax=N). |
| 2550 | | min_max_aux(_,V,V). |
| 2551 | | |
| 2552 | | % check if a B expression uses something like NAT,NAT1,INT, MAXINT or MININT. |
| 2553 | | uses_implementable_integers(BExpr) :- |
| 2554 | | map_over_bexpr(uses_implementable_integers_aux,BExpr). |
| 2555 | | |
| 2556 | | uses_implementable_integers_aux(maxint). |
| 2557 | | uses_implementable_integers_aux(minint). |
| 2558 | | uses_implementable_integers_aux(integer_set(X)) :- |
| 2559 | | (X='NAT1' ; X='NAT' ; X='INT'). |
| 2560 | | |
| 2561 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2562 | | % some checks |
| 2563 | | check_if_typed_predicate(b(Pred,X,_)) :- ground(X), X=pred, % at runtime there can be value(X) with variables inside ! |
| 2564 | | syntaxelement(Pred,_,_,_,_,TypePred), (TypePred=pred -> true ; TypePred = pred/only_typecheck). |
| 2565 | | check_if_typed_expression(b(Expr,Type,_)) :- |
| 2566 | | syntaxelement(Expr,_,_,_,_,TypeExpr), |
| 2567 | | (TypeExpr=expr -> true ; TypeExpr = expr/only_typecheck), |
| 2568 | | Type \== pred, Type \== subst, ground(Type). |
| 2569 | | check_if_typed_substitution(b(Subst,X,_)) :- ground(X), X=subst, |
| 2570 | | syntaxelement(Subst,_,_,_,_,subst). |
| 2571 | | |
| 2572 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2573 | | % transformations |
| 2574 | | |
| 2575 | | syntaxtransformation(Expr,Subs,Names,NSubs,NExpr) :- |
| 2576 | | functor(Expr,F,Arity), |
| 2577 | | functor(NExpr,F,Arity), |
| 2578 | | safe_syntaxelement(Expr,Subs,Names,Lists,Constant), |
| 2579 | | all_same_length(Lists,NLists), |
| 2580 | ? | syntaxelement(NExpr,NSubs,_,NLists,Constant,_). |
| 2581 | | % a faster non-backtracking version: |
| 2582 | | syntaxtransformation_det(Expr,Subs,Names,NSubs,NExpr) :- |
| 2583 | | functor(Expr,F,Arity), |
| 2584 | | functor(NExpr,F,Arity), |
| 2585 | | safe_syntaxelement_det(Expr,Subs,Names,Lists,Constant), |
| 2586 | | all_same_length(Lists,NLists), |
| 2587 | ? | syntaxelement(NExpr,NSubs,_,NLists,Constant,_). |
| 2588 | | |
| 2589 | | |
| 2590 | | safe_syntaxelement(Expr,Subs,Names,Lists,Constant) :- |
| 2591 | | ( syntaxelement(Expr,SubsX,NamesX,Lists,ConstantX,_) -> |
| 2592 | | Subs=SubsX, Names=NamesX, Constant=ConstantX |
| 2593 | | %(Subs,Names,Constant)=(SubsX,NamesX,ConstantX) |
| 2594 | | ; |
| 2595 | | functor(Expr,F,Arity), |
| 2596 | | add_error_fail(bsyntaxtree,'Uncovered syntax element: ', F/Arity) |
| 2597 | | ). |
| 2598 | | % a faster non-backtracking version of safe_syntaxelement, assuming Subs, Names, ... are fresh vars |
| 2599 | | safe_syntaxelement_det(Expr,Subs,Names,Lists,Constant) :- |
| 2600 | | (syntaxelement(Expr,Subs,Names,Lists,Constant,_) -> true |
| 2601 | | ; functor(Expr,F,Arity), |
| 2602 | | add_error_fail(bsyntaxtree,'Uncovered syntax element: ', F/Arity)). |
| 2603 | | |
| 2604 | | is_subst_syntaxelement(Subst) :- |
| 2605 | | syntaxelement(Subst,_,_,_,_,subst). |
| 2606 | | |
| 2607 | | % check if we have a syntax node without parameters |
| 2608 | | is_syntax_constant(Expr) :- atom(Expr), syntaxelement(Expr,_,_,_,_,_). |
| 2609 | | |
| 2610 | | % syntaxelement(Expr,SubExprs,Identifiers,Lists,Constant,Type): |
| 2611 | | % Expr: the expression itself |
| 2612 | | % SubExprs: a list of sub-expressions |
| 2613 | | % Identifiers: a list of identifiers that are newly introduced (e.g. by a quantifier) |
| 2614 | | % Lists: A list of lists in the expression, to prevent infinite loops when having variable parts |
| 2615 | | % Constant: A part of the expression that is not a sub-expression (e.g. the number in integer(...)) |
| 2616 | | % Type: Fundamental type of the element (predicate, expression, etc) |
| 2617 | | |
| 2618 | | % predicates |
| 2619 | | syntaxelement(truth, [], [], [], [], pred). |
| 2620 | | syntaxelement(falsity, [], [], [], [], pred). |
| 2621 | | syntaxelement(unknown_truth_value(Msg),[], [], [], Msg, pred). % artificial, e.g., created by well_def_analyser |
| 2622 | | syntaxelement(conjunct(A,B), [A,B],[], [], [], pred). |
| 2623 | | %syntaxelement(conjunct(As), As, [], [], [], pred). % TO DO: support associative version of conjunct |
| 2624 | | syntaxelement(negation(A), [A], [], [], [], pred). |
| 2625 | | syntaxelement(disjunct(A,B), [A,B],[], [], [], pred). |
| 2626 | | syntaxelement(implication(A,B), [A,B],[], [], [], pred). |
| 2627 | | syntaxelement(equivalence(A,B), [A,B],[], [], [], pred). |
| 2628 | | syntaxelement(equal(A,B), [A,B],[], [], [], pred). |
| 2629 | | syntaxelement(not_equal(A,B), [A,B],[], [], [], pred). |
| 2630 | | syntaxelement(member(A,B), [A,B],[], [], [], pred). |
| 2631 | | syntaxelement(not_member(A,B), [A,B],[], [], [], pred). |
| 2632 | | syntaxelement(subset(A,B), [A,B],[], [], [], pred). |
| 2633 | | syntaxelement(subset_strict(A,B), [A,B],[], [], [], pred). |
| 2634 | | syntaxelement(not_subset(A,B), [A,B],[], [], [], pred). |
| 2635 | | syntaxelement(not_subset_strict(A,B),[A,B],[], [], [], pred). |
| 2636 | | syntaxelement(less_equal(A,B), [A,B],[], [], [], pred). |
| 2637 | | syntaxelement(less(A,B), [A,B],[], [], [], pred). |
| 2638 | | syntaxelement(less_equal_real(A,B), [A,B],[], [], [], pred). |
| 2639 | | syntaxelement(less_real(A,B), [A,B],[], [], [], pred). |
| 2640 | | syntaxelement(greater_equal(A,B), [A,B],[], [], [], pred). |
| 2641 | | syntaxelement(greater(A,B), [A,B],[], [], [], pred). |
| 2642 | | syntaxelement(forall(Ids,D,P), [D,P|Ids],Ids,[Ids], [], pred). |
| 2643 | | syntaxelement(exists(Ids,P), [P|Ids], Ids,[Ids], [], pred). |
| 2644 | | syntaxelement(finite(A), [A], [], [], [], pred/only_typecheck). |
| 2645 | | syntaxelement(partition(S,Es), [S|Es],[],[Es],[],pred). |
| 2646 | | syntaxelement(kodkod(PId,Ids), Ids,[],[Ids],PId, pred). |
| 2647 | | syntaxelement(external_pred_call(F,Args),Args,[],[Args],F,pred). |
| 2648 | | |
| 2649 | | % expressions |
| 2650 | | syntaxelement(value(V), [], [], [], V, expr). |
| 2651 | | syntaxelement(operation_call_in_expr(Id,As), As, [], [As], Id, expr). % Do not treat Id as a sub-expression for find_identifier_uses, ... |
| 2652 | | %syntaxelement(operation_call_in_expr(Id,As), [Id|As], [], [As], [], expr). % was like this, but changed to avoid op(.) ids in find_identifier_uses |
| 2653 | | syntaxelement(boolean_true, [], [], [], [], expr). |
| 2654 | | syntaxelement(boolean_false, [], [], [], [], expr). |
| 2655 | | syntaxelement(max_int, [], [], [], [], expr). |
| 2656 | | syntaxelement(min_int, [], [], [], [], expr). |
| 2657 | | syntaxelement(empty_set, [], [], [], [], expr). |
| 2658 | | syntaxelement(bool_set, [], [], [], [], expr). |
| 2659 | | syntaxelement(float_set, [], [], [], [], expr). |
| 2660 | | syntaxelement(real(I), [], [], [], I, expr). |
| 2661 | | syntaxelement(real_set, [], [], [], [], expr). |
| 2662 | | syntaxelement(string_set, [], [], [], [], expr). |
| 2663 | | syntaxelement(convert_bool(A), [A], [], [], [], expr). |
| 2664 | | syntaxelement(convert_real(A), [A], [], [], [], expr). |
| 2665 | | syntaxelement(convert_int_floor(A), [A], [], [], [], expr). |
| 2666 | | syntaxelement(convert_int_ceiling(A), [A], [], [], [], expr). |
| 2667 | | syntaxelement(add(A,B), [A,B],[], [], [], expr). |
| 2668 | | syntaxelement(add_real(A,B), [A,B],[], [], [], expr). |
| 2669 | | syntaxelement(minus(A,B), [A,B],[], [], [], expr). |
| 2670 | | syntaxelement(minus_real(A,B), [A,B],[], [], [], expr). |
| 2671 | | syntaxelement(minus_or_set_subtract(A,B),[A,B],[], [], [], expr/only_typecheck). |
| 2672 | | syntaxelement(unary_minus(A), [A], [], [], [], expr). |
| 2673 | | syntaxelement(unary_minus_real(A), [A], [], [], [], expr). |
| 2674 | | syntaxelement(multiplication(A,B), [A,B],[], [], [], expr). |
| 2675 | | syntaxelement(multiplication_real(A,B),[A,B],[], [], [], expr). |
| 2676 | | syntaxelement(mult_or_cart(A,B), [A,B],[], [], [], expr/only_typecheck). |
| 2677 | | syntaxelement(cartesian_product(A,B), [A,B],[], [], [], expr). |
| 2678 | | syntaxelement(div(A,B), [A,B],[], [], [], expr). |
| 2679 | | syntaxelement(div_real(A,B), [A,B],[], [], [], expr). |
| 2680 | | syntaxelement(floored_div(A,B), [A,B],[], [], [], expr). |
| 2681 | | syntaxelement(modulo(A,B), [A,B],[], [], [], expr). |
| 2682 | | syntaxelement(power_of(A,B), [A,B],[], [], [], expr). |
| 2683 | | syntaxelement(power_of_real(A,B), [A,B],[], [], [], expr). |
| 2684 | | syntaxelement(successor, [], [], [], [], expr). |
| 2685 | | syntaxelement(predecessor, [], [], [], [], expr). |
| 2686 | | syntaxelement(max(A), [A], [], [], [], expr). |
| 2687 | | syntaxelement(max_real(A), [A], [], [], [], expr). |
| 2688 | | syntaxelement(min(A), [A], [], [], [], expr). |
| 2689 | | syntaxelement(min_real(A), [A], [], [], [], expr). |
| 2690 | | syntaxelement(card(A), [A], [], [], [], expr). |
| 2691 | | syntaxelement(couple(A,B), [A,B],[], [], [], expr). |
| 2692 | | syntaxelement(pow_subset(A), [A], [], [], [], expr). |
| 2693 | | syntaxelement(pow1_subset(A), [A], [], [], [], expr). |
| 2694 | | syntaxelement(fin_subset(A), [A], [], [], [], expr). |
| 2695 | | syntaxelement(fin1_subset(A), [A], [], [], [], expr). |
| 2696 | | syntaxelement(interval(A,B), [A,B],[], [], [], expr). |
| 2697 | | syntaxelement(union(A,B), [A,B],[], [], [], expr). |
| 2698 | | syntaxelement(intersection(A,B), [A,B],[], [], [], expr). |
| 2699 | | syntaxelement(set_subtraction(A,B), [A,B],[], [], [], expr). |
| 2700 | | syntaxelement(general_union(A), [A], [], [], [], expr). |
| 2701 | | syntaxelement(general_intersection(A), [A] , [], [], [], expr). |
| 2702 | | syntaxelement(relations(A,B), [A,B],[], [], [], expr). |
| 2703 | | syntaxelement(identity(A), [A], [], [], [], expr). |
| 2704 | | syntaxelement(event_b_identity, [], [], [], [], expr). % for Rodin 1.0, TO DO: Daniel please check |
| 2705 | | syntaxelement(reverse(A), [A], [], [], [], expr). |
| 2706 | | syntaxelement(first_projection(A,B), [A,B],[], [], [], expr/only_typecheck). |
| 2707 | | syntaxelement(first_of_pair(A), [A], [], [], [], expr). |
| 2708 | | syntaxelement(event_b_first_projection(A),[A], [], [], [], expr/only_typecheck). |
| 2709 | | syntaxelement(event_b_first_projection_v2,[], [], [], [], expr/only_typecheck). % for Rodin 1.0, TO DO: Daniel please check |
| 2710 | | syntaxelement(second_projection(A,B), [A,B],[], [], [], expr/only_typecheck). |
| 2711 | | syntaxelement(event_b_second_projection_v2,[], [], [], [], expr/only_typecheck). % for Rodin 1.0, TO DO: Daniel please check |
| 2712 | | syntaxelement(second_of_pair(A), [A], [], [], [], expr). |
| 2713 | | syntaxelement(event_b_second_projection(A),[A], [], [], [], expr/only_typecheck). |
| 2714 | | syntaxelement(composition(A,B), [A,B],[], [], [], expr). |
| 2715 | | syntaxelement(ring(A,B), [A,B],[], [], [], expr/only_typecheck). |
| 2716 | | syntaxelement(direct_product(A,B), [A,B],[], [], [], expr). |
| 2717 | | syntaxelement(parallel_product(A,B), [A,B],[], [], [], expr). |
| 2718 | | syntaxelement(trans_function(A), [A], [], [], [], expr). |
| 2719 | | syntaxelement(trans_relation(A), [A], [], [], [], expr). |
| 2720 | | syntaxelement(iteration(A,B), [A,B],[], [], [], expr). |
| 2721 | | syntaxelement(reflexive_closure(A), [A], [], [], [], expr). |
| 2722 | | syntaxelement(closure(A), [A], [], [], [], expr). |
| 2723 | | syntaxelement(domain(A), [A], [], [], [], expr). |
| 2724 | | syntaxelement(range(A), [A], [], [], [], expr). |
| 2725 | | syntaxelement(image(A,B), [A,B],[], [], [], expr). |
| 2726 | | syntaxelement(domain_restriction(A,B), [A,B],[], [], [], expr). |
| 2727 | | syntaxelement(domain_subtraction(A,B), [A,B],[], [], [], expr). |
| 2728 | | syntaxelement(range_restriction(A,B), [A,B],[], [], [], expr). |
| 2729 | | syntaxelement(range_subtraction(A,B), [A,B],[], [], [], expr). |
| 2730 | | syntaxelement(overwrite(A,B), [A,B],[], [], [], expr). |
| 2731 | | syntaxelement(partial_function(A,B), [A,B],[], [], [], expr). |
| 2732 | | syntaxelement(total_function(A,B), [A,B],[], [], [], expr). |
| 2733 | | syntaxelement(partial_injection(A,B), [A,B],[], [], [], expr). |
| 2734 | | syntaxelement(total_injection(A,B), [A,B],[], [], [], expr). |
| 2735 | | syntaxelement(partial_surjection(A,B), [A,B],[], [], [], expr). |
| 2736 | | syntaxelement(total_surjection(A,B), [A,B],[], [], [], expr). |
| 2737 | | syntaxelement(total_bijection(A,B), [A,B],[], [], [], expr). |
| 2738 | | syntaxelement(partial_bijection(A,B), [A,B],[], [], [], expr). |
| 2739 | | syntaxelement(total_relation(A,B), [A,B],[], [], [], expr). |
| 2740 | | syntaxelement(surjection_relation(A,B),[A,B],[], [], [], expr). |
| 2741 | | syntaxelement(total_surjection_relation(A,B),[A,B],[], [], [], expr). |
| 2742 | | syntaxelement(seq(A), [A], [], [], [], expr). |
| 2743 | | syntaxelement(seq1(A), [A], [], [], [], expr). |
| 2744 | | syntaxelement(iseq(A), [A], [], [], [], expr). |
| 2745 | | syntaxelement(iseq1(A), [A], [], [], [], expr). |
| 2746 | | syntaxelement(perm(A), [A], [], [], [], expr). |
| 2747 | | syntaxelement(empty_sequence, [], [], [], [], expr). |
| 2748 | | syntaxelement(size(A), [A], [], [], [], expr). |
| 2749 | | syntaxelement(first(A), [A], [], [], [], expr). |
| 2750 | | syntaxelement(last(A), [A], [], [], [], expr). |
| 2751 | | syntaxelement(front(A), [A], [], [], [], expr). |
| 2752 | | syntaxelement(tail(A), [A], [], [], [], expr). |
| 2753 | | syntaxelement(rev(A), [A], [], [], [], expr). |
| 2754 | | syntaxelement(concat(A,B), [A,B],[], [], [], expr). |
| 2755 | | syntaxelement(insert_front(A,B), [A,B],[], [], [], expr). |
| 2756 | | syntaxelement(insert_tail(A,B), [A,B],[], [], [], expr). |
| 2757 | | syntaxelement(restrict_front(A,B), [A,B],[], [], [], expr). |
| 2758 | | syntaxelement(restrict_tail(A,B), [A,B],[], [], [], expr). |
| 2759 | | syntaxelement(general_concat(A), [A], [], [], [], expr). |
| 2760 | | syntaxelement(function(A,B), [A,B],[], [], [], expr). |
| 2761 | | syntaxelement(external_function_call(F,Args),Args,[],[Args],F,expr). |
| 2762 | | syntaxelement(identifier(I), [], [], [], I, expr). |
| 2763 | | syntaxelement(lazy_lookup_expr(I), [], [], [], I, expr). |
| 2764 | | syntaxelement(lazy_lookup_pred(I), [], [], [], I, pred). |
| 2765 | | syntaxelement(integer(I), [], [], [], I, expr). |
| 2766 | | syntaxelement(integer_set(T), [], [], [], T, expr). |
| 2767 | | syntaxelement(string(S), [], [], [], S, expr). |
| 2768 | | syntaxelement(set_extension(L), L, [], [L], [], expr). |
| 2769 | | syntaxelement(sequence_extension(L), L, [], [L], [], expr). |
| 2770 | | syntaxelement(comprehension_set(Ids,P),[P|Ids], Ids,[Ids], [], expr). |
| 2771 | | syntaxelement(event_b_comprehension_set(Ids,E,P),[E,P|Ids], Ids,[Ids], [], expr/only_typecheck). |
| 2772 | | syntaxelement(lambda(Ids,P,E), [P,E|Ids],Ids,[Ids], [], expr). |
| 2773 | | syntaxelement(general_sum(Ids,P,E), [P,E|Ids],Ids,[Ids], [], expr). |
| 2774 | | syntaxelement(general_product(Ids,P,E), [P,E|Ids],Ids,[Ids], [], expr). |
| 2775 | | syntaxelement(quantified_union(Ids,P,E), [P,E|Ids],Ids,[Ids], [], expr). |
| 2776 | | syntaxelement(quantified_intersection(Ids,P,E), [P,E|Ids],Ids,[Ids], [], expr). |
| 2777 | | syntaxelement(struct(Rec), [Rec], [], [], [], expr). |
| 2778 | ? | syntaxelement(rec(Fields), FContent, [], [FContent], FNames, expr) :- syntaxfields(Fields,FContent, FNames). |
| 2779 | | syntaxelement(record_field(R,I), [R], [], [], I, expr). |
| 2780 | | syntaxelement(assertion_expression(Cond,ErrMsg,Expr), [Cond,Expr], [], [], ErrMsg, expr). |
| 2781 | | syntaxelement(typeset, [], [], [], [], expr/only_typecheck). |
| 2782 | | |
| 2783 | | syntaxelement(tree(A), [A], [], [], [], expr). |
| 2784 | | syntaxelement(btree(A), [A], [], [], [], expr). |
| 2785 | | syntaxelement(const(A,B), [A,B],[], [], [], expr). |
| 2786 | | syntaxelement(top(A), [A], [], [], [], expr). |
| 2787 | | syntaxelement(sons(A), [A], [], [], [], expr). |
| 2788 | | syntaxelement(prefix(A), [A], [], [], [], expr). |
| 2789 | | syntaxelement(postfix(A), [A], [], [], [], expr). |
| 2790 | | syntaxelement(sizet(A), [A], [], [], [], expr). |
| 2791 | | syntaxelement(mirror(A), [A], [], [], [], expr). |
| 2792 | | syntaxelement(rank(A,B), [A,B],[], [], [], expr). |
| 2793 | | syntaxelement(father(A,B), [A,B],[], [], [], expr). |
| 2794 | | syntaxelement(son(A,B,C), [A,B,C],[], [], [], expr). |
| 2795 | | syntaxelement(subtree(A,B), [A,B],[], [], [], expr). |
| 2796 | | syntaxelement(arity(A,B), [A,B],[], [], [], expr). |
| 2797 | | syntaxelement(bin(A), [A],[], [], [], expr). |
| 2798 | | syntaxelement(bin(A,B,C), [A,B,C],[], [], [], expr). |
| 2799 | | syntaxelement(infix(A), [A], [], [], [], expr). |
| 2800 | | syntaxelement(left(A), [A], [], [], [], expr). |
| 2801 | | syntaxelement(right(A), [A], [], [], [], expr). |
| 2802 | | |
| 2803 | | % substitutions |
| 2804 | | syntaxelement(skip, [], [], [], [], subst). |
| 2805 | | syntaxelement(precondition(A,B), [A,B],[], [], [], subst). |
| 2806 | | syntaxelement(assertion(A,B), [A,B],[], [], [], subst). |
| 2807 | | syntaxelement(witness_then(A,B), [A,B],[], [], [], subst). |
| 2808 | | syntaxelement(if_elsif(A,B), [A,B],[], [], [], subst/elsif). |
| 2809 | | syntaxelement(while(A,B,C,D), [A,B,C,D],[], [], [], subst). |
| 2810 | | % used only internally in the interpreter, contains last value of variant: |
| 2811 | | syntaxelement(while1(A,B,C,D,E), [A,B,C,D],[], [], E, subst). |
| 2812 | | syntaxelement(select_when(A,B), [A,B],[], [], [], subst/when). |
| 2813 | | syntaxelement(block(S),[S],[],[],[], subst/only_typecheck). |
| 2814 | | syntaxelement(assign(Lhs,Rhs),Exprs,[],[Lhs,Rhs], [], subst) :- append(Lhs,Rhs,Exprs). |
| 2815 | | syntaxelement(assign_single_id(Id,Rhs),[Id,Rhs],[],[], [], subst). |
| 2816 | | syntaxelement(any(Ids,P,S),[P,S|Ids],Ids,[Ids], [], subst). |
| 2817 | | syntaxelement(var(Ids,S), [S|Ids], Ids,[Ids], [], subst). |
| 2818 | | syntaxelement(if(Ifs), Ifs, [], [Ifs], [], subst). |
| 2819 | | syntaxelement(parallel(Ss), Ss, [], [Ss], [], subst). |
| 2820 | | syntaxelement(sequence(Ss), Ss, [], [Ss], [], subst). |
| 2821 | | syntaxelement(becomes_element_of(Ids,E), [E|Ids], [], [Ids], [], subst). |
| 2822 | | syntaxelement(becomes_such(Ids,P), [P|Ids], [], [Ids], [], subst). % Ids are new value, Ids$0 is old value |
| 2823 | | syntaxelement(evb2_becomes_such(Ids,P), [P|Ids], [], [Ids], [], subst/only_typecheck). |
| 2824 | | syntaxelement(let(Ids,P,S), [P,S|Ids], Ids, [Ids], [], subst). |
| 2825 | | syntaxelement(operation_call(Id,Rs,As), [Id|Exprs], [], [Rs,As], [], subst) :- append(Rs,As,Exprs). |
| 2826 | | syntaxelement(case(E,Eithers,Else), [E,Else|Eithers], [], [Eithers], [], subst). |
| 2827 | | syntaxelement(case_or(Es,S), [S|Es], [], [Es], [], subst/caseor). |
| 2828 | | syntaxelement(choice(Ss), Ss, [], [Ss], [], subst). |
| 2829 | | syntaxelement(select(Whens), Whens, [], [Whens], [], subst). |
| 2830 | | syntaxelement(select(Whens,Else), [Else|Whens], [], [Whens], [], subst). |
| 2831 | | syntaxelement(operation(I,Rs,As,B), [I,B|Ids], Ids, [Rs,As], [], subst) :- append(Rs,As,Ids). |
| 2832 | | syntaxelement(external_subst_call(F,Args),Args,[],[Args],F,subst). |
| 2833 | | |
| 2834 | | % elements of a VALUES clause |
| 2835 | | syntaxelement(values_entry(I,E),[I,E],[],[],[],values_entry). |
| 2836 | | |
| 2837 | | % syntax for Event-B events |
| 2838 | | syntaxelement(rlevent(I,Sec,St,Ps,G,Ts,As,VWs,PWs,Ums,Rs), Subs, [], [Ps,Ts,As,VWs,PWs,Ums,Rs], [I,Sec], subst) :- |
| 2839 | | append([[St],Ps,[G],Ts,As,VWs,PWs,Ums,Rs],Subs). |
| 2840 | | syntaxelement(witness(I,P), [I,P], [], [], [], witness). |
| 2841 | | |
| 2842 | | % extended syntax for Z |
| 2843 | | syntaxelement(let_predicate(Ids,As,Pred), Exprs, Ids, [Ids,As], [], pred) :- append([Ids,As,[Pred]],Exprs). |
| 2844 | | syntaxelement(let_expression(Ids,As,Expr), Exprs, Ids, [Ids,As], [], expr) :- append([Ids,As,[Expr]],Exprs). |
| 2845 | | syntaxelement(let_expression_global(Ids,As,Expr), Exprs, Ids, [Ids,As], [], expr) :- % version used by b_compiler |
| 2846 | | append([Ids,As,[Expr]],Exprs). |
| 2847 | | syntaxelement(lazy_let_expr(TID,A,Expr), [TID, A, Expr], [TID], [[TID],[A]], [], expr). |
| 2848 | | syntaxelement(lazy_let_pred(TID,A,Expr), [TID, A, Expr], [TID], [[TID],[A]], [], pred). |
| 2849 | | syntaxelement(lazy_let_subst(TID,A,Expr), [TID, A, Expr], [TID], [[TID],[A]], [], subst). |
| 2850 | | syntaxelement(if_then_else(If,Then,Else),[If,Then,Else], [], [], [], expr). |
| 2851 | | syntaxelement(compaction(A), [A], [], [], [], expr). |
| 2852 | | syntaxelement(mu(A), [A], [], [], [], expr). |
| 2853 | | syntaxelement(bag_items(A), [A], [], [], [], expr). |
| 2854 | | |
| 2855 | | syntaxelement(freetype_set(Id), [], [], [], Id, expr). |
| 2856 | | syntaxelement(freetype_case(Type,Case,Expr), [Expr], [], [], [Type,Case], pred). |
| 2857 | | syntaxelement(freetype_constructor(Type,Case,Expr), [Expr], [], [], [Type,Case], expr). |
| 2858 | | syntaxelement(freetype_destructor(Type,Case,Expr), [Expr], [], [], [Type,Case], expr). |
| 2859 | | |
| 2860 | | syntaxelement(ordinary, [], [], [], [], status). |
| 2861 | | syntaxelement(anticipated(Variant), [Variant], [], [], [], status). |
| 2862 | | syntaxelement(convergent(Variant), [Variant], [], [], [], status). |
| 2863 | | |
| 2864 | | % Just one ID expected |
| 2865 | | syntaxelement(recursive_let(Id,C),[Id,C],[Id],[],[], expr). % Note: Id is not really introduced ! |
| 2866 | | |
| 2867 | | |
| 2868 | | % fields of records |
| 2869 | | %syntaxfields(Fields,C,_) :- var(Fields),var(C),var(N),!, add_internal_error('Illegal call: ',syntaxfields(Fields,C,N)),fail. |
| 2870 | | syntaxfields([],[],[]). |
| 2871 | ? | syntaxfields([field(N,C)|Rest],[C|CRest],[N|NRest]) :- syntaxfields(Rest,CRest,NRest). |
| 2872 | | |
| 2873 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2874 | | % helper for declaration of quantified identifiers |
| 2875 | | |
| 2876 | | % has_declared_identifier/2 returns a list of identifiers which are declared in |
| 2877 | | % this AST node. The main difference to the Names variable when doing a |
| 2878 | | % syntaxtraversion/6 or similiar is that the identifiers are described by |
| 2879 | | % predicates. |
| 2880 | | has_declared_identifier(TExpr,Ids) :- |
| 2881 | | get_texpr_expr(TExpr,Expr), |
| 2882 | | ( default_declaration(Expr,_,Ids,_) |
| 2883 | | ; non_default_declaration(Expr,Ids)). |
| 2884 | | |
| 2885 | | add_declaration_for_identifier(b(Expr,Type,Infos),Decl,b(NExpr,Type,NewInfos)) :- |
| 2886 | | %delete(Infos,used_ids(_),NewInfos), % we cannot |
| 2887 | | ( default_declaration(Expr,Predicate,Ids,Constant) -> |
| 2888 | | same_functor(Expr,NExpr), |
| 2889 | | conjunct_predicates([Decl,Predicate],NPredicate), |
| 2890 | | default_declaration(NExpr,NPredicate,Ids,Constant) |
| 2891 | | ; non_default_declaration(Expr,Ids) -> |
| 2892 | | add_non_default_declaration(Expr,Decl,NExpr) |
| 2893 | | ), |
| 2894 | | add_used_ids(Infos,Ids,Decl,NewInfos). |
| 2895 | | |
| 2896 | | % add used ids of a predicate within quantification of Ids to current used_ids info; if it is there |
| 2897 | | add_used_ids(Infos,Ids,Pred,NewInfos) :- update_used_ids(Infos,OldUsed,NewInfos,NewUsed), |
| 2898 | | !, % a field needs updating |
| 2899 | | find_identifier_uses(Pred,[],NewIds), get_texpr_ids(Ids,UnsortedIds),sort(UnsortedIds,SIds), |
| 2900 | | ord_subtract(NewIds,SIds,NewIds2), |
| 2901 | | ord_union(NewIds2,OldUsed,NewUsed). |
| 2902 | | add_used_ids(I,_,_,I). |
| 2903 | | |
| 2904 | | % just update used_ids field (e.g., when just computed to store it for later) |
| 2905 | | update_used_ids(Infos,OldUsed,NewInfos,NewUsed) :- select(OldInfo,Infos,I1), |
| 2906 | | used_ids_like_info(OldInfo,F,OldUsed),!, |
| 2907 | | used_ids_like_info(NewInfo,F,NewUsed),NewInfos = [NewInfo|I1]. |
| 2908 | | |
| 2909 | | % info fields which contain used_ids information |
| 2910 | | used_ids_like_info(used_ids(UsedIds),used_ids,UsedIds). |
| 2911 | | used_ids_like_info(reads(UsedIds),reads,UsedIds). |
| 2912 | | |
| 2913 | | :- use_module(probsrc(btypechecker), [prime_identifiers/2]). |
| 2914 | | |
| 2915 | | % default_declaration(Expr,Predicate,Ids,Constant) |
| 2916 | | default_declaration(forall(Ids,D,P),D,Ids,P). |
| 2917 | | default_declaration(exists(Ids,P),P,Ids,[]). |
| 2918 | | default_declaration(comprehension_set(Ids,P),P,Ids,[]). |
| 2919 | | default_declaration(event_b_comprehension_set(Ids,E,P),P,Ids,E). % translated !? |
| 2920 | | default_declaration(lambda(Ids,P,E),P,Ids,E). |
| 2921 | | default_declaration(general_sum(Ids,P,E),P,Ids,E). |
| 2922 | | default_declaration(general_product(Ids,P,E),P,Ids,E). |
| 2923 | | default_declaration(quantified_union(Ids,P,E),P,Ids,E). |
| 2924 | | default_declaration(quantified_intersection(Ids,P,E),P,Ids,E). |
| 2925 | | default_declaration(any(Ids,P,S),P,Ids,S). |
| 2926 | | default_declaration(becomes_such(Ids,P),P,Ids,[]). |
| 2927 | | default_declaration(evb2_becomes_such(Ids,P),P,Primed,[]) :- |
| 2928 | | nl,print(evb2(Ids,Primed)),nl,nl, % no longer used, as it is translated to becomes_such |
| 2929 | | prime_identifiers(Ids,Primed). |
| 2930 | | default_declaration(rlevent(I,Sec,St,Ps,G,Ts,As,VWs,PWs,Ums,Rs),G,Ps, |
| 2931 | | [I,Sec,St,Ps,Ts,As,VWs,PWs,Ums,Rs]). |
| 2932 | | default_declaration(let_predicate(Ids,Ps,Body),Ps,Ids,Body) :- print(let(Ids)),nl. % TODO: check format of Ps |
| 2933 | | default_declaration(let_expression(Ids,Ps,Body),Ps,Ids,Body) :- print(let(Ids)),nl. % TODO: check format of Ps |
| 2934 | | default_declaration(let_expression_global(Ids,Ps,Body),Ps,Ids,Body) :- print(let(Ids)),nl. % TODO: check format of Ps |
| 2935 | | % TODO: lazy let ? |
| 2936 | | |
| 2937 | | non_default_declaration(operation(_I,Rs,As,_TBody),Ids) :- |
| 2938 | | append(Rs,As,Ids). |
| 2939 | | |
| 2940 | | add_non_default_declaration(operation(I,Rs,As,TBody),Decl,operation(I,Rs,As,NTBody)) :- |
| 2941 | | ( get_guard_and_copy(TBody,P,NP,NTBody) -> |
| 2942 | | conjunct_predicates([Decl,P],NP) |
| 2943 | | ; create_texpr(precondition(Decl,TBody),subst,[],NTBody)). |
| 2944 | | |
| 2945 | | get_guard_and_copy(TBody,P,NP,NTBody) :- remove_bt(TBody,Body,NBody,NTBody), |
| 2946 | | get_guard_copy2(Body,P,NP,NBody). |
| 2947 | | |
| 2948 | | get_guard_copy2(precondition(P,S),P,NP,precondition(NP,S)). |
| 2949 | | get_guard_copy2(rlevent(I,Sec,St,Ps, G,Ts,As,VWs,PWs,Ums,Rs), G, NG, |
| 2950 | | rlevent(I,Sec,St,Ps,NG,Ts,As,VWs,PWs,Ums,Rs)). |
| 2951 | | |
| 2952 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2953 | | % pattern definitions (not yet finished) |
| 2954 | | |
| 2955 | | bsyntax_pattern(Expr,TExpr) :- |
| 2956 | | var(Expr),!,Expr=TExpr. |
| 2957 | | bsyntax_pattern(-Expr,TExpr) :- |
| 2958 | | !,remove_all_infos(Expr,TExpr). |
| 2959 | | bsyntax_pattern(Expr,TExpr) :- |
| 2960 | | functor(Expr,b,3),!,Expr=TExpr. |
| 2961 | | bsyntax_pattern(Expr:Type/Info,TExpr) :- |
| 2962 | | !,bsyntax_pattern2(Expr,Type,Info,TExpr). |
| 2963 | | bsyntax_pattern(Expr:Type,TExpr) :- |
| 2964 | | !,bsyntax_pattern2(Expr,Type,_Info,TExpr). |
| 2965 | | bsyntax_pattern(Expr/Info,TExpr) :- |
| 2966 | | !,bsyntax_pattern2(Expr,_Type,Info,TExpr). |
| 2967 | | bsyntax_pattern(Expr,TExpr) :- |
| 2968 | | !,bsyntax_pattern2(Expr,_Type,_Info,TExpr). |
| 2969 | | |
| 2970 | | bsyntax_pattern2(Pattern,Type,Info,TExpr) :- |
| 2971 | | functor(Pattern,Functor,Arity), |
| 2972 | | functor(R,Functor,Arity), |
| 2973 | | create_texpr(R,Type,Info,TExpr), |
| 2974 | | syntaxelement(Pattern,PSubs,_,PLists,Const,EType), |
| 2975 | | syntaxelement(R,RSubs,_,RLists,Const,EType), |
| 2976 | | ( EType==pred -> Type=pred |
| 2977 | | ; EType==subst -> Type=subst |
| 2978 | | ; true), |
| 2979 | | all_same_length(PLists,RLists), |
| 2980 | | maplist(bsyntax_pattern,PSubs,RSubs). |
| 2981 | | |
| 2982 | | all_same_length([],[]). |
| 2983 | | all_same_length([A|Arest],[B|Brest]) :- |
| 2984 | | ( var(A),var(B) -> |
| 2985 | | add_error_fail(bsyntaxtree,'At least one list should contain nonvar elements for all_same_length',[A,B]) |
| 2986 | | ; |
| 2987 | | same_length(A,B)), |
| 2988 | | all_same_length(Arest,Brest). |
| 2989 | | |
| 2990 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2991 | | % strip an AST into a more compact form (without b/3 terms) |
| 2992 | | |
| 2993 | | strip_and_norm_ast(TExpr,SNExpr) :- |
| 2994 | | get_texpr_expr(TExpr,Expr), |
| 2995 | | strip_and_norm_ast_aux(Expr,SNExpr). |
| 2996 | | |
| 2997 | | :- use_module(tools,[safe_univ_no_cutoff/2]). |
| 2998 | | strip_and_norm_ast_aux(Expr,Res) :- |
| 2999 | | comm_assoc_subs(Expr,Op,Subs,[]), !, % associative & commutative operator detected |
| 3000 | | maplist(strip_and_norm_ast_aux,Subs,NSubs), % Subs are already unwrapped |
| 3001 | | sort(NSubs,Sorted), % in case there are associative operators that are not commutative: insert is_commutative check |
| 3002 | | safe_univ_no_cutoff(Res,[Op|Sorted]). |
| 3003 | | strip_and_norm_ast_aux(Expr,Res) :- |
| 3004 | | assoc_subs(Expr,Op,Subs,[]), !, % associative operator detected |
| 3005 | | maplist(strip_and_norm_ast_aux,Subs,NSubs), % Subs are already unwrapped |
| 3006 | | safe_univ_no_cutoff(Res,[Op|NSubs]). |
| 3007 | | strip_and_norm_ast_aux(Expr,SNExpr) :- |
| 3008 | | syntaxtransformation(Expr,Subs,_,NSubs,SExpr), |
| 3009 | | strip_and_norm_ast_l(Subs,NSubs), |
| 3010 | | norm_strip(SExpr,SNExpr). |
| 3011 | | |
| 3012 | | strip_and_norm_ast_l([],[]). |
| 3013 | | strip_and_norm_ast_l([TExpr|Trest],[NExpr|Nrest]) :- |
| 3014 | | strip_and_norm_ast(TExpr,NExpr), |
| 3015 | | strip_and_norm_ast_l(Trest,Nrest). |
| 3016 | | |
| 3017 | | norm_strip(greater_equal(A,B),less_equal(B,A)) :- !. |
| 3018 | | norm_strip(greater(A,B),less(B,A)) :- !. |
| 3019 | | norm_strip(set_extension(NL),set_extension(SNL)) :- !, |
| 3020 | | sort(NL,SNL). |
| 3021 | | norm_strip(Old,New) :- |
| 3022 | | functor(Old,Functor,2), |
| 3023 | | is_commutative(Functor),!, |
| 3024 | | arg(1,Old,OA), |
| 3025 | | arg(2,Old,OB), |
| 3026 | | ( OA @> OB -> New =.. [Functor,OB,OA] |
| 3027 | | ; New=Old). |
| 3028 | | norm_strip(Old,Old). |
| 3029 | | % TO DO: flatten associative operators into lists ! |
| 3030 | | |
| 3031 | | comm_assoc_subs(conjunct(TA,TB),conjunct) --> !, |
| 3032 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3033 | | comm_assoc_subs(A,conjunct), comm_assoc_subs(B,conjunct). |
| 3034 | | comm_assoc_subs(disjunct(TA,TB),disjunct) --> !, |
| 3035 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3036 | | comm_assoc_subs(A,disjunct), comm_assoc_subs(B,disjunct). |
| 3037 | | comm_assoc_subs(add(TA,TB),add) --> !, |
| 3038 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3039 | | comm_assoc_subs(A,add), comm_assoc_subs(B,add). |
| 3040 | | comm_assoc_subs(multiplication(TA,TB),multiplication) --> !, |
| 3041 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3042 | | comm_assoc_subs(A,multiplication), comm_assoc_subs(B,multiplication). |
| 3043 | | comm_assoc_subs(union(TA,TB),union) --> !, |
| 3044 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3045 | | comm_assoc_subs(A,union), comm_assoc_subs(B,union). |
| 3046 | | comm_assoc_subs(intersection(TA,TB),intersection) --> !, |
| 3047 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3048 | | comm_assoc_subs(A,intersection), comm_assoc_subs(B,intersection). |
| 3049 | | comm_assoc_subs(Expr,Op) --> {nonvar(Op)},[Expr]. % base case for other operators |
| 3050 | | |
| 3051 | | % detect just associative operators |
| 3052 | | assoc_subs(concat(TA,TB),concat) --> !, |
| 3053 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3054 | | assoc_subs(A,concat), assoc_subs(B,concat). |
| 3055 | | assoc_subs(composition(TA,TB),composition) --> !, |
| 3056 | | {get_texpr_expr(TA,A), get_texpr_expr(TB,B)}, |
| 3057 | | assoc_subs(A,composition), assoc_subs(B,composition). |
| 3058 | | assoc_subs(Expr,Op) --> {nonvar(Op)},[Expr]. % base case for other operators |
| 3059 | | |
| 3060 | | is_commutative(conjunct). |
| 3061 | | is_commutative(disjunct). |
| 3062 | | is_commutative(equivalence). |
| 3063 | | is_commutative(equal). |
| 3064 | | is_commutative(not_equal). |
| 3065 | | is_commutative(add). |
| 3066 | | is_commutative(multiplication). |
| 3067 | | is_commutative(union). |
| 3068 | | is_commutative(intersection). |
| 3069 | | |
| 3070 | | % check if two type expressions are same modulo info fields and reordering of commutative operators |
| 3071 | | % same_texpr does not reorder wrt commutativity. |
| 3072 | | same_norm_texpr(TExpr1,TExpr2) :- |
| 3073 | | strip_and_norm_ast(TExpr1,N1), |
| 3074 | | strip_and_norm_ast(TExpr2,N1). |
| 3075 | | |
| 3076 | | |
| 3077 | | % small utility to get functor of texpr: |
| 3078 | | get_texpr_functor(b(E,_,_),F,N) :- !, functor(E,F,N). |
| 3079 | | get_texpr_functor(E,_,+) :- add_error_fail(get_texpr_functor,'Not a typed expression: ',E). |
| 3080 | | |
| 3081 | | % ------------------------- |
| 3082 | | |
| 3083 | | % check if a ProB type is a set type: |
| 3084 | | is_set_type(set(Type),Type). |
| 3085 | | is_set_type(seq(Type),couple(integer,Type)). |
| 3086 | | % should we have a rule for any ?? : in all cases using is_set_type any seems not possible; better that we generate error message in get_set_type or get_texpr_set_type |
| 3087 | | % is_set_type(any,any). |
| 3088 | | |
| 3089 | | get_set_type(TypeX,Res) :- |
| 3090 | ? | (is_set_type(TypeX,SetType) -> Res=SetType ; add_error_fail(get_set_type,'Not a set type: ',TypeX)). |
| 3091 | | |
| 3092 | | get_texpr_set_type(X,Res) :- get_texpr_type(X,TypeX), |
| 3093 | | get_set_type(TypeX,Res). |
| 3094 | | |
| 3095 | | |
| 3096 | | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 3097 | | % check if a set contains all elements of a type, i.e., maximal type |
| 3098 | | is_just_type(Expr) :- is_just_type(Expr,[]). |
| 3099 | | % is_just_type(+Expr,+RTT): |
| 3100 | | % like is_just_type/1 but RTT is a list of identifiers (without type information) |
| 3101 | | % of variables or constants that are known to be types, too. |
| 3102 | | % E.g. is_just_type(a ** INTEGER) would fail but is_just_type(a ** INTEGER,[a]) would |
| 3103 | | % succeed. |
| 3104 | | is_just_type(b(E,T,I),RTT) :- is_just_type3(E,T,I,RTT). |
| 3105 | | |
| 3106 | | |
| 3107 | | is_just_type3(identifier(G),SType,Infos,RefsToTypes) :- |
| 3108 | | nonvar(SType), SType = set(Type), nonvar(Type), |
| 3109 | | ( Type = global(G), |
| 3110 | | memberchk(given_set,Infos) % no accidental local variable G that hides global G |
| 3111 | | ; memberchk(G,RefsToTypes) -> true |
| 3112 | | %; Type = freetype(G), |
| 3113 | | % memberchk(given_set,Infos) % no accidental local variable G that hides global G |
| 3114 | | % TODO: we do not know if the Freetype has restrictions (which are encoded in the PROPERTIES) |
| 3115 | | ),!. |
| 3116 | | is_just_type3(freetype_set(_),_,_,_). |
| 3117 | | is_just_type3(pow_subset(E),_,_,RTT) :- is_just_type(E,RTT). |
| 3118 | | is_just_type3(fin_subset(E),T,_,RTT) :- |
| 3119 | | is_finite_type_in_context(proving,T), % animation or proving |
| 3120 | | is_just_type(E,RTT). |
| 3121 | | is_just_type3(integer_set('INTEGER'),set(integer),_,_). |
| 3122 | | is_just_type3(bool_set,set(boolean),_,_). |
| 3123 | | is_just_type3(real_set,set(real),_,_). |
| 3124 | | is_just_type3(string_set,set(string),_,_). |
| 3125 | | is_just_type3(cartesian_product(A,B),_,_,RTT) :- |
| 3126 | | is_just_type(A,RTT),is_just_type(B,RTT). |
| 3127 | | is_just_type3(mult_or_cart(A,B),_,_,RTT) :- % is_just_type/1 could be called before the cleanup |
| 3128 | | is_just_type(A,RTT),is_just_type(B,RTT). % of an expression has finished |
| 3129 | | is_just_type3(relations(A,B),_,_,RTT) :- |
| 3130 | | is_just_type(A,RTT),is_just_type(B,RTT). |
| 3131 | | is_just_type3(struct(b(rec(Fields),_,_)),_,_,RTT) :- |
| 3132 | | maplist(field_is_just_type(RTT),Fields). |
| 3133 | | is_just_type3(typeset,_,_,_). |
| 3134 | | is_just_type3(comprehension_set(_,b(truth,_,_)),_,_,_). |
| 3135 | | is_just_type3(value(Val),ST,_,_) :- is_set_type(ST,Type), is_maximal_value(Val,Type). % also see: quick_is_definitely_maximal_set(Val). |
| 3136 | | |
| 3137 | | field_is_just_type(RTT,field(_,Set)) :- is_just_type(Set,RTT). |
| 3138 | | |
| 3139 | | is_maximal_value(V,_) :- var(V),!,fail. |
| 3140 | | is_maximal_value(global_set(GS),Type) :- (GS=='INTEGER' -> true ; Type==global(GS)). % we could call is_maximal_global_set(GS) or b_global_set (but requires compiled) |
| 3141 | | |
| 3142 | | % Generate a custom matching / visitor predicate |
| 3143 | | % bsyntaxtree:gen_visitor(bexpr_variables_aux,bexpr_variables) |
| 3144 | | /* |
| 3145 | | gen_visitor(Pred, BodyPred) :- syntaxelement(Expr,SubsX,_NamesX,_Lists,_ConstantX,_), |
| 3146 | | print_clause(Pred,BodyPred,Expr,SubsX), |
| 3147 | | fail. |
| 3148 | | gen_visitor(Pred, BodyPred) :- nl. |
| 3149 | | |
| 3150 | | print_clause(Pred,BodyPred,Expr,SubsX) :- E=..[Op|SubsX], format('~w(~w) :- ',[Pred,Expr]). |
| 3151 | | */ |
| 3152 | | |
| 3153 | | /* |
| 3154 | | * create_recursive_compset(+Ids,+Cond,+Type,+Infos,-RecId,-TCompSet) |
| 3155 | | * creates a recursive comprehension set: |
| 3156 | | * Ids is the list of the introduced typed identifiers |
| 3157 | | * Cond is the condition (a typed predicate) |
| 3158 | | * Infos are additional informations for the comprehension set syntax element |
| 3159 | | * RecId is the identifier (untyped, an atom) that can be used in Cond to refer to the |
| 3160 | | * comprehension set recursively. Usually RecId is used in Cond as a variable |
| 3161 | | * TCompSet is the generated recursive comprehension set, the recursion parameter is introduced |
| 3162 | | * by a recusive(Id,CompSet) syntax element |
| 3163 | | */ |
| 3164 | | create_recursive_compset(Ids,Cond,Type,Infos,RecId,TCompSet) :- |
| 3165 | | unique_id("recursive.",RecId), |
| 3166 | | add_symbolic_annotation(Infos,RInfos), |
| 3167 | | create_texpr(comprehension_set(Ids,Cond),Type,RInfos,TCompSet1), |
| 3168 | | create_typed_id(RecId,Type,TRecId), |
| 3169 | | create_texpr(recursive_let(TRecId,TCompSet1),Type,[],TCompSet). |
| 3170 | | |
| 3171 | | unique_typed_id(Prefix,Type,TId) :- |
| 3172 | | unique_id(Prefix,Id), |
| 3173 | | create_typed_id(Id,Type,TId). |
| 3174 | | |
| 3175 | | |
| 3176 | | mark_bexpr_as_symbolic(b(E,T,I),b(E2,T,RI)) :- |
| 3177 | | add_symbolic_annotation(I,RI), |
| 3178 | | mark_aux(E,E2). |
| 3179 | | mark_aux(union(A,B),R) :- !, R=union(SA,SB), |
| 3180 | | mark_bexpr_as_symbolic(A,SA), mark_bexpr_as_symbolic(B,SB). |
| 3181 | | % union is currently the only operator that is kept symbolically |
| 3182 | | mark_aux(A,A). |
| 3183 | | |
| 3184 | | add_symbolic_annotation([H|I],R) :- H == prob_annotation('SYMBOLIC'),!, R=[H|I]. |
| 3185 | | add_symbolic_annotation(I,R) :- !, R=[prob_annotation('SYMBOLIC')|I]. |
| 3186 | | |
| 3187 | | % identifier_sub_ast(+TExpr,+Identifier,-SubPosition): |
| 3188 | | % Find occurences of an identifier "Identifier" in an expression "TExpr" |
| 3189 | | % Returns a list of positions (beginning with 0) that describes the position of a sub-expression |
| 3190 | | % that contains all occurrences of Identifier in TExpr. |
| 3191 | | % E.g. [1,0,1] means "second sub-expression of TExpr, then the first sub-expression of that, |
| 3192 | | % then the second sub-expression of that". |
| 3193 | | % When an identifier has multiple occurences, the position of the sub-expression is returned |
| 3194 | | % where all occurences of it are located. |
| 3195 | | % If the identifier is not found, the call fails. |
| 3196 | | % Sub-expressions are meant like the ones syntaxtraversion or syntaxtransformation return. |
| 3197 | | identifier_sub_ast(TExpr,Identifier,SubPosition) :- |
| 3198 | | syntaxtraversion(TExpr,Expr,_Type,_Infos,AllSubs,Names), |
| 3199 | | identifier_sub_ast_aux(Expr,AllSubs,Names,Identifier,SubPosition). |
| 3200 | | identifier_sub_ast_aux(identifier(Identifier),[],[],Identifier,[]) :- !. |
| 3201 | | identifier_sub_ast_aux(_Expr,AllSubs,Names,Identifier,SubPosition) :- |
| 3202 | | get_texpr_id(TId,Identifier),nonmember(TId,Names), |
| 3203 | | % For each sub-expression E in the list AllSubs create a term Pos-E |
| 3204 | | % where Pos is E's position (starting with 0) in AllSubs |
| 3205 | | foldl(annotate_pos,AllSubs,AllAnnotatedSubs,0,_), |
| 3206 | | % Introduced identifiers occur alsa as sub-expressions, remove those |
| 3207 | | foldl(select_sub,Names,AllAnnotatedSubs,RealAnnSubs), |
| 3208 | | convlist_max(identifier_sub_ast_aux2(Identifier),2,RealAnnSubs,SubPositions), % find at most 2 sols |
| 3209 | | ( SubPositions = [SubPosition] -> true |
| 3210 | | ; SubPositions = [_,_|_] -> % More then one occurrences - make this the found node |
| 3211 | | SubPosition = []). |
| 3212 | | identifier_sub_ast_aux2(Identifier,Pos-TExpr,[Pos|SubPosition]) :- |
| 3213 | | identifier_sub_ast(TExpr,Identifier,SubPosition). |
| 3214 | | annotate_pos(TExpr,I-TExpr,I,I2) :- I2 is I+1. |
| 3215 | | select_sub(Name,AnnotatedSubs,Result) :- |
| 3216 | | selectchk(_Pos-Name,AnnotatedSubs,Result). |
| 3217 | | |
| 3218 | | |
| 3219 | | |
| 3220 | | % exchange_ast_position(+SubPosition,+OldTExpr,-OldInner,+NewInner,-NewTExpr): |
| 3221 | | % exchanges a sub-expression in the expression "OldTExpr". |
| 3222 | | % SubPosition is a list of positions like identifier_sub_ast/3 returns it. |
| 3223 | | % OldInner is the sub-expression found in OldTExpr. |
| 3224 | | % NewInner is the new sub-expression. |
| 3225 | | % NewTExpr is the new expression that originates from replacing OldInner by NewInner. |
| 3226 | | exchange_ast_position([],Old,Old,New,New). |
| 3227 | | exchange_ast_position([Pos|RestPos],OldTExpr,OldInner,NewInner,NewTExpr) :- |
| 3228 | | remove_bt_and_used_ids(OldTExpr,OldExpr,NewExpr,NewTExpr), % also invalidates used_ids info |
| 3229 | | syntaxtransformation(OldExpr,Subs,_Names,NSubs,NewExpr), |
| 3230 | | nth0(Pos,Subs, OldSelected,Rest), |
| 3231 | | nth0(Pos,NSubs,NewSelected,Rest), |
| 3232 | | exchange_ast_position(RestPos,OldSelected,OldInner,NewInner,NewSelected). |
| 3233 | | |
| 3234 | | |
| 3235 | | % ----------------------- |
| 3236 | | % utility to expand / inline all let expressions and let predicates: |
| 3237 | | % useful for tools that cannot handle the lets |
| 3238 | | |
| 3239 | | expand_all_lets(Expr,NewExpr) :- |
| 3240 | | transform_bexpr(tl_expand_lets,Expr,NewExpr). |
| 3241 | | |
| 3242 | | tl_expand_lets(b(E,_,_),Res) :- tl_expand_lets2(E,Res). |
| 3243 | | tl_expand_lets2(let_expression(Ids,Exprs,Body),NewBody) :- % expand LET expression |
| 3244 | | replace_ids_by_exprs(Body,Ids,Exprs,NewBody). |
| 3245 | | tl_expand_lets2(let_predicate(Ids,Exprs,Body),NewBody) :- % expand LET predicate |
| 3246 | | replace_ids_by_exprs(Body,Ids,Exprs,NewBody). |
| 3247 | | |
| 3248 | | % ----------------------- |
| 3249 | | |
| 3250 | | :- public check_used_ids/2. |
| 3251 | | % a simple checker, only checks used_ids info fields for entire typed expression: |
| 3252 | | check_used_ids(TExpr,PP) :- %format('CHECK AST for ~w~n',[PP]), |
| 3253 | | map_over_typed_bexpr(check_used_ids_texpr_fail(PP),TExpr). |
| 3254 | | check_used_ids(_,_). |
| 3255 | | check_used_ids_texpr_fail(PP,E) :- check_used_ids_texpr(PP,E),!,fail. |
| 3256 | | check_used_ids_texpr(PP,b(P,T,I)) :- member(used_ids(UIds1),I),!, |
| 3257 | | (find_identifier_uses(b(P,T,I),[],UIds2) -> true |
| 3258 | | ; add_internal_error('find_identifier_uses failed',PP),fail), |
| 3259 | | (UIds1==UIds2 -> true |
| 3260 | | ; format('*** Wrong used_ids Info (~w)!!~n Used_ids: ~w~n Comp_ids: ~w~n',[PP,UIds1,UIds2]), |
| 3261 | | translate:print_bexpr(b(P,T,I)),nl, |
| 3262 | | add_error(check_used_ids,'Wrong used_ids: ',PP,I) |
| 3263 | | ). |
| 3264 | | check_used_ids_texpr(_,_). |
| 3265 | | |
| 3266 | | % repair any broken used_ids info in typed expression TExpr and re-compute used_ids if necessary |
| 3267 | | % PP is a program point, will be reported in case of an error |
| 3268 | | repair_used_ids(PP,TExpr,Res) :- |
| 3269 | | (transform_bexpr(bsyntaxtree:repair_used_ids_info(PP),TExpr,NewTExpr) -> Res=NewTExpr |
| 3270 | | ; add_internal_error('Repairing used_ids failed:',PP), |
| 3271 | | Res=TExpr). |
| 3272 | | |
| 3273 | | % we could also simply call recompute_used_ids_inf; but it would not generate any messages |
| 3274 | | repair_used_ids_info(PP,b(P,T,I),b(P,T,NI)) :- %functor(P,FF,_), print(repair(FF)),nl, |
| 3275 | | select(used_ids(OldUsed),I,I2),!, |
| 3276 | | (find_identifier_uses(b(P,T,I),[],NewUsed) |
| 3277 | | -> (NewUsed=OldUsed -> NI=I |
| 3278 | | ; NI = [used_ids(NewUsed)|I2], |
| 3279 | | add_message(repair_used_ids,'Updating used_ids for: ',b(P,T,I),I2) |
| 3280 | | ) |
| 3281 | | ; add_internal_error('find_identifier_uses failed',PP), |
| 3282 | | NI=I |
| 3283 | | ). |
| 3284 | | repair_used_ids_info(PP,b(P,T,I),b(P,T,NI)) :- |
| 3285 | | requires_used_ids(P), |
| 3286 | | (find_identifier_uses(b(P,T,I),[],NewUsed) -> true |
| 3287 | | ; add_internal_error('find_identifier_uses failed',PP),fail |
| 3288 | | ), |
| 3289 | | !, |
| 3290 | | NI=[used_ids(NewUsed)|I]. |
| 3291 | | repair_used_ids_info(_,B,B). |
| 3292 | | |
| 3293 | | requires_used_ids(exists(_,_)). |
| 3294 | | requires_used_ids(forall(_,_,_)). |
| 3295 | | |
| 3296 | | % a simple checker to see if an AST is well-formed: |
| 3297 | | % can be tested e.g. as follows: b_get_invariant_from_machine(I), check_ast(I). |
| 3298 | | % called in prob_safe_mode by clean_up_section |
| 3299 | | |
| 3300 | | check_ast(TE) :- check_ast(false,TE). |
| 3301 | | check_ast(AllowVars,TExpr) :- %nl,print('CHECK AST'),nl, |
| 3302 | | map_over_typed_bexpr(check_ast_texpr(AllowVars),TExpr). |
| 3303 | | check_ast(_,_). |
| 3304 | | |
| 3305 | | :- use_module(typing_tools,[valid_ground_type/1]). |
| 3306 | | %check_ast_texpr(X) :- print(check(X)),nl,fail. |
| 3307 | | check_ast_texpr(AllowVars,AST) :- AST = b(E,Type,Infos), |
| 3308 | | (debug:debug_level_active_for(9) -> write(' check_ast: '),print_bexpr(AST), write(' :: '), write(Type), nl ; true), |
| 3309 | | (check_expr(E,Type,Infos) -> true |
| 3310 | | ; add_error(check_ast_texpr,'Invalid Expr: ', AST) %, trace, check_expr(E,Type,Infos) |
| 3311 | | ), |
| 3312 | | (check_type(Type,AllowVars) -> true |
| 3313 | | ; add_error(check_ast_texpr,'Invalid Type for: ',AST,Infos)), |
| 3314 | | safe_functor(E,F), |
| 3315 | | check_ast_typing(E,Type,Infos), |
| 3316 | | (check_infos(Infos,F) -> true ; add_error(check_ast_texpr,'Invalid Infos: ',AST)), |
| 3317 | | check_special_rules(E,Type,Infos), |
| 3318 | | fail. % to force backtracking in map_over_typed_bexpr |
| 3319 | | |
| 3320 | | |
| 3321 | | check_special_rules(operation_call_in_expr(Operation,_),_,OInfos) :- !, |
| 3322 | | get_texpr_info(Operation,Info), % reads info important for used_ids computation |
| 3323 | | (memberchk(reads(_V),Info) -> true |
| 3324 | | ; add_error(check_ast_texpr,'Missing reads info: ',Operation,OInfos)). |
| 3325 | | |
| 3326 | | |
| 3327 | | safe_functor(V,R) :- var(V),!,R='$VAR'. |
| 3328 | | safe_functor(E,F/N) :- functor(E,F,N). |
| 3329 | | |
| 3330 | | % check whether the type term is ok |
| 3331 | | check_type(X,AllowVars) :- var(X),!, |
| 3332 | | (AllowVars==true -> true ; add_error(check_type,'Variable type: ',X),fail). |
| 3333 | | check_type(pred,_) :- !. |
| 3334 | | check_type(subst,_) :- !. |
| 3335 | | check_type(op(Paras,Returns),AllowVars) :- !, |
| 3336 | | maplist(check_normal_type(AllowVars),Paras), |
| 3337 | | maplist(check_normal_type(AllowVars),Returns). |
| 3338 | | check_type(T,AllowVars) :- check_normal_type(AllowVars,T). |
| 3339 | | |
| 3340 | | check_normal_type(AllowVars,T) :- |
| 3341 | | (AllowVars \== true -> valid_ground_type(T) |
| 3342 | | ; ground(T) -> valid_ground_type(T) |
| 3343 | | ; true). % TO DO: call valid_ground_type but pass AllowVars |
| 3344 | | |
| 3345 | | :- use_module(probsrc(btypechecker), [lookup_type_for_expr/2, unify_types_werrors/4]). |
| 3346 | | % check whether type is compatible with operators |
| 3347 | | check_ast_typing(member(A,B),Type,Pos) :- !, |
| 3348 | | get_texpr_type(B,TB), check_set_type(TB,member,Pos), |
| 3349 | | check_type(Type,pred,member), |
| 3350 | | get_texpr_type(A,TA), |
| 3351 | | unify_types_werrors(set(TA),TB,Pos,member). |
| 3352 | | check_ast_typing(not_equal(A,B),Type,Pos) :- !, check_ast_typing(equal(A,B),Type,Pos). |
| 3353 | | check_ast_typing(equal(A,B),Type,Pos) :- !, |
| 3354 | | get_texpr_type(B,TB), |
| 3355 | | get_texpr_type(A,TA), |
| 3356 | | unify_types_werrors(TA,TB,Pos,'='), |
| 3357 | | (non_value_type(TA) |
| 3358 | | -> add_error(check_ast_typing,'Binary predicate has to have values as arguments:',TA,Pos) |
| 3359 | | ; Type=pred -> true |
| 3360 | | ; add_error(check_ast_typing,'Illegal type for binary predicate:',Type,Pos) |
| 3361 | | ). |
| 3362 | | check_ast_typing(greater_equal(A,B),Type,_) :- !, |
| 3363 | | get_texpr_type(A,TA),check_type(TA,integer,greater_equal), |
| 3364 | | get_texpr_type(B,TB),check_type(TB,integer,greater_equal), check_type(Type,pred,member). |
| 3365 | | check_ast_typing(Expr,Type,Pos) :- |
| 3366 | | syntaxtransformation(Expr,Subs,Names,NSubs,NewExpr), |
| 3367 | | check_names(Names,Pos), |
| 3368 | | (lookup_type(NewExpr,T) -> true |
| 3369 | | ; add_warning(check_ast_typing,'Unable to lookup type for: ',NewExpr), |
| 3370 | | fail |
| 3371 | | ), |
| 3372 | | !, |
| 3373 | | (unify_types_werrors(Type,T,Pos,'check_ast') |
| 3374 | | -> maplist(check_sub_type(Expr,Pos),Subs,NSubs) |
| 3375 | | ; add_error(check_ast_typing,'Type mismatch for expression:',Expr,Pos) |
| 3376 | | ). |
| 3377 | | check_ast_typing(_,subst,_) :- !. % ignore subst for the moment |
| 3378 | | check_ast_typing(operation(_TName,_Res,_Params,_TBody),_,_) :- !. % ignore operations for the moment |
| 3379 | | check_ast_typing(Expr,_,Pos) :- |
| 3380 | | syntaxtransformation(Expr,_,_Names,_,_NewExpr),!, |
| 3381 | | add_message(check_ast_typing,'Cannot lookup type for expression: ',Expr,Pos). |
| 3382 | | check_ast_typing(Expr,_,Pos) :- |
| 3383 | | add_message(check_ast_typing,'No applicable type rule for expression: ',Expr,Pos). |
| 3384 | | |
| 3385 | | non_value_type(X) :- var(X),!,fail. |
| 3386 | | non_value_type(pred). |
| 3387 | | non_value_type(subst). |
| 3388 | | non_value_type(op(_)). |
| 3389 | | |
| 3390 | | |
| 3391 | | check_names([],_). |
| 3392 | | check_names([H|T],Pos) :- |
| 3393 | | (member(H,T) -> add_error(check_ast_name,'Duplicate name:',H,Pos) ; check_names(T,Pos)). |
| 3394 | | |
| 3395 | | check_sub_type(OuterExpr,Pos,Arg,Type) :- get_texpr_type(Arg,T),!, |
| 3396 | | (unify_types_werrors(Type,T,Pos,'check_sub_type') -> true |
| 3397 | | ; add_error(check_ast_typing,'Type mismatch for sub-expression:',Arg,Pos), |
| 3398 | | write('Outer expression: '),translate:print_bexpr(OuterExpr),nl, |
| 3399 | | write('Outer type: '),write(Type),nl, |
| 3400 | | write('Arg type: '),write(T),nl,print(type(T)),nl, tools_printing:print_term_summary(Arg),nl,trace |
| 3401 | | ). |
| 3402 | | check_sub_type(_,Pos,Arg,_) :- |
| 3403 | | add_error(check_ast_typing,'Cannot extract type: ',Arg,Pos). |
| 3404 | | |
| 3405 | | lookup_type(identifier(_),_) :- !. % ignore typing issues for identifiers |
| 3406 | | lookup_type(Expr,Type) :- lookup_type_for_expr(Expr,Type). |
| 3407 | | |
| 3408 | | check_set_type(Var,_,_) :- var(Var),!. |
| 3409 | | check_set_type(set(_),_,_) :- !. |
| 3410 | | check_set_type(seq(_),_,_) :- !. |
| 3411 | | check_set_type(Type,Func,Pos) :- add_error(check_ast_typing,'Invalid type for operator: ',Func:Type,Pos). |
| 3412 | | |
| 3413 | | check_type(Type,Type,_) :- !. |
| 3414 | | check_type(Type,_,Func) :- add_error(check_ast_typing,'Unexpected type for operator: ',Func:Type). |
| 3415 | | |
| 3416 | | check_infos(X,F) :- var(X),!, add_error(check_infos,'Info field list not terminated: ',F:X),fail. |
| 3417 | | check_infos([],_). |
| 3418 | | check_infos([H|_],F) :- \+ ground(H),!, add_error(check_infos,'Info field not ground: ',F:H),fail. |
| 3419 | | check_infos([[H|T]|_],F) :- !, add_error(check_infos,'Info field contains nested list: ',F:[H|T]),fail. |
| 3420 | | check_infos([cse_used_ids(H)|T],F) :- member(cse_used_ids(H2),T),!, |
| 3421 | | add_error(check_infos,'Multiple cse_used_ids entries: ',F:[H,H2]),fail. |
| 3422 | | check_infos([used_ids(H)|T],F) :- member(used_ids(H2),T),!, |
| 3423 | | add_error(check_infos,'Multiple used_ids entries: ',F:[H,H2]),fail. |
| 3424 | | check_infos([nodeid(N1)|T],F) :- member(nodeid(N2),T),!, |
| 3425 | | add_error(check_infos,'Multiple nodeid entries: ',F:[N1,N2],[nodeid(N1)]),fail. |
| 3426 | | check_infos([removed_typing|T],F) :- member(removed_typing,T),!, |
| 3427 | | add_error(check_infos,'Multiple removed_typing entries: ',F,T),fail. |
| 3428 | | check_infos([_|T],F) :- check_infos(T,F). |
| 3429 | | |
| 3430 | | check_expr(Expr,Type,Infos) :- nonmember(contains_wd_condition,Infos), |
| 3431 | | sub_expression_contains_wd_condition(Expr,Sub), |
| 3432 | | TE = b(Expr,Type,Infos), |
| 3433 | | (Type = subst |
| 3434 | | -> fail % AST cleanup is not called for substitutions; WD-info not available for substitutions at the moment |
| 3435 | | ; translate_bexpression(TE,PS)), |
| 3436 | | functor(Expr,Functor,_), |
| 3437 | | functor(Sub,SubFunctor,_), |
| 3438 | | tools:ajoin(['Node for AST node ',Functor,' does not contain WD info from Subexpression ',SubFunctor,' :'],Msg), |
| 3439 | | add_warning(check_expr,Msg,PS,TE). |
| 3440 | | % well_def_analyser:nested_print_wd_bexpr(TE),nl. |
| 3441 | | % TODO: check when we have an unnecessary WD condition |
| 3442 | | check_expr(Expr,Type,Infos) :- nonmember(contains_wd_condition,Infos), |
| 3443 | | always_not_wd_top(Expr), |
| 3444 | | add_warning(check_expr,'AST is not well-defined but does not contain WD info: ',b(Expr,Type,Infos),Infos). |
| 3445 | | check_expr(member(LHS,RHS),Type,Infos) :- is_just_type(RHS), |
| 3446 | | get_preference(optimize_ast,true), |
| 3447 | | !, |
| 3448 | | TE = b(member(LHS,RHS),Type,Infos), |
| 3449 | | translate:translate_bexpression(TE,PS), |
| 3450 | | add_warning(check_expr,'AST contains redundant typing predicate: ',PS,TE). |
| 3451 | | check_expr(identifier(ID),_,_) :- illegal_id(ID),!, |
| 3452 | | add_error(check_infos,'Illegal identifier: ', identifier(ID)). |
| 3453 | | check_expr(lazy_lookup_expr(ID),_,_) :- illegal_id(ID),!, |
| 3454 | | add_error(check_infos,'Illegal identifier: ', lazy_lookup_expr(ID)). |
| 3455 | | check_expr(lazy_lookup_pred(ID),_,_) :- illegal_id(ID),!, |
| 3456 | | add_error(check_infos,'Illegal identifier: ', lazy_lookup_pred(ID)). |
| 3457 | | check_expr(exists(Parameters,Condition),pred,Infos) :- !, |
| 3458 | | check_used_ids(exists,Parameters,Condition,Infos,_Used). |
| 3459 | | check_expr(forall(Parameters,LHS,RHS),pred,Infos) :- !, |
| 3460 | | create_implication(LHS,RHS,Condition), |
| 3461 | | check_used_ids(forall,Parameters,Condition,Infos,_Used). % |
| 3462 | | check_expr(value(V),Type,_) :- !, check_bvalue(V,Type). |
| 3463 | | check_expr(_,_,_). |
| 3464 | | |
| 3465 | | % will check all used_ids fields (not just for exists and forall) |
| 3466 | | :- public check_used_ids_in_ast/1. |
| 3467 | | check_used_ids_in_ast(closure(_,_,TExpr)) :- !, (map_over_typed_bexpr(check_used_ids_aux,TExpr) ; true). |
| 3468 | | check_used_ids_in_ast(TExpr) :- map_over_typed_bexpr(check_used_ids_aux,TExpr). |
| 3469 | | check_used_ids_in_ast(_). |
| 3470 | | |
| 3471 | | check_used_ids_aux(AST) :- AST = b(_,_,Infos), |
| 3472 | ? | member(used_ids(_),Infos),!, |
| 3473 | | find_identifier_uses_if_necessary(AST,[],_), % will perform check |
| 3474 | | fail. |
| 3475 | | |
| 3476 | | % -------------------- |
| 3477 | | |
| 3478 | | :- use_module(specfile,[eventb_mode/0, z_or_tla_minor_mode/0]). |
| 3479 | | % check if an expression is definitely not WD; looking at the top-level operator only |
| 3480 | | always_not_wd_top(function(X,_)) :- definitely_empty_set(X). % TODO: detect a few more cases, e.g., arg not in dom |
| 3481 | | always_not_wd_top(power_of(X,Y)) :- (get_integer(Y,VY), VY < 0 -> true |
| 3482 | | ; eventb_mode, get_integer(X,VX), VX < 0). |
| 3483 | | always_not_wd_top(div(_,Val)) :- get_integer(Val,VV), VV==0. |
| 3484 | | always_not_wd_top(modulo(X,Y)) :- |
| 3485 | | (get_integer(Y,VY), VY=<0 |
| 3486 | | -> true % there seems to be a def for Z in Z Live, cf modulo2 |
| 3487 | | ; get_integer(X,VX), VX<0, \+ z_or_tla_minor_mode). |
| 3488 | | always_not_wd_top(min(X)) :- definitely_empty_set(X). |
| 3489 | | always_not_wd_top(max(X)) :- definitely_empty_set(X). |
| 3490 | | always_not_wd_top(size(X)) :- definitely_not_sequence(X). % TODO: detect infinite sets; also for card(_) |
| 3491 | | always_not_wd_top(first(X)) :- definitely_not_non_empty_sequence(X). |
| 3492 | | always_not_wd_top(front(X)) :- definitely_not_non_empty_sequence(X). |
| 3493 | | always_not_wd_top(last(X)) :- definitely_not_non_empty_sequence(X). |
| 3494 | | always_not_wd_top(tail(X)) :- definitely_not_non_empty_sequence(X). |
| 3495 | | always_not_wd_top(general_intersection(X)) :- definitely_empty_set(X). |
| 3496 | | |
| 3497 | | definitely_not_non_empty_sequence(X) :- |
| 3498 | | (definitely_empty_set(X) -> true ; definitely_not_sequence(X)). |
| 3499 | | |
| 3500 | | :- use_module(avl_tools,[avl_min_pair/3]). |
| 3501 | | definitely_not_sequence(b(value(A),_,_)) :- nonvar(A), A=avl_set(AVL), |
| 3502 | | avl_min_pair(AVL,int(StartIndex),_), StartIndex \= 1. |
| 3503 | | % TODO: treat set_extension |
| 3504 | | |
| 3505 | | :- use_module(b_ast_cleanup,[check_used_ids_info/4]). |
| 3506 | | check_used_ids(Quantifier,Parameters,Condition,Infos,Used) :- |
| 3507 | | select(used_ids(Used),Infos,Rest) |
| 3508 | | -> check_used_ids_info(Parameters,Condition,Used,Quantifier), %% comment in to check used_ids field |
| 3509 | | (member(used_ids(_),Rest) |
| 3510 | | -> add_internal_error('Multiple used_ids info fields:',Parameters:Infos) ; true) |
| 3511 | | ; |
| 3512 | | add_internal_error( |
| 3513 | | 'Expected information of used identifiers information',Quantifier:Parameters:Infos). |
| 3514 | | |
| 3515 | | illegal_id(ID) :- var(ID),!. |
| 3516 | | illegal_id(op(ID)) :- !, \+ atom(ID). |
| 3517 | | illegal_id(ID) :- \+ atom(ID). |
| 3518 | | |
| 3519 | | :- use_module(btypechecker, [unify_types_strict/2, couplise_list/2]). |
| 3520 | | :- use_module(avl_tools,[check_is_non_empty_avl/1]). |
| 3521 | | % TO DO: we could check type more |
| 3522 | | check_bvalue(V,_) :- var(V),!. |
| 3523 | | check_bvalue(avl_set(A),Type) :- !, unify_types_strict(Type,set(_)), |
| 3524 | | check_is_non_empty_avl(A). |
| 3525 | | check_bvalue(closure(_,T,B),Type) :- !, |
| 3526 | | couplise_list(T,CT), unify_types_strict(set(CT),Type), |
| 3527 | | check_ast(B). |
| 3528 | | check_bvalue(_,_). |
| 3529 | | |
| 3530 | | % ----------------------- |
| 3531 | | |
| 3532 | | |
| 3533 | | indent_ws(X) :- X<1,!. |
| 3534 | | indent_ws(X) :- print(' '), X1 is X-1, indent_ws(X1). |
| 3535 | | |
| 3536 | | print_ast_td(b(E,T,I),Level,L1) :- |
| 3537 | | indent_ws(Level), |
| 3538 | | (E=identifier(_) |
| 3539 | | -> format('~w (~w) -> ~w~n',[E,T,I]) |
| 3540 | | ; functor(E,F,N), |
| 3541 | | format('~w/~w (~w) -> ~w~n',[F,N,T,I]) |
| 3542 | | ), |
| 3543 | | L1 is Level+1. |
| 3544 | | print_ast(TExpr) :- |
| 3545 | | (map_over_typed_bexpr_top_down_acc(print_ast_td,TExpr,0),fail ; true). |
| 3546 | | |
| 3547 | | % --------------------- |
| 3548 | | |
| 3549 | | :- dynamic count_id_usage/2. |
| 3550 | | single_usage_id_count(Expr) :- uses_an_identifier(Expr,Id), |
| 3551 | | retract(count_id_usage(Id,Count)), |
| 3552 | | !, |
| 3553 | | Count=0, |
| 3554 | | C1 is Count+1, |
| 3555 | | assertz(count_id_usage(Id,C1)). |
| 3556 | | single_usage_id_count(_). |
| 3557 | | |
| 3558 | | % check if an identifier is used at most once |
| 3559 | | single_usage_identifier(ID,ExprOrPredicates,Count) :- |
| 3560 | | retractall(count_id_usage(_,_)), |
| 3561 | | assertz(count_id_usage(ID,0)), |
| 3562 | | % TO DO: take care of naming; do not count occurences when we enter scope defining ID |
| 3563 | | maplist(single_usage_cnt,ExprOrPredicates), |
| 3564 | | retract(count_id_usage(ID,Count)). |
| 3565 | | |
| 3566 | | single_usage_cnt(ExprOrPredicate) :- map_over_full_bexpr_no_fail(single_usage_id_count,ExprOrPredicate). |
| 3567 | | |
| 3568 | | gen_fresh_id_if_necessary(Default,Expr,FreshID) :- |
| 3569 | | occurs_in_expr(Default,Expr),!, |
| 3570 | | gensym('__FRESH_ID__',FreshID). % assumes _Fresh_XXX not used |
| 3571 | | gen_fresh_id_if_necessary(Default,_,Default). |
| 3572 | | |
| 3573 | | %% rewrite_if_then_else_expr_to_b(IfThenElseExpr, NExpr). |
| 3574 | | % Rewrite if-then-else expr to B as understood by Atelier-B. |
| 3575 | | % {d,x| d:BOOL & If => x=Then & not(if) => x=Else}(TRUE) |
| 3576 | | rewrite_if_then_else_expr_to_b(if_then_else(If,Then,Else), NExpr) :- |
| 3577 | | get_texpr_type(Then,Type), |
| 3578 | | ARG = b(boolean_true,boolean,[]), AT=boolean, % we could use unit type or BOOL here |
| 3579 | | gen_fresh_id_if_necessary('_zzzz_unary',b(if_then_else(If,Then,Else),Type,[]),AID1), |
| 3580 | | gen_fresh_id_if_necessary('_zzzz_binary',b(if_then_else(If,Then,Else),Type,[]),AID2), |
| 3581 | | safe_create_texpr(identifier(AID1), AT, [], Id1), % a dummy argument |
| 3582 | | safe_create_texpr(identifier(AID2), Type, [], Id2), % The result |
| 3583 | | safe_create_texpr(equal(Id2,Then), pred, [], Eq1), |
| 3584 | | safe_create_texpr(equal(Id2,Else), pred, [], Eq2), |
| 3585 | | safe_create_texpr(implication(If,Eq1), pred, [], Pred1), |
| 3586 | | safe_create_texpr(negation(If), pred, [], NIf), |
| 3587 | | safe_create_texpr(implication(NIf,Eq2), pred, [], Pred2), |
| 3588 | | safe_create_texpr(conjunct(Pred1,Pred2), pred, [], Pred), |
| 3589 | | safe_create_texpr(comprehension_set([Id1,Id2],Pred), set(couple(AT,Type)), [], FUN), |
| 3590 | | NExpr = function(FUN,ARG). |
| 3591 | | |
| 3592 | | |
| 3593 | | % -------------------- |
| 3594 | | |
| 3595 | | % apply normalisation rules from Atlier-B PP/ML provers |
| 3596 | | % see chapter 3 of Atelier-B prover manual |
| 3597 | | |
| 3598 | | normalise_bexpr_for_ml(TExpr,Res) :- |
| 3599 | | transform_bexpr(normalise_bexpr,TExpr,Res). |
| 3600 | | |
| 3601 | | normalise_bexpr(b(E,T,I),b(E2,T,I)) :- norm2(E,E2),!. |
| 3602 | | |
| 3603 | | norm2(equivalence(A,B),conjunct(TIMP1,TIMP2)) :- !, |
| 3604 | | safe_create_texpr(implication(A,B),pred,TIMP1), |
| 3605 | | safe_create_texpr(implication(B,A),pred,TIMP2). |
| 3606 | | norm2(subset_strict(A,B),conjunct(TMEM,TNEQ)) :- !, |
| 3607 | | norm2(subset(A,B),MEM), safe_create_texpr(MEM,pred,TMEM), |
| 3608 | | safe_create_not_equal(A,B,TNEQ). |
| 3609 | | norm2(subset(A,B),member(A,PowB)) :- !, % A <: B <===> A:POW(B) |
| 3610 | | get_texpr_type(A,TA), |
| 3611 | | safe_create_texpr(pow_subset(B),TA,PowB). |
| 3612 | | norm2(not_equal(A,B),negation(TEQ)) :- !, |
| 3613 | | safe_create_texpr(equal(A,B),pred,TEQ). |
| 3614 | | norm2(not_member(A,B),negation(TMEM)) :- !, |
| 3615 | | safe_create_texpr(member(A,B),pred,TMEM). |
| 3616 | | norm2(not_subset(A,B),negation(TMEM)) :- !, |
| 3617 | | norm2(subset(A,B),MEM),safe_create_texpr(MEM,pred,TMEM). |
| 3618 | | norm2(not_subset_strict(A,B),implication(TMEM,TEQ)) :- !, % A /<< : B <===> A:POW(B) => A=B |
| 3619 | | norm2(subset(A,B),MEM),safe_create_texpr(MEM,pred,TMEM), |
| 3620 | | safe_create_texpr(equal(A,B),pred,TEQ). |
| 3621 | | norm2(POW1,set_subtraction(TPOW,TSEMPTY)) :- not_empty_pow(POW1,A,POW), !, |
| 3622 | | % POW1(A) <===> POW(A) - {{}}, FIN1(A) <===> FIN(A) - {{}}, ... |
| 3623 | | safe_create_texpr(POW,pred,TPOW), |
| 3624 | | get_texpr_type(A,TA), TEMPTY = b(empty_set,TA,[]), |
| 3625 | | safe_create_texpr(set_extension([TEMPTY]),set(TA),TSEMPTY). |
| 3626 | | norm2(member(A,b(integer_set('NATURAL'),_,_)),conjunct(TMEM,TLEQ)) :- !, % A <: NATURAL <===> A:INTEGER & 0 <= A |
| 3627 | | INTEGER = b(integer_set('INTEGER'),set(integer),[]), |
| 3628 | | safe_create_texpr(member(A,INTEGER),pred,TMEM), |
| 3629 | | Zero = b(integer(0),integer,[]), |
| 3630 | | safe_create_texpr(less_equal(Zero,A),pred,TLEQ). |
| 3631 | | norm2(set_extension(List),Union) :- List = [H|T], T=[_|_], !, % {A,B} <===> {A} \/ {B} |
| 3632 | | get_texpr_type(H,Type), |
| 3633 | | set_extension_to_union(H,T,set(Type),b(Union,_,_)). |
| 3634 | | norm2(greater_equal(A,B),less_equal(B,A)) :- !. |
| 3635 | | norm2(greater(A,B),less_equal(B1,A)) :- !, plus1(B,B1). |
| 3636 | | norm2(less(A,B),less_equal(A,B1)) :- !, minus1(B,B1). % the normalisation rule in chapter 3 is actually false |
| 3637 | | norm2(integer_set(NAT1),set_subtraction(TNAT,TSZero)) :- nat1(NAT1,NAT), !, % NATURAL1 <===> NATURAL - {0} |
| 3638 | | TNAT = b(integer_set(NAT),set(integer),[]), |
| 3639 | | set_with_zero(TSZero). |
| 3640 | | norm2(empty_sequence,empty_set) :- !. |
| 3641 | | norm2(perm(A),intersection(ISEQ,PSURJ)) :- !, % perm(A) <===> iseq(A) /\ (NATURAL-{0} +->> A) |
| 3642 | | get_texpr_type(A,TA), |
| 3643 | | safe_create_texpr(iseq(A),set(seq(TA)),ISEQ), |
| 3644 | | set_with_zero(TSZero), |
| 3645 | | NATURAL = b(integer_set('NATURAL'),set(integer),[]), |
| 3646 | | safe_create_texpr(set_subtraction(NATURAL,TSZero),set(integer),DOM), |
| 3647 | | safe_create_texpr(partial_surjection(DOM,A),set(seq(TA)),PSURJ). |
| 3648 | | % TODO: total_relation, if_then_else, ...? |
| 3649 | | |
| 3650 | | set_with_zero(TSZero) :- % {0} |
| 3651 | | TZero = b(integer(0),TA,[]), |
| 3652 | | safe_create_texpr(set_extension([TZero]),set(TA),TSZero). |
| 3653 | | |
| 3654 | | % TODO: more intelligent versions like x-1 ==> x ... |
| 3655 | | plus1(A,Plus1) :- One = b(integer(1),integer,[]), |
| 3656 | | safe_create_texpr(add(A,One),integer,Plus1). |
| 3657 | | minus1(A,Plus1) :- One = b(integer(1),integer,[]), |
| 3658 | | safe_create_texpr(minus(A,One),integer,Plus1). |
| 3659 | | |
| 3660 | | not_empty_pow(pow1_subset(A),A,pow_subset(A)). |
| 3661 | | not_empty_pow(fin1_subset(A),A,fin_subset(A)). |
| 3662 | | not_empty_pow(seq1(A),A,seq(A)). |
| 3663 | | not_empty_pow(iseq1(A),A,iseq(A)). |
| 3664 | | |
| 3665 | | nat1('NATURAL1','NATURAL'). |
| 3666 | | nat1('NAT1','NAT'). |
| 3667 | | |
| 3668 | | safe_create_not_equal(A,B,TNEQ) :- |
| 3669 | | safe_create_texpr(equal(A,B),pred,TEQ), |
| 3670 | | safe_create_texpr(negation(TEQ),pred,TNEQ). |
| 3671 | | |
| 3672 | | set_extension_to_union(H,[],Type,Res) :- !, |
| 3673 | | safe_create_texpr(set_extension([H]),Type,Res). |
| 3674 | | set_extension_to_union(H,[H2|T],Type,Res) :- |
| 3675 | | safe_create_texpr(set_extension([H]),Type,TH), |
| 3676 | | set_extension_to_union(H2,T,Type,TUnion), |
| 3677 | | safe_create_texpr(union(TH,TUnion),Type,Res). |