model_parser.mli 7.52 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
(********************************************************************)
(*                                                                  *)
(*  The Why3 Verification Platform   /   The Why3 Development Team  *)
(*  Copyright 2010-2015   --   INRIA - CNRS - Paris-Sud University  *)
(*                                                                  *)
(*  This software is distributed under the terms of the GNU Lesser  *)
(*  General Public License version 2.1, with the special exception  *)
(*  on linking described in file LICENSE.                           *)
(*                                                                  *)
(********************************************************************)

12
(*
13
***************************************************************
14 15 16
**  Counter-example model values
****************************************************************
*)
17 18 19
type model_value =
 | Integer of string
 | Array of model_array
20
 | Bitvector of int
21
 | Unparsed of string
22
and  arr_index = {
23
  arr_index_key : model_value;
24 25 26 27 28 29 30
  arr_index_value : model_value;
}
and model_array = {
  arr_others  : model_value;
  arr_indices : arr_index list;
}

31 32
val array_create_constant :
  value : model_value ->
33 34 35
  model_array
(** Creates constant array with all indices equal to the parameter value. *)

36 37 38 39
val array_add_element :
  array : model_array ->
  index : model_value ->
  value : model_value ->
40
  model_array
41
(** Adds an element to the array.
42
    @param array : the array to that the element will be added
43

44 45 46 47 48 49 50 51
    @param index : the index on which the element will be added.
    Note that the index must be of value model_value.Integer

    @param value : the value of the element to be added
*)

val print_model_value : Format.formatter -> model_value -> unit

52 53

(*
54
***************************************************************
55 56 57
**  Model elements
***************************************************************
*)
58

59
type model_element_kind =
60 61 62 63 64 65
| Result
  (* Result of a function call (if the counter-example is for postcondition)  *)
| Old
  (* Old value of function argument (if the counter-example is for postcondition)  *)
| Other

66 67 68 69 70 71 72
(** Information about the name of the model element *)
type model_element_name = {
  men_name   : string;
    (** The name of the source-code element.  *)
  men_kind   : model_element_kind;
    (** The kind of model element. *)
}
73

74 75
(** Counter-example model elements. Each element represents
    a counter-example for a single source-code element.*)
76
type model_element = {
77 78
  me_name     : model_element_name;
    (** Information about the name of the model element  *)
79 80 81 82
  me_value    : model_value;
    (** Counter-example value for the element. *)
  me_location : Loc.position option;
    (** Source-code location of the element. *)
83 84
  me_term     : Term.term option;
    (** Why term corresponding to the element.  *)
85 86 87 88
  me_text_info: bool;
    (** True if the model element represents just textual
        information and not source-code element.
        In this case, just me_name is printed, not its value.*)
89 90
}

91 92 93 94
val create_model_element :
  name     : string ->
  value    : model_value ->
  ?location : Loc.position ->
95 96
  ?term     : Term.term ->
  unit ->
97
  model_element
98
(** Creates a counter-example model element.
99 100 101 102
    @param name : the name of the source-code element

    @param value  : counter-example value for the element

103 104
    @param location : source-code location of the element

105
    @param term : why term corresponding to the element *)
106

107
(*
108
***************************************************************
109 110
**  Model definitions
***************************************************************
111 112
*)
type model
113

114 115
val is_model_empty : model -> bool
val default_model : model
116 117

(*
118
***************************************************************
119 120 121
**  Quering the model
***************************************************************
*)
122

123
val print_model :
124
  ?me_name_trans:(model_element_name -> string) ->
125
  Format.formatter ->
126
  model ->
127 128 129 130
  unit
(** Prints the counter-example model

    @param me_name_trans the transformation of the model elements
131 132
      names. The input is information about model element name. The
      output is the name of the model element that should be displayed.
133 134 135 136
    @param model the counter-example model to print
*)

val model_to_string :
137
  ?me_name_trans:(model_element_name -> string) ->
138 139 140
  model ->
  string
(** See print_model  *)
141

142
val print_model_vc_term :
143
  ?me_name_trans: (model_element_name -> string) ->
144 145 146 147 148 149 150 151 152 153 154 155
  ?sep: string ->
  Format.formatter ->
  model ->
  unit
(** Prints counter-example model elements related to term that
    triggers VC.

    @param sep separator of counter-example model elements
    @param me_name_trans see print_model
    @model the counter-example model.
*)

156
val model_vc_term_to_string :
157
  ?me_name_trans: (model_element_name -> string) ->
158 159 160 161 162 163 164 165
  ?sep: string ->
  model ->
  string
(** Gets string with counter-example model elements related to term that
    triggers VC.
    See print_model_vc_term
*)

166
val print_model_json :
167
  ?me_name_trans:(model_element_name -> string) ->
168
  Format.formatter ->
169
  model ->
170 171
  unit
(** Prints counter-example model to json format.
172

173 174 175
    @param me_name_trans see print_model
    @model the counter-example model to print.
*)
176

177
val model_to_string_json :
178
  ?me_name_trans:(model_element_name -> string) ->
179 180 181
  model ->
  string
(** See print_model_json *)
182

183
val interleave_with_source :
184 185
  ?start_comment:string ->
  ?end_comment:string ->
186
  ?me_name_trans:(model_element_name -> string) ->
187
  model ->
188 189
  filename:string ->
  source_code:string ->
190
  string
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
(** Given a source code and a counter-example model interleaves
    the source code with information in about the counter-example.
    That is, for each location in counter-example trace creates
    a comment in the output source code with information about
    values of counter-example model elements.

    @param start_comment the string that starts a comment
    @param end_comment the string that ends a comment
    @param me_name_trans see print_model
    @param model counter-example model
    @param filename the file name of the source
    @param source_code the input source code

    @return the source code with added comments with information
    about counter-example model
*)
207 208

(*
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
***************************************************************
**  Filtering the model
***************************************************************
*)
val model_for_positions_and_decls : model ->
  positions: Loc.position list -> model
(** Given a model and a list of source-code positions returns model
    that contains only elements from the input model that are on these
    positions plus for every file in the model, elements that are
    in the positions of function declarations. Elements with other
    positions are filtered out.

    Assumes that for each file the element on the first line of the model
    has position of function declaration.

    Only filename and line number is used to identify positions.
*)

(*
***************************************************************
229 230 231 232
** Registering model parser
***************************************************************
*)
type model_parser =  string -> Printer.printer_mapping -> model
233 234
(** Parses the input string into model elements, estabilishes
    a mapping between these elements and mapping from printer
235 236
    and builds model data structure.
*)
237

238 239
type raw_model_parser =  string -> model_element list
(** Parses the input string into model elements. *)
240

241
val register_model_parser : desc:Pp.formatted -> string -> raw_model_parser -> unit
242 243 244 245

val lookup_model_parser : string -> model_parser

val list_model_parsers : unit -> (string * Pp.formatted) list