Source file `operator.ml`

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
(****************************************************************************)
(*                                                                          *)
(* This file is part of MOPSA, a Modular Open Platform for Static Analysis. *)
(*                                                                          *)
(* Copyright (C) 2017-2019 The MOPSA Project.                               *)
(*                                                                          *)
(* This program is free software: you can redistribute it and/or modify     *)
(* it under the terms of the GNU Lesser General Public License as published *)
(* by the Free Software Foundation, either version 3 of the License, or     *)
(* (at your option) any later version.                                      *)
(*                                                                          *)
(* This program is distributed in the hope that it will be useful,          *)
(* but WITHOUT ANY WARRANTY; without even the implied warranty of           *)
(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *)
(* GNU Lesser General Public License for more details.                      *)
(*                                                                          *)
(* You should have received a copy of the GNU Lesser General Public License *)
(* along with this program.  If not, see <http://www.gnu.org/licenses/>.    *)
(*                                                                          *)
(****************************************************************************)

(** Extensible type of operators. *)


open Mopsa_utils
open Format

type operator = ..

(** Basic operators *)
type operator +=
  | O_eq         (** == *)
  | O_ne         (** != *)
  | O_lt         (** < *)
  | O_le         (** <= *)
  | O_gt         (** > *)
  | O_ge         (** >= *)

  | O_log_not    (** Logical negation *)
  | O_log_or     (** || *)
  | O_log_and    (** && *)
  | O_log_xor    (** xor *)

  | O_cast       (** cast operator *)


let operator_compare_chain = TypeExt.mk_compare_chain (fun o1 o2 ->
    compare o1 o2
  )

let operator_pp_chain = TypeExt.mk_print_chain (fun fmt op ->
    match op with
    | O_lt -> pp_print_string fmt "<"
    | O_le -> pp_print_string fmt "<="
    | O_gt -> pp_print_string fmt ">"
    | O_ge -> pp_print_string fmt ">="
    | O_eq -> pp_print_string fmt "=="
    | O_ne -> pp_print_string fmt "!="
    | O_log_or -> pp_print_string fmt "or"
    | O_log_and -> pp_print_string fmt "and"
    | O_log_not -> pp_print_string fmt "not"
    | O_log_xor -> pp_print_string fmt "xor"
    | O_cast -> pp_print_string fmt "cast"
    | _ -> Exceptions.panic "operator_pp_chain: unknown operator"
  )


let register_operator (info: operator TypeExt.info) : unit =
  TypeExt.register info operator_compare_chain operator_pp_chain

let register_operator_compare cmp = TypeExt.register_compare cmp operator_compare_chain

let register_operator_pp pp = TypeExt.register_print pp operator_pp_chain

let compare_operator o1 o2 = TypeExt.compare operator_compare_chain o1 o2

let pp_operator fmt operator = TypeExt.print operator_pp_chain fmt operator

let is_comparison_op = function
  | O_eq | O_ne | O_gt | O_ge | O_lt | O_le -> true
  | _ -> false

let is_logic_op = function
  | O_log_and | O_log_or | O_log_not | O_log_xor -> true
  | _ -> false

let negate_logic_op = function
  | O_log_and -> O_log_or
  | O_log_or  -> O_log_and
  | op -> Exceptions.panic "don't know how to negate operator %a" pp_operator op

let negate_comparison_op = function
  | O_eq -> O_ne
  | O_ne -> O_eq
  | O_lt -> O_ge
  | O_le -> O_gt
  | O_gt -> O_le
  | O_ge -> O_lt
  | op -> Exceptions.panic "don't know how to negate operator %a" pp_operator op