[kernel] Rename children to child

src/kernel_services/analysis/dominators.ml

@@ -156,13 +156,13 @@ module Compute (Analysis : Analysis) = struct
   (* Generic function to test the strict (post)domination of 2 statements. *)
   let mem_strict a b = get_strict b |> StmtSet.mem a
 
-  (* The nearest common ancestor (resp. children) is the ancestor which is
+  (* The nearest common ancestor (resp. child) is the ancestor which is
      dominated (resp. postdominated) by all common ancestors, ie. the lowest
      (resp. highest) ancestor in the domination tree. *)
   let nearest stmtl =
     (* Get the set of strict (post)doms for each statement and intersect them to
        keep the common ones. If one of them is unreachable, they do not
-       share a common ancestor/children. *)
+       share a common ancestor/child. *)
     let common_set =
       match stmtl with
       | [] -> StmtSet.empty
@@ -259,6 +259,6 @@ let get_strict_postdominators = PostDominators.get_strict
 let postdominates = PostDominators.mem
 let strictly_postdominates = PostDominators.mem_strict
 let get_ipostdom s = PostDominators.nearest [s]
-let nearest_common_children = PostDominators.nearest
+let nearest_common_child = PostDominators.nearest
 let pretty_postdominators = PostDominators.pretty
 let print_dot_postdominators = PostDominators.print_dot

src/kernel_services/analysis/dominators.mli

@@ -36,7 +36,7 @@
     (post)dominator of [s] that strictly (post)dominates [s] but is
     (post)dominated by all other (post)dominators of [s].
 
-    A common ancestor (or children) of a list of statements is a (post)dominator
+    A common ancestor (or child) of a list of statements is a (post)dominator
     that (post)dominates all the statements
 
     @before Frama-C+dev This module was using [Dataflow2] instead of
@@ -112,8 +112,8 @@ val nearest_common_ancestor : stmt list -> stmt option
     raised a failed assertion in case of unreachable statement.
 *)
 
-val nearest_common_children : stmt list -> stmt option
-(** Return the closest common children of the given statement list.
+val nearest_common_child : stmt list -> stmt option
+(** Return the closest common child of the given statement list.
     @since Frama-C+dev
 *)
 

tests/misc/oracle/test_dominators.res.oracle

@@ -30,7 +30,7 @@ Computing for function f:
 Immediate dominators of f (sid, idom, ipostdom):
   (1, none, 3), (3, 1, 6), (4, 3, none), (5, 4, none), (6, 3, 53),
   (53, 6, 8), (8, 53, 54), (54, 8, 55), (55, 54, none)
-Nearest common ancestors/children of f (sid, sid, ancestor, children):
+Nearest common ancestors/child of f (sid, sid, ancestor, child):
   (1, 1, none, 3), (1, 3, none, 6), (1, 4, none, none), (1, 5, none, none),
   (1, 6, none, 53), (1, 53, none, 8), (1, 8, none, 54), (1, 54, none, 55),
   (1, 55, none, none), (3, 1, none, 6), (3, 3, 1, 6), (3, 4, 1, none),
@@ -89,7 +89,7 @@ Immediate dominators of g (sid, idom, ipostdom):
   (10, none, 12), (12, 10, 59), (13, 12, 15), (14, none, 15), (15, 13, 20),
   (16, 12, 57), (57, 16, 18), (18, 57, 58), (58, 18, 59), (20, 15, 59),
   (59, 12, none)
-Nearest common ancestors/children of g (sid, sid, ancestor, children):
+Nearest common ancestors/child of g (sid, sid, ancestor, child):
   (10, 10, none, 12), (10, 12, none, 59), (10, 13, none, 59),
   (10, 14, none, 59), (10, 15, none, 59), (10, 16, none, 59),
   (10, 57, none, 59), (10, 18, none, 59), (10, 58, none, 59),
@@ -167,7 +167,7 @@ Immediate dominators of h (sid, idom, ipostdom):
   (22, none, none), (23, 22, none), (24, 23, none), (26, 24, none),
   (27, 26, none), (28, 26, none), (30, 28, none), (31, 30, none),
   (33, 30, none), (34, 27, none), (36, none, none)
-Nearest common ancestors/children of h (sid, sid, ancestor, children):
+Nearest common ancestors/child of h (sid, sid, ancestor, child):
   (22, 22, none, none), (22, 23, none, none), (22, 24, none, none),
   (22, 26, none, none), (22, 27, none, none), (22, 28, none, none),
   (22, 30, none, none), (22, 31, none, none), (22, 33, none, none),
@@ -251,7 +251,7 @@ Immediate dominators of i (sid, idom, ipostdom):
   (38, none, 40), (40, 38, 44), (41, 40, 50), (43, 40, 44), (44, 40, 46),
   (46, 44, 47), (47, 46, 62), (48, 46, 49), (49, 48, 50), (50, 40, 44),
   (62, 47, none)
-Nearest common ancestors/children of i (sid, sid, ancestor, children):
+Nearest common ancestors/child of i (sid, sid, ancestor, child):
   (38, 38, none, 40), (38, 40, none, 44), (38, 41, none, 44),
   (38, 43, none, 44), (38, 44, none, 46), (38, 46, none, 47),
   (38, 47, none, 62), (38, 48, none, 44), (38, 49, none, 44),

tests/misc/test_dominators.ml

@@ -26,7 +26,7 @@ let print_immediate f =
     f.svar.vname
     (Pretty_utils.pp_list ~pre:"@[" ~sep:",@ " ~suf:"@]" pp_res) res
 
-(** For each couple of statement of [f], find their common ancestor and children
+(** For each couple of statement of [f], find their common ancestor and child
     and print the quadruplets. *)
 let print_nearest f =
   assert (Dominators.nearest_common_ancestor [] = None);
@@ -34,13 +34,13 @@ let print_nearest f =
     List.map (fun s ->
         List.map (fun s' ->
             let dom = Dominators.nearest_common_ancestor [s; s'] in
-            let postdom = Dominators.nearest_common_children [s; s'] in
+            let postdom = Dominators.nearest_common_child [s; s'] in
             [string_of_int s.sid; string_of_int s'.sid; get dom; get postdom]
           ) f.sallstmts
       ) f.sallstmts
     |> List.flatten
   in
-  Format.printf "@[<v2>Nearest common ancestors/children of %s (sid, sid, ancestor, children):@;%a@]@;"
+  Format.printf "@[<v2>Nearest common ancestors/child of %s (sid, sid, ancestor, child):@;%a@]@;"
     f.svar.vname
     (Pretty_utils.pp_list ~pre:"@[" ~sep:",@ " ~suf:"@]" pp_res) res