model_parser.mli 9.62 KB
Newer Older
1 2 3
(********************************************************************)
(*                                                                  *)
(*  The Why3 Verification Platform   /   The Why3 Development Team  *)
MARCHE Claude's avatar
MARCHE Claude committed
4
(*  Copyright 2010-2017   --   INRIA - CNRS - Paris-Sud University  *)
5 6 7 8 9 10 11
(*                                                                  *)
(*  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
type model_value =
 | Integer of string
19
 | Decimal of (string * string)
20
 | Boolean of bool
21
 | Array of model_array
22
 | Record of model_record
23
 | Bitvector of string
24
 | Unparsed of string
25
and  arr_index = {
26
  arr_index_key : string;
27 28 29 30 31 32
  arr_index_value : model_value;
}
and model_array = {
  arr_others  : model_value;
  arr_indices : arr_index list;
}
33 34 35 36
and model_record ={
  discrs : model_value list;
  fields : model_value list;
}
37

38 39
val array_create_constant :
  value : model_value ->
40 41 42
  model_array
(** Creates constant array with all indices equal to the parameter value. *)

43 44
val array_add_element :
  array : model_array ->
45
  index : string      ->
46
  value : model_value ->
47
  model_array
48
(** Adds an element to the array.
49
    @param array : the array to that the element will be added
50

51 52 53 54 55 56 57 58
    @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

59 60

(*
61
***************************************************************
62 63 64
**  Model elements
***************************************************************
*)
65

66
type model_element_kind =
67 68 69
| Result
  (* Result of a function call (if the counter-example is for postcondition)  *)
| Old
70 71 72 73
  (* Old value of function argument (if the counter-example is for postcondition) *)
| Error_message
  (* The model element represents error message, not source-code element.
     The error message is saved in the name of the model element.*)
74 75
| Other

76 77 78 79 80 81 82
(** 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. *)
}
83

84 85
(** Counter-example model elements. Each element represents
    a counter-example for a single source-code element.*)
86
type model_element = {
87 88
  me_name     : model_element_name;
    (** Information about the name of the model element  *)
89 90 91 92
  me_value    : model_value;
    (** Counter-example value for the element. *)
  me_location : Loc.position option;
    (** Source-code location of the element. *)
93 94
  me_term     : Term.term option;
    (** Why term corresponding to the element.  *)
95 96
}

97 98 99 100
val create_model_element :
  name     : string ->
  value    : model_value ->
  ?location : Loc.position ->
101 102
  ?term     : Term.term ->
  unit ->
103
  model_element
104
(** Creates a counter-example model element.
105 106 107 108
    @param name : the name of the source-code element

    @param value  : counter-example value for the element

109 110
    @param location : source-code location of the element

111
    @param term : why term corresponding to the element *)
112

113
(*
114
***************************************************************
115 116
**  Model definitions
***************************************************************
117 118
*)
type model
119

120 121
val is_model_empty : model -> bool
val default_model : model
122 123

(*
124
***************************************************************
125 126 127
**  Quering the model
***************************************************************
*)
128

129
val print_model :
130
  ?me_name_trans:(model_element_name -> string) ->
131
  Format.formatter ->
132
  model ->
133 134 135 136
  unit
(** Prints the counter-example model

    @param me_name_trans the transformation of the model elements
137 138
      names. The input is information about model element name. The
      output is the name of the model element that should be displayed.
139 140 141 142
    @param model the counter-example model to print
*)

val model_to_string :
143
  ?me_name_trans:(model_element_name -> string) ->
144 145 146
  model ->
  string
(** See print_model  *)
147

148
val print_model_vc_term :
149
  ?me_name_trans: (model_element_name -> string) ->
150 151 152 153 154 155 156 157 158 159 160 161
  ?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.
*)

162
val model_vc_term_to_string :
163
  ?me_name_trans: (model_element_name -> string) ->
164 165 166 167 168 169 170 171
  ?sep: string ->
  model ->
  string
(** Gets string with counter-example model elements related to term that
    triggers VC.
    See print_model_vc_term
*)

172
val print_model_json :
173
  ?me_name_trans:(model_element_name -> string) ->
174
  ?vc_line_trans:(int -> string) ->
175
  Format.formatter ->
176
  model ->
177 178
  unit
(** Prints counter-example model to json format.
179

180
    @param me_name_trans see print_model
181 182 183 184 185 186 187 188 189 190
    @param vc_line_trans the transformation from the line number corresponding
      to the term that triggers VC before splitting VC to the name of JSON field
      storing counterexample information related to this term. By default, this
      information is stored in JSON field corresponding to this line, i.e.,
      the transformation is string_of_int.
      Note that the exact line of the construct that triggers VC may not be
      known. This can happen if the term that triggers VC spans multiple lines
      and it is splitted.
      This transformation can be used to store the counterexample information
      related to this term in dedicated JSON field.
191 192
    @model the counter-example model to print.

193 194 195 196 197 198 199 200 201 202 203 204
    The format is the following:
    - counterexample is JSON object with fields indexed by names of files
      storing values of counterexample_file
    - counterexample_file is JSON object with fields indexed by line numbers
      storing values of counterexample_line
    - counterexample_line is JSON array (ordered list) with elements
      corresponding to counterexample_element
    - counterexample_element is JSON object with following fields
      - "name": name of counterexample element
      - "value": value of counterexample element
      - "kind": kind of counterexample element:
        - "result": Result of a function call (if the counter-example is for postcondition)
205
        - "old": Old value of function argument (if the counter-example is for postcondition)
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
        - "error_message": The model element represents error message, not source-code element.
            The error message is saved in the name of the model element
        - "other"

    Example:
    {
      "records.adb": {
          "84": [
            {
              "name": "A.A",
              "value": "255",
              "kind": "other"
            },
            {
              "name": "B.B",
              "value": "0",
              "kind": "other"
            }
          ]
      }
    }
227
*)
228

229
val model_to_string_json :
230
  ?me_name_trans:(model_element_name -> string) ->
231
  ?vc_line_trans:(int -> string) ->
232 233 234
  model ->
  string
(** See print_model_json *)
235

236
val interleave_with_source :
237 238
  ?start_comment:string ->
  ?end_comment:string ->
239
  ?me_name_trans:(model_element_name -> string) ->
240
  model ->
241 242
  filename:string ->
  source_code:string ->
243
  string
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
(** 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
*)
260 261

(*
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
***************************************************************
**  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.
*)

(*
***************************************************************
282 283 284 285
** Registering model parser
***************************************************************
*)
type model_parser =  string -> Printer.printer_mapping -> model
286 287
(** Parses the input string into model elements, estabilishes
    a mapping between these elements and mapping from printer
288 289
    and builds model data structure.
*)
290

291 292
type raw_model_parser =  string -> model_element list
(** Parses the input string into model elements. *)
293

294
val register_model_parser : desc:Pp.formatted -> string -> raw_model_parser -> unit
295 296 297 298

val lookup_model_parser : string -> model_parser

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