Implement the multiple-starters feature:

[tatoo.git] / src / tatoo.ml

diff --git a/src/tatoo.ml b/src/tatoo.ml
index 4d7e693..d8c3e09 100644 (file)
--- a/src/tatoo.ml
+++ b/src/tatoo.ml
@@ -24,56 +24,123 @@ let time f arg msg =
   r
 
 
+let compose_parallel run auto_list tree nodes () =
+  match auto_list with
+    [ auto ] -> [run auto tree nodes]
+  | _ -> assert false
+
+let compose_sequential run auto_list tree nodes () =
+  [ List.fold_left (fun acc auto ->
+    run auto tree acc) nodes auto_list ]
+
+
+let restart_parallel run auto_list tree nodes () =
+  match auto_list with
+    [ auto ] -> List.map snd (run auto tree nodes)
+  | _ -> assert false
+
+let restart_sequential run auto_list tree nodes () =
+  List.map (fun auto -> run auto tree nodes) auto_list
+
 let main () =
   let () = Options.parse () in
   let doc =
     let fd, close_fd = match !Options.input_file with
-      None -> stdin, ignore
+      None | Some "-" | Some "/dev/stdin" -> stdin, ignore
     | Some input ->
         let fd = open_in input in fd, fun () -> close_in fd
     in
     let d = time Naive_tree.load_xml_file fd "parsing xml document" in
     close_fd (); d
   in
-  let query =
+  let queries =
     time
-      Xpath.Parser.parse
-      (Ulexing.from_latin1_string !Options.query)
-      "parsing XPath query"
+      (fun l ->
+        List.map (fun q ->
+          Xpath.Parser.parse
+            (Ulexing.from_utf8_string q)) l)
+      !Options.queries
+      "parsing XPath queries"
   in
-  let auto =
-    time Xpath.Compile.path query "compiling XPath query"
+  (* parallel, compose  ->     action
+     true, true -> Ata.concat of all automata and single run
+     true, false -> Ata.merge of all automata and single run
+     false, true -> Eval first, then run on results then ...
+     false, false -> Eval first on root, then second on root then ...
+  *)
+  let auto_list =
+    time
+      (fun l ->
+        List.map (fun query -> Xpath.Compile.path query) l)
+      queries
+      "compiling XPath queries"
+  in
+  let auto_list =
+    if !Options.parallel then
+      match auto_list with
+        fst :: rest ->
+          let f =
+            if !Options.compose then
+              Ata.concat
+            else
+              Ata.merge
+          in
+          let big_auto = List.fold_left f fst rest in
+          [big_auto]
+      | _ -> assert false
+
+    else
+      auto_list
   in
-  let auto = time Ata.copy auto "copying Automaton" in
   let output =
     match !Options.output_file with
     | None | Some "-" | Some "/dev/stdout" -> stdout
     | Some f -> open_out f
   in
   if !Options.stats then begin
-    Logger.msg `STATS "Query: %a " Xpath.Ast.print_path query;
-    Logger.msg `STATS "@[Automaton: @\n%a@]" Ata.print auto;
+    List.iter (fun query ->
+      Logger.msg `STATS "Query: %a " Xpath.Ast.print_path query) queries;
+    List.iter (fun auto ->
+      Logger.msg `STATS "@[Automaton: @\n%a@]" Ata.print auto) auto_list;
   end;
 
   let module Naive = Run.Make(Naive_tree) in
-  let results =
-    time (Naive.eval auto doc) ([Naive_tree.root doc]) "evaluating query"
+  let result_list =
+    let root = [ Naive_tree.root doc] in
+    let f, msg =
+      match !Options.parallel, !Options.compose with
+        true, true ->
+          compose_parallel Naive.eval auto_list doc root, "parallel/compose"
+      | true, false ->
+          restart_parallel Naive.full_eval auto_list doc root, "parallel/restart"
+      | false, true ->
+          compose_sequential Naive.eval auto_list doc root , "sequential/compose"
+      | false, false ->
+          restart_sequential Naive.eval auto_list doc root, "sequential/restart"
+    in
+    time f () ("evaluating query in " ^ msg ^ " mode")
   in
   time (fun () ->
-  output_string output "<xml_result>\n";
-  if !Options.count then begin
-    output_string output (string_of_int (List.length results));
-    output_char output '\n';
-  end else
-    List.iter (fun n ->
-      Naive_tree.print_xml output doc n;
-      output_char output '\n'
-    ) results;
-  output_string output "</xml_result>\n";
-  flush output;
-  if output != stdout then close_out output
+    let count = ref 1 in
+    List.iter (fun results ->
+      output_string output "<xml_result num=\"";
+      output_string output (string_of_int !count);
+      output_string output "\" >\n";
+      if !Options.count then begin
+        output_string output (string_of_int (List.length results));
+        output_char output '\n';
+      end else
+        List.iter (fun n ->
+          Naive_tree.print_xml output doc n;
+          output_char output '\n'
+        ) results;
+      output_string output "</xml_result>\n";
+      incr count
+    ) result_list;
+    flush output;
+    if output != stdout then close_out output
 
-) () "serializing results"
+  ) () "serializing results"
 
 
 let () =