engine/cocci_vs_c.mli

   1 (*****************************************************************************)
   2 (* Cocci vs C *)
   3 (*****************************************************************************)
   4
   5 (* This module was introduced to factorize code between
   6  * pattern.ml and transformation.ml. In both cases we need
   7  * to "compare" a piece of C with a piece of Cocci, and depending
   8  * if we want just to pattern or transform, we perform different
   9  * actions on the tokens. So, the common code is in this module
  10  * and the module specific actions are in pattern.ml and transformation.ml.
  11  *
  12  * We could have used a visitor approach as in visitor_c but I prefer
  13  * this time to use a functor. The specific actions are passed
  14  * via a module to the functor.
  15  *
  16  * If the functor is too complex too understand, you can look at
  17  * the comments in pattern.ml and transformation.ml to look at
  18  * how it was done before, which may help to understand how
  19  * it is done now.
  20  *
  21  * You can also look at the papers on parser combinators in haskell
  22  * (cf a pearl by meijer in ICFP) to understand our monadic
  23  * approach to matching/unifying.
  24  *)
  25
  26
  27 (* should be used as less as possible. Most of the time the code in
  28  * cocci_vs_c should be the same if we pattern or transform *)
  29 type mode = PatternMode | TransformMode
  30
  31 (* used in both pattern and transform, in envf *)
  32 val equal_metavarval :
  33   Ast_c.metavar_binding_kind -> Ast_c.metavar_binding_kind -> bool
  34
  35 (* for inherited metavariables.  no declaration link on expressions *)
  36 val equal_inh_metavarval :
  37   Ast_c.metavar_binding_kind -> Ast_c.metavar_binding_kind -> bool
  38
  39 (*****************************************************************************)
  40 (* The parameter of the functor (the specific actions) *)
  41 (*****************************************************************************)
  42
  43
  44 module type PARAM =
  45   sig
  46     type tin
  47     type 'a tout
  48
  49     (* a matcher between 'a' and 'b'  take 'a' and 'b' in parameter,
  50      * and "something" (tin; a state that is threaded across calls),
  51      * and return a new 'a' and 'b' encapsulated in "something" (tout)
  52      *)
  53     type ('a, 'b) matcher = 'a -> 'b -> tin -> ('a * 'b) tout
  54
  55     val mode : mode
  56
  57     (* -------------------------------------------------------------------- *)
  58     (* The monadic combinators *)
  59     (* -------------------------------------------------------------------- *)
  60
  61     (* it kinds of take a matcher in parameter, and another matcher,
  62      * and returns a matcher, so =~ matcher -> matcher -> matcher
  63      *)
  64     val ( >>= ) :
  65       (tin -> ('a * 'b) tout) ->
  66       ('a -> 'b -> tin -> ('c * 'd) tout) ->
  67       tin -> ('c * 'd) tout
  68
  69     val return : 'a * 'b -> tin -> ('a * 'b) tout
  70     val fail : tin -> ('a * 'b) tout
  71
  72     val ( >||> ) :  (tin -> 'a tout) -> (tin -> 'a tout) -> tin -> 'a tout
  73     val ( >|+|> ) : (tin -> 'a tout) -> (tin -> 'a tout) -> tin -> 'a tout
  74     val ( >&&> ) :  (tin -> bool) -> (tin -> 'a tout) -> tin -> 'a tout
  75
  76     (* -------------------------------------------------------------------- *)
  77     (* Tokens tagging *)
  78     (* -------------------------------------------------------------------- *)
  79     val tokenf :     ('a Ast_cocci.mcode,  Ast_c.info) matcher
  80     val tokenf_mck : (Ast_cocci.mcodekind, Ast_c.info) matcher
  81
  82     (* -------------------------------------------------------------------- *)
  83     (* Distr_f functions, to tag a range of tokens *)
  84     (* -------------------------------------------------------------------- *)
  85
  86     val distrf_e :
  87       (Ast_cocci.meta_name Ast_cocci.mcode, Ast_c.expression) matcher
  88
  89     val distrf_args :
  90       (Ast_cocci.meta_name Ast_cocci.mcode,
  91       (Ast_c.argument, Ast_c.il) Common.either list)
  92       matcher
  93
  94     val distrf_type :
  95       (Ast_cocci.meta_name Ast_cocci.mcode, Ast_c.fullType) matcher
  96
  97     val distrf_params :
  98       (Ast_cocci.meta_name Ast_cocci.mcode,
  99       (Ast_c.parameterType, Ast_c.il) Common.either list)
 100       matcher
 101     val distrf_param :
 102       (Ast_cocci.meta_name Ast_cocci.mcode, Ast_c.parameterType) matcher
 103
 104     val distrf_ini :
 105       (Ast_cocci.meta_name Ast_cocci.mcode, Ast_c.initialiser) matcher
 106
 107     val distrf_node :
 108       (Ast_cocci.meta_name Ast_cocci.mcode, Control_flow_c.node) matcher
 109
 110     val distrf_define_params :
 111       (Ast_cocci.meta_name Ast_cocci.mcode,
 112       (string Ast_c.wrap, Ast_c.il) Common.either list)
 113       matcher
 114
 115     val distrf_struct_fields :
 116       (Ast_cocci.meta_name Ast_cocci.mcode, Ast_c.field list)
 117       matcher
 118
 119     val distrf_cst :
 120       (Ast_cocci.meta_name Ast_cocci.mcode,
 121       (Ast_c.constant, string) Common.either Ast_c.wrap)
 122       matcher
 123
 124     (* -------------------------------------------------------------------- *)
 125     (* Modifying nested expression and nested types, with Exp and Ty *)
 126     (* -------------------------------------------------------------------- *)
 127
 128     val cocciExp :
 129       (Ast_cocci.expression, Ast_c.expression) matcher ->
 130       (Ast_cocci.expression, Control_flow_c.node) matcher
 131
 132     val cocciExpExp :
 133       (Ast_cocci.expression, Ast_c.expression) matcher ->
 134       (Ast_cocci.expression, Ast_c.expression) matcher
 135
 136     val cocciTy :
 137       (Ast_cocci.fullType, Ast_c.fullType) matcher ->
 138       (Ast_cocci.fullType, Control_flow_c.node) matcher
 139
 140     val cocciInit :
 141       (Ast_cocci.initialiser, Ast_c.initialiser) matcher ->
 142       (Ast_cocci.initialiser, Control_flow_c.node) matcher
 143
 144     (* -------------------------------------------------------------------- *)
 145     (* Environment manipulation. Extract info from tin, the "something" *)
 146     (* -------------------------------------------------------------------- *)
 147     val envf :
 148       Ast_cocci.keep_binding ->
 149       Ast_cocci.inherited ->
 150       Ast_cocci.meta_name Ast_cocci.mcode * Ast_c.metavar_binding_kind *
 151           (* pos info, if needed *)
 152           (unit -> Common.filename * string * Ast_c.posl * Ast_c.posl) ->
 153       (unit -> tin -> 'x tout) -> (tin -> 'x tout)
 154
 155     val check_idconstraint :
 156       ('a -> 'b -> bool) -> 'a -> 'b ->
 157         (unit -> tin -> 'x tout) -> (tin -> 'x tout)
 158
 159     val check_constraints_ne :
 160       ('a, 'b) matcher -> 'a list -> 'b ->
 161         (unit -> tin -> 'x tout) -> (tin -> 'x tout)
 162
 163     val all_bound : Ast_cocci.meta_name list -> tin -> bool
 164
 165
 166     val optional_storage_flag : (bool -> tin -> 'x tout) -> (tin -> 'x tout)
 167     val optional_qualifier_flag : (bool -> tin -> 'x tout) -> (tin -> 'x tout)
 168     val value_format_flag: (bool -> tin -> 'x tout) -> (tin -> 'x tout)
 169
 170
 171   end
 172
 173
 174 (*****************************************************************************)
 175 (* The functor itself *)
 176 (*****************************************************************************)
 177
 178 module COCCI_VS_C :
 179   functor (X : PARAM) ->
 180     sig
 181       type ('a, 'b) matcher = 'a -> 'b -> X.tin -> ('a * 'b) X.tout
 182
 183       val rule_elem_node : (Ast_cocci.rule_elem, Control_flow_c.node) matcher
 184
 185       val expression :     (Ast_cocci.expression, Ast_c.expression)   matcher
 186
 187       (* there are far more functions in this functor but they do not have
 188        * to be exported
 189        *)
 190
 191     end
 192
 193