2 * Copyright 2005-2008, Ecole des Mines de Nantes, University of Copenhagen
3 * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller
4 * This file is part of Coccinelle.
6 * Coccinelle is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, according to version 2 of the License.
10 * Coccinelle is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with Coccinelle. If not, see <http://www.gnu.org/licenses/>.
18 * The authors reserve the right to distribute this or future versions of
19 * Coccinelle under other licenses.
23 (* Detects subtrees that are all minus/plus and nodes that are "binding
24 context nodes". The latter is a node whose structure and immediate tokens
25 are the same in the minus and plus trees, and such that for every child,
26 the set of context nodes in the child subtree is the same in the minus and
29 module Ast
= Ast_cocci
30 module Ast0
= Ast0_cocci
31 module V0
= Visitor_ast0
32 module U
= Unparse_ast0
34 (* --------------------------------------------------------------------- *)
35 (* Generic access to code *)
37 let set_mcodekind x mcodekind
=
39 Ast0.DotsExprTag
(d
) -> Ast0.set_mcodekind d mcodekind
40 | Ast0.DotsInitTag
(d
) -> Ast0.set_mcodekind d mcodekind
41 | Ast0.DotsParamTag
(d
) -> Ast0.set_mcodekind d mcodekind
42 | Ast0.DotsStmtTag
(d
) -> Ast0.set_mcodekind d mcodekind
43 | Ast0.DotsDeclTag
(d
) -> Ast0.set_mcodekind d mcodekind
44 | Ast0.DotsCaseTag
(d
) -> Ast0.set_mcodekind d mcodekind
45 | Ast0.IdentTag
(d
) -> Ast0.set_mcodekind d mcodekind
46 | Ast0.ExprTag
(d
) -> Ast0.set_mcodekind d mcodekind
47 | Ast0.ArgExprTag
(d
) | Ast0.TestExprTag
(d
) ->
48 failwith
"not possible - iso only"
49 | Ast0.TypeCTag
(d
) -> Ast0.set_mcodekind d mcodekind
50 | Ast0.ParamTag
(d
) -> Ast0.set_mcodekind d mcodekind
51 | Ast0.DeclTag
(d
) -> Ast0.set_mcodekind d mcodekind
52 | Ast0.InitTag
(d
) -> Ast0.set_mcodekind d mcodekind
53 | Ast0.StmtTag
(d
) -> Ast0.set_mcodekind d mcodekind
54 | Ast0.CaseLineTag
(d
) -> Ast0.set_mcodekind d mcodekind
55 | Ast0.TopTag
(d
) -> Ast0.set_mcodekind d mcodekind
56 | Ast0.IsoWhenTag
(_
) -> failwith
"only within iso phase"
57 | Ast0.IsoWhenTTag
(_
) -> failwith
"only within iso phase"
58 | Ast0.IsoWhenFTag
(_
) -> failwith
"only within iso phase"
59 | Ast0.MetaPosTag
(p
) -> failwith
"metapostag only within iso phase"
61 let set_index x index
=
63 Ast0.DotsExprTag
(d
) -> Ast0.set_index d index
64 | Ast0.DotsInitTag
(d
) -> Ast0.set_index d index
65 | Ast0.DotsParamTag
(d
) -> Ast0.set_index d index
66 | Ast0.DotsStmtTag
(d
) -> Ast0.set_index d index
67 | Ast0.DotsDeclTag
(d
) -> Ast0.set_index d index
68 | Ast0.DotsCaseTag
(d
) -> Ast0.set_index d index
69 | Ast0.IdentTag
(d
) -> Ast0.set_index d index
70 | Ast0.ExprTag
(d
) -> Ast0.set_index d index
71 | Ast0.ArgExprTag
(d
) | Ast0.TestExprTag
(d
) ->
72 failwith
"not possible - iso only"
73 | Ast0.TypeCTag
(d
) -> Ast0.set_index d index
74 | Ast0.ParamTag
(d
) -> Ast0.set_index d index
75 | Ast0.InitTag
(d
) -> Ast0.set_index d index
76 | Ast0.DeclTag
(d
) -> Ast0.set_index d index
77 | Ast0.StmtTag
(d
) -> Ast0.set_index d index
78 | Ast0.CaseLineTag
(d
) -> Ast0.set_index d index
79 | Ast0.TopTag
(d
) -> Ast0.set_index d index
80 | Ast0.IsoWhenTag
(_
) -> failwith
"only within iso phase"
81 | Ast0.IsoWhenTTag
(_
) -> failwith
"only within iso phase"
82 | Ast0.IsoWhenFTag
(_
) -> failwith
"only within iso phase"
83 | Ast0.MetaPosTag
(p
) -> failwith
"metapostag only within iso phase"
85 let get_index = function
86 Ast0.DotsExprTag
(d
) -> Index.expression_dots d
87 | Ast0.DotsInitTag
(d
) -> Index.initialiser_dots d
88 | Ast0.DotsParamTag
(d
) -> Index.parameter_dots d
89 | Ast0.DotsStmtTag
(d
) -> Index.statement_dots d
90 | Ast0.DotsDeclTag
(d
) -> Index.declaration_dots d
91 | Ast0.DotsCaseTag
(d
) -> Index.case_line_dots d
92 | Ast0.IdentTag
(d
) -> Index.ident d
93 | Ast0.ExprTag
(d
) -> Index.expression d
94 | Ast0.ArgExprTag
(d
) | Ast0.TestExprTag
(d
) ->
95 failwith
"not possible - iso only"
96 | Ast0.TypeCTag
(d
) -> Index.typeC d
97 | Ast0.ParamTag
(d
) -> Index.parameterTypeDef d
98 | Ast0.InitTag
(d
) -> Index.initialiser d
99 | Ast0.DeclTag
(d
) -> Index.declaration d
100 | Ast0.StmtTag
(d
) -> Index.statement d
101 | Ast0.CaseLineTag
(d
) -> Index.case_line d
102 | Ast0.TopTag
(d
) -> Index.top_level d
103 | Ast0.IsoWhenTag
(_
) -> failwith
"only within iso phase"
104 | Ast0.IsoWhenTTag
(_
) -> failwith
"only within iso phase"
105 | Ast0.IsoWhenFTag
(_
) -> failwith
"only within iso phase"
106 | Ast0.MetaPosTag
(p
) -> failwith
"metapostag only within iso phase"
108 (* --------------------------------------------------------------------- *)
109 (* Collect the line numbers of the plus code. This is used for disjunctions.
110 It is not completely clear why this is necessary, but it seems like an easy
111 fix for whatever is the problem that is discussed in disj_cases *)
113 let plus_lines = ref ([] : int list
)
116 let rec loop = function
119 match compare n x
with
123 | _
-> failwith
"not possible" in
124 plus_lines := loop !plus_lines
127 let rec loop = function
129 | [x
] -> if n
< x
then (min
,x
) else (x
,max
)
133 else if n
> x1
&& n
< x2
then (x1
,x2
) else loop (x2
::rest
) in
136 let collect_plus_lines top
=
139 let option_default = () in
140 let donothing r k e
= k e
in
141 let mcode (_
,_
,info
,mcodekind
,_
) =
143 Ast0.PLUS
-> insert info
.Ast0.line_start
146 V0.combiner
bind option_default
147 mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
149 donothing donothing donothing donothing donothing donothing
150 donothing donothing donothing donothing donothing donothing donothing
151 donothing donothing in
152 fn.V0.combiner_top_level top
154 (* --------------------------------------------------------------------- *)
156 type kind
= Neutral
| AllMarked
| NotAllMarked
(* marked means + or - *)
158 (* --------------------------------------------------------------------- *)
159 (* The first part analyzes each of the minus tree and the plus tree
162 (* ints are unique token indices (offset field) *)
164 Token
(* tokens *) of kind
* int (* unique index *) * Ast0.mcodekind
*
165 int list
(* context tokens *)
166 | Recursor
(* children *) of kind
*
167 int list
(* indices of all tokens at the level below *) *
168 Ast0.mcodekind list
(* tokens at the level below *) *
170 | Bind
(* neighbors *) of kind
*
171 int list
(* indices of all tokens at current level *) *
172 Ast0.mcodekind list
(* tokens at current level *) *
173 int list
(* indices of all tokens at the level below *) *
174 Ast0.mcodekind list
(* tokens at the level below *)
177 let kind2c = function
179 | AllMarked
-> "allmarked"
180 | NotAllMarked
-> "notallmarked"
182 let node2c = function
183 Token
(k
,_
,_
,_
) -> Printf.sprintf
"token %s\n" (kind2c k
)
184 | Recursor
(k
,_
,_
,_
) -> Printf.sprintf
"recursor %s\n" (kind2c k
)
185 | Bind
(k
,_
,_
,_
,_
,_
) -> Printf.sprintf
"bind %s\n" (kind2c k
)
187 (* goal: detect negative in both tokens and recursors, or context only in
191 (k1
,k2
) when k1
= k2
-> k1
192 | (Neutral
,AllMarked
) -> AllMarked
193 | (AllMarked
,Neutral
) -> AllMarked
194 | _
-> NotAllMarked
in
197 (* there are tokens at this level, so ignore the level below *)
198 (Token
(k1
,i1
,t1
,l1
),Token
(k2
,i2
,t2
,l2
)) ->
199 Bind
(lub(k1
,k2
),[i1
;i2
],[t1
;t2
],[],[],[l1
;l2
])
202 (* there are tokens at this level, so ignore the level below *)
203 | (Token
(k1
,i1
,t1
,l1
),Recursor
(k2
,_
,_
,l2
)) ->
204 Bind
(lub(k1
,k2
),[i1
],[t1
],[],[],[l1
;l2
])
205 | (Recursor
(k1
,_
,_
,l1
),Token
(k2
,i2
,t2
,l2
)) ->
206 Bind
(lub(k1
,k2
),[i2
],[t2
],[],[],[l1
;l2
])
209 (* there are tokens at this level, so ignore the level below *)
210 | (Token
(k1
,i1
,t1
,l1
),Bind
(k2
,i2
,t2
,_
,_
,l2
)) ->
211 Bind
(lub(k1
,k2
),i1
::i2
,t1
::t2
,[],[],l1
::l2
)
212 | (Bind
(k1
,i1
,t1
,_
,_
,l1
),Token
(k2
,i2
,t2
,l2
)) ->
213 Bind
(lub(k1
,k2
),i1
@[i2
],t1
@[t2
],[],[],l1
@[l2
])
216 | (Recursor
(k1
,bi1
,bt1
,l1
),Bind
(k2
,i2
,t2
,bi2
,bt2
,l2
)) ->
217 Bind
(lub(k1
,k2
),i2
,t2
,bi1
@bi2
,bt1
@bt2
,l1
::l2
)
218 | (Bind
(k1
,i1
,t1
,bi1
,bt1
,l1
),Recursor
(k2
,bi2
,bt2
,l2
)) ->
219 Bind
(lub(k1
,k2
),i1
,t1
,bi1
@bi2
,bt1
@bt2
,l1
@[l2
])
221 (* recursor/recursor and bind/bind - not likely to ever occur *)
222 | (Recursor
(k1
,bi1
,bt1
,l1
),Recursor
(k2
,bi2
,bt2
,l2
)) ->
223 Bind
(lub(k1
,k2
),[],[],bi1
@bi2
,bt1
@bt2
,[l1
;l2
])
224 | (Bind
(k1
,i1
,t1
,bi1
,bt1
,l1
),Bind
(k2
,i2
,t2
,bi2
,bt2
,l2
)) ->
225 Bind
(lub(k1
,k2
),i1
@i2
,t1
@t2
,bi1
@bi2
,bt1
@bt2
,l1
@l2
)
228 let option_default = (*Bind(Neutral,[],[],[],[],[])*)
229 Recursor
(Neutral
,[],[],[])
231 let mcode (_
,_
,info
,mcodekind
,pos
) =
232 let offset = info
.Ast0.offset in
234 Ast0.MINUS
(_
) -> Token
(AllMarked
,offset,mcodekind
,[])
235 | Ast0.PLUS
-> Token
(AllMarked
,offset,mcodekind
,[])
236 | Ast0.CONTEXT
(_
) -> Token
(NotAllMarked
,offset,mcodekind
,[offset])
237 | _
-> failwith
"not possible"
239 let neutral_mcode (_
,_
,info
,mcodekind
,pos
) =
240 let offset = info
.Ast0.offset in
242 Ast0.MINUS
(_
) -> Token
(Neutral
,offset,mcodekind
,[])
243 | Ast0.PLUS
-> Token
(Neutral
,offset,mcodekind
,[])
244 | Ast0.CONTEXT
(_
) -> Token
(Neutral
,offset,mcodekind
,[offset])
245 | _
-> failwith
"not possible"
247 let is_context = function Ast0.CONTEXT
(_
) -> true | _
-> false
249 let union_all l
= List.fold_left
Common.union_set
[] l
251 (* is minus is true when we are processing minus code that might be
252 intermingled with plus code. it is used in disj_cases *)
253 let classify is_minus all_marked table code
=
254 let mkres builder k il tl bil btl l e
=
256 then Ast0.set_mcodekind e
(all_marked
()) (* definitive *)
258 let check_index il tl
=
259 if List.for_all
is_context tl
261 (let e1 = builder e
in
262 let index = (get_index e1)@il
in
264 let _ = Hashtbl.find table
index in
266 (Printf.sprintf
"%d: index %s already used\n"
267 (Ast0.get_info e
).Ast0.line_start
268 (String.concat
" " (List.map string_of_int
index)))
269 with Not_found
-> Hashtbl.add table
index (e1,l
)) in
270 if il
= [] then check_index bil btl
else check_index il tl
);
272 then Recursor
(k
, bil
, btl
, union_all l
)
273 else Recursor
(k
, il
, tl
, union_all l
) in
275 let compute_result builder e
= function
276 Bind
(k
,il
,tl
,bil
,btl
,l
) -> mkres builder k il tl bil btl l e
277 | Token
(k
,il
,tl
,l
) -> mkres builder k
[il
] [tl
] [] [] [l
] e
278 | Recursor
(k
,bil
,btl
,l
) -> mkres builder k
[] [] bil btl
[l
] e
in
280 let make_not_marked = function
281 Bind
(k
,il
,tl
,bil
,btl
,l
) -> Bind
(NotAllMarked
,il
,tl
,bil
,btl
,l
)
282 | Token
(k
,il
,tl
,l
) -> Token
(NotAllMarked
,il
,tl
,l
)
283 | Recursor
(k
,bil
,btl
,l
) -> Recursor
(NotAllMarked
,bil
,btl
,l
) in
285 let do_nothing builder r k e
= compute_result builder e
(k e
) in
287 let disj_cases disj starter code
fn ender
=
288 (* neutral_mcode used so starter and ender don't have an affect on
289 whether the code is considered all plus/minus, but so that they are
290 consider in the index list, which is needed to make a disj with
291 something in one branch and nothing in the other different from code
292 that just has the something (starter/ender enough, mids not needed
293 for this). Cannot agglomerate + code over | boundaries, because two -
294 cases might have different + code, and don't want to put the + code
295 together into one unit. *)
296 let make_not_marked =
299 (let min = Ast0.get_line disj
in
300 let max = Ast0.get_line_end disj
in
301 let (plus_min
,plus_max
) = find min (min-1) (max+1) in
302 if max > plus_max
then make_not_marked else (function x
-> x
))
303 else make_not_marked in
304 bind (neutral_mcode starter
)
305 (bind (List.fold_right
bind
306 (List.map
make_not_marked (List.map
fn code
))
308 (neutral_mcode ender
)) in
310 (* no whencode in plus tree so have to drop it *)
311 (* need special cases for dots, nests, and disjs *)
312 let expression r k e
=
313 compute_result Ast0.expr e
314 (match Ast0.unwrap e
with
315 Ast0.NestExpr
(starter
,exp
,ender
,whencode
,multi
) ->
316 k
(Ast0.rewrap e
(Ast0.NestExpr
(starter
,exp
,ender
,None
,multi
)))
317 | Ast0.Edots
(dots
,whencode
) ->
318 k
(Ast0.rewrap e
(Ast0.Edots
(dots
,None
)))
319 | Ast0.Ecircles
(dots
,whencode
) ->
320 k
(Ast0.rewrap e
(Ast0.Ecircles
(dots
,None
)))
321 | Ast0.Estars
(dots
,whencode
) ->
322 k
(Ast0.rewrap e
(Ast0.Estars
(dots
,None
)))
323 | Ast0.DisjExpr
(starter
,expr_list
,_,ender
) ->
324 disj_cases e starter expr_list r
.V0.combiner_expression ender
327 (* not clear why we have the next two cases, since DisjDecl and
328 DisjType shouldn't have been constructed yet, as they only come from isos *)
329 let declaration r k e
=
330 compute_result Ast0.decl e
331 (match Ast0.unwrap e
with
332 Ast0.DisjDecl
(starter
,decls
,_,ender
) ->
333 disj_cases e starter decls r
.V0.combiner_declaration ender
334 | Ast0.Ddots
(dots
,whencode
) ->
335 k
(Ast0.rewrap e
(Ast0.Ddots
(dots
,None
)))
336 (* Need special cases for the following so that the type will be
337 considered as a unit, rather than distributed around the
338 declared variable. This needs to be done because of the call to
339 compute_result, ie the processing of each term should make a
340 side-effect on the complete term structure as well as collecting
341 some information about it. So we have to visit each complete
342 term structure. In (all?) other such cases, we visit the terms
343 using rebuilder, which just visits the subterms, rather than
344 reordering their components. *)
345 | Ast0.Init
(stg
,ty
,id
,eq
,ini
,sem
) ->
346 bind (match stg
with Some stg
-> mcode stg
| _ -> option_default)
347 (bind (r
.V0.combiner_typeC ty
)
348 (bind (r
.V0.combiner_ident id
)
350 (bind (r
.V0.combiner_initialiser ini
) (mcode sem
)))))
351 | Ast0.UnInit
(stg
,ty
,id
,sem
) ->
352 bind (match stg
with Some stg
-> mcode stg
| _ -> option_default)
353 (bind (r
.V0.combiner_typeC ty
)
354 (bind (r
.V0.combiner_ident id
) (mcode sem
)))
358 compute_result Ast0.param e
359 (match Ast0.unwrap e
with
360 Ast0.Param
(ty
,Some id
) ->
361 (* needed for the same reason as in the Init and UnInit cases *)
362 bind (r
.V0.combiner_typeC ty
) (r
.V0.combiner_ident id
)
366 compute_result Ast0.typeC e
367 (match Ast0.unwrap e
with
368 Ast0.DisjType
(starter
,types
,_,ender
) ->
369 disj_cases e starter types r
.V0.combiner_typeC ender
372 let initialiser r k i
=
373 compute_result Ast0.ini i
374 (match Ast0.unwrap i
with
375 Ast0.Idots
(dots
,whencode
) ->
376 k
(Ast0.rewrap i
(Ast0.Idots
(dots
,None
)))
379 let statement r k s
=
380 compute_result Ast0.stmt s
381 (match Ast0.unwrap s
with
382 Ast0.Nest
(started
,stm_dots
,ender
,whencode
,multi
) ->
383 k
(Ast0.rewrap s
(Ast0.Nest
(started
,stm_dots
,ender
,[],multi
)))
384 | Ast0.Dots
(dots
,whencode
) ->
385 k
(Ast0.rewrap s
(Ast0.Dots
(dots
,[])))
386 | Ast0.Circles
(dots
,whencode
) ->
387 k
(Ast0.rewrap s
(Ast0.Circles
(dots
,[])))
388 | Ast0.Stars
(dots
,whencode
) ->
389 k
(Ast0.rewrap s
(Ast0.Stars
(dots
,[])))
390 | Ast0.Disj
(starter
,statement_dots_list
,_,ender
) ->
391 disj_cases s starter statement_dots_list r
.V0.combiner_statement_dots
393 (* Why? There is nothing there
394 (* cases for everything with extra mcode *)
395 | Ast0.FunDecl
((info
,bef
),_,_,_,_,_,_,_,_)
396 | Ast0.Decl
((info
,bef
),_) ->
397 bind (mcode ((),(),info
,bef
)) (k s
)
398 | Ast0.IfThen
(_,_,_,_,_,(info
,aft
))
399 | Ast0.IfThenElse
(_,_,_,_,_,_,_,(info
,aft
))
400 | Ast0.While
(_,_,_,_,_,(info
,aft
)) ->
401 | Ast0.For
(_,_,_,_,_,_,_,_,_,(info
,aft
)) ->
402 bind (k s
) (mcode ((),(),info
,aft
))
403 | Ast0.Iterator
(_,_,_,_,_,(info
,aft
))
409 let do_top builder r k e
= compute_result builder e
(k e
) in
412 V0.combiner bind option_default
413 mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
415 (do_nothing Ast0.dotsExpr
) (do_nothing Ast0.dotsInit
)
416 (do_nothing Ast0.dotsParam
) (do_nothing Ast0.dotsStmt
)
417 (do_nothing Ast0.dotsDecl
) (do_nothing Ast0.dotsCase
)
418 (do_nothing Ast0.ident
) expression typeC initialiser param declaration
419 statement (do_nothing Ast0.case_line
) (do_top Ast0.top
) in
420 combiner.V0.combiner_top_level code
422 (* --------------------------------------------------------------------- *)
423 (* Traverse the hash tables and find corresponding context nodes that have
424 the same context children *)
426 (* this is just a sanity check - really only need to look at the top-level
428 let equal_mcode (_,_,info1
,_,_) (_,_,info2
,_,_) =
429 info1
.Ast0.offset = info2
.Ast0.offset
431 let equal_option e1 e2
=
433 (Some x
, Some y
) -> equal_mcode x y
434 | (None
, None
) -> true
438 match (Ast0.unwrap d1
,Ast0.unwrap d2
) with
439 (Ast0.DOTS
(l1
),Ast0.DOTS
(l2
)) -> List.length l1
= List.length l2
440 | (Ast0.CIRCLES
(l1
),Ast0.CIRCLES
(l2
)) -> List.length l1
= List.length l2
441 | (Ast0.STARS
(l1
),Ast0.STARS
(l2
)) -> List.length l1
= List.length l2
444 let rec equal_ident i1 i2
=
445 match (Ast0.unwrap i1
,Ast0.unwrap i2
) with
446 (Ast0.Id
(name1
),Ast0.Id
(name2
)) -> equal_mcode name1 name2
447 | (Ast0.MetaId
(name1
,_,_),Ast0.MetaId
(name2
,_,_)) ->
448 equal_mcode name1 name2
449 | (Ast0.MetaFunc
(name1
,_,_),Ast0.MetaFunc
(name2
,_,_)) ->
450 equal_mcode name1 name2
451 | (Ast0.MetaLocalFunc
(name1
,_,_),Ast0.MetaLocalFunc
(name2
,_,_)) ->
452 equal_mcode name1 name2
453 | (Ast0.OptIdent
(_),Ast0.OptIdent
(_)) -> true
454 | (Ast0.UniqueIdent
(_),Ast0.UniqueIdent
(_)) -> true
457 let rec equal_expression e1 e2
=
458 match (Ast0.unwrap
e1,Ast0.unwrap e2
) with
459 (Ast0.Ident
(_),Ast0.Ident
(_)) -> true
460 | (Ast0.Constant
(const1
),Ast0.Constant
(const2
)) -> equal_mcode const1 const2
461 | (Ast0.FunCall
(_,lp1
,_,rp1
),Ast0.FunCall
(_,lp2
,_,rp2
)) ->
462 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
463 | (Ast0.Assignment
(_,op1
,_,_),Ast0.Assignment
(_,op2
,_,_)) ->
465 | (Ast0.CondExpr
(_,why1
,_,colon1
,_),Ast0.CondExpr
(_,why2
,_,colon2
,_)) ->
466 equal_mcode why1 why2
&& equal_mcode colon1 colon2
467 | (Ast0.Postfix
(_,op1
),Ast0.Postfix
(_,op2
)) -> equal_mcode op1 op2
468 | (Ast0.Infix
(_,op1
),Ast0.Infix
(_,op2
)) -> equal_mcode op1 op2
469 | (Ast0.Unary
(_,op1
),Ast0.Unary
(_,op2
)) -> equal_mcode op1 op2
470 | (Ast0.Binary
(_,op1
,_),Ast0.Binary
(_,op2
,_)) -> equal_mcode op1 op2
471 | (Ast0.Paren
(lp1
,_,rp1
),Ast0.Paren
(lp2
,_,rp2
)) ->
472 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
473 | (Ast0.ArrayAccess
(_,lb1
,_,rb1
),Ast0.ArrayAccess
(_,lb2
,_,rb2
)) ->
474 equal_mcode lb1 lb2
&& equal_mcode rb1 rb2
475 | (Ast0.RecordAccess
(_,pt1
,_),Ast0.RecordAccess
(_,pt2
,_)) ->
477 | (Ast0.RecordPtAccess
(_,ar1
,_),Ast0.RecordPtAccess
(_,ar2
,_)) ->
479 | (Ast0.Cast
(lp1
,_,rp1
,_),Ast0.Cast
(lp2
,_,rp2
,_)) ->
480 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
481 | (Ast0.SizeOfExpr
(szf1
,_),Ast0.SizeOfExpr
(szf2
,_)) ->
482 equal_mcode szf1 szf2
483 | (Ast0.SizeOfType
(szf1
,lp1
,_,rp1
),Ast0.SizeOfType
(szf2
,lp2
,_,rp2
)) ->
484 equal_mcode szf1 szf2
&& equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
485 | (Ast0.TypeExp
(_),Ast0.TypeExp
(_)) -> true
486 | (Ast0.MetaErr
(name1
,_,_),Ast0.MetaErr
(name2
,_,_))
487 | (Ast0.MetaExpr
(name1
,_,_,_,_),Ast0.MetaExpr
(name2
,_,_,_,_))
488 | (Ast0.MetaExprList
(name1
,_,_),Ast0.MetaExprList
(name2
,_,_)) ->
489 equal_mcode name1 name2
490 | (Ast0.EComma
(cm1
),Ast0.EComma
(cm2
)) -> equal_mcode cm1 cm2
491 | (Ast0.DisjExpr
(starter1
,_,mids1
,ender1
),
492 Ast0.DisjExpr
(starter2
,_,mids2
,ender2
)) ->
493 equal_mcode starter1 starter2
&&
494 List.for_all2
equal_mcode mids1 mids2
&&
495 equal_mcode ender1 ender2
496 | (Ast0.NestExpr
(starter1
,_,ender1
,_,m1
),
497 Ast0.NestExpr
(starter2
,_,ender2
,_,m2
)) ->
498 equal_mcode starter1 starter2
&& equal_mcode ender1 ender2
&& m1
= m2
499 | (Ast0.Edots
(dots1
,_),Ast0.Edots
(dots2
,_))
500 | (Ast0.Ecircles
(dots1
,_),Ast0.Ecircles
(dots2
,_))
501 | (Ast0.Estars
(dots1
,_),Ast0.Estars
(dots2
,_)) -> equal_mcode dots1 dots2
502 | (Ast0.OptExp
(_),Ast0.OptExp
(_)) -> true
503 | (Ast0.UniqueExp
(_),Ast0.UniqueExp
(_)) -> true
506 let rec equal_typeC t1 t2
=
507 match (Ast0.unwrap t1
,Ast0.unwrap t2
) with
508 (Ast0.ConstVol
(cv1
,_),Ast0.ConstVol
(cv2
,_)) -> equal_mcode cv1 cv2
509 | (Ast0.BaseType
(ty1
,sign1
),Ast0.BaseType
(ty2
,sign2
)) ->
510 equal_mcode ty1 ty2
&& equal_option sign1 sign2
511 | (Ast0.ImplicitInt
(sign1
),Ast0.ImplicitInt
(sign2
)) ->
512 equal_mcode sign1 sign2
513 | (Ast0.Pointer
(_,star1
),Ast0.Pointer
(_,star2
)) ->
514 equal_mcode star1 star2
515 | (Ast0.Array
(_,lb1
,_,rb1
),Ast0.Array
(_,lb2
,_,rb2
)) ->
516 equal_mcode lb1 lb2
&& equal_mcode rb1 rb2
517 | (Ast0.StructUnionName
(kind1
,_),Ast0.StructUnionName
(kind2
,_)) ->
518 equal_mcode kind1 kind2
519 | (Ast0.FunctionType
(ty1
,lp1
,p1
,rp1
),Ast0.FunctionType
(ty2
,lp2
,p2
,rp2
)) ->
520 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
521 | (Ast0.StructUnionDef
(_,lb1
,_,rb1
),
522 Ast0.StructUnionDef
(_,lb2
,_,rb2
)) ->
523 equal_mcode lb1 lb2
&& equal_mcode rb1 rb2
524 | (Ast0.TypeName
(name1
),Ast0.TypeName
(name2
)) -> equal_mcode name1 name2
525 | (Ast0.MetaType
(name1
,_),Ast0.MetaType
(name2
,_)) ->
526 equal_mcode name1 name2
527 | (Ast0.DisjType
(starter1
,_,mids1
,ender1
),
528 Ast0.DisjType
(starter2
,_,mids2
,ender2
)) ->
529 equal_mcode starter1 starter2
&&
530 List.for_all2
equal_mcode mids1 mids2
&&
531 equal_mcode ender1 ender2
532 | (Ast0.OptType
(_),Ast0.OptType
(_)) -> true
533 | (Ast0.UniqueType
(_),Ast0.UniqueType
(_)) -> true
536 let equal_declaration d1 d2
=
537 match (Ast0.unwrap d1
,Ast0.unwrap d2
) with
538 (Ast0.Init
(stg1
,_,_,eq1
,_,sem1
),Ast0.Init
(stg2
,_,_,eq2
,_,sem2
)) ->
539 equal_option stg1 stg2
&& equal_mcode eq1 eq2
&& equal_mcode sem1 sem2
540 | (Ast0.UnInit
(stg1
,_,_,sem1
),Ast0.UnInit
(stg2
,_,_,sem2
)) ->
541 equal_option stg1 stg2
&& equal_mcode sem1 sem2
542 | (Ast0.MacroDecl
(nm1
,lp1
,_,rp1
,sem1
),Ast0.MacroDecl
(nm2
,lp2
,_,rp2
,sem2
)) ->
543 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
&& equal_mcode sem1 sem2
544 | (Ast0.TyDecl
(_,sem1
),Ast0.TyDecl
(_,sem2
)) -> equal_mcode sem1 sem2
545 | (Ast0.Ddots
(dots1
,_),Ast0.Ddots
(dots2
,_)) -> equal_mcode dots1 dots2
546 | (Ast0.OptDecl
(_),Ast0.OptDecl
(_)) -> true
547 | (Ast0.UniqueDecl
(_),Ast0.UniqueDecl
(_)) -> true
548 | (Ast0.DisjDecl
_,_) | (_,Ast0.DisjDecl
_) ->
549 failwith
"DisjDecl not expected here"
552 let equal_initialiser i1 i2
=
553 match (Ast0.unwrap i1
,Ast0.unwrap i2
) with
554 (Ast0.InitExpr
(_),Ast0.InitExpr
(_)) -> true
555 | (Ast0.InitList
(lb1
,_,rb1
),Ast0.InitList
(lb2
,_,rb2
)) ->
556 (equal_mcode lb1 lb2
) && (equal_mcode rb1 rb2
)
557 | (Ast0.InitGccDotName
(dot1
,_,eq1
,_),Ast0.InitGccDotName
(dot2
,_,eq2
,_)) ->
558 (equal_mcode dot1 dot2
) && (equal_mcode eq1 eq2
)
559 | (Ast0.InitGccName
(_,eq1
,_),Ast0.InitGccName
(_,eq2
,_)) ->
561 | (Ast0.InitGccIndex
(lb1
,_,rb1
,eq1
,_),Ast0.InitGccIndex
(lb2
,_,rb2
,eq2
,_)) ->
562 (equal_mcode lb1 lb2
) && (equal_mcode rb1 rb2
) && (equal_mcode eq1 eq2
)
563 | (Ast0.InitGccRange
(lb1
,_,dots1
,_,rb1
,eq1
,_),
564 Ast0.InitGccRange
(lb2
,_,dots2
,_,rb2
,eq2
,_)) ->
565 (equal_mcode lb1 lb2
) && (equal_mcode dots1 dots2
) &&
566 (equal_mcode rb1 rb2
) && (equal_mcode eq1 eq2
)
567 | (Ast0.IComma
(cm1
),Ast0.IComma
(cm2
)) -> equal_mcode cm1 cm2
568 | (Ast0.Idots
(d1
,_),Ast0.Idots
(d2
,_)) -> equal_mcode d1 d2
569 | (Ast0.OptIni
(_),Ast0.OptIni
(_)) -> true
570 | (Ast0.UniqueIni
(_),Ast0.UniqueIni
(_)) -> true
573 let equal_parameterTypeDef p1 p2
=
574 match (Ast0.unwrap p1
,Ast0.unwrap p2
) with
575 (Ast0.VoidParam
(_),Ast0.VoidParam
(_)) -> true
576 | (Ast0.Param
(_,_),Ast0.Param
(_,_)) -> true
577 | (Ast0.MetaParam
(name1
,_),Ast0.MetaParam
(name2
,_))
578 | (Ast0.MetaParamList
(name1
,_,_),Ast0.MetaParamList
(name2
,_,_)) ->
579 equal_mcode name1 name2
580 | (Ast0.PComma
(cm1
),Ast0.PComma
(cm2
)) -> equal_mcode cm1 cm2
581 | (Ast0.Pdots
(dots1
),Ast0.Pdots
(dots2
))
582 | (Ast0.Pcircles
(dots1
),Ast0.Pcircles
(dots2
)) -> equal_mcode dots1 dots2
583 | (Ast0.OptParam
(_),Ast0.OptParam
(_)) -> true
584 | (Ast0.UniqueParam
(_),Ast0.UniqueParam
(_)) -> true
587 let rec equal_statement s1 s2
=
588 match (Ast0.unwrap s1
,Ast0.unwrap s2
) with
589 (Ast0.FunDecl
(_,fninfo1
,_,lp1
,_,rp1
,lbrace1
,_,rbrace1
),
590 Ast0.FunDecl
(_,fninfo2
,_,lp2
,_,rp2
,lbrace2
,_,rbrace2
)) ->
591 (List.length fninfo1
) = (List.length fninfo2
) &&
592 List.for_all2 equal_fninfo fninfo1 fninfo2
&&
593 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
&&
594 equal_mcode lbrace1 lbrace2
&& equal_mcode rbrace1 rbrace2
595 | (Ast0.Decl
(_,_),Ast0.Decl
(_,_)) -> true
596 | (Ast0.Seq
(lbrace1
,_,rbrace1
),Ast0.Seq
(lbrace2
,_,rbrace2
)) ->
597 equal_mcode lbrace1 lbrace2
&& equal_mcode rbrace1 rbrace2
598 | (Ast0.ExprStatement
(_,sem1
),Ast0.ExprStatement
(_,sem2
)) ->
599 equal_mcode sem1 sem2
600 | (Ast0.IfThen
(iff1
,lp1
,_,rp1
,_,_),Ast0.IfThen
(iff2
,lp2
,_,rp2
,_,_)) ->
601 equal_mcode iff1 iff2
&& equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
602 | (Ast0.IfThenElse
(iff1
,lp1
,_,rp1
,_,els1
,_,_),
603 Ast0.IfThenElse
(iff2
,lp2
,_,rp2
,_,els2
,_,_)) ->
604 equal_mcode iff1 iff2
&&
605 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
&& equal_mcode els1 els2
606 | (Ast0.While
(whl1
,lp1
,_,rp1
,_,_),Ast0.While
(whl2
,lp2
,_,rp2
,_,_)) ->
607 equal_mcode whl1 whl2
&& equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
608 | (Ast0.Do
(d1
,_,whl1
,lp1
,_,rp1
,sem1
),Ast0.Do
(d2
,_,whl2
,lp2
,_,rp2
,sem2
)) ->
609 equal_mcode whl1 whl2
&& equal_mcode d1 d2
&&
610 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
&& equal_mcode sem1 sem2
611 | (Ast0.For
(fr1
,lp1
,_,sem11
,_,sem21
,_,rp1
,_,_),
612 Ast0.For
(fr2
,lp2
,_,sem12
,_,sem22
,_,rp2
,_,_)) ->
613 equal_mcode fr1 fr2
&& equal_mcode lp1 lp2
&&
614 equal_mcode sem11 sem12
&& equal_mcode sem21 sem22
&&
616 | (Ast0.Iterator
(nm1
,lp1
,_,rp1
,_,_),Ast0.Iterator
(nm2
,lp2
,_,rp2
,_,_)) ->
617 equal_mcode lp1 lp2
&& equal_mcode rp1 rp2
618 | (Ast0.Switch
(switch1
,lp1
,_,rp1
,lb1
,case1
,rb1
),
619 Ast0.Switch
(switch2
,lp2
,_,rp2
,lb2
,case2
,rb2
)) ->
620 equal_mcode switch1 switch2
&& equal_mcode lp1 lp2
&&
621 equal_mcode rp1 rp2
&& equal_mcode lb1 lb2
&&
623 | (Ast0.Break
(br1
,sem1
),Ast0.Break
(br2
,sem2
)) ->
624 equal_mcode br1 br2
&& equal_mcode sem1 sem2
625 | (Ast0.Continue
(cont1
,sem1
),Ast0.Continue
(cont2
,sem2
)) ->
626 equal_mcode cont1 cont2
&& equal_mcode sem1 sem2
627 | (Ast0.Label
(_,dd1
),Ast0.Label
(_,dd2
)) ->
629 | (Ast0.Goto
(g1
,_,sem1
),Ast0.Goto
(g2
,_,sem2
)) ->
630 equal_mcode g1 g2
&& equal_mcode sem1 sem2
631 | (Ast0.Return
(ret1
,sem1
),Ast0.Return
(ret2
,sem2
)) ->
632 equal_mcode ret1 ret2
&& equal_mcode sem1 sem2
633 | (Ast0.ReturnExpr
(ret1
,_,sem1
),Ast0.ReturnExpr
(ret2
,_,sem2
)) ->
634 equal_mcode ret1 ret2
&& equal_mcode sem1 sem2
635 | (Ast0.MetaStmt
(name1
,_),Ast0.MetaStmt
(name2
,_))
636 | (Ast0.MetaStmtList
(name1
,_),Ast0.MetaStmtList
(name2
,_)) ->
637 equal_mcode name1 name2
638 | (Ast0.Disj
(starter1
,_,mids1
,ender1
),Ast0.Disj
(starter2
,_,mids2
,ender2
)) ->
639 equal_mcode starter1 starter2
&&
640 List.for_all2
equal_mcode mids1 mids2
&&
641 equal_mcode ender1 ender2
642 | (Ast0.Nest
(starter1
,_,ender1
,_,m1
),Ast0.Nest
(starter2
,_,ender2
,_,m2
)) ->
643 equal_mcode starter1 starter2
&& equal_mcode ender1 ender2
&& m1
= m2
644 | (Ast0.Exp
(_),Ast0.Exp
(_)) -> true
645 | (Ast0.TopExp
(_),Ast0.TopExp
(_)) -> true
646 | (Ast0.Ty
(_),Ast0.Ty
(_)) -> true
647 | (Ast0.TopInit
(_),Ast0.TopInit
(_)) -> true
648 | (Ast0.Dots
(d1
,_),Ast0.Dots
(d2
,_))
649 | (Ast0.Circles
(d1
,_),Ast0.Circles
(d2
,_))
650 | (Ast0.Stars
(d1
,_),Ast0.Stars
(d2
,_)) -> equal_mcode d1 d2
651 | (Ast0.Include
(inc1
,name1
),Ast0.Include
(inc2
,name2
)) ->
652 equal_mcode inc1 inc2
&& equal_mcode name1 name2
653 | (Ast0.Define
(def1
,_,_,_),Ast0.Define
(def2
,_,_,_)) ->
654 equal_mcode def1 def2
655 | (Ast0.OptStm
(_),Ast0.OptStm
(_)) -> true
656 | (Ast0.UniqueStm
(_),Ast0.UniqueStm
(_)) -> true
659 and equal_fninfo x y
=
661 (Ast0.FStorage
(s1
),Ast0.FStorage
(s2
)) -> equal_mcode s1 s2
662 | (Ast0.FType
(_),Ast0.FType
(_)) -> true
663 | (Ast0.FInline
(i1
),Ast0.FInline
(i2
)) -> equal_mcode i1 i2
664 | (Ast0.FAttr
(i1
),Ast0.FAttr
(i2
)) -> equal_mcode i1 i2
667 let equal_case_line c1 c2
=
668 match (Ast0.unwrap c1
,Ast0.unwrap c2
) with
669 (Ast0.Default
(def1
,colon1
,_),Ast0.Default
(def2
,colon2
,_)) ->
670 equal_mcode def1 def2
&& equal_mcode colon1 colon2
671 | (Ast0.Case
(case1
,_,colon1
,_),Ast0.Case
(case2
,_,colon2
,_)) ->
672 equal_mcode case1 case2
&& equal_mcode colon1 colon2
673 | (Ast0.OptCase
(_),Ast0.OptCase
(_)) -> true
676 let rec equal_top_level t1 t2
=
677 match (Ast0.unwrap t1
,Ast0.unwrap t2
) with
678 (Ast0.DECL
(_),Ast0.DECL
(_)) -> true
679 | (Ast0.FILEINFO
(old_file1
,new_file1
),Ast0.FILEINFO
(old_file2
,new_file2
)) ->
680 equal_mcode old_file1 old_file2
&& equal_mcode new_file1 new_file2
681 | (Ast0.CODE
(_),Ast0.CODE
(_)) -> true
682 | (Ast0.ERRORWORDS
(_),Ast0.ERRORWORDS
(_)) -> true
685 let root_equal e1 e2
=
687 (Ast0.DotsExprTag
(d1
),Ast0.DotsExprTag
(d2
)) -> dots equal_expression d1 d2
688 | (Ast0.DotsParamTag
(d1
),Ast0.DotsParamTag
(d2
)) ->
689 dots equal_parameterTypeDef d1 d2
690 | (Ast0.DotsStmtTag
(d1
),Ast0.DotsStmtTag
(d2
)) -> dots equal_statement d1 d2
691 | (Ast0.DotsDeclTag
(d1
),Ast0.DotsDeclTag
(d2
)) -> dots equal_declaration d1 d2
692 | (Ast0.DotsCaseTag
(d1
),Ast0.DotsCaseTag
(d2
)) -> dots equal_case_line d1 d2
693 | (Ast0.IdentTag
(i1
),Ast0.IdentTag
(i2
)) -> equal_ident i1 i2
694 | (Ast0.ExprTag
(e1),Ast0.ExprTag
(e2
)) -> equal_expression e1 e2
695 | (Ast0.ArgExprTag
(d
),_) -> failwith
"not possible - iso only"
696 | (Ast0.TypeCTag
(t1
),Ast0.TypeCTag
(t2
)) -> equal_typeC t1 t2
697 | (Ast0.ParamTag
(p1
),Ast0.ParamTag
(p2
)) -> equal_parameterTypeDef p1 p2
698 | (Ast0.InitTag
(d1
),Ast0.InitTag
(d2
)) -> equal_initialiser d1 d2
699 | (Ast0.DeclTag
(d1
),Ast0.DeclTag
(d2
)) -> equal_declaration d1 d2
700 | (Ast0.StmtTag
(s1
),Ast0.StmtTag
(s2
)) -> equal_statement s1 s2
701 | (Ast0.TopTag
(t1
),Ast0.TopTag
(t2
)) -> equal_top_level t1 t2
702 | (Ast0.IsoWhenTag
(_),_) | (_,Ast0.IsoWhenTag
(_))
703 | (Ast0.IsoWhenTTag
(_),_) | (_,Ast0.IsoWhenTTag
(_))
704 | (Ast0.IsoWhenFTag
(_),_) | (_,Ast0.IsoWhenFTag
(_)) ->
705 failwith
"only within iso phase"
708 let default_context _ =
709 Ast0.CONTEXT
(ref(Ast.NOTHING
,
710 Ast0.default_token_info
,Ast0.default_token_info
))
712 let traverse minus_table plus_table
=
717 let (plus_e
,plus_l
) = Hashtbl.find plus_table key
in
718 if root_equal e plus_e
&&
719 List.for_all
(function x
-> x
)
720 (List.map2
Common.equal_set l plus_l
)
722 let i = Ast0.fresh_index
() in
723 (set_index e
i; set_index plus_e
i;
724 set_mcodekind e
(default_context());
725 set_mcodekind plus_e
(default_context()))
726 with Not_found
-> ())
729 (* --------------------------------------------------------------------- *)
730 (* contextify the whencode *)
734 let option_default = () in
736 let do_nothing r k e
= Ast0.set_mcodekind e
(default_context()); k e
in
738 V0.combiner bind option_default
739 mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
741 do_nothing do_nothing do_nothing do_nothing do_nothing do_nothing
742 do_nothing do_nothing do_nothing do_nothing do_nothing do_nothing
743 do_nothing do_nothing do_nothing
745 let contextify_whencode =
747 let option_default = () in
749 let do_nothing r k e
= k e
in
751 let expression r k e
=
753 match Ast0.unwrap e
with
754 Ast0.NestExpr
(_,_,_,Some whencode
,_)
755 | Ast0.Edots
(_,Some whencode
)
756 | Ast0.Ecircles
(_,Some whencode
)
757 | Ast0.Estars
(_,Some whencode
) ->
758 contextify_all.V0.combiner_expression whencode
761 let initialiser r k
i =
762 match Ast0.unwrap
i with
763 Ast0.Idots
(dots,Some whencode
) ->
764 contextify_all.V0.combiner_initialiser whencode
767 let whencode = function
768 Ast0.WhenNot sd
-> contextify_all.V0.combiner_statement_dots sd
769 | Ast0.WhenAlways s
-> contextify_all.V0.combiner_statement s
770 | Ast0.WhenModifier
(_) -> ()
771 | Ast0.WhenNotTrue
(e
) -> contextify_all.V0.combiner_expression e
772 | Ast0.WhenNotFalse
(e
) -> contextify_all.V0.combiner_expression e
in
774 let statement r k
(s
: Ast0.statement) =
776 match Ast0.unwrap s
with
777 Ast0.Nest
(_,_,_,whn
,_)
778 | Ast0.Dots
(_,whn
) | Ast0.Circles
(_,whn
) | Ast0.Stars
(_,whn
) ->
779 List.iter
whencode whn
783 V0.combiner bind option_default
784 mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
786 do_nothing do_nothing do_nothing do_nothing do_nothing do_nothing
789 do_nothing initialiser do_nothing do_nothing statement do_nothing
791 combiner.V0.combiner_top_level
793 (* --------------------------------------------------------------------- *)
795 (* the first int list is the tokens in the node, the second is the tokens
796 in the descendents *)
798 (Hashtbl.create
(50) : (int list
, Ast0.anything
* int list list
) Hashtbl.t
)
800 (Hashtbl.create
(50) : (int list
, Ast0.anything
* int list list
) Hashtbl.t
)
803 match Ast0.unwrap t
with
805 | Ast0.FILEINFO
(_) -> true
806 | Ast0.ERRORWORDS
(_) -> false
807 | Ast0.CODE
(_) -> true
808 | Ast0.OTHER
(_) -> failwith
"unexpected top level code"
810 (* ------------------------------------------------------------------- *)
811 (* alignment of minus and plus *)
813 let concat = function
817 let rec loop = function
820 (match Ast0.unwrap x
with
821 Ast0.DECL
(s
) -> let stms = loop rest
in s
::stms
823 let stms = loop rest
in
824 (match Ast0.unwrap ss
with
825 Ast0.DOTS
(d
) -> d
@stms
826 | _ -> failwith
"no dots allowed in pure plus code")
827 | _ -> failwith
"plus code is being discarded") in
829 Compute_lines.statement_dots
830 (Ast0.rewrap
(List.hd l
) (Ast0.DOTS
(loop l
))) in
831 [Ast0.rewrap
res (Ast0.CODE
res)]
833 let collect_up_to m plus
=
834 let minfo = Ast0.get_info m
in
835 let mend = minfo.Ast0.logical_end
in
836 let rec loop = function
839 let pinfo = Ast0.get_info p
in
840 let pstart = pinfo.Ast0.logical_start
in
843 else let (plus
,rest
) = loop plus
in (p
::plus
,rest
) in
844 let (plus
,rest
) = loop plus
in
847 let realign minus plus
=
848 let rec loop = function
849 ([],_) -> failwith
"not possible, some context required"
850 | ([m
],p
) -> ([m
],concat p
)
852 let (p
,plus
) = collect_up_to m plus
in
853 let (minus
,plus
) = loop (minus
,plus
) in
857 (* ------------------------------------------------------------------- *)
858 (* check compatible: check that at the top level the minus and plus code is
859 of the same kind. Could go further and make the correspondence between the
860 code between ...s. *)
862 let isonly f l
= match Ast0.undots l
with [s
] -> f s
| _ -> false
864 let isall f l
= List.for_all
(isonly f
) l
867 match Ast0.unwrap s
with
869 | Ast0.Disj
(_,stmts
,_,_) -> isall is_exp stmts
873 match Ast0.unwrap s
with
875 | Ast0.Disj
(_,stmts
,_,_) -> isall is_ty stmts
879 match Ast0.unwrap s
with
880 Ast0.TopInit
(e
) -> true
881 | Ast0.Disj
(_,stmts
,_,_) -> isall is_init stmts
885 match Ast0.unwrap s
with
886 Ast0.Decl
(_,e
) -> true
887 | Ast0.FunDecl
(_,_,_,_,_,_,_,_,_) -> true
888 | Ast0.Disj
(_,stmts
,_,_) -> isall is_decl stmts
891 let rec is_fndecl s
=
892 match Ast0.unwrap s
with
893 Ast0.FunDecl
(_,_,_,_,_,_,_,_,_) -> true
894 | Ast0.Disj
(_,stmts
,_,_) -> isall is_fndecl stmts
897 let rec is_toplevel s
=
898 match Ast0.unwrap s
with
899 Ast0.Decl
(_,e
) -> true
900 | Ast0.FunDecl
(_,_,_,_,_,_,_,_,_) -> true
901 | Ast0.Disj
(_,stmts
,_,_) -> isall is_toplevel stmts
902 | Ast0.ExprStatement
(fc
,_) ->
903 (match Ast0.unwrap fc
with
904 Ast0.FunCall
(_,_,_,_) -> true
906 | Ast0.Include
(_,_) -> true
907 | Ast0.Define
(_,_,_,_) -> true
910 let check_compatible m p
=
914 "incompatible minus and plus code starting on lines %d and %d"
915 (Ast0.get_line m
) (Ast0.get_line p
)) in
916 match (Ast0.unwrap m
, Ast0.unwrap p
) with
917 (Ast0.DECL
(decl1
),Ast0.DECL
(decl2
)) ->
918 if not
(is_decl decl1
&& is_decl decl2
)
920 | (Ast0.DECL
(decl1
),Ast0.CODE
(code2
)) ->
921 let v1 = is_decl decl1
in
922 let v2 = List.for_all
is_toplevel (Ast0.undots code2
) in
923 if !Flag.make_hrule
= None
&& v1 && not
v2 then fail()
924 | (Ast0.CODE
(code1
),Ast0.DECL
(decl2
)) ->
925 let v1 = List.for_all
is_toplevel (Ast0.undots code1
) in
926 let v2 = is_decl decl2
in
927 if v1 && not
v2 then fail()
928 | (Ast0.CODE
(code1
),Ast0.CODE
(code2
)) ->
929 let v1 = isonly is_init code1
in
930 let v2a = isonly is_init code2
in
931 let v2b = isonly is_exp code2
in
933 then (if not
(v2a || v2b) then fail())
935 let testers = [is_exp;is_ty] in
938 let v1 = isonly tester code1
in
939 let v2 = isonly tester code2
in
940 if (v1 && not
v2) or (!Flag.make_hrule
= None
&& v2 && not
v1)
943 let v1 = isonly is_fndecl code1
in
944 let v2 = List.for_all
is_toplevel (Ast0.undots code2
) in
945 if !Flag.make_hrule
= None
&& v1 && not
v2 then fail()
946 | (Ast0.FILEINFO
(_,_),Ast0.FILEINFO
(_,_)) -> ()
947 | (Ast0.OTHER
(_),Ast0.OTHER
(_)) -> ()
950 (* ------------------------------------------------------------------- *)
952 (* returns a list of corresponding minus and plus trees *)
953 let context_neg minus plus
=
954 Hashtbl.clear
minus_table;
955 Hashtbl.clear
plus_table;
956 List.iter
contextify_whencode minus
;
957 let (minus
,plus
) = realign minus plus
in
958 let rec loop = function
961 failwith
(Printf.sprintf
"%d plus things remaining" (List.length l
))
968 (function _ -> Ast0.MINUS
(ref([],Ast0.default_token_info
)))
972 | (((m
::minus
) as mall
),((p
::plus
) as pall
)) ->
973 let minfo = Ast0.get_info m
in
974 let pinfo = Ast0.get_info p
in
975 let mstart = minfo.Ast0.logical_start
in
976 let mend = minfo.Ast0.logical_end
in
977 let pstart = pinfo.Ast0.logical_start
in
978 let pend = pinfo.Ast0.logical_end
in
979 if (iscode m
or iscode p
) &&
980 (mend + 1 = pstart or pend + 1 = mstart or (* adjacent *)
981 (mstart <= pstart && mend >= pstart) or
982 (pstart <= mstart && pend >= mstart)) (* overlapping or nested *)
985 (* ensure that the root of each tree has a unique index,
986 although it might get overwritten if the node is a context
988 let i = Ast0.fresh_index
() in
989 Ast0.set_index m
i; Ast0.set_index p
i;
990 check_compatible m p
;
991 collect_plus_lines p
;
994 (function _ -> Ast0.MINUS
(ref([],Ast0.default_token_info
)))
996 let _ = classify false (function _ -> Ast0.PLUS
) plus_table p
in
997 traverse minus_table plus_table;
998 (m
,p
)::loop(minus
,plus
)
1001 if not
(iscode m
or iscode p
)
1002 then loop(minus
,plus
)
1010 (function _ -> Ast0.MINUS
(ref([],Ast0.default_token_info
)))
1014 else loop(mall
,plus
) in