Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package coccinelle for openSUSE:Factory checked in at 2026-09-21 12:20:55 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/coccinelle (Old) and /work/SRC/openSUSE:Factory/.coccinelle.new.383539 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "coccinelle" Mon Sep 21 12:20:55 2026 rev:42 rq:1379284 version:1.3.3 Changes: -------- --- /work/SRC/openSUSE:Factory/coccinelle/coccinelle.changes 2026-08-25 13:20:33.570952500 +0200 +++ /work/SRC/openSUSE:Factory/.coccinelle.new.383539/coccinelle.changes 2026-09-21 12:20:56.966598794 +0200 @@ -1,0 +2,10 @@ +Sun Sep 13 12:03:42 UTC 2026 - Martin Pluskal <[email protected]> + +- Update to version 1.3.3: + * Clean up unused label and guard arguments in predmaker + and asttoctl2 + * Cache satLabel results by predicate identity for faster + rule evaluation + * Minor documentation updates + +------------------------------------------------------------------- Old: ---- coccinelle-1.3.2.tar.xz New: ---- coccinelle-1.3.3.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ coccinelle.spec ++++++ --- /var/tmp/diff_new_pack.VHoHsu/_old 2026-09-21 12:20:57.841635381 +0200 +++ /var/tmp/diff_new_pack.VHoHsu/_new 2026-09-21 12:20:57.842635422 +0200 @@ -1,7 +1,7 @@ # # spec file for package coccinelle # -# Copyright (c) 2026 SUSE LLC +# Copyright (c) 2026 SUSE LLC and contributors # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -38,7 +38,7 @@ %define pkg coccinelle %global _buildshell /bin/bash Name: %pkg%nsuffix -Version: 1.3.2 +Version: 1.3.3 Release: 0 %{?ocaml_preserve_bytecode} Summary: Semantic patch utility @@ -65,6 +65,7 @@ Requires: findutils Requires: grep Requires: which + %description Coccinelle is a program matching and transformation engine which provides the language SmPL (Semantic Patch Language) for specifying @@ -84,6 +85,9 @@ BuildRequires: autoconf BuildRequires: automake BuildRequires: hevea +BuildRequires: texlive-latex +BuildRequires: texlive-metafont +BuildRequires: texlive-mfware BuildRequires: ocaml(ocaml.opt) BuildRequires: ocamlfind(findlib) BuildRequires: ocamlfind(parmap) @@ -92,12 +96,15 @@ BuildRequires: tex(alltt.sty) BuildRequires: tex(amsmath.sty) BuildRequires: tex(amssymb.sty) +BuildRequires: tex(babel-english.tex) BuildRequires: tex(boxedminipage.sty) BuildRequires: tex(color.sty) BuildRequires: tex(colortbl.sty) BuildRequires: tex(comment.sty) BuildRequires: tex(endnotes.sty) +BuildRequires: tex(english.ldf) BuildRequires: tex(epsfig.sty) +BuildRequires: tex(fancyhdr.sty) BuildRequires: tex(fancyvrb.sty) BuildRequires: tex(fontenc.sty) BuildRequires: tex(fullpage.sty) @@ -120,12 +127,7 @@ BuildRequires: tex(wrapfig.sty) BuildRequires: tex(xspace.sty) BuildRequires: tex(xy.sty) -BuildRequires: tex(babel-english.tex) -BuildRequires: tex(fancyhdr.sty) -BuildRequires: tex(english.ldf) -BuildRequires: texlive-latex -BuildRequires: texlive-metafont -BuildRequires: texlive-mfware + %description Coccinelle is a program matching and transformation engine which provides the language SmPL (Semantic Patch Language) for specifying @@ -136,6 +138,7 @@ BuildRequires: %pkg = %version BuildRequires: ocaml(ocaml.opt) BuildRequires: ocamlfind(findlib) + %description %endif ++++++ _service ++++++ --- /var/tmp/diff_new_pack.VHoHsu/_old 2026-09-21 12:20:57.898637764 +0200 +++ /var/tmp/diff_new_pack.VHoHsu/_new 2026-09-21 12:20:57.901637890 +0200 @@ -36,7 +36,7 @@ <param name="exclude">tools/obsolete</param> <param name="exclude">tools/spgen/.gitignore</param> <param name="filename">coccinelle</param> - <param name="revision">fe6931b57746efa8912adfed9b47b9a8a903325d</param> + <param name="revision">11b93adb6516a358a6687051e5762136666626e0</param> <param name="scm">git</param> <param name="submodules">disable</param> <param name="url">https://gitlab.inria.fr/coccinelle/coccinelle.git</param> ++++++ coccinelle-1.3.2.tar.xz -> coccinelle-1.3.3.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/coccinelle-1.3.2/ctl/ctl_engine.ml new/coccinelle-1.3.3/ctl/ctl_engine.ml --- old/coccinelle-1.3.2/ctl/ctl_engine.ml 2026-08-20 14:13:37.000000000 +0200 +++ new/coccinelle-1.3.3/ctl/ctl_engine.ml 2026-09-02 14:30:47.000000000 +0200 @@ -1497,18 +1497,44 @@ let memo_label = (Hashtbl.create(101) : (P.t, (G.node * substitution) list) Hashtbl.t) +(* The keys of memo_label are whole predicates, so both the hashing and the +key equality test done by Hashtbl.find walk the predicate structure, which +can descend into a rule_elem. The same predicate object is looked up once +per occurrence of a Pred leaf per evaluation pass, which makes these walks +a bottleneck when a subformula is evaluated many times, as happens when the +first & breaks up the results of its left argument (see A.And in satloop). +Physical identity gives a sound fast path: (==) implies (=). Entries are +only added for keys that are (being) stored in memo_label, so the two +tables always agree. *) +module PhysPredHash = + Hashtbl.Make + (struct + type t = P.t + let equal = (==) + let hash = Hashtbl.hash + end) +let memo_label_phys = + (PhysPredHash.create(101) : (G.node * substitution) list PhysPredHash.t) + let satLabel label required p = let triples = if !pSATLABEL_MEMO_OPT then try - let states_subs = Hashtbl.find memo_label p in + let states_subs = + try PhysPredHash.find memo_label_phys p + with Not_found -> + let states_subs = Hashtbl.find memo_label p in + PhysPredHash.add memo_label_phys p states_subs; + states_subs in List.map (function (st,th) -> (st,th,[])) states_subs with Not_found -> let triples = setify(label p) in - Hashtbl.add memo_label p - (List.map (function (st,th,_) -> (st,th)) triples); + let states_subs = + List.map (function (st,th,_) -> (st,th)) triples in + Hashtbl.add memo_label p states_subs; + PhysPredHash.add memo_label_phys p states_subs; triples else setify(label p) in (* normalize first; conj_subst relies on sorting *) @@ -2364,6 +2390,7 @@ | n -> let _ = fn() in (Hashtbl.clear reachable_table; Hashtbl.clear memo_label; + PhysPredHash.clear memo_label_phys; triples := 0; iter fn (n-1)) @@ -2379,6 +2406,7 @@ begin Hashtbl.clear reachable_table; Hashtbl.clear memo_label; + PhysPredHash.clear memo_label_phys; List.iter (function (opt,_) -> opt := true) options; List.iter (function (calls,_,save_calls) -> save_calls := !calls) counters; @@ -2500,6 +2528,7 @@ | Some x -> step_count := x); Hashtbl.clear reachable_table; Hashtbl.clear memo_label; + PhysPredHash.clear memo_label_phys; let (x,label,preproc,states) = m in if (!Flag_ctl.bench > 0) || preprocess m reqopt then diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/coccinelle-1.3.2/engine/asttoctl2.ml new/coccinelle-1.3.3/engine/asttoctl2.ml --- old/coccinelle-1.3.2/engine/asttoctl2.ml 2026-08-20 14:13:37.000000000 +0200 +++ new/coccinelle-1.3.3/engine/asttoctl2.ml 2026-09-02 14:30:47.000000000 +0200 @@ -157,24 +157,24 @@ (* label used to be used here, but it is not used; label is only needed after and within dots *) -let predmaker guard pred label = CTL.Pred pred +let predmaker pred = CTL.Pred pred -let aftpred = predmaker false (Lib_engine.After, CTL.Control) -let retpred = predmaker false (Lib_engine.Return, CTL.Control) -let funpred = predmaker false (Lib_engine.FunHeader, CTL.Control) -let unsbrpred = predmaker false (Lib_engine.UnsafeBrace, CTL.Control) -let toppred = predmaker false (Lib_engine.Top, CTL.Control) -let exitpred = predmaker false (Lib_engine.ErrorExit, CTL.Control) -let endpred = predmaker false (Lib_engine.PreExit, CTL.Control) -let preendpred = predmaker false (Lib_engine.PreExit, CTL.Control) -let gotopred = predmaker false (Lib_engine.Goto, CTL.Control) -let inlooppred = predmaker false (Lib_engine.InLoop, CTL.Control) -let truepred = predmaker false (Lib_engine.TrueBranch, CTL.Control) -let esctruepred = predmaker false (Lib_engine.EscTrueBranch, CTL.Control) -let falsepred = predmaker false (Lib_engine.FalseBranch, CTL.Control) -let fallpred = predmaker false (Lib_engine.FallThrough, CTL.Control) -let loopfallpred = predmaker false (Lib_engine.LoopFallThrough, CTL.Control) -let gotoaftpred = predmaker false (Lib_engine.GotoAfter, CTL.Control) +let aftpred = predmaker (Lib_engine.After, CTL.Control) +let retpred = predmaker (Lib_engine.Return, CTL.Control) +let funpred = predmaker (Lib_engine.FunHeader, CTL.Control) +let unsbrpred = predmaker (Lib_engine.UnsafeBrace, CTL.Control) +let toppred = predmaker (Lib_engine.Top, CTL.Control) +let exitpred = predmaker (Lib_engine.ErrorExit, CTL.Control) +let endpred = predmaker (Lib_engine.PreExit, CTL.Control) +let preendpred = predmaker (Lib_engine.PreExit, CTL.Control) +let gotopred = predmaker (Lib_engine.Goto, CTL.Control) +let inlooppred = predmaker (Lib_engine.InLoop, CTL.Control) +let truepred = predmaker (Lib_engine.TrueBranch, CTL.Control) +let esctruepred = predmaker (Lib_engine.EscTrueBranch, CTL.Control) +let falsepred = predmaker (Lib_engine.FalseBranch, CTL.Control) +let fallpred = predmaker (Lib_engine.FallThrough, CTL.Control) +let loopfallpred = predmaker (Lib_engine.LoopFallThrough, CTL.Control) +let gotoaftpred = predmaker (Lib_engine.GotoAfter, CTL.Control) (*let aftret label_var = ctl_or (aftpred label_var) @@ -487,26 +487,26 @@ recursor.V.combiner_rule_elem (* code is not a DisjRuleElem *) -let make_match label guard code = +let make_match guard code = let v = fresh_var() in let matcher = Lib_engine.Match(code) in if contains_modif code && not guard - then CTL.Exists(true,v,predmaker guard (matcher,CTL.Modif v) label) + then CTL.Exists(true,v,predmaker (matcher,CTL.Modif v)) else let iso_info = !Flag.track_iso_usage && not (Ast.get_isos code = []) in (match (iso_info,!onlyModif,guard, intersect !used_after (Ast.get_fvs code)) with (false,true,_,[]) | (_,_,true,_) -> - predmaker guard (matcher,CTL.Control) label - | _ -> CTL.Exists(true,v,predmaker guard (matcher,CTL.UnModif v) label)) + predmaker (matcher,CTL.Control) + | _ -> CTL.Exists(true,v,predmaker (matcher,CTL.UnModif v))) -let make_raw_match label guard code = +let make_raw_match guard code = match intersect !used_after (Ast.get_fvs code) with - [] -> predmaker guard (Lib_engine.Match(code),CTL.Control) label + [] -> predmaker (Lib_engine.Match(code),CTL.Control) | _ -> let v = fresh_var() in - CTL.Exists(true,v,predmaker guard (Lib_engine.Match(code),CTL.UnModif v) - label) + CTL.Exists(true,v,predmaker (Lib_engine.Match(code),CTL.UnModif v) + ) let rec seq_fvs quantified = function [] -> [] @@ -971,15 +971,15 @@ (* code might be a DisjRuleElem, in which case we break it apart code might contain an Exp or Ty this one pushes the quantifier inwards *) -let do_re_matches label guard res quantified minus_quantified = +let do_re_matches guard res quantified minus_quantified = let make_guard_match x = let stmt_fvs = Ast.get_mfvs x in let fvs = get_unquantified minus_quantified stmt_fvs in - non_saved_quantify fvs (make_match None true x) in + non_saved_quantify fvs (make_match true x) in let make_match x = let stmt_fvs = Ast.get_fvs x in let fvs = get_unquantified quantified stmt_fvs in - quantify guard fvs (make_match None guard x) in + quantify guard fvs (make_match guard x) in (* label used to be used here, but it is not use; label is only needed after and within dots ctl_and CTL.NONSTRICT (label_pred_maker label) *) @@ -1000,22 +1000,19 @@ code doesn't contain an Exp or Ty this one is for use when it is not practical to push the quantifier inwards *) -let header_match label guard code : ('a, Ast.meta_name, 'b) CTL.generic_ctl = +let header_match guard code : ('a, Ast.meta_name, 'b) CTL.generic_ctl = match Ast.unwrap code with Ast.DisjRuleElem(res) -> - let make_match = make_match None guard in + let make_match = make_match guard in let orop = if guard then ctl_or else ctl_seqor in -(* label used to be used here, but it is not use; label is only needed after -and within dots - ctl_and CTL.NONSTRICT (label_pred_maker label) *) (List.fold_left orop CTL.False (List.map make_match res)) - | _ -> make_match label guard code + | _ -> make_match guard code (* --------------------------------------------------------------------- *) (* control structures *) let end_control_structure fvs header body after_pred - after_checks no_after_checks (afvs,afresh,ainh,aft) after label guard = + after_checks no_after_checks (afvs,afresh,ainh,aft) after guard = (* aft indicates what is added after the whole if, which has to be added to the endif node *) let (aft_needed,after_branch) = @@ -1024,7 +1021,7 @@ (false,make_seq_after2 guard after_pred after) | _ -> let match_endif = - let make_match = make_match label guard in + let make_match = make_match guard in make_meta_rule_elem make_match guard "1" aft Ast.CstrTrue (afvs,afresh,ainh) in (true, make_seq_after_ex guard after_pred @@ -1048,7 +1045,7 @@ ctl_ax_absolute s body))) let ifthen ifheader branch ((afvs,_,_,_) as aft) after - quantified minus_quantified label llabel slabel recurse make_match guard = + quantified minus_quantified llabel slabel recurse make_match guard = (* "if (test) thn" becomes: if(test) & AX((TrueBranch & AX thn) v FallThrough v After) @@ -1078,11 +1075,11 @@ (* no point to put a label on truepred etc; it is local to this construct so it must have the same label *) make_seq guard - [truepred None; recurse branch NotTop Tail new_quantified new_mquantified + [truepred; recurse branch NotTop Tail new_quantified new_mquantified (Some (lv,used)) llabel slabel guard] in - let after_pred = aftpred None in + let after_pred = aftpred in let or_cases after_branch = - Common.Left [true_branch; fallpred None; after_branch] in + Common.Left [true_branch; fallpred; after_branch] in let (if_header,wrapper) = if !used then @@ -1092,10 +1089,10 @@ else (if_header,function x -> x) in wrapper (end_control_structure bfvs if_header or_cases after_pred - (Some(ctl_ex after_pred)) None aft after label guard) + (Some(ctl_ex after_pred)) None aft after guard) let ifthenelse ifheader branch1 els branch2 ((afvs,_,_,_) as aft) after - quantified minus_quantified label llabel slabel recurse make_match guard = + quantified minus_quantified llabel slabel recurse make_match guard = (* "if (test) thn else els" becomes: if(test) & AX((TrueBranch & AX thn) v (FalseBranch & AX (else & AX els)) v After) @@ -1153,17 +1150,17 @@ let used = ref false in let true_branch = make_seq guard - [truepred None; recurse branch1 NotTop Tail new_quantified new_mquantified + [truepred; recurse branch1 NotTop Tail new_quantified new_mquantified (Some (lv,used)) llabel slabel guard] in let false_branch = make_seq guard - [falsepred None; + [falsepred; quantify guard (Common.minus_set (Ast.get_fvs els) new_quantified) - (header_match None guard els); + (header_match guard els); recurse branch2 NotTop Tail new_quantified new_mquantified (Some (lv,used)) llabel slabel guard] in - let after_pred = aftpred None in + let after_pred = aftpred in let or_cases after_branch = Common.Left [true_branch; false_branch; after_branch] in let s = guard_to_strict guard in @@ -1176,12 +1173,12 @@ else (if_header,function x -> x) in wrapper (end_control_structure bothfvs if_header or_cases after_pred - (Some(ctl_and s (ctl_ex (falsepred None)) (ctl_ex after_pred))) - (Some(ctl_ex (falsepred None))) - aft after label guard) + (Some(ctl_and s (ctl_ex (falsepred)) (ctl_ex after_pred))) + (Some(ctl_ex (falsepred))) + aft after guard) let forwhile inloop header body ((afvs,_,_,_) as aft) after - quantified minus_quantified label recurse make_match guard = + quantified minus_quantified recurse make_match guard = let process _ = (* the translation in this case is similar to that of an if with no else *) (* free variables *) @@ -1206,9 +1203,9 @@ recurse body NotTop Tail new_quantified new_mquantified (Some (lv,used)) (Some (lv,used)) None guard in if inloop - then make_seq guard [inlooppred None; dobody] + then make_seq guard [inlooppred; dobody] else dobody in - let after_pred = (if inloop then loopfallpred else aftpred) None in + let after_pred = (if inloop then loopfallpred else aftpred) in let or_cases after_branch = Common.Left [body; after_branch] in let (header,wrapper) = @@ -1220,7 +1217,7 @@ else (header,function x -> x) in wrapper (end_control_structure bfvs header or_cases after_pred - (Some(ctl_ex after_pred)) None aft after label guard) in + (Some(ctl_ex after_pred)) None aft after guard) in match (Ast.unwrap body,aft) with (Ast.Atomic(re),(_,_,_,Ast.CONTEXT(_,Ast.NOTHING))) -> let pos_unitary pos = @@ -1243,7 +1240,7 @@ | _ -> process() let dowhile doheader body whiletail after quantified - minus_quantified label recurse make_match guard = + minus_quantified recurse make_match guard = let (dofvs,bfvs,whilefvs) = match seq_fvs quantified @@ -1268,13 +1265,13 @@ let lv = get_label_ctr() in let tail_branch = ctl_and CTL.NONSTRICT tailer - (ctl_and CTL.NONSTRICT (ctl_ex (inlooppred None)) (ctl_ex (fallpred None))) in + (ctl_and CTL.NONSTRICT (ctl_ex (inlooppred)) (ctl_ex (fallpred))) in let used = ref false in let body = make_seq guard [recurse body NotTop (After (tail_branch)) new_quantified new_mquantified (Some (lv, used)) (Some (lv, used)) None guard] in - let after_branch = aftpred None in + let after_branch = aftpred in let or_cases after_branch = Common.Left [body; after_branch] in let (header, wrapper) = if !used @@ -1283,7 +1280,7 @@ (ctl_and CTL.NONSTRICT header label_pred, (function body -> quantify true [lv] body)) else (header, function x -> x) in wrapper (end_control_structure bfvs header or_cases after_branch - (Some(ctl_ex after_branch)) None aft after label guard) + (Some(ctl_ex after_branch)) None aft after guard) (* --------------------------------------------------------------------- *) (* statement metavariables *) @@ -1310,7 +1307,7 @@ ctl_and CTL.NONSTRICT (ctl_not (ctl_back_ax label_pred)) x)) | Ast.NotSequencible -> body (function x -> x) -let svar_context_with_add_after stmt s label quantified d ast +let svar_context_with_add_after stmt s quantified d ast seqible after process_bef_aft guard fvinfo = let label_var = (*fresh_label_var*) string2var "_lab" in let label_pred = @@ -1318,7 +1315,7 @@ (*let prelabel_pred = CTL.Pred (Lib_engine.PrefixLabel(label_var),CTL.Control) in*) let matcher d = - let make_match = make_match None guard in + let make_match = make_match guard in make_meta_rule_elem make_match guard "2" d Ast.CstrTrue fvinfo in let full_metamatch = matcher d in let first_metamatch = @@ -1351,7 +1348,7 @@ ctl_and CTL.NONSTRICT middle_metamatch prelabel_pred in *) - let to_end = ctl_or (aftpred None) (loopfallpred None) in + let to_end = ctl_or (aftpred) (loopfallpred) in let left_or = (* the whole statement is one node *) make_seq_after guard (ctl_and CTL.NONSTRICT (ctl_not (ctl_ex to_end)) full_metamatch) after in @@ -1380,13 +1377,13 @@ let body f = ctl_and CTL.NONSTRICT label_pred (f (ctl_and CTL.NONSTRICT - (make_raw_match label false ast) (ctl_or left_or right_or))) in + (make_raw_match false ast) (ctl_or left_or right_or))) in let stmt_fvs = Ast.get_fvs stmt in let fvs = get_unquantified quantified stmt_fvs in quantify guard (label_var::fvs) (sequencibility body label_pred process_bef_aft seqible) -let svar_minus_or_no_add_after stmt s label quantified d ast +let svar_minus_or_no_add_after stmt s quantified d ast seqible after process_bef_aft guard fvinfo = let label_var = (*fresh_label_var*) string2var "_lab" in let label_pred = @@ -1394,17 +1391,17 @@ let prelabel_pred = CTL.Pred (Lib_engine.PrefixLabel(label_var),CTL.Control) in let matcher d = - let make_match = make_match None guard in + let make_match = make_match guard in make_meta_rule_elem make_match guard "3" d Ast.CstrTrue fvinfo in let ender = match (d,after) with (Ast.PLUS _, _) -> failwith "asttoctl2: not possible 15" | (Ast.CONTEXT(pos,Ast.NOTHING),(Tail|End|VeryEnd)) -> (* just match the root. don't care about label; always ok *) - make_raw_match None false ast + make_raw_match false ast | (Ast.CONTEXT(pos,Ast.BEFORE(_,_)),(Tail|End|VeryEnd)) -> ctl_and CTL.NONSTRICT - (make_raw_match None false ast) (* statement *) + (make_raw_match false ast) (* statement *) (matcher d) (* transformation *) | (Ast.CONTEXT(pos,(Ast.NOTHING|Ast.BEFORE(_,_))), ((After a | Guard a) as after)) -> @@ -1413,14 +1410,14 @@ (* not really sure what this is doing, esp is_compound... *) let first_metamatch = matcher d in (* try to follow after link *) - let to_end = ctl_or (aftpred None) (loopfallpred None) in + let to_end = ctl_or (aftpred) (loopfallpred) in let is_compound = ctl_ex (make_seq_ex guard [to_end; make_seq_after guard CTL.True after]) in let not_compound = make_seq_after guard (ctl_not (ctl_ex to_end)) after in - ctl_and CTL.NONSTRICT (make_raw_match label false ast) + ctl_and CTL.NONSTRICT (make_raw_match false ast) (ctl_and CTL.NONSTRICT first_metamatch (ctl_or is_compound not_compound)) | (Ast.CONTEXT(pos,(Ast.AFTER _|Ast.BEFOREAFTER _)),_) -> @@ -1433,10 +1430,10 @@ | _ -> (matcher d, matcher(Ast.MINUS(pos,inst,adj,Ast.NOREPLACEMENT)), ctl_and CTL.NONSTRICT - (ctl_not (make_raw_match label false ast)) + (ctl_not (make_raw_match false ast)) (matcher(Ast.MINUS(pos,inst,adj,Ast.NOREPLACEMENT)))) in (* try to follow after link *) - let to_end = ctl_or (aftpred None) (loopfallpred None) in + let to_end = ctl_or (aftpred) (loopfallpred) in let is_compound = ctl_ex (make_seq_ex guard @@ -1444,7 +1441,7 @@ let not_compound = make_seq_after guard (ctl_not (ctl_ex to_end)) after in ctl_and CTL.NONSTRICT - (ctl_and CTL.NONSTRICT (make_raw_match label false ast) + (ctl_and CTL.NONSTRICT (make_raw_match false ast) (ctl_and CTL.NONSTRICT first_metamatch (ctl_or is_compound not_compound))) (* don't have to put anything before the beginning, so don't have to @@ -1453,7 +1450,7 @@ what they should because it is in the lhs of the andany. *) (CTL.HackForStmt(CTL.FORWARD,CTL.NONSTRICT, ctl_and CTL.NONSTRICT label_pred - (make_raw_match label false ast), + (make_raw_match false ast), ctl_and CTL.NONSTRICT prelabel_pred rest_metamatch)) in let body f = ctl_and CTL.NONSTRICT label_pred (f ender) in @@ -1466,13 +1463,13 @@ (* dots and nests *) let dots_au is_strict toend label s wrapcode n x seq_after y quantifier = - let matchgoto = gotopred None in + let matchgoto = gotopred in let matchbreak = - make_match None false + make_match false (wrapcode (Ast.Break(Ast.make_mcode "break",Ast.make_mcode ";"))) in let matchcontinue = - make_match None false + make_match false (wrapcode (Ast.Continue(Ast.make_mcode "continue",Ast.make_mcode ";"))) in let op = if quantifier = !exists then ctl_au else ctl_anti_au in @@ -1480,9 +1477,9 @@ if quantifier = Exists then Common.Left(CTL.False) else if toend - then Common.Left(CTL.Or(aftpred label,exitpred label)) + then Common.Left(CTL.Or(aftpred, exitpred)) else if is_strict - then Common.Left(aftpred label) + then Common.Left(aftpred) else Common.Right (function vx -> function v -> @@ -1506,10 +1503,10 @@ | _ -> false in is_paren e1 or is_paren e2 | _ -> false in *) - ctl_or (aftpred label) + ctl_or (aftpred) (quantify false [lv] (ctl_and CTL.NONSTRICT - (ctl_and CTL.NONSTRICT (esctruepred label) labelpred) + (ctl_and CTL.NONSTRICT (esctruepred) labelpred) (op CTL.NONSTRICT (ctl_and CTL.NONSTRICT (ctl_not v) (ctl_and CTL.NONSTRICT vx preflabelpred)) @@ -1517,12 +1514,12 @@ (if !Flag_matcher.only_return_is_error_exit then (ctl_and CTL.NONSTRICT - (retpred None) (ctl_not seq_after)) + (retpred) (ctl_not seq_after)) else (ctl_or (ctl_and CTL.NONSTRICT - (ctl_or (aftpred None) - (ctl_or (retpred None) matchcontinue)) + (ctl_or (aftpred) + (ctl_or (retpred) matchcontinue)) (ctl_not seq_after)) (ctl_and CTL.NONSTRICT (ctl_or matchgoto matchbreak) @@ -1596,10 +1593,10 @@ | Ast.WhenModifier(_) -> (poswhen,negwhen) | Ast.WhenNotTrue(e) -> (poswhen, - ctl_or (whencond_true e label guard quantified) negwhen) + ctl_or (whencond_true e guard quantified) negwhen) | Ast.WhenNotFalse(e) -> (poswhen, - ctl_or (whencond_false e label guard quantified) negwhen)) + ctl_or (whencond_false e guard quantified) negwhen)) (CTL.True,CTL.False(*bef_aft*)) (List.rev whencodes) in (*bef_aft modifies arg so that inside of a nest can't cause the next to overshoot its boundaries, eg a() <...f()...> b() where f is @@ -1610,7 +1607,7 @@ (* if !exists then*) (* add in After, because it's not part of the program *) - ctl_or (aftpred label) negwhen + ctl_or (aftpred) negwhen (*else negwhen*) in ctl_and_ns poswhen (ctl_not negwhen) in (* process dot code, if any *) @@ -1660,8 +1657,8 @@ assert (label = None); ctl_and CTL.NONSTRICT (ctl_uncheck f) labelled | VeryEnd -> - let exit = endpred label in - let errorexit = exitpred label in + let exit = endpred in + let errorexit = exitpred in ctl_or exit errorexit (* not at all sure what the next two mean... *) | End -> CTL.True @@ -1669,8 +1666,8 @@ (match label with Some (lv,used) -> used := true; ctl_or (CTL.Pred(Lib_engine.Label lv,CTL.Control)) - (ctl_back_ex (ctl_or (retpred label) (gotopred label))) - | None -> endpred label) + (ctl_back_ex (ctl_or (retpred) (gotopred))) + | None -> endpred) (* was the following, but not clear why sgrep should allow incomplete patterns let exit = endpred label in @@ -1680,7 +1677,7 @@ else exit (* end at the real end of the function *) *) in let exists_without_after = if quantifier = Exists - then (ctl_not (aftpred None)) + then (ctl_not (aftpred)) else CTL.True in plus_modifier (dots_au is_strict ((after = Tail) || (after = VeryEnd)) @@ -1697,11 +1694,11 @@ List.fold_left Common.union_set [] (List.map get_whencond_exps res) | _ -> failwith "asttoctl2: not possible 17" -and make_whencond_headers e e1 label guard quantified = +and make_whencond_headers e e1 guard quantified = let fvs = Ast.get_fvs e in let header_pred fvs h = quantify guard (get_unquantified quantified fvs) - (make_match label guard h) in + (make_match guard h) in let if_header e1 = header_pred fvs (Ast.rewrap e @@ -1758,26 +1755,26 @@ List.fold_left ctl_or CTL.False (List.map for_header e1) in (if_headers, while_exp_headers, while_decl_headers, for_headers) -and whencond_true e label guard quantified = +and whencond_true e guard quantified = let e1 = get_whencond_exps e in let (if_headers, while_exp_headers, while_decl_headers, for_headers) = - make_whencond_headers e e1 label guard quantified in + make_whencond_headers e e1 guard quantified in ctl_or - (ctl_and CTL.NONSTRICT (truepred label) (ctl_back_ex if_headers)) - (ctl_and CTL.NONSTRICT (inlooppred label) + (ctl_and CTL.NONSTRICT (truepred) (ctl_back_ex if_headers)) + (ctl_and CTL.NONSTRICT (inlooppred) (ctl_back_ex (ctl_or while_exp_headers (ctl_or while_decl_headers for_headers)))) -and whencond_false e label guard quantified = +and whencond_false e guard quantified = let e1 = get_whencond_exps e in let (if_headers, while_exp_headers, while_decl_headers, for_headers) = - make_whencond_headers e e1 label guard quantified in + make_whencond_headers e e1 guard quantified in (* if with else *) - ctl_or (ctl_and CTL.NONSTRICT (falsepred label) (ctl_back_ex if_headers)) + ctl_or (ctl_and CTL.NONSTRICT (falsepred) (ctl_back_ex if_headers)) (* if without else *) - (ctl_or (ctl_and CTL.NONSTRICT (fallpred label) (ctl_back_ex if_headers)) + (ctl_or (ctl_and CTL.NONSTRICT (fallpred) (ctl_back_ex if_headers)) (* failure of loop test *) - (ctl_and CTL.NONSTRICT (loopfallpred label) + (ctl_and CTL.NONSTRICT (loopfallpred) (ctl_or (ctl_back_ex while_exp_headers) (ctl_or (ctl_back_ex while_decl_headers) (ctl_back_ex for_headers))))) @@ -1861,7 +1858,7 @@ let make_seq = make_seq guard in let make_seq_after = make_seq_after guard in let real_make_match = make_match in - let make_match = header_match label guard in + let make_match = header_match guard in let dots_done = ref false in (* hack for dots cases we can easily handle *) @@ -1878,7 +1875,7 @@ keep,seqible,_) | Ast.MetaStmt((s,_,(Ast.CONTEXT(_,Ast.AFTER(_,_)) as d),_),cstr, keep,seqible,_) -> - svar_context_with_add_after stmt s label quantified d ast seqible + svar_context_with_add_after stmt s quantified d ast seqible after (process_bef_aft pos quantified minus_quantified label llabel slabel true) @@ -1886,7 +1883,7 @@ (Ast.get_fvs stmt, Ast.get_fresh stmt, Ast.get_inherited stmt) | Ast.MetaStmt((s,_,d,_),cstr,keep,seqible,_) -> - svar_minus_or_no_add_after stmt s label quantified d ast seqible + svar_minus_or_no_add_after stmt s quantified d ast seqible after (process_bef_aft pos quantified minus_quantified label llabel slabel true) @@ -1897,7 +1894,7 @@ let term ast = match Ast.unwrap ast with Ast.DisjRuleElem(res) -> - do_re_matches label guard res quantified minus_quantified + do_re_matches guard res quantified minus_quantified | Ast.Exp(_) | Ast.Ty(_) | Ast.TopId(_) -> let stmt_fvs = Ast.get_fvs stmt in let fvs = get_unquantified quantified stmt_fvs in @@ -1958,7 +1955,7 @@ make_match(Ast.rewrap ast (Ast.ReturnExpr(ret,edots,semi))) in (match new_mc with Some new_mc -> - let exit = endpred None in + let exit = endpred in let mod_rbrace = Ast.rewrap ast (Ast.SeqEnd (("}",info,new_mc,pos@spos))) in let stripped_rbrace = @@ -2035,7 +2032,7 @@ (* label is not needed; paren_pred is enough *) quantify guard rbfvs (ctl_au (make_match empty_rbrace) - (ctl_and (real_make_match None guard rbrace) paren_pred)) in + (ctl_and (real_make_match guard rbrace) paren_pred)) in let new_quantified2 = Common.union_set b1fvs (Common.union_set b2fvs quantified) in let new_mquantified2 = @@ -2047,7 +2044,7 @@ (make_seq [start_brace; (ctl_or - (if !exists = Exists then CTL.False else (aftpred label)) + (if !exists = Exists then CTL.False else (aftpred)) (quantify guard b2fvs (statement_list body NotTop (After (make_seq_after end_brace after)) @@ -2085,7 +2082,7 @@ quantify true [pv;lv] (quantify guard b1fvs (make_seq_ex guard - [start_brace;aftpred label; + [start_brace;aftpred; make_seq_after end_brace after])) else if ends_in_return body then @@ -2102,7 +2099,7 @@ let pattern2 = let body = preprocess_dots body in (* redo, to drop braces *) make_seq - [gotopred label; + [gotopred; ctl_au (make_match empty_rbrace) (ctl_ax (* skip the destination label *) @@ -2136,9 +2133,9 @@ (CTL.FORWARD,CTL.STRICT, CTL.Pred (Lib_engine.PrefixLabel(lv),CTL.Control), - ctl_or (aftpred None) (* jll new! *) + ctl_or (aftpred) (* jll new! *) (ctl_and(*brace must be after goto*) - (gotopred (Some (lv,ref true))) + (gotopred) (* want AF even for sgrep *) (CTL.AF (CTL.FORWARD,CTL.STRICT,end_brace))))) @@ -2150,35 +2147,35 @@ [ctl_and start_brace (* check that we always escape with a goto *) (* must use EX because we want to follow control edges *) - (ctl_and (ctl_ex (gotoaftpred None)) + (ctl_and (ctl_ex (gotoaftpred)) (ctl_not (ctl_ex - (ctl_and (aftpred None) - (ctl_not (gotoaftpred None)))))); + (ctl_and (aftpred) + (ctl_not (gotoaftpred)))))); real_code])) in ctl_or pattern_as_given (ctl_or pattern2 pattern3) else pattern_as_given | Ast.IfThen(ifheader,branch,aft) -> ifthen ifheader branch aft after quantified minus_quantified - label llabel slabel (statement pos) make_match guard + llabel slabel (statement pos) make_match guard | Ast.IfThenElse(ifheader,branch1,els,branch2,aft) -> ifthenelse ifheader branch1 els branch2 aft after quantified - minus_quantified label llabel slabel (statement pos) make_match guard + minus_quantified llabel slabel (statement pos) make_match guard | Ast.While(header,body,aft) | Ast.For(header,body,aft) | Ast.Iterator(header,body,aft) -> forwhile true header body aft after quantified minus_quantified - label (statement pos) make_match guard + (statement pos) make_match guard | Ast.ScopedGuard(header,body,aft) -> forwhile false header body aft after quantified minus_quantified - label (statement pos) make_match guard + (statement pos) make_match guard | Ast.Do(doheader,body,whiletail) -> dots_done := true; dowhile doheader body whiletail after quantified minus_quantified - label (statement pos) make_match guard + (statement pos) make_match guard | Ast.Disj(stmt_dots_list) -> (* list shouldn't be empty *) (*ctl_and seems pointless, disjuncts see label too @@ -2376,7 +2373,7 @@ match seq_fvs new2_quantified [Ast.get_fvs header] with [(e1fvs,_)] -> e1fvs | _ -> failwith "asttoctl2: not possible 24" in - quantify guard e1fvs (real_make_match label true header) + quantify guard e1fvs (real_make_match true header) | Ast.OptCase(case_line) -> failwith "not supported") cases in let lv = get_label_ctr() in @@ -2433,8 +2430,8 @@ | _ -> false) cases then function x -> x - else function x -> ctl_or (fallpred label) x in - let after_pred = aftpred label in + else function x -> ctl_or (fallpred) x in + let after_pred = aftpred in let body after_branch = Common.Right (ctl_or @@ -2462,7 +2459,7 @@ else (switch_header,function x -> x) in wrapper (end_control_structure b1fvs switch_header body - after_pred (Some(ctl_ex after_pred)) None aft after label guard) + after_pred (Some(ctl_ex after_pred)) None aft after guard) | Ast.FunDecl(header,lbrace,body,rbrace,(afvs,afresh,ainh,aft)) -> (* what to do with afvs??? *) let (aafvs,ahfvs,hfvs,b1fvs,lbfvs,b2fvs,b3fvs,rbfvs) = @@ -2612,7 +2609,7 @@ let leftarg = if quantifier = Exists then - ctl_and (ctl_not (aftpred None)) leftarg + ctl_and (ctl_not (aftpred)) leftarg else leftarg in op leftarg (ctl_and @@ -2670,7 +2667,7 @@ quantify guard aafvs (* vars needed only for ender *) (make_meta_rule_elem make_match guard "7" aft Ast.CstrExit (afvs,afresh,ainh)) in CTL.AndAny(CTL.FORWARD,CTL.NONSTRICT,function_header, - ctl_or (ctl_not (preendpred label)) match_ender) in + ctl_or (ctl_not (preendpred)) match_ender) in quantify guard ahfvs (quantify guard b1fvs (make_seq [function_header; quantify guard b2fvs body_code])) @@ -2715,11 +2712,11 @@ let body_code = match body with Ast.DefineStms body -> - statement_list body NotTop (After(endpred None)) + statement_list body NotTop (After(endpred)) (Common.union_set bfvs quantified) (Common.union_set mbfvs minus_quantified) None llabel slabel true guard pos - | Ast.DefineAttr attr -> make_seq_after (make_match attr) (After(endpred None)) in + | Ast.DefineAttr attr -> make_seq_after (make_match attr) (After(endpred)) in quantify guard bfvs (make_seq [define_header; body_code]) | Ast.AsStmt(stmt,asstmt) -> ctl_and @@ -2749,8 +2746,8 @@ let case2 = ctl_and CTL.NONSTRICT (ctl_not (CTL.Ref v)) term in CTL.Let (v,ctl_or - (ctl_back_ex (ctl_or (truepred label) (inlooppred label))) - (ctl_back_ex (ctl_back_ex (falsepred label))), + (ctl_back_ex (ctl_or (truepred) (inlooppred))) + (ctl_back_ex (ctl_back_ex (falsepred))), ctl_or case1 case2) | Ast.NoDots -> term @@ -2762,7 +2759,7 @@ let paren_pred = CTL.Pred (Lib_engine.Paren n,CTL.Control) in let s = guard_to_strict guard in quantify true (get_unquantified quantified [n]) - (ctl_and s (make_raw_match None guard re) paren_pred) + (ctl_and s (make_raw_match guard re) paren_pred) | Ast.Other s -> statement pos s NotTop Tail quantified minus_quantified label llabel slabel guard @@ -2809,17 +2806,17 @@ | _ -> None in if starts_with_dots then (* EX because there is a loop on enter/top *) - ctl_and CTL.NONSTRICT (toppred None) (ctl_ex formula) + ctl_and CTL.NONSTRICT (toppred) (ctl_ex formula) else match starts_with_non_context_brace with None -> formula | Some false -> ctl_and CTL.NONSTRICT - (ctl_not(CTL.EX(CTL.BACKWARD,funpred None))) + (ctl_not(CTL.EX(CTL.BACKWARD,funpred))) formula | Some true -> ctl_and CTL.NONSTRICT - (ctl_not(CTL.EX(CTL.BACKWARD,unsbrpred None))) + (ctl_not(CTL.EX(CTL.BACKWARD,unsbrpred))) formula (* Look for a rule that has a statement and a ..., which should not diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/coccinelle-1.3.2/extra/io.github.coccinelle.coccinelle.metainfo.xml new/coccinelle-1.3.3/extra/io.github.coccinelle.coccinelle.metainfo.xml --- old/coccinelle-1.3.2/extra/io.github.coccinelle.coccinelle.metainfo.xml 2026-08-20 14:13:37.000000000 +0200 +++ new/coccinelle-1.3.3/extra/io.github.coccinelle.coccinelle.metainfo.xml 2026-09-02 14:30:47.000000000 +0200 @@ -13,7 +13,7 @@ <p>Coccinelle is a program matching and transformation engine which provides the language SmPL (Semantic Patch Language) for specifying desired matches and transformations in C code. Coccinelle was initially targeted towards performing collateral evolutions in Linux. Such evolutions comprise the changes that are needed in client code in response to evolutions in library APIs, and may include modifications such as renaming a function, adding a function argument whose value is somehow context-dependent, and reorganizing a data structure. Beyond collateral evolutions, Coccinelle is successfully used (by us and others) for finding and fixing bugs in systems code.</p> </description> <releases> - <release version="1.3.2" date="2026-08-18" type="stable"/> + <release version="1.3.3" date="2026-09-02" type="stable"/> </releases> <url type="homepage">https://coccinelle.gitlabpages.inria.fr/website/</url> <url type="contact">https://sympa.inria.fr/sympa/info/cocci</url> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/coccinelle-1.3.2/version new/coccinelle-1.3.3/version --- old/coccinelle-1.3.2/version 2026-08-20 14:13:37.000000000 +0200 +++ new/coccinelle-1.3.3/version 2026-09-02 14:30:47.000000000 +0200 @@ -1 +1 @@ -1.3.2 +1.3.3
