2 * Copyright 2010, INRIA, University of Copenhagen
3 * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
4 * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
5 * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
6 * This file is part of Coccinelle.
8 * Coccinelle is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, according to version 2 of the License.
12 * Coccinelle is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Coccinelle. If not, see <http://www.gnu.org/licenses/>.
20 * The authors reserve the right to distribute this or future versions of
21 * Coccinelle under other licenses.
25 (* detect statements that are between dots in the minus code, because they
26 may need a special treatment if they are if branches *)
28 module Ast0
= Ast0_cocci
29 module Ast
= Ast_cocci
30 module V0
= Visitor_ast0
31 module VT0
= Visitor_ast0_types
33 (* --------------------------------------------------------------------- *)
34 (* --------------------------------------------------------------------- *)
38 match Ast0.undots l
with
43 match List.rev
(Ast0.undots l
) with
47 let modif_before_mcode mc
=
48 match Ast0.get_mcode_mcodekind mc
with
49 Ast0.MINUS mc
-> true (*conservative; don't want to hunt right for + code*)
50 | Ast0.PLUS _
-> failwith
"not possible"
53 (Ast.BEFORE _
,_
,_
) -> true
54 | (Ast.BEFOREAFTER _
,_
,_
) -> true
56 | Ast0.MIXED mc
-> true (* don't think mcode can be mixed *)
58 let modif_after_mcodekind = function
59 Ast0.MINUS mc
-> true (*conservative; don't want to hunt right for + code*)
60 | Ast0.PLUS _
-> failwith
"not possible"
63 (Ast.AFTER _
,_
,_
) -> true
64 | (Ast.BEFOREAFTER _
,_
,_
) -> true
66 | Ast0.MIXED mc
-> true (* don't think mcode can be mixed *)
68 let modif_after_mcode mc
= modif_after_mcodekind (Ast0.get_mcode_mcodekind mc
)
74 Ast.StatementTag
(_
) | Ast.StmtDotsTag
(_
)
75 | Ast.DeclarationTag
(_
) | Ast.DeclDotsTag
(_
) -> true | _
-> false))
78 match Ast0.get_mcodekind x
with
79 Ast0.PLUS _
-> failwith
"not possible"
82 (* do better for the common case of replacing a stmt by another one *)
83 ([[Ast.StatementTag
(s
)]],ti
) ->
84 (match Ast.unwrap s
with
85 Ast.IfThen
(_
,_
,_
) -> true (* potentially dangerous *)
86 | _
-> mc
:= ([[Ast.StatementTag
(s
)]],ti
); false)
88 | Ast0.CONTEXT mc
| Ast0.MIXED mc
->
90 (Ast.BEFORE _
,_
,_
) -> true
91 | (Ast.BEFOREAFTER _
,_
,_
) -> true
95 match Ast0.get_mcodekind x
with
96 Ast0.PLUS _
-> failwith
"not possible"
99 (* do better for the common case of replacing a stmt by another one *)
100 ([[Ast.StatementTag
(s
)]],ti
) ->
101 (match Ast.unwrap s
with
102 Ast.IfThen
(_
,_
,_
) -> true (* potentially dangerous *)
103 | _
-> mc
:= ([[Ast.StatementTag
(s
)]],ti
); false)
104 | (l
,_
) when any_statements l
-> true
105 | (l
,ti
) -> mc
:= (l
,ti
); false)
106 | Ast0.CONTEXT mc
| Ast0.MIXED mc
->
108 (Ast.AFTER _
,_
,_
) -> true
109 | (Ast.BEFOREAFTER _
,_
,_
) -> true
113 let rec left_ident i
=
115 match Ast0.unwrap i
with
116 Ast0.Id
(name
) -> modif_before_mcode name
117 | Ast0.MetaId
(name
,_
,_
) -> modif_before_mcode name
118 | Ast0.MetaFunc
(name
,_
,_
) -> modif_before_mcode name
119 | Ast0.MetaLocalFunc
(name
,_
,_
) -> modif_before_mcode name
120 | Ast0.OptIdent
(id
) -> left_ident id
121 | Ast0.UniqueIdent
(id
) -> left_ident id
123 (* --------------------------------------------------------------------- *)
126 let rec left_expression e
=
128 match Ast0.unwrap e
with
129 Ast0.Ident
(id
) -> left_ident id
130 | Ast0.Constant
(const
) -> modif_before_mcode const
131 | Ast0.FunCall
(fn
,lp
,args
,rp
) -> left_expression fn
132 | Ast0.Assignment
(left
,op
,right
,_
) -> left_expression left
133 | Ast0.CondExpr
(exp1
,why
,exp2
,colon
,exp3
) -> left_expression exp1
134 | Ast0.Postfix
(exp
,op
) -> left_expression exp
135 | Ast0.Infix
(exp
,op
) -> modif_before_mcode op
136 | Ast0.Unary
(exp
,op
) -> modif_before_mcode op
137 | Ast0.Binary
(left
,op
,right
) -> left_expression left
138 | Ast0.Nested
(left
,op
,right
) -> left_expression left
139 | Ast0.Paren
(lp
,exp
,rp
) -> modif_before_mcode lp
140 | Ast0.ArrayAccess
(exp1
,lb
,exp2
,rb
) -> left_expression exp1
141 | Ast0.RecordAccess
(exp
,pt
,field
) -> left_expression exp
142 | Ast0.RecordPtAccess
(exp
,ar
,field
) -> left_expression exp
143 | Ast0.Cast
(lp
,ty
,rp
,exp
) -> modif_before_mcode lp
144 | Ast0.SizeOfExpr
(szf
,exp
) -> modif_before_mcode szf
145 | Ast0.SizeOfType
(szf
,lp
,ty
,rp
) -> modif_before_mcode szf
146 | Ast0.TypeExp
(ty
) -> left_typeC ty
147 | Ast0.MetaErr
(name
,_
,_
) -> modif_before_mcode name
148 | Ast0.MetaExpr
(name
,_
,ty
,_
,_
) -> modif_before_mcode name
149 | Ast0.MetaExprList
(name
,_
,_
) -> modif_before_mcode name
150 | Ast0.EComma
(cm
) -> modif_before_mcode cm
151 | Ast0.DisjExpr
(_
,exp_list
,_
,_
) -> List.exists
left_expression exp_list
152 | Ast0.NestExpr
(starter
,expr_dots
,ender
,_
,multi
) ->
153 left_dots left_expression expr_dots
154 | Ast0.Edots
(dots
,_
) | Ast0.Ecircles
(dots
,_
) | Ast0.Estars
(dots
,_
) -> false
155 | Ast0.OptExp
(exp
) -> left_expression exp
156 | Ast0.UniqueExp
(exp
) -> left_expression exp
158 (* --------------------------------------------------------------------- *)
163 match Ast0.unwrap t
with
164 Ast0.ConstVol
(cv
,ty
) -> modif_before_mcode cv
165 | Ast0.BaseType
(ty
,strings
) -> modif_before_mcode (List.hd strings
)
166 | Ast0.Signed
(sgn
,ty
) -> modif_before_mcode sgn
167 | Ast0.Pointer
(ty
,star
) -> left_typeC ty
168 | Ast0.FunctionPointer
(ty
,lp1
,star
,rp1
,lp2
,params
,rp2
) -> left_typeC ty
169 | Ast0.FunctionType
(Some ty
,lp1
,params
,rp1
) -> left_typeC ty
170 | Ast0.FunctionType
(None
,lp1
,params
,rp1
) -> modif_before_mcode lp1
171 | Ast0.Array
(ty
,lb
,size
,rb
) -> left_typeC ty
172 | Ast0.EnumName
(kind
,name
) -> modif_before_mcode kind
173 | Ast0.EnumDef
(ty
,lb
,ids
,rb
) -> left_typeC ty
174 | Ast0.StructUnionName
(kind
,name
) -> modif_before_mcode kind
175 | Ast0.StructUnionDef
(ty
,lb
,decls
,rb
) -> left_typeC ty
176 | Ast0.TypeName
(name
) -> modif_before_mcode name
177 | Ast0.MetaType
(name
,_
) -> modif_before_mcode name
178 | Ast0.DisjType
(lp
,types
,mids
,rp
) -> List.exists left_typeC types
179 | Ast0.OptType
(ty
) -> left_typeC ty
180 | Ast0.UniqueType
(ty
) -> left_typeC ty
182 (* --------------------------------------------------------------------- *)
183 (* Variable declaration *)
184 (* Even if the Cocci program specifies a list of declarations, they are
185 split out into multiple declarations of a single variable each. *)
187 and left_declaration d
=
189 match Ast0.unwrap d
with
190 Ast0.MetaDecl
(name
,_
) | Ast0.MetaField
(name
,_
) -> modif_before_mcode name
191 | Ast0.Init
(Some stg
,ty
,id
,eq
,ini
,sem
) -> modif_before_mcode stg
192 | Ast0.Init
(None
,ty
,id
,eq
,ini
,sem
) -> left_typeC ty
193 | Ast0.UnInit
(Some stg
,ty
,id
,sem
) -> modif_before_mcode stg
194 | Ast0.UnInit
(None
,ty
,id
,sem
) -> left_typeC ty
195 | Ast0.MacroDecl
(name
,lp
,args
,rp
,sem
) -> left_ident name
196 | Ast0.TyDecl
(ty
,sem
) -> left_typeC ty
197 | Ast0.Typedef
(stg
,ty
,id
,sem
) -> modif_before_mcode stg
198 | Ast0.DisjDecl
(_
,decls
,_
,_
) -> List.exists left_declaration decls
199 | Ast0.Ddots
(dots
,_
) -> false
200 | Ast0.OptDecl
(decl
) -> left_declaration decl
201 | Ast0.UniqueDecl
(decl
) -> left_declaration decl
203 and right_declaration d
=
205 match Ast0.unwrap d
with
206 Ast0.MetaDecl
(name
,_
) | Ast0.MetaField
(name
,_
) -> modif_before_mcode name
207 | Ast0.Init
(_
,ty
,id
,eq
,ini
,sem
) -> modif_after_mcode sem
208 | Ast0.UnInit
(_
,ty
,id
,sem
) -> modif_after_mcode sem
209 | Ast0.MacroDecl
(name
,lp
,args
,rp
,sem
) -> modif_after_mcode sem
210 | Ast0.TyDecl
(ty
,sem
) -> modif_after_mcode sem
211 | Ast0.Typedef
(stg
,ty
,id
,sem
) -> modif_after_mcode sem
212 | Ast0.DisjDecl
(_
,decls
,_
,_
) -> List.exists right_declaration decls
213 | Ast0.Ddots
(dots
,_
) -> false
214 | Ast0.OptDecl
(decl
) -> right_declaration decl
215 | Ast0.UniqueDecl
(decl
) -> right_declaration decl
217 (* --------------------------------------------------------------------- *)
220 and left_statement s
=
222 match Ast0.unwrap s
with
223 Ast0.FunDecl
(_
,fninfo
,name
,lp
,params
,rp
,lbrace
,body
,rbrace
) ->
224 (* irrelevant *) false
225 | Ast0.Decl
(_
,decl
) -> left_declaration decl
226 | Ast0.Seq
(lbrace
,body
,rbrace
) -> modif_before_mcode lbrace
227 | Ast0.ExprStatement
(exp
,sem
) -> left_expression exp
228 | Ast0.IfThen
(iff
,lp
,exp
,rp
,branch1
,(info
,aft
)) -> modif_before_mcode iff
229 | Ast0.IfThenElse
(iff
,lp
,exp
,rp
,branch1
,els
,branch2
,(info
,aft
)) ->
230 modif_before_mcode iff
231 | Ast0.While
(whl
,lp
,exp
,rp
,body
,(info
,aft
)) -> modif_before_mcode whl
232 | Ast0.Do
(d
,body
,whl
,lp
,exp
,rp
,sem
) -> modif_before_mcode d
233 | Ast0.For
(fr
,lp
,e1
,sem1
,e2
,sem2
,e3
,rp
,body
,(info
,aft
)) ->
234 modif_before_mcode fr
235 | Ast0.Iterator
(nm
,lp
,args
,rp
,body
,(info
,aft
)) -> left_ident nm
236 | Ast0.Switch
(switch
,lp
,exp
,rp
,lb
,decls
,cases
,rb
) ->
237 modif_before_mcode switch
238 | Ast0.Break
(br
,sem
) -> modif_before_mcode br
239 | Ast0.Continue
(cont
,sem
) -> modif_before_mcode cont
240 | Ast0.Label
(l
,dd
) -> left_ident l
241 | Ast0.Goto
(goto
,l
,sem
) -> modif_before_mcode goto
242 | Ast0.Return
(ret
,sem
) -> modif_before_mcode ret
243 | Ast0.ReturnExpr
(ret
,exp
,sem
) -> modif_before_mcode ret
244 | Ast0.MetaStmt
(name
,pure
) -> modif_before_mcode name
245 | Ast0.MetaStmtList
(name
,_
) -> modif_before_mcode name
246 | Ast0.Disj
(_
,statement_dots_list
,_
,_
) ->
247 List.exists
(left_dots left_statement
) statement_dots_list
248 | Ast0.Nest
(starter
,stmt_dots
,ender
,whencode
,multi
) ->
249 left_dots left_statement stmt_dots
250 | Ast0.Exp
(exp
) -> false (* can only be replaced by an expression *)
251 | Ast0.TopExp
(exp
) -> false (* as above *)
252 | Ast0.Ty
(ty
) -> false (* can only be replaced by a type *)
253 | Ast0.TopInit
(init
) -> false (* can only be replaced by an init *)
254 | Ast0.Dots
(d
,whn
) | Ast0.Circles
(d
,whn
) | Ast0.Stars
(d
,whn
) -> false
255 | Ast0.Include
(inc
,s
) -> modif_before_mcode inc
256 | Ast0.Define
(def
,id
,params
,body
) -> modif_before_mcode def
257 | Ast0.OptStm
(re
) -> left_statement re
258 | Ast0.UniqueStm
(re
) -> left_statement re
260 and right_statement s
=
262 match Ast0.unwrap s
with
263 Ast0.FunDecl
(_
,fninfo
,name
,lp
,params
,rp
,lbrace
,body
,rbrace
) ->
264 (* irrelevant *) false
265 | Ast0.Decl
(_
,decl
) -> right_declaration decl
266 | Ast0.Seq
(lbrace
,body
,rbrace
) -> modif_after_mcode rbrace
267 | Ast0.ExprStatement
(exp
,sem
) -> modif_after_mcode sem
268 | Ast0.IfThen
(iff
,lp
,exp
,rp
,branch1
,(info
,aft
)) -> modif_after_mcodekind aft
269 | Ast0.IfThenElse
(iff
,lp
,exp
,rp
,branch1
,els
,branch2
,(info
,aft
)) ->
270 modif_after_mcodekind aft
271 | Ast0.While
(whl
,lp
,exp
,rp
,body
,(info
,aft
)) -> modif_after_mcodekind aft
272 | Ast0.Do
(d
,body
,whl
,lp
,exp
,rp
,sem
) -> modif_after_mcode sem
273 | Ast0.For
(fr
,lp
,e1
,sem1
,e2
,sem2
,e3
,rp
,body
,(info
,aft
)) ->
274 modif_after_mcodekind aft
275 | Ast0.Iterator
(nm
,lp
,args
,rp
,body
,(info
,aft
)) ->
276 modif_after_mcodekind aft
277 | Ast0.Switch
(switch
,lp
,exp
,rp
,lb
,decls
,cases
,rb
) -> modif_after_mcode rb
278 | Ast0.Break
(br
,sem
) -> modif_after_mcode sem
279 | Ast0.Continue
(cont
,sem
) -> modif_after_mcode sem
280 | Ast0.Label
(l
,dd
) -> modif_after_mcode dd
281 | Ast0.Goto
(goto
,l
,sem
) -> modif_after_mcode sem
282 | Ast0.Return
(ret
,sem
) -> modif_after_mcode sem
283 | Ast0.ReturnExpr
(ret
,exp
,sem
) -> modif_after_mcode sem
284 | Ast0.MetaStmt
(name
,pure
) -> modif_after_mcode name
285 | Ast0.MetaStmtList
(name
,_
) -> modif_after_mcode name
286 | Ast0.Disj
(_
,statement_dots_list
,_
,_
) ->
287 List.exists
(right_dots right_statement
) statement_dots_list
288 | Ast0.Nest
(starter
,stmt_dots
,ender
,whencode
,multi
) ->
289 right_dots right_statement stmt_dots
290 | Ast0.Exp
(exp
) -> false (* can only be replaced by an expression *)
291 | Ast0.TopExp
(exp
) -> false (* as above *)
292 | Ast0.Ty
(ty
) -> false (* can only be replaced by a type *)
293 | Ast0.TopInit
(init
) -> false (* can only be replaced by an init *)
294 | Ast0.Dots
(d
,whn
) | Ast0.Circles
(d
,whn
) | Ast0.Stars
(d
,whn
) -> false
295 | Ast0.Include
(inc
,s
) -> modif_after_mcode s
296 | Ast0.Define
(def
,id
,params
,body
) -> right_dots right_statement body
297 | Ast0.OptStm
(re
) -> right_statement re
298 | Ast0.UniqueStm
(re
) -> right_statement re
300 (* --------------------------------------------------------------------- *)
303 (* A very coarse approximation. We would really only like to return true
304 if a new statement is added. For this it would be best to correlate with the
305 plus slice. Or at least be sure that the new stuff is on the far left or
308 let rec adding_something s
=
309 match Ast0.get_mcodekind s
with
312 (* do better for the common case of replacing a stmt by another one *)
313 ([[Ast.StatementTag
(s
)]],ti
) ->
314 (match Ast.unwrap s
with
315 Ast.IfThen
(_
,_
,_
) -> true (* potentially dangerous *)
316 | _
-> mc
:= ([[Ast.StatementTag
(s
)]],ti
); false)
318 | Ast0.CONTEXT
(mc
) ->
319 let (text
,tinfo1
,tinfo2
) = !mc
in
320 (match text
with Ast.NOTHING
-> false | _
-> true)
322 not
(contains_only_minus
.VT0.combiner_rec_statement s
) (*&&
323 (left_statement s) or (right_statement s)*)
324 | _
-> failwith
"unexpected plus code"
326 (* why do we need this; MINUS should mean the same thing *)
327 and contains_only_minus
=
328 let bind x y
= x
&& y
in
329 let option_default = true in
330 let mcodekind = function
335 | Ast0.CONTEXT
(mc
) -> false
337 let mcode (_
,_
,_
,mc
,_
,_
) = mcodekind mc
in
339 let donothing r k e
= mcodekind (Ast0.get_mcodekind e
) && k e
in
342 match Ast0.unwrap e
with
343 Ast0.DOTS
([]) | Ast0.CIRCLES
([]) | Ast0.STARS
([]) -> true
346 let expression r k e
=
347 mcodekind (Ast0.get_mcodekind e
) &&
348 match Ast0.unwrap e
with
349 Ast0.DisjExpr
(starter
,expr_list
,mids
,ender
) ->
350 List.for_all r
.VT0.combiner_rec_expression expr_list
353 let declaration r k e
=
354 mcodekind (Ast0.get_mcodekind e
) &&
355 match Ast0.unwrap e
with
356 Ast0.DisjDecl
(starter
,decls
,mids
,ender
) ->
357 List.for_all r
.VT0.combiner_rec_declaration decls
361 mcodekind (Ast0.get_mcodekind e
) &&
362 match Ast0.unwrap e
with
363 Ast0.DisjType
(starter
,types
,mids
,ender
) ->
364 List.for_all r
.VT0.combiner_rec_typeC types
367 let statement r k e
=
368 mcodekind (Ast0.get_mcodekind e
) &&
369 match Ast0.unwrap e
with
370 Ast0.Disj
(starter
,statement_dots_list
,mids
,ender
) ->
371 List.for_all r
.VT0.combiner_rec_statement_dots statement_dots_list
374 let case_line r k e
=
375 mcodekind (Ast0.get_mcodekind e
) &&
376 match Ast0.unwrap e
with
377 Ast0.DisjCase
(starter
,case_list
,mids
,ender
) ->
378 List.for_all r
.VT0.combiner_rec_case_line case_list
381 V0.flat_combiner
bind option_default
382 mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
383 dots dots dots dots dots dots
384 donothing expression typeC donothing donothing declaration
385 statement case_line donothing
388 (* needs a special case when there is a Disj or an empty DOTS *)
389 (* ---------------------------------------------------------------------- *)
394 if (acpi_device_dir(device))
396 remove_proc_entry(acpi_device_bid(device), acpi_ac_dir);
397 + acpi_device_dir(device) = NULL;
400 The last two + lines get associated with the end of the if, not with the
401 branch, so the braces get added in oddly.
404 let add_braces orig_s
=
406 (Iso_pattern.rebuild_mcode None
).VT0.rebuilder_rec_statement orig_s
in
408 match Ast0.get_mcodekind
s with
410 let (text
,tinfo
) = !mc
in
411 Ast0.MINUS
(ref([Ast.mkToken
"{"]::text
@[[Ast.mkToken
"}"]],tinfo
))
412 | Ast0.CONTEXT
(mc
) ->
413 let (text
,tinfo1
,tinfo2
) = !mc
in
415 (* this is going to be a mess if we allow it to be iterable...
416 there would be one level of braces for every added things.
417 need to come up with something better, or just add {} in the
421 Ast.BEFOREAFTER
([Ast.mkToken
"{"]::bef
,[[Ast.mkToken
"}"]],
423 | Ast.AFTER
(aft
,_
) ->
424 Ast.BEFOREAFTER
([[Ast.mkToken
"{"]],aft
@[[Ast.mkToken
"}"]],
426 | Ast.BEFOREAFTER
(bef
,aft
,_
) ->
427 Ast.BEFOREAFTER
([Ast.mkToken
"{"]::bef
,aft
@[[Ast.mkToken
"}"]],
430 Ast.BEFOREAFTER
([[Ast.mkToken
"{"]],[[Ast.mkToken
"}"]],
432 Ast0.CONTEXT
(ref(new_text,tinfo1
,tinfo2
))
434 let (text
,tinfo1
,tinfo2
) = !mc
in
438 Ast.BEFOREAFTER
([Ast.mkToken
"{"]::bef
,[[Ast.mkToken
"}"]],
440 | Ast.AFTER
(aft
,_
) ->
441 Ast.BEFOREAFTER
([[Ast.mkToken
"{"]],aft
@[[Ast.mkToken
"}"]],
443 | Ast.BEFOREAFTER
(bef
,aft
,_
) ->
444 Ast.BEFOREAFTER
([Ast.mkToken
"{"]::bef
,aft
@[[Ast.mkToken
"}"]],
447 Ast.BEFOREAFTER
([[Ast.mkToken
"{"]],[[Ast.mkToken
"}"]],
449 Ast0.MIXED
(ref(new_text,tinfo1
,tinfo2
))
450 | _
-> failwith
"unexpected plus code" in
451 Ast0.set_mcodekind
s new_mcodekind;
452 Compute_lines.compute_statement_lines
true s
454 (* ---------------------------------------------------------------------- *)
457 match Ast0.unwrap x
with
458 Ast0.Dots
(_
,_
) | Ast0.Circles
(_
,_
) | Ast0.Stars
(_
,_
)
459 | Ast0.Nest
(_
,_
,_
,_
,_
) -> true
463 match Ast0.get_mcodekind
s with
464 Ast0.MINUS
(_
) -> true
467 let rec unchanged_minus s =
468 match Ast0.get_mcodekind
s with
469 Ast0.MINUS
(mc
) -> (match !mc
with ([],_
) -> true | _
-> false)
472 let rec do_branch s =
475 Ast0.set_dots_bef_aft
s (Ast0.DroppingBetweenDots
(add_braces s))
477 match Ast0.unwrap
s with
478 Ast0.Disj
(starter
,statement_dots_list
,mids
,ender
) ->
482 match Ast0.unwrap
s with
484 Ast0.rewrap
s (Ast0.DOTS
([do_branch s]))
486 | _
-> failwith
"not supported")
487 statement_dots_list
in
488 Ast0.rewrap
s (Ast0.Disj
(starter
,stmts,mids
,ender
))
491 let rec statement dots_before dots_after
s =
493 if dots_before
&& dots_after
497 (let with_braces = add_braces s in
498 Ast0.set_dots_bef_aft
s (Ast0.DroppingBetweenDots
(with_braces)))
499 else if adding_something s
501 (let with_braces = add_braces s in
502 Ast0.set_dots_bef_aft
s (Ast0.AddingBetweenDots
(with_braces)))
506 match Ast0.unwrap
s with
507 Ast0.FunDecl
(x
,fninfo
,name
,lp
,params
,rp
,lbrace
,body
,rbrace
) ->
508 (* true for close brace, because that represents any way we can
509 exit the function, which is not necessarily followed by an explicit
512 (Ast0.FunDecl
(x
,fninfo
,name
,lp
,params
,rp
,lbrace
,
513 statement_dots
false true body
,
515 | Ast0.Decl
(_
,_
) -> s
516 | Ast0.Seq
(lbrace
,body
,rbrace
) ->
518 (Ast0.Seq
(lbrace
,statement_dots
false false body
,rbrace
))
519 | Ast0.ExprStatement
(exp
,sem
) -> do_one s
520 | Ast0.IfThen
(iff
,lp
,exp
,rp
,branch1
,x
) ->
523 (Ast0.IfThen
(iff
,lp
,exp
,rp
,statement false false branch1
,x
)))
524 | Ast0.IfThenElse
(iff
,lp
,exp
,rp
,branch1
,els
,branch2
,x
) ->
529 statement false false branch1
,els
,
530 statement false false branch2
,x
)))
531 | Ast0.While
(whl
,lp
,exp
,rp
,body
,x
) ->
534 (Ast0.While
(whl
,lp
,exp
,rp
,statement false false body
,x
)))
535 | Ast0.Do
(d
,body
,whl
,lp
,exp
,rp
,sem
) ->
538 (Ast0.Do
(d
,statement false false body
,whl
,lp
,exp
,rp
,sem
)))
539 | Ast0.For
(fr
,lp
,e1
,sem1
,e2
,sem2
,e3
,rp
,body
,x
) ->
542 (Ast0.For
(fr
,lp
,e1
,sem1
,e2
,sem2
,e3
,rp
,
543 statement false false body
,x
)))
544 | Ast0.Iterator
(nm
,lp
,args
,rp
,body
,x
) ->
547 (Ast0.Iterator
(nm
,lp
,args
,rp
,statement false false body
,x
)))
548 | Ast0.Switch
(switch
,lp
,exp
,rp
,lb
,decls
,cases
,rb
) ->
551 (Ast0.Switch
(switch
,lp
,exp
,rp
,lb
,decls
,
554 (List.map
case_line (Ast0.undots cases
))),
556 | Ast0.Break
(br
,sem
) -> do_one s
557 | Ast0.Continue
(cont
,sem
) -> do_one s
558 | Ast0.Label
(l
,dd
) -> do_one s
559 | Ast0.Goto
(goto
,l
,sem
) -> do_one s
560 | Ast0.Return
(ret
,sem
) -> do_one s
561 | Ast0.ReturnExpr
(ret
,exp
,sem
) -> do_one s
562 | Ast0.MetaStmt
(name
,_
) -> do_one s
563 | Ast0.MetaStmtList
(name
,_
) -> do_one s
564 | Ast0.Disj
(starter
,statement_dots_list
,mids
,ender
) ->
567 List.map
(statement_dots dots_before dots_after
)
570 | Ast0.Nest
(starter
,stmt_dots
,ender
,whencode
,multi
) ->
571 (match Ast0.get_mcode_mcodekind starter
with
572 Ast0.MINUS _
-> (* everything removed, like -... *) s
576 (starter
,statement_dots
true true stmt_dots
,ender
,
579 | Ast0.TopExp
(exp
) -> s
581 | Ast0.TopInit
(init
) -> s
582 | Ast0.Dots
(d
,whn
) | Ast0.Circles
(d
,whn
) | Ast0.Stars
(d
,whn
) -> s
583 | Ast0.Include
(inc
,string) -> s (* doesn't affect the need for braces *)
584 | Ast0.Define
(def
,id
,params
,body
) -> s (* same as include *)
587 (Ast0.OptStm
(statement dots_before dots_after re
))
588 | Ast0.UniqueStm
(re
) ->
590 (Ast0.UniqueStm
(statement dots_before dots_after re
))
594 (match Ast0.unwrap c
with
595 Ast0.Default
(def
,colon
,code
) ->
596 Ast0.Default
(def
,colon
,statement_dots
false false code
)
597 | Ast0.Case
(case
,exp
,colon
,code
) ->
598 Ast0.Case
(case
,exp
,colon
,statement_dots
false false code
)
599 | Ast0.DisjCase
(starter
,case_lines
,mids
,ender
) ->
600 Ast0.DisjCase
(starter
,List.map
case_line case_lines
,mids
,ender
)
601 | Ast0.OptCase
(case
) -> Ast0.OptCase
(case_line c
))
603 and do_statement_dots dots_before dots_after
= function
605 | [x
] -> [statement dots_before dots_after x
]
606 | dots::rest
when is_dots dots ->
607 dots::(do_statement_dots
true dots_after rest
)
608 | x
::(dots::_
as rest
) when is_dots dots ->
609 (statement dots_before
true x
)::
610 do_statement_dots
false dots_after rest
612 (statement dots_before
false x
)::
613 do_statement_dots
false dots_after rest
615 and statement_dots dots_before dots_after d
=
617 (match Ast0.unwrap d
with
619 Ast0.DOTS
(do_statement_dots dots_before dots_after l
)
621 Ast0.CIRCLES
(do_statement_dots dots_before dots_after l
)
623 Ast0.STARS
(do_statement_dots dots_before dots_after l
))
627 (match Ast0.unwrap t
with
628 Ast0.DECL
(stmt_dots
) -> Ast0.DECL
(statement true true stmt_dots
)
629 | Ast0.CODE
(stmt_dots
) -> Ast0.CODE
(statement_dots
true true stmt_dots
)
632 let single_statement l
=
633 if !Flag_parsing_cocci.sgrep_mode
then l
else List.map
top_level l