1 (* Yoann Padioleau, Julia Lawall
3 * Copyright (C) 2010, University of Copenhagen DIKU and INRIA.
4 * Copyright (C) 2006, 2007, 2008, 2009 Ecole des Mines de Nantes and DIKU
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License (GPL)
8 * version 2 as published by the Free Software Foundation.
10 * This program 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 * file license.txt for more details.
16 * Modifications by Julia Lawall for better newline handling.
22 module TH
= Token_helpers
25 (* should keep comments and directives in between adjacent deleted terms,
26 but not comments and directives within deleted terms. should use the
27 labels found in the control-flow graph *)
31 (*****************************************************************************)
33 (*****************************************************************************)
34 let pr2, pr2_once
= Common.mk_pr2_wrappers
Flag_parsing_c.verbose_unparsing
36 (*****************************************************************************)
37 (* Types used during the intermediate phases of the unparsing *)
38 (*****************************************************************************)
42 | T1
of Parser_c.token
44 (* The cocci_tag of the token should always be a NOTHING. The mark of
45 * the token can only be OriginTok or ExpandedTok. Why not get rid of
46 * token and get something simpler ? because we need to know if the
47 * info is a TCommentCpp or TCommentSpace, etc for some of the further
48 * analysis so easier to keep with the token.
50 * This type contains the whole information. Have all the tokens with this
54 Min
of (int list
(* match numbers from witness trees *) *
55 Ast_cocci.adjacency
(* adjacency information *))
59 | T2
of Parser_c.token
* min
*
60 int option (* orig index, abstracting away comments and space *)
62 | Cocci2
of string * int (* line *) * int (* lcol *) * int (* rcol *)
63 * Unparse_cocci.nlhint
option
67 | Unindent_cocci2
of bool (* true for permanent, false for temporary *)
72 | T3
of Parser_c.token
77 (* similar to the tech in parsing_hack *)
78 type token_extended
= {
81 idx
: int option; (* to know if 2 tokens were consecutive in orig file *)
82 mutable new_tokens_before
: token2 list
;
83 mutable remove
: bool;
87 (*****************************************************************************)
89 (*****************************************************************************)
91 let info_of_token1 t
=
94 | T1 tok
-> TH.info_of_tok tok
96 let print_token1 = function
97 T1 tok
-> TH.str_of_tok tok
98 | Fake1 info
-> "fake"
100 let str_of_token2 = function
101 | T2
(t
,_
,_
) -> TH.str_of_tok t
103 | Cocci2
(s
,_
,_
,_
,_
) -> s
106 | Indent_cocci2
-> ""
107 | Unindent_cocci2 _
-> ""
110 let print_token2 = function
114 | Parser_c.TCommentSpace _
-> " sp "
115 | Parser_c.TCommentNewline _
-> " nl "
116 | Parser_c.TCommentCpp _
-> " cp "
117 | Parser_c.TCommentMisc _
-> " misc "
118 | Parser_c.TComment _
-> " comment "
123 Printf.sprintf
"-%d[%s]"
124 (match adj
with Ast_cocci.ADJ n
-> n
| _
-> -1)
125 (String.concat
" " (List.map string_of_int index
))
127 "T2:"^
b_str^
t_str^
TH.str_of_tok t
132 Printf.sprintf
"-%d[%s]"
133 (match adj
with Ast_cocci.ADJ n
-> n
| _
-> -1)
134 (String.concat
" " (List.map string_of_int index
))
137 | Cocci2
(s
,_
,lc
,rc
,_
) -> Printf.sprintf
"Cocci2:%d:%d%s" lc rc s
139 | Comma s
-> "Comma:"^s
140 | Indent_cocci2
-> "Indent"
141 | Unindent_cocci2 _
-> "Unindent"
142 | EatSpace2
-> "EatSpace"
144 let simple_print_all_tokens1 l
=
145 List.iter
(function x
-> Printf.printf
"|%s| " (print_token1 x
)) l
;
148 let simple_print_all_tokens2 l
=
149 List.iter
(function x
-> Printf.printf
"|%s| " (print_token2 x
)) l
;
152 let str_of_token3 = function
153 | T3 t
-> TH.str_of_tok t
154 | Cocci3 s
| C3 s
-> s
158 let mk_token_extended x
=
161 | T2
(_
,_
, idx
) -> idx
165 str
= str_of_token2 x
;
167 new_tokens_before
= [];
171 let rebuild_tokens_extented toks_ext
=
172 let _tokens = ref [] in
173 toks_ext
+> List.iter
(fun tok
->
174 tok
.new_tokens_before
+> List.iter
(fun x
-> push2 x
_tokens);
175 if not tok
.remove
then push2 tok
.tok2
_tokens;
177 let tokens = List.rev
!_tokens in
178 (tokens +> List.map
mk_token_extended)
181 let mcode_contain_plus = function
182 | Ast_cocci.CONTEXT
(_
,Ast_cocci.NOTHING
) -> false
183 | Ast_cocci.CONTEXT _
-> true
184 (* patch: when need full coccinelle transformation *)
185 | Ast_cocci.MINUS
(_
,_
,_
,Ast_cocci.NOREPLACEMENT
) -> false
186 | Ast_cocci.MINUS
(_
,_
,_
,Ast_cocci.REPLACEMENT _
) -> true(*REPL is not empty*)
187 | Ast_cocci.PLUS _
-> raise Impossible
189 let contain_plus info
=
190 let mck = Ast_c.mcode_of_info info
in
191 mcode_contain_plus mck
193 (*****************************************************************************)
194 (* Last fix on the ast *)
195 (*****************************************************************************)
197 (* Because of the ugly trick to handle initialiser, I generate fake ','
198 * for the last initializer element, but if there is nothing around it,
199 * I don't want in the end to print it.
202 let remove_useless_fakeInfo_struct program
=
203 let bigf = { Visitor_c.default_visitor_c_s
with
204 Visitor_c.kini_s
= (fun (k
,bigf) ini
->
206 | InitList args
, ii
->
209 | [i1
;i2
;iicommaopt
] ->
210 if (not
(contain_plus iicommaopt
)) && (not
(contain_plus i2
))
211 && (Ast_c.is_fake iicommaopt
)
212 (* sometimes the guy put a normal iicommaopt *)
213 then InitList args
, [i1
;i2
]
214 else InitList args
, [i1
;i2
;iicommaopt
]
215 | [i1
;i2
;iicommaopt
;end_comma_opt
] ->
216 (* only in #define. end_comma_opt canot be fake *)
217 (* not sure if this will be considered ambiguous with a previous
219 if (not
(contain_plus iicommaopt
)) && (not
(contain_plus i2
))
220 && (Ast_c.is_fake iicommaopt
)
221 (* sometimes the guy put a normal iicommaopt *)
222 then InitList args
, [i1
;i2
;end_comma_opt
]
223 else InitList args
, [i1
;i2
;iicommaopt
;end_comma_opt
]
224 | _
-> raise Impossible
229 Visitor_c.vk_toplevel_s
bigf program
232 (*****************************************************************************)
233 (* Tokens1 generation *)
234 (*****************************************************************************)
236 let get_fakeInfo_and_tokens celem toks
=
237 let toks_in = ref toks
in
238 let toks_out = ref [] in
240 (* todo? verify good order of position ? *)
242 match Ast_c.pinfo_of_info info
with
244 Common.push2
(Fake1 info
) toks_out
245 | OriginTok _
| ExpandedTok _
->
246 (* get the associated comments/space/cppcomment tokens *)
247 let (before
, x
, after
) =
248 !toks_in +> Common.split_when
(fun tok
->
249 info
=*= TH.info_of_tok tok
)
251 assert(info
=*= TH.info_of_tok x
);
252 (*old: assert(before +> List.for_all (TH.is_comment)); *)
253 before
+> List.iter
(fun x
->
254 if not
(TH.is_comment x
)
255 then pr2 ("WEIRD: not a comment:" ^
TH.str_of_tok x
)
256 (* case such as int asm d3("x"); not yet in ast *)
258 before
+> List.iter
(fun x
-> Common.push2
(T1 x
) toks_out);
259 push2
(T1 x
) toks_out;
261 | AbstractLineTok _
->
262 (* can be called on type info when for instance use -type_c *)
263 if !Flag_parsing_c.pretty_print_type_info
264 then Common.push2
(Fake1 info
) toks_out
265 else raise Impossible
(* at this stage *)
268 let pr_space _
= () in (* use the spacing that is there already *)
270 Pretty_print_c.pp_program_gen
pr_elem pr_space celem
;
272 if not
(null
!toks_in)
273 then failwith
"WEIRD: unparsing not finished";
277 (* Fake nodes that have BEFORE code or are - should be moved over any subsequent
278 whitespace and newlines, but not any comments, to get as close to the affected
279 code as possible. Similarly, fake nodes that have AFTER code should be moved
280 backwards. No fake nodes should have both before and after code. *)
282 let displace_fake_nodes toks
=
283 let is_fake = function Fake1 _
-> true | _
-> false in
284 let is_whitespace = function
285 T1
(Parser_c.TCommentSpace _
)
287 | T1
(Parser_c.TCommentNewline _
) -> true
291 try Some
(Common.split_when
is_fake toks
)
292 with Not_found
-> None
in
294 Some
(bef
,((Fake1 info
) as fake
),aft
) ->
295 (match !(info
.cocci_tag
) with
298 (Ast_cocci.CONTEXT
(_
,Ast_cocci.BEFORE _
),_
)
299 | (Ast_cocci.MINUS
(_
,_
,_
,Ast_cocci.REPLACEMENT _
),_
) ->
300 (* move the fake node forwards *)
301 let (whitespace
,rest
) = Common.span
is_whitespace aft
in
302 bef
@ whitespace
@ fake
:: (loop rest
)
303 | (Ast_cocci.CONTEXT
(_
,Ast_cocci.AFTER _
),_
) ->
304 (* move the fake node backwards *)
305 let revbef = List.rev bef
in
306 let (revwhitespace
,revprev
) = Common.span
is_whitespace revbef in
307 let whitespace = List.rev revwhitespace
in
308 let prev = List.rev revprev
in
309 prev @ fake
:: (loop (whitespace @ aft
))
310 | (Ast_cocci.CONTEXT
(_
,Ast_cocci.NOTHING
),_
) ->
311 bef
@ fake
:: (loop aft
)
312 | (Ast_cocci.CONTEXT
(_
,Ast_cocci.BEFOREAFTER _
),_
) ->
313 failwith
"fake node should not be before-after"
314 | _
-> bef
@ fake
:: (loop aft
) (* old: was removed when have simpler yacfe *)
317 bef
@ fake
:: (loop aft
)
320 | _
-> raise Impossible
in
323 (*****************************************************************************)
324 (* Tokens2 generation *)
325 (*****************************************************************************)
327 let comment2t2 = function
329 (* not sure iif the following list is exhaustive or complete *)
330 (Token_c.CppAttr
|Token_c.CppMacro
|Token_c.CppPassingCosWouldGetError
),
331 (info
: Token_c.info
)) ->
333 | (Token_c.TCommentCpp x
,(info
: Token_c.info
)) ->
334 C2
("\n"^info
.Common.str^
"\n")
335 | x
-> failwith
(Printf.sprintf
"unexpected comment %s" (Common.dump x
))
337 let expand_mcode toks
=
338 let toks_out = ref [] in
342 let add_elem t minus
=
345 let str = Ast_c.str_of_info info
in
347 then push2
(Fake2 minus
) toks_out
348 (* fx the fake "," at the end of a structure or enum.
349 no idea what other fake info there can be... *)
350 else push2
(Comma
str) toks_out
354 (*let (a,b) = !((TH.info_of_tok tok).cocci_tag) in*)
355 (* no tag on expandedTok ! *)
356 let modified = function
358 | Some
(Ast_cocci.CONTEXT
(pos
,Ast_cocci.NOTHING
),l
) -> false
360 (if (TH.is_expanded tok
&&
361 modified !((TH.info_of_tok tok
).cocci_tag
)
362 (*!((TH.info_of_tok tok).cocci_tag) <> Ast_c.emptyAnnot*))
366 "expanded token %s on line %d is either modified or stored in a metavariable"
367 (TH.str_of_tok tok
) (TH.line_of_tok tok
)));
369 let tok'
= tok +> TH.visitor_info_of_tok
(fun i
->
370 { i
with cocci_tag
= ref Ast_c.emptyAnnot
; }
374 if TH.is_origin
tok && not
(TH.is_real_comment
tok)
382 push2
(T2
(tok'
, minus
, optindex)) toks_out
387 Ast_c.mcode_and_env_of_cocciref
((info_of_token1 t
).cocci_tag
) in
389 let pr_cocci s ln col rcol hint
=
390 push2
(Cocci2
(s
,ln
,col
,rcol
,hint
)) toks_out in
392 (match Ast_c.pinfo_of_info info
with
393 Ast_c.AbstractLineTok _
->
394 push2
(C2
(Ast_c.str_of_info info
)) toks_out
395 | Ast_c.FakeTok
(s
,_
) ->
396 push2
(C2 s
) toks_out
398 Printf.printf
"line: %s\n" (Common.dump info
);
399 failwith
"not an abstract line");
400 (!(info
.Ast_c.comments_tag
)).Ast_c.mafter
+>
401 List.iter
(fun x
-> Common.push2
(comment2t2 x
) toks_out) in
403 let pr_barrier ln col
= (* marks a position, used around C code *)
404 push2
(Cocci2
("",ln
,col
,col
,None
)) toks_out in
405 let pr_nobarrier ln col
= () in (* not needed for linux spacing *)
407 let pr_cspace _
= push2
(C2
" ") toks_out in
409 let pr_space _
= () (* rely on add_space in cocci code *) in
410 let pr_arity _
= () (* not interested *) in
412 let indent _
= push2 Indent_cocci2
toks_out in
413 let unindent x
= push2
(Unindent_cocci2 x
) toks_out in
414 let eat_space _
= push2 EatSpace2
toks_out in
417 (env
, pr_cocci, pr_c, pr_cspace,
418 (match !Flag_parsing_c.spacing
with
419 Flag_parsing_c.SMPL
-> pr_space | _
-> pr_cspace),
421 (match !Flag_parsing_c.spacing
with
422 Flag_parsing_c.SMPL
-> pr_barrier | _
-> pr_nobarrier),
423 indent, unindent, eat_space) in
425 (* old: when for yacfe with partial cocci:
429 (* patch: when need full coccinelle transformation *)
430 let unparser = Unparse_cocci.pp_list_list_any
args_pp false in
432 | Ast_cocci.MINUS
(_
,inst
,adj
,any_xxs
) ->
433 (* Why adding ? because I want to have all the information, the whole
434 * set of tokens, so I can then process and remove the
435 * is_between_two_minus for instance *)
436 add_elem t
(Min
(inst
,adj
));
438 Ast_cocci.NOREPLACEMENT
-> ()
439 | Ast_cocci.REPLACEMENT
(any_xxs
,_
) ->
440 unparser any_xxs
Unparse_cocci.InPlace
)
441 | Ast_cocci.CONTEXT
(_
,any_befaft
) ->
442 (match any_befaft
with
443 | Ast_cocci.NOTHING
->
445 | Ast_cocci.BEFORE
(xxs
,_
) ->
446 unparser xxs
Unparse_cocci.Before
;
448 | Ast_cocci.AFTER
(xxs
,_
) ->
450 unparser xxs
Unparse_cocci.After
;
451 | Ast_cocci.BEFOREAFTER
(xxs
, yys
, _
) ->
452 unparser xxs
Unparse_cocci.Before
;
454 unparser yys
Unparse_cocci.After
;
456 | Ast_cocci.PLUS _
-> raise Impossible
460 toks
+> List.iter
expand_info;
464 (*****************************************************************************)
465 (* Tokens2 processing, filtering, adjusting *)
466 (*****************************************************************************)
468 let is_space = function
469 | T2
(Parser_c.TCommentSpace _
,_b
,_i
) -> true (* only whitespace *)
472 let is_newline = function
473 | T2
(Parser_c.TCommentNewline _
,_b
,_i
) -> true
476 let is_whitespace = function
479 | Parser_c.TCommentSpace _
-> true (* only whitespace *)
480 | Parser_c.TCommentNewline _
(* newline plus whitespace *) -> true
485 let is_minusable_comment = function
488 | Parser_c.TCommentSpace _
(* only whitespace *)
489 (* patch: coccinelle *)
490 | Parser_c.TCommentNewline _
(* newline plus whitespace *) -> true
491 | Parser_c.TComment _
when !Flag_parsing_c.keep_comments
-> false
492 | Parser_c.TComment _
493 | Parser_c.TCommentCpp
(Token_c.CppAttr
, _
)
494 | Parser_c.TCommentCpp
(Token_c.CppMacro
, _
)
495 | Parser_c.TCommentCpp
(Token_c.CppDirective
, _
) (* result was false *)
498 | Parser_c.TCommentMisc _
499 | Parser_c.TCommentCpp
(Token_c.CppPassingCosWouldGetError
, _
)
506 let is_minusable_comment_nocpp = function
509 | Parser_c.TCommentSpace _
(* only whitespace *)
510 (* patch: coccinelle *)
511 | Parser_c.TCommentNewline _
(* newline plus whitespace *) -> true
512 | Parser_c.TComment _
when !Flag_parsing_c.keep_comments
-> false
513 | Parser_c.TComment _
-> true
514 | Parser_c.TCommentCpp
(Token_c.CppAttr
, _
)
515 | Parser_c.TCommentCpp
(Token_c.CppMacro
, _
)
516 | Parser_c.TCommentCpp
(Token_c.CppDirective
, _
)
519 | Parser_c.TCommentMisc _
520 | Parser_c.TCommentCpp
(Token_c.CppPassingCosWouldGetError
, _
)
527 let all_coccis = function
528 Cocci2 _
| C2 _
| Comma _
| Indent_cocci2
| Unindent_cocci2 _
532 (*previously gave up if the first character was a newline, but not clear why*)
533 let is_minusable_comment_or_plus x
= is_minusable_comment x
or all_coccis x
535 let set_minus_comment adj
= function
537 let str = TH.str_of_tok t
in
539 | Parser_c.TCommentSpace _
540 (* patch: coccinelle *)
541 | Parser_c.TCommentNewline _
-> ()
543 | Parser_c.TComment _
544 | Parser_c.TCommentCpp
(Token_c.CppAttr
, _
)
545 | Parser_c.TCommentCpp
(Token_c.CppMacro
, _
)
546 | Parser_c.TCommentCpp
(Token_c.CppDirective
, _
)
548 pr2 (Printf.sprintf
"%d: ERASING_COMMENTS: %s"
549 (TH.line_of_tok t
) str)
550 | _
-> raise Impossible
553 (* patch: coccinelle *)
554 | T2
(t
,Min adj
,idx
) as x
-> x
556 | _
-> raise Impossible
558 let set_minus_comment_or_plus adj
= function
559 Cocci2 _
| C2 _
| Comma _
| Indent_cocci2
| Unindent_cocci2 _
560 | EatSpace2
as x
-> x
561 | x
-> set_minus_comment adj x
564 xs
+> Common.exclude
(function
565 | T2
(t
,Min adj
,_
) -> true
569 let drop_expanded xs
=
570 xs
+> Common.exclude
(function
571 | T2
(t
,_
,_
) when TH.is_expanded t
-> true
576 xs
+> Common.exclude
(function
581 let remove_minus_and_between_and_expanded_and_fake xs
=
583 (* get rid of expanded tok *)
584 let xs = drop_expanded xs in
586 let minus_or_comment = function
587 T2
(_
,Min adj
,_
) -> true
588 | x
-> is_minusable_comment x
in
590 let minus_or_comment_nocpp = function
591 T2
(_
,Min adj
,_
) -> true
592 | x
-> is_minusable_comment_nocpp x
in
594 let common_adj (index1
,adj1
) (index2
,adj2
) =
595 let same_adj = (* same adjacency info *)
596 match (adj1
,adj2
) with
597 (Ast_cocci.ADJ adj1
,Ast_cocci.ADJ adj2
) -> adj1
= adj2
598 | (Ast_cocci.ALLMINUS
,_
) | (_
,Ast_cocci.ALLMINUS
) -> true in
600 (* non-empty intersection of witness trees *)
601 not
((Common.inter_set index1 index2
) = []) in
603 (* new idea: collects regions not containing non-space context code
604 if two adjacent adjacent minus tokens satisfy common_adj then delete
605 all spaces, comments etc between them
606 if two adjacent minus tokens do not satisfy common_adj only delete
607 the spaces between them if there are no comments, etc.
608 if the region contain no plus code and is both preceded and followed
609 by a newline, delete the initial newline. *)
611 let rec adjust_around_minus = function
613 | (T2
(Parser_c.TCommentNewline c
,_b
,_i
) as x
)::
614 ((Fake2
(Min adj1
) | T2
(_
,Min adj1
,_
)) as t1
)::xs ->
615 let (minus_list
,rest
) = Common.span not_context
(t1
::xs) in
616 let contains_plus = List.exists is_plus minus_list
in
618 match List.rev minus_list
with
619 (T2
(Parser_c.TCommentNewline c
,_b
,_i
))::rest
620 when List.for_all
minus_or_comment minus_list
->
621 set_minus_comment_or_plus adj1
x
623 x :: adjust_within_minus
contains_plus minus_list
@
624 adjust_around_minus rest
625 | ((Fake2
(Min adj1
) | T2
(_
,Min adj1
,_
)) as t1
)::xs ->
626 let (minus_list
,rest
) = Common.span not_context
(t1
::xs) in
627 let contains_plus = List.exists is_plus minus_list
in
628 adjust_within_minus
contains_plus minus_list
@ adjust_around_minus rest
630 x :: adjust_around_minus xs
631 and adjust_within_minus cp
(* contains plus *) = function
632 ((Fake2
(Min adj1
) | T2
(_
,Min adj1
,_
)) as t1
)::xs ->
633 let not_minus = function T2
(_
,Min _
,_
) -> false | _
-> true in
634 let (not_minus_list
,rest
) = Common.span
not_minus xs in
637 ((Fake2
(Min adj2
) | T2
(_
,Min adj2
,_
)) as t2
)::xs
638 when common_adj adj1 adj2
->
639 (List.map
(set_minus_comment_or_plus adj1
) not_minus_list
)
640 @ (adjust_within_minus cp
(t2
::xs))
641 | ((Fake2
(Min adj2
) | T2
(_
,Min adj2
,_
)) as t2
)::xs ->
642 if not cp
&& List.for_all
is_whitespace not_minus_list
644 (List.map
(set_minus_comment_or_plus adj1
) not_minus_list
)
645 @ (adjust_within_minus cp
(t2
::xs))
647 not_minus_list
@ (adjust_within_minus cp
(t2
::xs))
652 (* remove spaces after removed stuff, eg a comma after a
654 let (spaces
,rest
) = Common.span
is_space xs in
655 (List.map
(set_minus_comment_or_plus adj1
) spaces
)
657 | xs -> failwith
"should always start with minus"
658 and not_context
= function
659 (T2
(_
,Ctx
,_
) as x) when not
(is_minusable_comment x) -> false
661 and is_plus
= function
662 C2 _
| Comma _
| Cocci2 _
-> true
665 let xs = adjust_around_minus xs in
667 (* get rid of fake tok *)
668 let xs = drop_fake xs in
670 (* this drops blank lines after a brace introduced by removing code *)
671 let minus_or_comment_nonl = function
672 T2
(_
,Min adj
,_
) -> true
673 | T2
(Parser_c.TCommentNewline _
,_b
,_i
) -> false
674 | x -> is_minusable_comment x in
676 let rec adjust_after_brace = function
678 | ((T2
(_
,Ctx
,_
)) as x)::((T2
(_
,Min adj
,_
)::_
) as xs)
679 when str_of_token2 x =$
= "{" ->
680 let (between_minus
,rest
) = Common.span
minus_or_comment_nonl xs in
681 let is_whitespace = function
682 T2
(Parser_c.TCommentSpace _
,_b
,_i
)
684 | T2
(Parser_c.TCommentNewline _
,_b
,_i
) -> true
686 let (newlines
,rest
) = Common.span
is_whitespace rest
in
687 let (drop_newlines
,last_newline
) =
688 let rec loop = function
690 | ((T2
(Parser_c.TCommentNewline _
,_b
,_i
)) as x) :: rest
->
693 let (drop_newlines
,last_newline
) = loop xs in
694 (drop_newlines
,x::last_newline
) in
695 loop (List.rev newlines
) in
696 x::between_minus
@(List.map
(set_minus_comment adj
) drop_newlines
)@
698 adjust_after_brace rest
699 | x::xs -> x::adjust_after_brace xs in
701 let xs = adjust_after_brace xs in
703 (* search backwards from context } over spaces until reaching a newline.
704 then go back over all minus code until reaching some context or + code.
705 get rid of all intervening spaces, newlines, and comments
707 let rec adjust_before_brace = function
709 | ((T2
(t
,Ctx
,_
)) as x)::xs when str_of_token2 x =$
= "}" or is_newline x ->
710 let (outer_spaces
,rest
) = Common.span
is_space xs in
713 ((T2
(Parser_c.TCommentNewline _
,Ctx
,_i
)) as h
) ::
714 (* the rest of this code is the same as from_newline below
715 but merging them seems to be error prone... *)
716 ((T2
(t
, Min adj
, idx
)) as m
) :: rest
->
717 let (spaces
,rest
) = Common.span
minus_or_comment_nocpp rest
in
719 (List.map
(set_minus_comment adj
) spaces
) @
720 (adjust_before_brace rest
)
721 | _
-> adjust_before_brace rest
)
722 | x::xs -> x :: (adjust_before_brace xs) in
724 let from_newline = function
725 ((T2
(t
, Min adj
, idx
)) as m
) :: rest
->
726 let (spaces
,rest
) = Common.span
minus_or_comment_nocpp rest
in
728 (List.map
(set_minus_comment adj
) spaces
) @
729 (adjust_before_brace rest
)
730 | ((T2
(t0
, Ctx
, idx0
)) as m0
) :: ((T2
(t
, Min adj
, idx
)) as m
) :: rest
731 when TH.str_of_tok t0
= "" ->
732 (* This is for the case of a #define that is completely deleted,
733 because a #define has a strange EOL token at the end.
734 We hope there i no other kind of token that is represented by
735 "", but it seems like changing the kind of token might break
736 the end of entity recognition in the C parser.
737 See parsing_hacks.ml *)
738 let (spaces
,rest
) = Common.span
minus_or_comment_nocpp rest
in
740 (List.map
(set_minus_comment adj
) spaces
) @
741 (adjust_before_brace rest
)
742 | rest
-> adjust_before_brace rest
in
744 let xs = List.rev
(from_newline (List.rev
xs)) in
745 let xs = drop_minus xs in
748 (* things that should not be followed by space - boundary between SmPL
750 let adjust_eat_space toks
=
751 let rec loop = function
753 | EatSpace2
:: x :: rest
when is_space x -> loop rest
754 | EatSpace2
:: rest
-> loop rest
755 | x :: xs -> x :: loop xs in
758 (* normally, in C code, a semicolon is not preceded by a space or newline *)
759 let adjust_before_semicolon toks
=
760 let toks = List.rev
toks in
761 let rec search_semic = function
763 | ((T2
(_
,Ctx
,_
)) as x)::xs | ((Cocci2 _
) as x)::xs ->
764 if List.mem
(str_of_token2 x) [";";")";","]
765 then x :: search_semic (search_minus
false xs)
766 else x :: search_semic xs
767 | x::xs -> x :: search_semic xs
768 and search_minus seen_minus
xs =
769 let (spaces
, rest
) = Common.span
is_space xs in
770 (* only delete spaces if something is actually deleted *)
772 ((T2
(_
,Min _
,_
)) as a
)::rerest
-> a
:: search_minus
true rerest
773 | _
-> if seen_minus
then rest
else xs in
774 List.rev
(search_semic toks)
776 (* normally, in C code, a ( is not followed by a space or newline *)
777 let adjust_after_paren toks =
778 let rec search_paren = function
780 | ((T2
(_
,Ctx
,_
)) as x)::xs | ((Cocci2 _
) as x)::xs ->
781 if List.mem
(str_of_token2 x) ["("] (* other things? *)
782 then x :: search_paren(search_minus
false xs)
783 else x :: search_paren xs
784 | x::xs -> x :: search_paren xs
785 and search_minus seen_minus
xs =
786 let (spaces
, rest
) = Common.span
is_whitespace xs in
787 (* only delete spaces if something is actually deleted *)
789 ((T2
(_
,Min _
,_
)) as a
)::rerest
-> (* minus *)
790 a
:: search_minus
true rerest
791 | ((T2
(_
,Ctx
,_
)) as a
)::rerest
when str_of_token2 a
= "," ->
792 (* comma after ( will be deleted, so consider it as minus code
794 a
:: search_minus
true rerest
795 | _
-> if seen_minus
then rest
else xs in (* drop trailing space *)
798 (* this is for the case where braces are added around an if branch *)
799 let paren_then_brace toks =
800 let rec search_paren = function
802 | ((T2
(_
,Ctx
,_
)) as x)::xs ->
803 if List.mem
(str_of_token2 x) [")"]
804 then x :: search_paren(search_plus
xs)
805 else x :: search_paren xs
806 | x::xs -> x :: search_paren xs
808 let (spaces
, rest
) = Common.span
is_whitespace xs in
810 (* move the brace up to the previous line *)
811 ((Cocci2
("{",_
,_
,_
,_
)) as x) :: (((Cocci2 _
) :: _
) as rest
) ->
812 (C2
" ") :: x :: spaces
@ rest
816 let is_ident_like s
= s
==~
Common.regexp_alpha
818 let rec drop_space_at_endline = function
822 ((((T2
(Parser_c.TCommentSpace _
,Ctx
,_
)) | Cocci2
("\n",_
,_
,_
,_
) |
823 (T2
(Parser_c.TCommentNewline _
,Ctx
,_
))) :: _
) as rest
) ->
824 (* when unparse_cocci doesn't know whether space is needed *)
825 drop_space_at_endline rest
826 | ((T2
(Parser_c.TCommentSpace _
,Ctx
,_i
)) as a
)::rest
->
827 let (outer_spaces
,rest
) = Common.span
is_space rest
in
828 let minus_or_comment_or_space_nocpp = function
829 T2
(_
,Min adj
,_
) -> true
830 | (T2
(Parser_c.TCommentSpace _
,Ctx
,_i
)) -> true
831 | (T2
(Parser_c.TCommentNewline _
,Ctx
,_i
)) -> false
833 let (minus
,rest
) = Common.span
minus_or_comment_or_space_nocpp rest
in
834 let fail _
= a
:: outer_spaces
@ minus
@ (drop_space_at_endline rest
) in
835 if List.exists
(function T2
(_
,Min adj
,_
) -> true | _
-> false) minus
838 ((T2
(Parser_c.TCommentNewline _
,Ctx
,_i
)) as a
)::rest
->
839 (* drop trailing spaces *)
840 minus
@a
::(drop_space_at_endline rest
)
844 a
:: drop_space_at_endline rest
846 (* if a removed ( is between two tokens, then add a space *)
847 let rec paren_to_space = function
851 | ((T2
(_
,Ctx
,_
)) as a
)::((T2
(t
,Min _
,_
)) as b
)::((T2
(_
,Ctx
,_
)) as c
)::rest
852 when not
(is_whitespace a
) && TH.str_of_tok t
= "(" ->
853 a
:: b
:: (C2
" ") :: (paren_to_space (c
:: rest
))
854 | a
:: rest
-> a
:: (paren_to_space rest
)
856 let rec add_space xs =
860 | (Cocci2
(sx
,lnx
,_
,rcolx
,_
) as x)::((Cocci2
(sy
,lny
,lcoly
,_
,_
)) as y
)::xs
861 when !Flag_parsing_c.spacing
= Flag_parsing_c.SMPL
&&
862 not
(lnx
= -1) && lnx
= lny
&& not
(rcolx
= -1) && rcolx
< lcoly
->
863 (* this only works within a line. could consider whether
864 something should be done to add newlines too, rather than
865 printing them explicitly in unparse_cocci. *)
866 x::C2
(String.make
(lcoly
-rcolx
) ' '
)::add_space (y
::xs)
867 | (Cocci2
(sx
,lnx
,_
,rcolx
,_
) as x)::((Cocci2
(sy
,lny
,lcoly
,_
,_
)) as y
)::xs
868 when !Flag_parsing_c.spacing
= Flag_parsing_c.SMPL
&&
869 not
(lnx
= -1) && lnx
< lny
&& not
(rcolx
= -1) ->
870 (* this only works within a line. could consider whether
871 something should be done to add newlines too, rather than
872 printing them explicitly in unparse_cocci. *)
873 x::C2
(String.make
(lny
-lnx
) '
\n'
)::
874 C2
(String.make
(lcoly
-1) ' '
):: (* -1 is for the + *)
876 | ((T2
(_
,Ctx
,_
)) as x)::((Cocci2 _
) as y
)::xs -> (* add space on boundary *)
877 let sx = str_of_token2 x in
878 let sy = str_of_token2 y
in
879 if is_ident_like sx && (is_ident_like sy or List.mem
sy ["="])
880 then x::C2
" "::(add_space (y
::xs))
881 else x::(add_space (y
::xs))
882 | x::y
::xs -> (* not boundary, not sure if it is possible *)
883 let sx = str_of_token2 x in
884 let sy = str_of_token2 y
in
885 if is_ident_like sx && is_ident_like sy
886 then x::C2
" "::(add_space (y
::xs))
887 else x::(add_space (y
::xs))
889 (* A fake comma is added at the end of an unordered initlist or a enum
890 decl, if the initlist or enum doesn't already end in a comma. This is only
891 needed if there is + code, ie if we see Cocci after it in the code sequence *)
893 let rec drop_end_comma = function
896 | ((Comma
",") as x) :: rest
->
897 let (newlines
,rest2
) = Common.span
is_whitespace rest
in
899 (Cocci2 _
) :: _
-> x :: drop_end_comma rest
900 | _
-> drop_end_comma rest
)
901 | x :: xs -> x :: drop_end_comma xs
903 (* The following only works for the outermost function call. Stack records
904 the column of all open parentheses. Space_cell contains the most recent
905 comma in the outermost function call. The goal is to decide whether this
906 should be followed by a space or a newline and indent. *)
907 let add_newlines toks tabbing_unit
=
908 let create_indent n
=
910 match tabbing_unit
with
911 Some
("\t",_
) -> ("\t",8)
912 | Some
("",_
) -> ("\t",8) (* not sure why... *)
913 | Some
(s
,_
) -> (s
,String.length s
) (* assuming only spaces *)
914 | None
-> ("\t",8) in
917 then tu ^
loop (seen
+ tlen
)
918 else String.make
(n
-seen
) ' '
in
920 let check_for_newline count
x = function
921 Some
(start
,space_cell
) when count
> Flag_parsing_c.max_width
->
922 space_cell
:= "\n"^
(create_indent x);
923 Some
(x + (count
- start
))
925 (* the following is for strings that may contain newline *)
926 let string_length s count
=
927 let l = list_of_string s
in
935 let rec loop info count
= function
937 | ((T2
(tok,_
,_
)) as a
)::xs ->
938 a
:: loop info
(string_length (TH.str_of_tok
tok) count
) xs
939 | ((Cocci2
(s
,line
,lcol
,rcol
,hint
)) as a
)::xs ->
940 let (stack
,space_cell
) = info
in
943 None
-> loop info
(string_length s count
) xs
944 | Some
Unparse_cocci.StartBox
->
945 let count = string_length s
count in
946 loop (count::stack
,space_cell
) count xs
947 | Some
Unparse_cocci.EndBox
->
948 let count = string_length s
count in
951 (match check_for_newline count x space_cell
with
952 Some
count -> loop ([],None
) count xs
953 | None
-> loop ([],None
) count xs)
954 | _
-> loop (List.tl stack
,space_cell
) count xs)
955 | Some
(Unparse_cocci.SpaceOrNewline sp
) ->
956 let count = string_length s
(count + 1 (*space*)) in
959 (match check_for_newline count x space_cell
with
960 Some
count -> loop (stack
,Some
(x,sp
)) count xs
961 | None
-> loop (stack
,Some
(count,sp
)) count xs)
962 | _
-> loop info
count xs) in
964 | ((C2
(s
)) as a
)::xs -> a
:: loop info
(string_length s
count) xs
965 | ((Comma
(s
)) as a
)::xs -> a
:: loop info
(string_length s
count) xs
966 | Fake2 _
:: _
| Indent_cocci2
:: _
967 | Unindent_cocci2 _
::_
| EatSpace2
::_
->
968 failwith
"unexpected fake, indent, unindent, or eatspace" in
969 let redo_spaces prev = function
970 Cocci2
(s
,line
,lcol
,rcol
,Some
(Unparse_cocci.SpaceOrNewline sp
)) ->
971 C2
!sp
:: Cocci2
(s
,line
,lcol
,rcol
,None
) :: prev
973 (match !Flag_parsing_c.spacing
with
974 Flag_parsing_c.SMPL
-> toks
975 | _
-> List.rev
(List.fold_left
redo_spaces [] (loop ([],None
) 0 toks)))
977 (* When insert some new code, because of a + in a SP, we must add this
978 * code at the right place, with the good indentation. So each time we
979 * encounter some spacing info, with some newline, we maintain the
980 * current indentation level used.
982 * TODO problems: not accurate. ex: TODO
984 * TODO: if in #define region, should add a \ \n
986 let new_tabbing2 space
=
987 (list_of_string space
)
989 +> Common.take_until
(fun c
-> c
=<= '
\n'
)
991 +> List.map string_of_char
995 Common.profile_code
"C unparsing.new_tabbing" (fun () -> new_tabbing2 a
)
998 let rec adjust_indentation xs =
1000 let _current_tabbing = ref ([] : string list
) in
1001 let tabbing_unit = ref None
in
1003 let string_of_list l = String.concat
"" (List.map string_of_char
l) in
1005 (* try to pick a tabbing unit for the plus code *)
1006 let adjust_tabbing_unit old_tab new_tab
=
1007 if !tabbing_unit =*= None
&& String.length new_tab
> String.length old_tab
1009 let old_tab = list_of_string
old_tab in
1010 let new_tab = list_of_string
new_tab in
1011 let rec loop = function
1013 tabbing_unit := Some
(string_of_list new_tab,List.rev
new_tab)
1014 | (_
,[]) -> failwith
"not possible"
1015 | (o
::os
,n
::ns
) -> loop (os
,ns
) in (* could check for equality *)
1016 loop (old_tab,new_tab) in
1019 let remtab tu current_tab =
1020 let current_tab = List.rev(list_of_string current_tab) in
1021 let rec loop = function
1022 ([],new_tab) -> string_of_list (List.rev new_tab)
1023 | (_,[]) -> (-*weird; tabbing unit used up more than the current tab*-)
1025 | (t::ts,n::ns) when t =<= n -> loop (ts,ns)
1026 | (_,ns) -> (-* mismatch; remove what we can *-)
1027 string_of_list (List.rev ns) in
1028 loop (tu,current_tab) in
1031 let rec find_first_tab started
= function
1033 | ((T2
(tok,_
,_
)) as x)::xs when str_of_token2 x =$
= "{" ->
1034 find_first_tab true xs
1035 (* patch: coccinelle *)
1036 | ((T2
(Parser_c.TCommentNewline s
, _
, _
)) as x)::_
1038 let s = str_of_token2 x +> new_tabbing in
1039 tabbing_unit := Some
(s,List.rev
(list_of_string
s))
1040 | x::xs -> find_first_tab started
xs in
1041 find_first_tab false xs;
1043 let rec balanced ct
= function
1045 | ((T2
(tok,_
,_
)) as x)::xs ->
1046 (match str_of_token2 x with
1047 "(" -> balanced (ct
+1) xs
1048 | ")" -> balanced (ct
-1) xs
1049 | _
-> balanced ct
xs)
1050 | x::xs -> balanced ct
xs in
1052 let update_tabbing started
s x =
1053 let old_tabbing = !_current_tabbing in
1054 str_of_token2 x +> new_tabbing +> (fun s -> _current_tabbing := [s]);
1055 (* only trust the indentation after the first { *)
1059 (String.concat
"" old_tabbing)
1060 (String.concat
"" !_current_tabbing) in
1062 let rec aux started
xs =
1065 (* patch: coccinelle *)
1066 | ((T2
(Parser_c.TCommentNewline
s,_
,_
)) as x)::
1067 Unindent_cocci2
(false)::xs ->
1068 update_tabbing started
s x;
1069 (C2
"\n")::aux started
xs
1070 | (Cocci2
("\n",_
,_
,_
,_
))::Unindent_cocci2
(false)::xs ->
1071 (C2
"\n")::aux started
xs
1072 | ((T2
(tok,_
,_
)) as x)::(T2
(Parser_c.TCommentNewline
s, _
, _
))::
1073 ((Cocci2
("{",_
,_
,_
,_
)) as a
)::xs
1074 when started
&& str_of_token2 x =$
= ")" ->
1075 (* to be done for if, etc, but not for a function header *)
1076 x::(C2
" ")::a
::(aux started
xs)
1077 | ((T2
(Parser_c.TCommentNewline
s, _
, _
)) as x)::xs
1079 balanced 0 (fst
(Common.span
(function x -> not
(is_newline x)) xs)) ->
1080 update_tabbing started
s x;
1081 let coccis_rest = Common.span
all_coccis xs in
1082 (match coccis_rest with
1083 (_
::_
,((T2
(tok,_
,_
)) as y
)::_
) when str_of_token2 y
=$
= "}" ->
1084 (* the case where cocci code has been added before a close } *)
1085 x::aux started
(Indent_cocci2
::xs)
1086 | _
-> x::aux started
xs)
1087 | Indent_cocci2
::((Cocci2
(sy,lny
,lcoly
,_
,_
)) as y
)::xs
1088 when !Flag_parsing_c.spacing
= Flag_parsing_c.SMPL
->
1089 let tu = String.make
(lcoly
-1) ' '
in
1090 _current_tabbing := tu::(!_current_tabbing);
1091 C2
(tu)::aux started
(y
::xs)
1092 | Indent_cocci2
::xs ->
1093 (match !tabbing_unit with
1094 None
-> aux started
xs
1096 _current_tabbing := tu::(!_current_tabbing);
1097 (* can't be C2, for later phases *)
1098 Cocci2
(tu,-1,-1,-1,None
)::aux started
xs)
1099 | Unindent_cocci2
(permanent
)::xs ->
1100 (match !_current_tabbing with
1101 [] -> aux started
xs
1103 _current_tabbing := new_tabbing;
1105 (* border between existing code and cocci code *)
1106 | ((T2
(tok,_
,_
)) as x)::((Cocci2
("\n",_
,_
,_
,_
)) as y
)::xs
1107 when str_of_token2 x =$
= "{" ->
1108 x::aux true (y
::Indent_cocci2
::xs)
1109 | ((Cocci2 _
) as x)::((T2
(tok,_
,_
)) as y
)::xs
1110 when str_of_token2 y
=$
= "}" ->
1111 x::aux started
(y
::Unindent_cocci2
true::xs)
1112 (* starting the body of the function *)
1113 | ((T2
(tok,_
,_
)) as x)::xs when str_of_token2 x =$
= "{" -> x::aux true xs
1114 | ((Cocci2
("{",_
,_
,_
,_
)) as a
)::xs -> a
::aux true xs
1115 | ((Cocci2
("\n",_
,_
,_
,_
)) as x)::xs ->
1116 (* dont inline in expr because of weird eval order of ocaml *)
1117 let s = String.concat
"" !_current_tabbing in
1118 (* can't be C2, for later phases *)
1119 x::Cocci2
(s,-1,-1,-1,None
)::aux started
xs
1120 | x::xs -> x::aux started
xs in
1121 (aux false xs,!tabbing_unit)
1124 let rec find_paren_comma = function
1127 (* do nothing if was like this in original file *)
1128 | ({ str = "("; idx
= Some p1
} as _x1
)::({ str = ","; idx
= Some p2
} as x2
)
1129 ::xs when p2
=|= p1
+ 1 ->
1130 find_paren_comma (x2
::xs)
1132 | ({ str = ","; idx
= Some p1
} as _x1
)::({ str = ","; idx
= Some p2
} as x2
)
1133 ::xs when p2
=|= p1
+ 1 ->
1134 find_paren_comma (x2
::xs)
1136 | ({ str = ","; idx
= Some p1
} as _x1
)::({ str = ")"; idx
= Some p2
} as x2
)
1137 ::xs when p2
=|= p1
+ 1 ->
1138 find_paren_comma (x2
::xs)
1140 (* otherwise yes can adjust *)
1141 | ({ str = "(" } as _x1
)::({ str = ","} as x2
)::xs ->
1143 find_paren_comma (x2
::xs)
1144 | ({ str = "," } as x1
)::({ str = ","} as x2
)::xs ->
1146 find_paren_comma (x2
::xs)
1148 | ({ str = "," } as x1
)::({ str = ")"} as x2
)::xs ->
1150 find_paren_comma (x2
::xs)
1156 let fix_tokens toks =
1157 let toks = toks +> List.map
mk_token_extended in
1159 let cleaner = toks +> Common.exclude
(function
1160 | {tok2
= T2
(t
,_
,_
)} -> TH.is_real_comment t
(* I want the ifdef *)
1163 find_paren_comma cleaner;
1165 let toks = rebuild_tokens_extented toks in
1166 toks +> List.map
(fun x -> x.tok2
)
1170 (*****************************************************************************)
1171 (* Final unparsing (and debugging support) *)
1172 (*****************************************************************************)
1175 type kind_token2
= KFake
| KCocci
| KC
| KExpanded
| KOrigin
1177 let kind_of_token2 = function
1179 | Cocci2 _
-> KCocci
1183 (match TH.pinfo_of_tok t
with
1184 | ExpandedTok _
-> KExpanded
1185 | OriginTok _
-> KOrigin
1186 | FakeTok _
-> raise Impossible
(* now a Fake2 *)
1187 | AbstractLineTok _
-> raise Impossible
(* now a KC *)
1189 | Unindent_cocci2 _
| Indent_cocci2
| EatSpace2
-> raise Impossible
1193 let start_mark = function
1197 | KExpanded
-> "!E!"
1200 let print_all_tokens2 pr
xs =
1201 if !Flag_parsing_c.debug_unparsing
1203 let current_kind = ref KOrigin
in
1204 xs +> List.iter
(fun t
->
1205 let newkind = kind_of_token2 t
in
1206 if newkind =*= !current_kind
1207 then pr
(str_of_token2 t
)
1210 pr
(start_mark newkind);
1211 pr
(str_of_token2 t
);
1212 current_kind := newkind
1216 xs +> List.iter
(fun x -> pr
(str_of_token2 x))
1221 (*****************************************************************************)
1223 (*****************************************************************************)
1225 (* old: PPviatok was made in the beginning to allow to pretty print a
1226 * complete C file, including a modified C file by transformation.ml,
1227 * even if we don't handle yet in pretty_print_c.ml, ast_to_flow (and
1228 * maybe flow_to_ast) all the cases. Indeed we don't need to do some
1229 * fancy stuff when a function was not modified at all. Just need to
1230 * print the list of token as-is. But now pretty_print_c.ml handles
1231 * almost everything so maybe less useful. Maybe PPviatok allows to
1232 * optimize a little the pretty printing.
1234 * update: now have PPviastr which goes even faster than PPviatok, so
1235 * PPviatok has disappeared.
1238 type ppmethod
= PPnormal
| PPviastr
1243 (* The pp_program function will call pretty_print_c.ml with a special
1244 * function to print the leaf components, the tokens. When we want to
1245 * print a token, we need to print also maybe the space and comments that
1246 * were close to it in the original file (and that was omitted during the
1247 * parsing phase), and honor what the cocci-info attached to the token says.
1248 * Maybe we will not print the token if it's a MINUS-token, and maybe we will
1249 * print it and also print some cocci-code attached in a PLUS to it.
1250 * So we will also maybe call unparse_cocci. Because the cocci-code may
1251 * contain metavariables, unparse_cocci will in fact sometimes call back
1252 * pretty_print_c (which will this time don't call back again unparse_cocci)
1255 let pp_program2 xs outfile
=
1256 Common.with_open_outfile outfile
(fun (pr
,chan
) ->
1258 if !Flag_parsing_c.debug_unparsing
1259 then begin pr2_no_nl
s; flush stderr
end
1262 (* Common.pr2 ("UNPARSING: >" ^ s ^ "<"); *)
1265 xs +> List.iter
(fun ((e
,(str, toks_e
)), ppmethod
) ->
1266 (* here can still work on ast *)
1267 let e = remove_useless_fakeInfo_struct e in
1271 (* now work on tokens *)
1272 (* phase1: just get all the tokens, all the information *)
1273 assert(toks_e
+> List.for_all
(fun t
->
1274 TH.is_origin t
or TH.is_expanded t
1276 let toks = get_fakeInfo_and_tokens e toks_e
in
1277 let toks = displace_fake_nodes toks in
1278 (* assert Origin;ExpandedTok;Faketok *)
1279 let toks = expand_mcode toks in
1281 (* assert Origin;ExpandedTok; + Cocci + C (was AbstractLineTok)
1282 * and no tag information, just NOTHING. *)
1285 if !Flag.sgrep_mode2
1287 (* nothing else to do for sgrep *)
1288 drop_expanded(drop_fake(drop_minus toks))
1290 (* phase2: can now start to filter and adjust *)
1291 (let (toks,tu) = adjust_indentation toks in
1292 let toks = adjust_eat_space toks in
1293 let toks = adjust_before_semicolon toks in(*before remove minus*)
1294 let toks = adjust_after_paren toks in(*also before remove minus*)
1295 let toks = drop_space_at_endline toks in
1296 let toks = paren_to_space toks in
1297 let toks = drop_end_comma toks in
1298 let toks = remove_minus_and_between_and_expanded_and_fake toks in
1299 (* assert Origin + Cocci + C and no minus *)
1300 let toks = add_space toks in
1301 let toks = add_newlines toks tu in
1302 let toks = paren_then_brace toks in
1303 let toks = fix_tokens toks in
1306 (* in theory here could reparse and rework the ast! or
1307 * apply some SP. Not before cos julia may have generated
1308 * not parsable file. Need do unparsing_tricks call before being
1309 * ready to reparse. *)
1310 print_all_tokens2 pr toks;
1312 | PPviastr
-> pr str
1316 let pp_program a b
=
1317 Common.profile_code
"C unparsing" (fun () -> pp_program2 a b
)
1320 let pp_program_default xs outfile
=
1321 let xs'
= xs +> List.map
(fun x -> x, PPnormal
) in
1322 pp_program xs' outfile