X-Git-Url: http://git.nguyen.vg/gitweb/?a=blobdiff_plain;f=ata.ml;h=f2b9e7298ebc1723e0849100e7d743a5e01e61f0;hb=bfedbb29aa139abed0a311fd2ab2d00f15e1ed9e;hp=9eb531188d21ce58d57ab4e5df74fb2ac5069679;hpb=6a7025fee3c050eff58baa536a14d80baf5c1b87;p=SXSI%2Fxpathcomp.git

diff --git a/ata.ml b/ata.ml
index 9eb5311..f2b9e72 100644
--- a/ata.ml
+++ b/ata.ml
@@ -1,6 +1,6 @@
 INCLUDE "debug.ml"
 INCLUDE "utils.ml"
-
+open Camlp4.Struct
 type jump_kind = [ `TAG of Tag.t | `CONTAINS of string | `NOTHING ]
 
 (* Todo : move elsewhere *)
@@ -58,8 +58,8 @@ struct
       match f.pos with
 	| False -> 0
 	| True -> 1
-	| Or (f1,f2) -> HASHINT3(PRIME2,f1.Node.id, f2.Node.id)
-	| And (f1,f2) -> HASHINT3(PRIME3,f1.Node.id,f2.Node.id)
+	| Or (f1,f2) -> HASHINT3(PRIME2,Uid.to_int f1.Node.id, Uid.to_int f2.Node.id)
+	| And (f1,f2) -> HASHINT3(PRIME3,Uid.to_int f1.Node.id, Uid.to_int f2.Node.id)
 	| Atom(d,p,s) -> HASHINT4(PRIME4,hash_const_variant d,vb p,s)	    
     end
 
@@ -197,7 +197,9 @@ module Transition = struct
   type node = State.t*TagSet.t*bool*Formula.t*bool
   include Hcons.Make(struct
 		       type t = node
-		       let hash (s,ts,m,f,b) = HASHINT5(s,TagSet.uid ts,Formula.uid f,vb m,vb b)
+		       let hash (s,ts,m,f,b) = HASHINT5(s,Uid.to_int (TagSet.uid ts),
+							Uid.to_int (Formula.uid f),
+							vb m,vb b)
 		       let equal (s,ts,b,f,m) (s',ts',b',f',m') = 
 			 s == s' && ts == ts' && b==b' && m==m' && f == f'
 		     end)
@@ -284,7 +286,9 @@ module FormTable = Hashtbl.Make(struct
 				  let equal (f1,s1,t1) (f2,s2,t2) =
 				    f1 == f2 && s1 == s2 && t1 == t2
 				  let hash (f,s,t) = 
-				    HASHINT3(Formula.uid f ,StateSet.uid s,StateSet.uid t)
+				    HASHINT3(Uid.to_int (Formula.uid f),
+					     Uid.to_int (StateSet.uid s),
+					     Uid.to_int (StateSet.uid t))
 				end)
 module F = Formula
 
@@ -328,16 +332,20 @@ let eval_form_bool =
       in loop f
 
 	   
-module FTable = Hashtbl.Make( struct
-				type t = Tag.t*Formlist.t*StateSet.t*StateSet.t
-				let equal (tg1,f1,s1,t1) (tg2,f2,s2,t2) =
-				  tg1 == tg2 && f1 == f2 &&  s1 == s2 && t1 == t2;;
-				let hash (tg,f,s,t) =  HASHINT4(tg,Formlist.uid f ,StateSet.uid s,StateSet.uid t);;
-			      end)
+module FTable = Hashtbl.Make(struct
+			       type t = Tag.t*Formlist.t*StateSet.t*StateSet.t
+			       let equal (tg1,f1,s1,t1) (tg2,f2,s2,t2) =
+				 tg1 == tg2 && f1 == f2 &&  s1 == s2 && t1 == t2;;
+			       let hash (tg,f,s,t) =  
+				 HASHINT4(tg, Uid.to_int (Formlist.uid f),
+					  Uid.to_int (StateSet.uid s),
+					  Uid.to_int (StateSet.uid t))
+			     end)
 
 
 let h_f = FTable.create BIG_H_SIZE 
-
+type merge_conf = NO | ONLY1 | ONLY2 | ONLY12 | MARK | MARK1 | MARK2 | MARK12
+(* 000 001 010 011 100 101 110 111 *)
 let eval_formlist tag s1 s2 fl =
   let rec loop fl =
           try 
@@ -355,8 +363,32 @@ let eval_formlist tag s1 s2 fl =
 		      else res
 		      in FTable.add h_f (tag,fl,s1,s2) r;r
 		  | Formlist.Nil -> StateSet.empty,(false,false,false,false)
-  in loop fl
-	      
+  in 
+  let r,conf = loop fl
+  in
+  r,(match  conf with
+    | (false,_,_,_) -> NO
+    | (_,false,false,false) -> NO
+    | (_,true,false,false) -> ONLY1
+    | (_,false,true,false) -> ONLY2
+    | (_,true,true,false) -> ONLY12
+    | (_,false,false,true) -> MARK
+    | (_,true,false,true) -> MARK1
+    | (_,false,true,true) -> MARK2
+    | _ -> MARK12)
+
+let bool_of_merge conf =
+  match  conf with
+    | NO -> false,false,false,false
+    | ONLY1 -> true,true,false,false
+    | ONLY2 -> true,false,true,false 
+    | ONLY12 -> true,true,true,false 
+    | MARK -> true,false,false,true
+    | MARK1 -> true,true,false,true
+    | MARK2 -> true,false,true,true
+    | MARK12 -> true,true,true,true
+
+
 let tags_of_state a q = 
   Hashtbl.fold  
     (fun p l acc -> 
@@ -394,13 +426,16 @@ let tags_of_state a q =
       val fold : ( elt -> 'a -> 'a) -> t -> 'a -> 'a
       val map : ( elt -> elt) -> t -> t
       val length : t -> int
-      val merge : (bool*bool*bool*bool) -> elt -> t -> t -> t 
+      val merge : merge_conf -> elt -> t -> t -> t 
+      val mk_quick_tag_loop : (elt -> elt -> 'a*t array) -> 'a -> int -> Tree.t -> Tag.t -> (elt -> elt -> 'a*t array)
+      val mk_quick_star_loop : (elt -> elt -> 'a*t array) -> 'a -> int -> Tree.t -> (elt -> elt -> 'a*t array)
     end
 
     module Integer : ResultSet =
     struct
       type t = int
       type elt = [`Tree] Tree.node
+
       let empty = 0
       let cons _ x = x+1
       let concat x y = x + y
@@ -408,7 +443,8 @@ let tags_of_state a q =
       let fold _ _ _ = failwith "fold not implemented"
       let map _ _ = failwith "map not implemented"
       let length x = x
-      let merge (rb,rb1,rb2,mark) t res1 res2 = 
+      let merge2 conf t res1 res2 = 
+	let rb,rb1,rb2,mark = conf in
 	if rb then
 	  let res1 = if rb1 then res1 else 0
 	  and res2 = if rb2 then res2 else 0
@@ -416,9 +452,27 @@ let tags_of_state a q =
 	    if mark then 1+res1+res2
 	    else res1+res2
 	else 0
+      let merge conf t res1 res2 = 
+	match conf with
+	    NO -> 0                         
+	  | MARK -> 1
+	  | MARK1 -> res1+1         
+	  | ONLY1 -> res1                
+	  | ONLY2 -> res2           
+	  | ONLY12 -> res1+res2     
+	  | MARK2 -> res2+1         
+	  | MARK12 -> res1+res2+1   
+
+      let mk_quick_tag_loop _ sl ss tree tag = ();
+	fun t ctx ->
+	  (sl, Array.make ss (Tree.subtree_tags tree tag t))
+      let mk_quick_star_loop _ sl ss tree = ();
+	fun t ctx -> 
+	  (sl, Array.make ss (Tree.subtree_elements tree t))
+	  
     end
 
-    module IdSet : ResultSet = 
+    module IdSet : ResultSet= 
     struct
       type elt = [`Tree] Tree.node
       type node = Nil 
@@ -460,45 +514,153 @@ let tags_of_state a q =
 	in
 	  { l with node = loop l.node }
 	    
-      let merge (rb,rb1,rb2,mark) t res1 res2 = 
-	if rb then
-	  let res1 = if rb1 then res1 else empty
- 	  and res2 = if rb2 then res2 else empty
-	  in
-	    if mark then { node = Cons(t,(Concat(res1.node,res2.node)));
-			   length = res1.length + res2.length + 1;}
-	    else
-	      { node = (Concat(res1.node,res2.node));
-		length = res1.length + res2.length ;}
-	else empty 	  
-
-	   
+      let merge conf t res1 res2 = 
+	match conf with
+	   NO -> empty
+	  | MARK -> cons t empty
+	  | ONLY1 -> res1
+	  | ONLY2 -> res2
+	  | ONLY12 -> { node = (Concat(res1.node,res2.node));
+			length = res1.length + res2.length ;}
+	  | MARK12 -> { node = Cons(t,(Concat(res1.node,res2.node)));
+			length = res1.length + res2.length + 1;}
+	  | MARK1 -> { node = Cons(t,res1.node);
+			length = res1.length + 1;}
+	  | MARK2 -> { node = Cons(t,res2.node);
+		       length = res2.length + 1;}
+
+      let mk_quick_tag_loop f _ _ _ _ = f
+      let mk_quick_star_loop f _ _ _ = f
     end
-    module GResult = struct
-      type t
+    module GResult(Doc : sig val doc : Tree.t end) = struct
+      type bits
       type elt = [` Tree] Tree.node
-      external create_empty : int -> t = "caml_result_set_create"
-      external set : t -> int -> t = "caml_result_set_set"
-      external next : t -> int -> int = "caml_result_set_next"
-      external clear : t -> int -> int -> unit = "caml_result_set_clear"
-      let empty = create_empty 100000000
+      external create_empty : int -> bits = "caml_result_set_create" "noalloc"
+      external set : bits -> int -> unit = "caml_result_set_set" "noalloc"
+      external next : bits -> int -> int = "caml_result_set_next" "noalloc"
+      external count : bits -> int  = "caml_result_set_count" "noalloc"
+      external clear : bits -> elt -> elt -> unit = "caml_result_set_clear" "noalloc"
+	 
+      external set_tag_bits : bits -> Tag.t -> Tree.t -> elt -> elt = "caml_set_tag_bits" "noalloc"
+      type t = 
+	 { segments : elt list;
+	   bits : bits;
+	 }
+
+      let ebits = 
+	let size = (Tree.subtree_size Doc.doc Tree.root) in
+	create_empty (size*2+1)
+
+      let empty = { segments = [];
+		    bits = ebits }
 	
-      let cons e t = set t (Obj.magic e)
-      let concat _ t = t
+      let cons e t = 
+	let rec loop l = match l with
+	  | [] -> { bits = (set t.bits (Obj.magic e);t.bits);
+		    segments = [ e ] }
+	  | p::r -> 
+	      if Tree.is_binary_ancestor Doc.doc e p then
+	      loop r
+	      else
+	      { bits = (set t.bits (Obj.magic e);t.bits);
+		segments = e::l }
+	in
+	loop t.segments
+		    
+      let concat t1 t2 =
+	if t2.segments == [] then t1
+	else
+	if t1.segments == [] then t2
+	else
+	let h2 = List.hd t2.segments in
+	let rec loop l = match l with
+	  | [] -> t2.segments
+	  | p::r -> 
+	      if Tree.is_binary_ancestor Doc.doc p h2 then
+	      l
+	      else
+	      p::(loop r)
+	in
+	{ bits = t1.bits;
+	  segments = loop t1.segments 
+	}
+
       let iter f t =
 	let rec loop i = 
 	  if i == -1 then ()
-	  else (f (Obj.magic i);loop (next t i))
-	in loop 0
+	  else (f ((Obj.magic i):elt);loop (next t.bits i))
+	in loop (next t.bits 0)
 	  
-      let fold _ _ _ = failwith "noop"
+      let fold f t acc = 
+	let rec loop i acc = 
+	  if i == -1 then acc
+	  else loop (next t.bits i) (f ((Obj.magic i):elt) acc)
+	in loop (next t.bits 0) acc
+
       let map _ _ = failwith "noop"
-      let length t = let cpt = ref ~-1 in
-      iter (fun _ -> incr cpt) t; !cpt
+      (*let length t = let cpt = ref 0 in
+      iter (fun _ -> incr cpt) t; !cpt *)
+      let length t = count t.bits 
       
+      let clear_bits t = 
+	let rec loop l = match l with
+	   [] -> ()
+	  | idx::ll ->
+	      clear t.bits idx (Tree.closing Doc.doc idx); loop ll
+	in
+	loop t.segments;empty
+
       let merge (rb,rb1,rb2,mark) elt t1 t2 =
-	if mark then (set t1 (Obj.magic elt) ; t1) else t1
-	  
+	if rb then
+(*	let _ = Printf.eprintf "Lenght before merging is %i %i\n"
+	  (List.length t1.segments) (List.length t2.segments)
+	in *)
+	match t1.segments,t2.segments with
+ 	   [],[] -> if mark then cons elt empty else empty
+	  | [_],[] when rb1 -> if mark then cons elt t1 else t1
+	  | [], [_] when rb2 -> if mark then cons elt t2 else t2
+	  | [_],[_] when rb1 && rb2 -> if mark then cons elt empty else
+	    concat t1 t2
+	  | _ -> 
+	let t1 = if rb1 then t1 else clear_bits t1
+	and t2 = if rb2 then t2 else clear_bits t2
+	in
+	(if mark then cons elt (concat t1 t2)
+	 else concat t1 t2)
+	else
+	let _ = clear_bits t1 in
+	clear_bits t2
+
+      let merge conf t t1 t2 = 
+	match t1.segments,t2.segments,conf with
+	  | _,_,NO -> let _ = clear_bits t1 in clear_bits t2
+	  | [],[],(MARK1|MARK2|MARK12|MARK) -> cons t empty
+	  | [],[],_ -> empty
+	  | [_],[],(ONLY1|ONLY12) -> t1
+	  | [_],[],(MARK1|MARK12) -> cons t t1
+	  | [],[_],(ONLY2|ONLY12) -> t2
+	  | [],[_],(MARK2|MARK12) -> cons t t2
+	  | [_],[_],ONLY12 -> concat t1 t2
+	  | [_],[_],MARK12 -> cons t empty
+	  | _,_,MARK -> let _ = clear_bits t2 in cons t (clear_bits t1)	    
+	  | _,_,ONLY1 -> let _ = clear_bits t2 in t1
+	  | _,_,ONLY2 -> let _ = clear_bits t1 in t2
+	  | _,_,ONLY12 -> concat t1 t2
+	  | _,_,MARK1 -> let _ = clear_bits t2 in cons t t1
+	  | _,_,MARK2 -> let _ = clear_bits t1 in cons t t2
+	  | _,_,MARK12 ->  cons t (concat t1 t2)
+
+      let mk_quick_tag_loop _ sl ss tree tag = ();
+	fun t _ ->	  
+	  let res = empty in
+	  let first = set_tag_bits empty.bits tag tree t in
+	  let res = 
+	    if first == Tree.nil then res else 
+	    cons first res 
+	  in
+	  (sl, Array.make ss res)
+
+      let mk_quick_star_loop f _ _ _ = f
     end
     module Run (RS : ResultSet) =
     struct
@@ -574,7 +736,11 @@ END
 	      (fun (_,t) -> let _,_,_,f,_ = Transition.node t in
 	      StateSet.mem s ((fun (_,_,x) -> x) (access (Formula.st f)))) (Hashtbl.find a.trans s) 
 		     
-
+	  let is_final_marking a s =
+	    List.exists (fun (_,t) -> let _,_,m,f,_ = Transition.node t in m&& (Formula.is_true f))
+	      (Hashtbl.find a.trans s)
+	      
+	      
 	  let decide a c_label l_label dir_states dir =
 			
 	    let l = StateSet.fold 
@@ -638,8 +804,8 @@ END
 	  (mk_fun (fun _ -> Tree.nil) "Tree.mk_nil")
 	  (mk_fun (Tree.tagged_child tree) "Tree.tagged_child") 
 	  (mk_fun (Tree.select_child tree) "Tree.select_child")
-	  (mk_fun (Tree.tagged_desc tree) "Tree.tagged_desc")
-	  (mk_fun (Tree.select_desc tree) "Tree.select_desc") 
+	  (mk_fun (Tree.tagged_descendant tree) "Tree.tagged_desc")
+	  (mk_fun (Tree.select_descendant tree) "Tree.select_desc") 
 	  (mk_fun (fun _ _ -> Tree.first_child tree) "[FIRSTCHILD]Tree.select_child_desc")
 	  (mk_fun (Tree.first_element tree) "Tree.first_element")
 	  (mk_fun (Tree.first_child tree) "Tree.first_child") 
@@ -647,20 +813,51 @@ END
       let choose_jump_next tree d = 
 	choose_jump d
   	  (mk_fun (fun _ _ -> Tree.nil) "Tree.mk_nil2")
-	  (mk_fun (Tree.tagged_sibling_ctx tree) "Tree.tagged_sibling_ctx")
-	  (mk_fun (Tree.select_sibling_ctx tree) "Tree.select_sibling_ctx")
-	  (mk_fun (Tree.tagged_foll_ctx tree) "Tree.tagged_foll_ctx")
-	  (mk_fun (Tree.select_foll_ctx tree) "Tree.select_foll_ctx")
-	  (mk_fun (fun _ _ -> Tree.next_sibling_ctx tree) "[NEXTSIBLING]Tree.select_sibling_foll_ctx")
-	  (mk_fun (Tree.next_element_ctx tree) "Tree.next_element_ctx")	  
-	  (mk_fun (Tree.next_sibling_ctx tree) "Tree.node_sibling_ctx")	  
+	  (mk_fun (Tree.tagged_following_sibling_below tree) "Tree.tagged_sibling_ctx")
+	  (mk_fun (Tree.select_following_sibling_below tree) "Tree.select_sibling_ctx")
+	  (mk_fun (Tree.tagged_following_below tree) "Tree.tagged_foll_ctx")
+	  (mk_fun (Tree.select_following_below tree) "Tree.select_foll_ctx")
+	  (mk_fun (fun _ _ -> Tree.next_sibling_below tree) "[NEXTSIBLING]Tree.select_sibling_foll_ctx")
+	  (mk_fun (Tree.next_element_below tree) "Tree.next_element_ctx")	  
+	  (mk_fun (Tree.next_sibling_below tree) "Tree.node_sibling_ctx")	  
 			  
 	  
       module SListTable = Hashtbl.Make(struct type t = SList.t
 					      let equal = (==)
-					      let hash t = t.SList.Node.id 
+					      let hash t = Uid.to_int t.SList.Node.id
 				       end)
-      module TransCache = 
+
+
+      module TransCache =
+      struct
+	type cell = { key : int;
+		      obj : Obj.t }
+	type 'a t = cell array
+	let dummy = { key = 0; obj = Obj.repr () }
+	let create n = Array.create 25000 dummy
+	let hash a b = HASHINT2(Obj.magic a, Uid.to_int b.SList.Node.id)
+
+	let find_slot t key =
+	  let rec loop i =
+	    if (t.(i)  != dummy) && (t.(i).key != key)
+	    then loop ((i+1 mod 25000))
+	    else i
+	  in loop (key mod 25000)
+	;;
+
+	let find t k1 k2 = 
+	  let i = find_slot t (hash k1 k2) in
+	  if t.(i) == dummy then raise Not_found
+	  else Obj.magic (t.(i).obj)
+	    
+	let add t k1 k2 v = 
+	  let key = hash k1 k2 in
+	  let i = find_slot t key in
+	  t.(i)<- { key = key; obj = (Obj.repr v) }
+
+      end
+
+      module TransCache2 = 
       struct
 	type 'a t = Obj.t array SListTable.t
 	let create n = SListTable.create n
@@ -692,7 +889,34 @@ END
 
       end
 
-      let td_trans = TransCache.create 10000 (* should be number of tags *number of states^2
+      module TransCache = 
+      struct 
+	external get : 'a array -> int ->'a = "%array_unsafe_get"
+	external set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"
+	type fun_tree = [`Tree] Tree.node -> [`Tree] Tree.node -> SList.t*RS.t array
+	type t = fun_tree array array
+	let dummy_cell = [||] 
+	let create n = Array.create n dummy_cell
+	let dummy = fun _ _-> assert false
+	let find h tag slist =
+	  let tab = get h (Uid.to_int slist.SList.Node.id) in
+	  if tab == dummy_cell then raise Not_found
+	  else
+	  let res = get tab tag in
+	  if res == dummy then raise Not_found else res
+
+	let add (h : t) tag slist (data : fun_tree) =
+	  let tab = get h (Uid.to_int slist.SList.Node.id) in
+	  let tab = if tab == dummy_cell then
+	    let x = Array.create 100000 dummy in
+	    (set h (Uid.to_int slist.SList.Node.id) x;x)
+	  else tab
+	  in
+	  set tab tag data	  
+      end
+	
+	
+      let td_trans = TransCache.create 100000 (* should be number of tags *number of states^2
 						in the document *)
 
       let empty_size n =
@@ -700,50 +924,123 @@ END
 	  | n -> loop (SList.cons StateSet.empty acc) (n-1)
 	in loop SList.nil n
 	     
-
-      module Fold2ResOld = Hashtbl.Make(struct 
-				       type t = Formlistlist.t*SList.t*SList.t
-				       let hash (f,s,t) = HASHINT3(f.Formlistlist.Node.id,
-								   s.SList.Node.id,
-								   t.SList.Node.id)
-				       let equal (a,b,c) (d,e,f) = a==d && b == e && c == f
-				     end)
-
       module FllTable = Hashtbl.Make (struct type t = Formlistlist.t
 					     let equal = (==)
-					     let hash t = t.Formlistlist.Node.id
+					     let hash t = Uid.to_int t.Formlistlist.Node.id
 				      end)
 	
-      module Fold2Res =
-      struct
-	type 'a t = 'a SListTable.t SListTable.t FllTable.t
-	let create n = Array.init 10000 (fun _ -> FllTable.create n)
-
-	let find h tag fl s1 s2 =
-	  let hf = h.(tag) in
-	  let hs1 = FllTable.find hf fl in
-	  let hs2 = SListTable.find hs1 s1 in
-	  SListTable.find hs2 s2
-	  
+      module Fold2Res = struct
+	external get : 'a array -> int ->'a = "%array_unsafe_get"
+	external set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"
+	external field1 : 'a -> 'b = "%field1"
+	type 'a t = 'a array array array array
+	let dummy = [||]
+	let dummy_val : 'a =
+	  let v = Obj.repr ((),2,()) in
+	  Obj.magic v
+
+
+	let create n = Array.create n dummy
+	let find h tag fl s1 s2 = 
+	  let af = get h tag in
+	  if af == dummy then raise Not_found
+	  else 
+	  let as1 = get af (Uid.to_int fl.Formlistlist.Node.id) in
+	  if as1 == dummy then raise Not_found
+	  else 
+	  let as2 = get as1 (Uid.to_int s1.SList.Node.id) in
+	  if as2 == dummy then raise Not_found
+	  else 
+	  let v = get as2 (Uid.to_int s2.SList.Node.id) in
+	  if field1 v == 2 then raise Not_found
+	  else 
+	  v
+
+	
 	let add h tag fl s1 s2 data = 
-	  let hf = h.(tag) in
-	  let hs1 =
-	    try FllTable.find hf fl with
-	      | Not_found -> 
-		  let hs1 = SListTable.create SMALL_H_SIZE
-		  in FllTable.add hf fl hs1;hs1
+	  let af =
+	    let x = get h tag in
+	    if x == dummy then 
+	    begin
+	      let y = Array.make 100000 dummy in
+	      set h tag y;y
+	    end
+	    else x
 	  in
-	  let hs2 =
-	    try SListTable.find hs1 s1
-	    with
-	      | Not_found ->
-		  let hs2 = SListTable.create SMALL_H_SIZE
-		  in SListTable.add hs1 s1 hs2;hs2
+	  let as1 = 
+	    let x = get af (Uid.to_int fl.Formlistlist.Node.id) in 
+	    if x == dummy then
+	    begin
+	      let y = Array.make 100000 dummy in
+	      set af (Uid.to_int fl.Formlistlist.Node.id) y;y
+	    end
+	    else x
 	  in
-	  SListTable.add hs2 s2 data
+	  let as2 = 
+	    let x = get as1 (Uid.to_int s1.SList.Node.id) in 
+	    if x == dummy then 
+	    begin
+	      let y = Array.make 100000 dummy_val in
+	      set as1 (Uid.to_int s1.SList.Node.id) y;y
+	    end
+	    else x
+	  in
+	  set as2 (Uid.to_int s2.SList.Node.id) data    
+      end
+
+
+
+
+	
+      module Fold2Res2 = struct
+	include Hashtbl.Make(struct 
+			       type t = Tag.t*Formlistlist.t*SList.t*SList.t
+			       let equal (a,b,c,d) (x,y,z,t) =
+				 a == x && b == y && c == z && d == t
+			       let hash (a,b,c,d) = HASHINT4 (a,
+							      Uid.to_int b.Formlistlist.Node.id,
+							      Uid.to_int c.SList.Node.id,
+							      Uid.to_int d.SList.Node.id)
+			     end)
+	let add h t f s1 s2 d =
+	  add h (t,f,s1,s2) d
+	let find h t f s1 s2 =
+	  find h (t,f,s1,s2)
       end
 
-      let h_fold2 = Fold2Res.create SMALL_H_SIZE
+      module Fold2ResOld =
+      struct
+	type cell = { key : int;
+		      obj : Obj.t }
+	type 'a t = cell array
+	let dummy = { key = 0; obj = Obj.repr () }
+	let create n = Array.create 25000 dummy
+	let hash a b c d = HASHINT4(Obj.magic a, 
+				    Uid.to_int b.Formlistlist.Node.id, 
+				    Uid.to_int c.SList.Node.id,
+				    Uid.to_int d.SList.Node.id)
+
+	let find_slot t key =
+	  let rec loop i =
+	    if (t.(i)  != dummy) && (t.(i).key != key)
+	    then loop ((i+1 mod 25000))
+	    else i
+	  in loop (key mod 25000)
+	;;
+
+	let find t k1 k2 k3 k4 = 
+	  let i = find_slot t (hash k1 k2 k3 k4) in
+	  if t.(i) == dummy then raise Not_found
+	  else Obj.magic (t.(i).obj)
+	    
+	let add t k1 k2 k3 k4 v = 
+	  let key = hash k1 k2 k3 k4 in
+	  let i = find_slot t key in
+	  t.(i)<- { key = key; obj = (Obj.repr v) }
+
+      end
+
+      let h_fold2 = Fold2Res.create 10000
       
       let top_down ?(noright=false) a tree t slist ctx slot_size =	
 	let pempty = empty_size slot_size in	
@@ -751,35 +1048,37 @@ END
 	(* evaluation starts from the right so we put sl1,res1 at the end *)
 	let eval_fold2_slist fll t tag (sl2,res2) (sl1,res1) =
 	  let res = Array.copy rempty in
-	  try
-	    let r,b,btab = Fold2Res.find h_fold2 tag fll sl1 sl2  in
-	    if b then for i=0 to slot_size - 1 do
-	      res.(i) <- RS.merge btab.(i) t res1.(i) res2.(i);
-	    done;
-	    r,res
-	  with
-	     Not_found ->
-	       let btab = Array.make slot_size (false,false,false,false) in	    
-	       let rec fold l1 l2 fll i aq ab = 
-		 match fll.Formlistlist.Node.node,
-		   l1.SList.Node.node,
-		   l2.SList.Node.node
-		 with	     
-		   | Formlistlist.Cons(fl,fll),
-		    SList.Cons(s1,ll1),
-		    SList.Cons(s2,ll2) ->
-		       let r',((b,_,_,_) as flags) = eval_formlist tag s1 s2 fl in
- 		       let _ = btab.(i) <- flags
+  	   try
+	     let r,b,btab = Fold2Res.find h_fold2 tag fll sl1 sl2  in
+	     if b then for i=0 to slot_size - 1 do
+	     res.(i) <- RS.merge btab.(i) t res1.(i) res2.(i);
+	     done;
+	     r,res
+	     with
+	     Not_found -> 
+	       begin 
+		 let btab = Array.make slot_size NO in	    
+		 let rec fold l1 l2 fll i aq ab = 
+		   match fll.Formlistlist.Node.node,
+		     l1.SList.Node.node,
+		     l2.SList.Node.node
+		   with	     
+		     | Formlistlist.Cons(fl,fll),
+		      SList.Cons(s1,ll1),
+		      SList.Cons(s2,ll2) ->
+			 let r',conf = eval_formlist tag s1 s2 fl in
+ 			 let _ = btab.(i) <- conf
 		       in
-		       fold ll1 ll2 fll (i+1) (SList.cons r' aq) (b||ab)
-		   | _ -> aq,ab
-	       in
-	       let r,b = fold sl1 sl2 fll 0 SList.nil false in
-	       Fold2Res.add h_fold2 tag fll sl1 sl2 (r,b,btab);
-	       if b then for i=0 to slot_size - 1 do
-		 res.(i) <- RS.merge btab.(i) t res1.(i) res2.(i);
-	       done;
-	       r,res
+			 fold ll1 ll2 fll (i+1) (SList.cons r' aq) ((conf!=NO)||ab)
+		     | _ -> aq,ab
+		 in
+		 let r,b = fold sl1 sl2 fll 0 SList.nil false in
+		  Fold2Res.add h_fold2 tag fll sl1 sl2 (r,b,btab); 
+		 if b then for i=0 to slot_size - 1 do
+		   res.(i) <- RS.merge btab.(i) t res1.(i) res2.(i);
+		 done;
+		 r,res;
+	       end
 	in
 
 	let null_result = (pempty,Array.copy rempty) in
@@ -794,7 +1093,7 @@ END
 	    try
 	      TransCache.find td_trans tag slist
 	    with	
-	      | Not_found ->
+	      | Not_found -> 
 		  let fl_list,llist,rlist,ca,da,sa,fa = 
 		    SList.fold 
 		      (fun set (fll_acc,lllacc,rllacc,ca,da,sa,fa) -> (* For each set *)
@@ -806,7 +1105,7 @@ END
 				     (ts,t)  ->
 				       if (TagSet.mem tag ts)
 				       then 
-					 let _,_,_,f,_ = Transition.node t in
+					 let _,_,_,f,_ = t.Transition.node in
 					 let (child,desc,below),(sibl,foll,after) = Formula.st f in
 					   (Formlist.cons t fl_acc,
 					    StateSet.union ll_acc below,
@@ -832,7 +1131,10 @@ END
 		  let d_n = Algebra.decide a tags_siblings tags_after (StateSet.union sa fa) false in
 		  let f_kind,first = choose_jump_down tree d_f
 		  and n_kind,next = if noright then (`NIL, fun _ _ -> Tree.nil )
-		  else choose_jump_next tree d_n in
+		  else choose_jump_next tree d_n in 
+		  (*let f_kind,first = `ANY, Tree.first_child tree
+		  and n_kind,next = `ANY, Tree.next_sibling_below tree 
+		  in *)
 		  let empty_res = null_result in
                   let cont =
                     match f_kind,n_kind with
@@ -840,13 +1142,24 @@ END
 			  (fun t _ -> eval_fold2_slist fl_list t (Tree.tag tree t) empty_res empty_res)
 		      |  _,`NIL -> (
                            match f_kind with
-                             |`TAG(tag') ->
-                                (fun t _ -> eval_fold2_slist fl_list t (Tree.tag tree t) empty_res
-                                  (loop_tag tag' (first t) llist t ))
-			     | `ANY ->
+                             (*|`TAG(tag') ->				
+				let default = fun t _ -> eval_fold2_slist fl_list t (Tree.tag tree t) empty_res
+                                  (loop_tag tag' (first t) llist t )
+				in
+				let cf = SList.hd llist in
+				if (slot_size == 1) && StateSet.is_singleton cf
+				then
+				let s = StateSet.choose cf in
+				if (Algebra.is_rec a s fst) && (Algebra.is_rec a s snd)
+				&& (Algebra.is_final_marking a s)
+				then 
+				RS.mk_quick_tag_loop default llist 1 tree tag' 
+				else default
+				else default *)
+			     | _ ->
 				 (fun t _ -> eval_fold2_slist fl_list t (Tree.tag tree t) empty_res
 				   (loop (first t) llist t ))
-			     | _ -> assert false)
+			 )
                       | `NIL,_ -> (
                           match n_kind with
                             |`TAG(tag') ->
@@ -856,17 +1169,16 @@ END
 				 let res2 = loop (next t ctx) ctx in				   
 				 eval_fold2_slist fl_list t tag res2 empty_res		  
 			       in loop
-			       else
+			       else 
                                (fun t ctx -> eval_fold2_slist fl_list t (Tree.tag tree t)
                                  (loop_tag tag' (next t ctx) rlist ctx ) empty_res)
 											     
-                            | `ANY ->
+                            | _ ->
                                 (fun t ctx -> eval_fold2_slist fl_list t (Tree.tag tree t)
                                    (loop (next t ctx) rlist ctx ) empty_res)
-				  
-                            | _ -> assert false)
+			)
 			  
-                      | `TAG(tag1),`TAG(tag2) ->			  
+                      | `TAG(tag1),`TAG(tag2) ->
                           (fun t ctx ->
 			     eval_fold2_slist fl_list t (Tree.tag tree t)
                                (loop_tag tag2 (next t ctx) rlist ctx )
@@ -885,16 +1197,16 @@ END
                               (loop (first t) llist t ))
 								   
                       | `ANY,`ANY ->
-			  if SList.equal slist rlist && SList.equal slist llist
+			  (*if SList.equal slist rlist && SList.equal slist llist
 			  then
 			  let rec loop t ctx = 
 			    if t == Tree.nil then empty_res else
-			    let r1 = loop (first t) t 
+			    let r1 = loop (first t) t
 			    and r2 = loop (next t ctx) ctx
 			    in
 			    eval_fold2_slist fl_list t (Tree.tag tree t) r2 r1
 			  in loop
-			  else 
+			  else *)
                           (fun t ctx ->
                              eval_fold2_slist fl_list t (Tree.tag tree t)
                                (loop (next t ctx) rlist ctx )
@@ -904,7 +1216,7 @@ END
                              eval_fold2_slist fl_list t (Tree.tag tree t)
                                (loop (next t ctx) rlist ctx )
                                (loop (first t) llist t ))
-                      | _ -> assert false
+ 
 		  in
 		  let cont = D_IF_( (fun t ctx ->
                                        let a,b = cont t ctx in
@@ -912,8 +1224,8 @@ END
                                        (a,b)
                                     ) ,cont)
                   in
-                  (TransCache.add td_trans tag slist (Obj.repr cont) ;cont)
-	  in (Obj.magic cont) t ctx
+                  (   TransCache.add td_trans tag slist cont  ;   cont)
+	  in cont t ctx
 	       
 	in 
 	  (if noright then loop_no_right else loop) t slist ctx
@@ -944,7 +1256,7 @@ END
 	    if Ptss.mem s c.sets then
 	      { c with results = IMap.add s (RS.concat r (IMap.find s c.results)) c.results}
 	    else
-	      { hash = HASHINT2(c.hash,Ptset.Int.uid s);
+	      { hash = HASHINT2(c.hash,Uid.to_int (Ptset.Int.uid s));
 		sets = Ptss.add s c.sets;
 		results = IMap.add s r c.results
 	      }
@@ -978,7 +1290,7 @@ END
 	    in
 	    let h,s =
 	      Ptss.fold 
-		(fun s (ah,ass) -> (HASHINT2(ah,Ptset.Int.uid s),
+		(fun s (ah,ass) -> (HASHINT2(ah, Uid.to_int (Ptset.Int.uid s)),
 				    Ptss.add s ass))
 		(Ptss.union c1.sets c2.sets) (0,Ptss.empty)
 	    in
@@ -996,7 +1308,7 @@ END
 	    match SList.node sl,fl with
 	      |SList.Nil,[] -> acc
 	      |SList.Cons(s,sll), formlist::fll ->
-		 let r',(rb,rb1,rb2,mark) = 
+		 let r',mcnf = 
 		   let key = SList.hash sl,Formlist.hash formlist,dir in
 		   try 
 		     Hashtbl.find h_fold key
@@ -1006,6 +1318,7 @@ END
 			else eval_formlist tag Ptset.Int.empty s formlist 
 		      in (Hashtbl.add h_fold key res;res)
 		 in
+		 let (rb,rb1,rb2,mark) = bool_of_merge mcnf in
 		 if rb && ((dir&&rb1)|| ((not dir) && rb2))
 		 then 
 		 let acc = 
@@ -1024,7 +1337,7 @@ END
 	let h_trans = Hashtbl.create 4096
 
 	let get_up_trans slist ptag a tree =	  
-	  let key = (HASHINT2(SList.uid slist,ptag)) in
+	  let key = (HASHINT2(Uid.to_int slist.SList.Node.id ,ptag)) in
 	    try
 	  Hashtbl.find h_trans key		
 	  with
@@ -1125,7 +1438,7 @@ END
 	    match k with
 	      | `TAG (tag) -> 
 		  (*Tree.tagged_lowest t tag, fun tree -> Tree.tagged_next tree tag*)
-		  (Tree.tagged_desc tree tag t, let jump = Tree.tagged_foll_ctx tree tag
+		  (Tree.tagged_descendant tree tag t, let jump = Tree.tagged_following_below tree tag
 		  in fun n -> jump n t )
 	      | `CONTAINS(_) -> (Tree.text_below tree t,let jump = Tree.text_next tree 
 				 in fun n -> jump n t)
@@ -1152,5 +1465,11 @@ END
     let top_down_count a t = let module RI = Run(Integer) in Integer.length (RI.run_top_down a t)
     let top_down a t = let module RI = Run(IdSet) in (RI.run_top_down a t)
     let bottom_up_count a t k = let module RI = Run(Integer) in Integer.length (RI.run_bottom_up a t k)
+    let bottom_up a t k = let module RI = Run(IdSet) in (RI.run_bottom_up a t k)
 
+    module Test (Doc : sig val doc : Tree.t end) =
+      struct
+	module Results = GResult(Doc)
+	let top_down a t = let module R = Run(Results) in (R.run_top_down a t)
+      end