X-Git-Url: http://git.nguyen.vg/gitweb/?a=blobdiff_plain;f=ata.ml;h=3741b569f134acf7a0f7284d292157a3de9a73b0;hb=be1caa5c46009c13241cc48ed34a36ee2936ef87;hp=42bf24ec377a94f65d42694c5c30da6f2bacf50e;hpb=83b4813de7204842bb59d5cb0aec71aff633ca85;p=SXSI%2Fxpathcomp.git

diff --git a/ata.ml b/ata.ml
index 42bf24e..3741b56 100644
--- a/ata.ml
+++ b/ata.ml
@@ -194,16 +194,18 @@ end
   
 module Transition = struct
   
-  type node = State.t*bool*Formula.t*bool
+  type node = State.t*TagSet.t*bool*Formula.t*bool
   include Hcons.Make(struct
 		       type t = node
-		       let hash (s,m,f,b) = HASHINT4(s,Formula.uid f,vb m,vb b)
-		       let equal (s,b,f,m) (s',b',f',m') = 
-			 s == s' && b==b' && m==m' && Formula.equal f f' 
+		       let hash (s,ts,m,f,b) = HASHINT5(s,TagSet.uid ts,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)
     
-  let print ppf f = let (st,mark,form,b) = node f in
-    Format.fprintf ppf "%i %s" st (if mark then "⇒" else "→");
+  let print ppf f = let (st,ts,mark,form,b) = node f in
+    Format.fprintf ppf "(%i, " st;
+    TagSet.print ppf ts;
+    Format.fprintf ppf ") %s" (if mark then "⇒" else "→");
     Formula.print ppf form;
     Format.fprintf ppf "%s%!" (if b then " (b)" else "")
 
@@ -212,7 +214,7 @@ module Transition = struct
   let ( ?< ) x = x
   let ( >< ) state (l,mark) = state,(l,mark,false)
   let ( ><@ ) state (l,mark) = state,(l,mark,true)
-  let ( >=> ) (state,(label,mark,bur)) form = (state,label,(make (state,mark,form,bur)))
+  let ( >=> ) (state,(label,mark,bur)) form = (state,label,(make (state,label,mark,form,bur)))
   end
 
 end
@@ -254,7 +256,7 @@ let dump ppf a =
 		       if y-x == 0 then TagSet.compare tsy tsx else y-x) l in
   let maxh,maxt,l_print = 
     List.fold_left (
-      fun (maxh,maxt,l) ((ts,q),(_,b,f,_)) ->			  
+      fun (maxh,maxt,l) ((ts,q),(_,_,b,f,_)) ->			  
 	let s = 
 	  if TagSet.is_finite ts 
 	  then "{" ^ (TagSet.fold (fun t a -> a ^ " '" ^ (Tag.to_string t)^"'") ts "") ^" }"
@@ -326,30 +328,32 @@ let eval_form_bool =
       in loop f
 
 	   
-module FTable = Hashtbl.Make( struct
-				type t = Formlist.t*StateSet.t*StateSet.t
-				let equal (f1,s1,t1) (f2,s2,t2) =
-				  f1 == f2 &&  s1 == s2 && t1 == t2;;
-				let hash (f,s,t) =  HASHINT3(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,Formlist.uid f ,StateSet.uid s,StateSet.uid t);;
+			     end)
 
 
 let h_f = FTable.create BIG_H_SIZE 
 
-let eval_formlist s1 s2 fl =
+let eval_formlist tag s1 s2 fl =
   let rec loop fl =
           try 
-	    FTable.find h_f (fl,s1,s2)
+	    FTable.find h_f (tag,fl,s1,s2)
 	  with 
 	    | Not_found  -> 
 		match Formlist.node fl with
 		  | Formlist.Cons(f,fll) ->
-		      let q,mark,f,_ = Transition.node f in
-		      let b,b1,b2 = eval_form_bool f s1 s2 in
+		      let q,ts,mark,f,_ = Transition.node f in
+		      let b,b1,b2 = 
+			if TagSet.mem tag ts then eval_form_bool f s1 s2 else (false,false,false)
+		      in
 		      let (s,(b',b1',b2',amark)) as res = loop fll in
 		      let r = if b then (StateSet.add q s, (b, b1'||b1,b2'||b2,mark||amark))
 		      else res
-		      in FTable.add h_f (fl,s1,s2) r;r
+		      in FTable.add h_f (tag,fl,s1,s2) r;r
 		  | Formlist.Nil -> StateSet.empty,(false,false,false,false)
   in loop fl
 	      
@@ -358,7 +362,7 @@ let tags_of_state a q =
     (fun p l acc -> 
        if p == q then List.fold_left 
 	 (fun acc (ts,t) -> 
-	    let _,_,_,aux = Transition.node t in
+	    let _,_,_,_,aux = Transition.node t in
 	      if aux then acc else
 		TagSet.cup ts acc) acc l
 	 
@@ -382,7 +386,7 @@ let tags_of_state a q =
     module type ResultSet = 
     sig
       type t
-      type elt = [` Tree] Tree.node
+      type elt = [` Tree ] Tree.node
       val empty : t
       val cons : elt -> t -> t
       val concat : t -> t -> t
@@ -391,6 +395,8 @@ let tags_of_state a q =
       val map : ( elt -> elt) -> t -> t
       val length : t -> int
       val merge : (bool*bool*bool*bool) -> 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 =
@@ -412,6 +418,13 @@ let tags_of_state a q =
 	    if mark then 1+res1+res2
 	    else res1+res2
 	else 0
+      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 = 
@@ -466,35 +479,99 @@ let tags_of_state a q =
 	    else
 	      { node = (Concat(res1.node,res2.node));
 		length = res1.length + res2.length ;}
-	else empty 	  
-
-	   
+	else empty 
+      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"
+      external set : bits -> int -> unit = "caml_result_set_set"
+      external next : bits -> int -> int = "caml_result_set_next"
+      external clear : bits -> elt -> elt -> unit = "caml_result_set_clear"
+
+      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 map _ _ = failwith "noop"
-      let length t = let cpt = ref ~-1 in
+      let length t = let cpt = ref 0 in
       iter (fun _ -> incr cpt) t; !cpt
       
       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
+	  | [p],[] when rb1 -> if mark then cons elt t1 else t1
+	  | [], [p] when rb2 -> if mark then cons elt t2 else t2
+	  | [x],[y] when rb1 && rb2 -> if mark then cons elt empty else
+	    concat t1 t2
+	  | _,_ -> 
+	let t1 = if rb1 then t1 else 
+	(List.iter (fun idx -> clear t1.bits idx (Tree.closing Doc.doc idx)) t1.segments;empty)
+	and t2 = if rb2 then t2 else 
+	(List.iter (fun idx -> clear t2.bits idx (Tree.closing Doc.doc idx)) t2.segments;empty)
+	in
+	(if mark then cons elt (concat t1 t2)
+	 else concat t1 t2)
+	else
+	let _ = 
+	  List.iter (fun idx -> clear t1.bits idx (Tree.closing Doc.doc idx)) t1.segments;
+	  List.iter (fun idx -> clear t2.bits idx (Tree.closing Doc.doc idx)) t2.segments
+	in
+	empty	  
+      let mk_quick_tag_loop f _ _ _ _ = f
+      let mk_quick_star_loop f _ _ _ = f
     end
     module Run (RS : ResultSet) =
     struct
@@ -512,26 +589,43 @@ END
       let mk_fun f s = D_IGNORE_(register_funname f s,f)
       let mk_app_fun f arg s = let g = f arg in 
 	D_IGNORE_(register_funname g ((get_funname f) ^ " " ^ s), g) 
+      let mk_app_fun2 f arg1 arg2 s = let g = f arg1 arg2 in 
+	D_IGNORE_(register_funname g ((get_funname f) ^ " " ^ s), g) 
 
       let string_of_ts tags = (Ptset.Int.fold (fun t a -> a ^ " " ^ (Tag.to_string t) ) tags "{")^ " }"
 
 
-
       module Algebra =
 	struct
-	  type jump = [ `LONG | `CLOSE | `NIL ]
-	  type t = jump*Ptset.Int.t
-	      
-	  let merge_jump (j1,l1) (j2,l2) = 
+	  type jump = [ `NIL | `ANY |`ANYNOTEXT | `JUMP ]
+	  type t = jump*Ptset.Int.t*Ptset.Int.t
+	  let jts = function 
+	  | `JUMP -> "JUMP"
+	  | `NIL -> "NIL"
+	  | `ANY -> "ANY"
+	  | `ANYNOTEXT -> "ANYNOTEXT"
+	  let merge_jump (j1,c1,l1) (j2,c2,l2) = 
 	    match j1,j2 with
-	      | _ when j1 = j2 -> (j1,Ptset.Int.union l1 l2)
-	      | _,`NIL -> j1,l1
-	      | `NIL,_ -> j2,l2
-	      | _,_ -> (`CLOSE, Ptset.Int.union l1 l2)
+	      | _,`NIL -> (j1,c1,l1)
+	      | `NIL,_ -> (j2,c2,l2)
+	      | `ANY,_ -> (`ANY,Ptset.Int.empty,Ptset.Int.empty)
+	      | _,`ANY -> (`ANY,Ptset.Int.empty,Ptset.Int.empty)
+	      | `ANYNOTEXT,_ -> 
+ 		  if Ptset.Int.mem Tag.pcdata (Ptset.Int.union c2 l2) then
+		  (`ANY,Ptset.Int.empty,Ptset.Int.empty)
+		  else
+		  (`ANYNOTEXT,Ptset.Int.empty,Ptset.Int.empty)
+	      | _,`ANYNOTEXT -> 
+		  if Ptset.Int.mem Tag.pcdata (Ptset.Int.union c1 l1) then
+		  (`ANY,Ptset.Int.empty,Ptset.Int.empty)
+		  else
+		  (`ANYNOTEXT,Ptset.Int.empty,Ptset.Int.empty)
+	      | `JUMP,`JUMP -> (`JUMP, Ptset.Int.union c1 c2,Ptset.Int.union l1 l2)
 
 	  let merge_jump_list = function 
-	    | [] -> `NIL,Ptset.Int.empty
-	    | p::r -> List.fold_left (merge_jump) p r
+	    | [] -> `NIL,Ptset.Int.empty,Ptset.Int.empty
+	    | p::r -> 
+		List.fold_left (merge_jump) p r
 	      
 	  let labels a s = 
 	    Hashtbl.fold 
@@ -542,7 +636,7 @@ END
 
 		  (List.fold_left 
 		      (fun acc (ts,f) ->
-			let _,_,_,bur = Transition.node f in
+			let _,_,_,_,bur = Transition.node f in
 			if bur then acc else TagSet.cup acc ts) 
 		    acc l)
 		else acc ) a.trans TagSet.empty
@@ -550,91 +644,141 @@ END
 	    
 	  let is_rec a s access = 
 	    List.exists
-	      (fun (_,t) -> let _,_,f,_ = Transition.node t in
-	      StateSet.mem s (access f)) (Hashtbl.find a.trans s) 
+	      (fun (_,t) -> let _,_,_,f,_ = Transition.node t in
+	      StateSet.mem s ((fun (_,_,x) -> x) (access (Formula.st f)))) (Hashtbl.find a.trans s) 
 		     
-
-	  let decide a c_label l_label dir_states access =
+	  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 
 	      (fun s l -> 
-		 let s_rec= is_rec a s access in
-		 let tlabels,jmp = 
-		   if s_rec then l_label,`LONG 
-		   else c_label,`CLOSE in			      
-		 let slabels = TagSet.positive ((TagSet.cap (labels a s) tlabels))
+		 let s_rec = is_rec a s (if dir then fst else snd) in
+		 let s_rec = if dir then s_rec else
+		 (* right move *)
+		 is_rec a s fst
 		 in
-		   (if Ptset.Int.is_empty slabels
-		    then `NIL,Ptset.Int.empty
-		    else  jmp,slabels)::l) dir_states []
-	    in merge_jump_list l
-		 
-
-	    
+		 let s_lab = labels a s in
+		 let jmp,cc,ll = 
+		   if (not (TagSet.is_finite s_lab)) then
+		   if TagSet.mem Tag.pcdata s_lab then  (`ANY,Ptset.Int.empty,Ptset.Int.empty)
+		   else (`ANYNOTEXT,Ptset.Int.empty,Ptset.Int.empty)
+		   else 
+		   if s_rec 
+		   then (`JUMP,Ptset.Int.empty, TagSet.positive 
+			   (TagSet.cap (TagSet.inj_positive l_label) s_lab))
+		   else (`JUMP,TagSet.positive 
+			   (TagSet.cap (TagSet.inj_positive c_label) s_lab),
+			 Ptset.Int.empty )
+		 in
+		   (if jmp != `ANY 
+		    && jmp != `ANYNOTEXT 
+		    && Ptset.Int.is_empty cc 
+		    && Ptset.Int.is_empty ll
+		    then (`NIL,Ptset.Int.empty,Ptset.Int.empty)
+		    else  (jmp,cc,ll))::l) dir_states []
+	    in merge_jump_list l		 	    
 	    
 	      
 	end 
 
 
-      let choose_jump tagset qtags1 qtagsn a f_nil  f_t1 f_s1 f_tn f_sn f_notext f_maytext =
-	let tags1,hastext1,fin1 = inter_text tagset (tags a qtags1) in
-	let tagsn,hastextn,finn = inter_text tagset (tags a qtagsn) in
-	  (*if (hastext1||hastextn) then (`ANY,f_text)  (* jumping to text nodes doesn't work really well *)
-	  else*)
-	  if (Ptset.Int.is_empty tags1) && (Ptset.Int.is_empty tagsn) then (`NIL,f_nil)
-	  else if (Ptset.Int.is_empty tagsn) then 
-	    if (Ptset.Int.is_singleton tags1) 
-	    then (* TaggedChild/Sibling *)
-	      let tag = (Ptset.Int.choose tags1) in (`TAG(tag),mk_app_fun f_t1 tag (Tag.to_string tag))
-	    else (* SelectChild/Sibling *)
-	      (`ANY,mk_app_fun f_s1 tags1 (string_of_ts tags1))
-	  else if (Ptset.Int.is_empty tags1) then 
-	    if (Ptset.Int.is_singleton tagsn) 
-	    then (* TaggedDesc/Following *)
-	      let tag = (Ptset.Int.choose tagsn) in  (`TAG(tag),mk_app_fun f_tn tag (Tag.to_string tag))
-	    else (* SelectDesc/Following *)
-	      (`ANY,mk_app_fun f_sn tagsn (string_of_ts tagsn))
-	  else if (hastext1||hastextn) then (`ANY,f_maytext)
-	  else (`ANY,f_notext)
+
+      let choose_jump (d,cl,ll) f_nil f_t1 f_s1 f_tn f_sn f_s1n f_notext f_maytext =
+	match d with
+	  | `NIL -> (`NIL,f_nil)
+	  | `ANYNOTEXT -> `ANY,f_notext
+	  | `ANY -> `ANY,f_maytext
+	  | `JUMP -> 
+	      if Ptset.Int.is_empty cl then
+	      if Ptset.Int.is_singleton ll then
+	      let tag = Ptset.Int.choose ll in 
+	      (`TAG(tag),mk_app_fun f_tn tag (Tag.to_string tag))
+	      else
+	      (`MANY(ll),mk_app_fun f_sn ll (string_of_ts ll))
+	      else if Ptset.Int.is_empty ll then
+	      if Ptset.Int.is_singleton cl then
+	      let tag = Ptset.Int.choose cl in 
+	      (`TAG(tag),mk_app_fun f_t1 tag (Tag.to_string tag))
+	      else
+	      (`MANY(cl),mk_app_fun f_s1 cl (string_of_ts cl))
+	      else
+	      (`ANY,mk_app_fun2 f_s1n cl ll ((string_of_ts cl) ^ " " ^ (string_of_ts ll)))
+
+	  | _ -> assert false
 	  
-      let choose_jump_down tree a b c d = 
-	choose_jump a b c d
+      let choose_jump_down tree d =
+	choose_jump d
 	  (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 (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")
+	  (mk_fun (Tree.first_child tree) "Tree.first_child") 
 
-      let choose_jump_next tree a b c d = 
-	choose_jump a b c d
+      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 (Tree.next_element_ctx tree) "Tree.node_element_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")	  
 			  
-      module SetTagKey =
-      struct 
-	type t = Tag.t*SList.t
-	let equal (t1,s1) (t2,s2) =  t1 == t2 && s1 == s2
-	let hash (t,s) = HASHINT2(t,s.SList.Node.id)
+	  
+      module SListTable = Hashtbl.Make(struct type t = SList.t
+					      let equal = (==)
+					      let hash t = t.SList.Node.id 
+				       end)
+      module TransCache = 
+      struct
+	type 'a t = Obj.t array SListTable.t
+	let create n = SListTable.create n
+	let dummy = Obj.repr (fun _ -> assert false)
+	let find (h :'a t) tag slist : 'a =
+	  let tab = 
+	    try
+	      SListTable.find h slist
+	    with
+	       Not_found -> 
+		 SListTable.add h slist (Array.create 10000 dummy);
+		 raise Not_found
+	  in
+	  let res = tab.(tag) in
+	  if res == dummy then raise Not_found else (Obj.magic res)
+
+	let add (h : 'a t) tag slist (data : 'a) =
+	  let tab = 
+	    try
+	      SListTable.find h slist
+	    with
+	       Not_found -> 
+		 let arr = Array.create 10000 dummy in
+		 SListTable.add h slist arr;
+		 arr
+	  in
+	  tab.(tag) <- (Obj.repr data)
+	  
+
       end
-	
-      module CachedTransTable = Hashtbl.Make(SetTagKey)
-      let td_trans = CachedTransTable.create 4093
-	
-	
+
+      let td_trans = TransCache.create 10000 (* should be number of tags *number of states^2
+						in the document *)
+
       let empty_size n =
 	let rec loop acc = function 0 -> acc
 	  | n -> loop (SList.cons StateSet.empty acc) (n-1)
 	in loop SList.nil n
 	     
 
-      module Fold2Res = Hashtbl.Make(struct 
+      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,
@@ -642,22 +786,56 @@ END
 				       let equal (a,b,c) (d,e,f) = a==d && b == e && c == f
 				     end)
 
-      let h_fold2 = Fold2Res.create BIG_H_SIZE
+      module FllTable = Hashtbl.Make (struct type t = Formlistlist.t
+					     let equal = (==)
+					     let hash t = 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
+	  
+	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
+	  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
+	  in
+	  SListTable.add hs2 s2 data
+      end
+
+      let h_fold2 = Fold2Res.create SMALL_H_SIZE
       
       let top_down ?(noright=false) a tree t slist ctx slot_size =	
 	let pempty = empty_size slot_size in	
 	let rempty = Array.make slot_size RS.empty in
 	(* evaluation starts from the right so we put sl1,res1 at the end *)
-	let eval_fold2_slist fll t (sl2,res2) (sl1,res1) =
+	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 (fll,sl1,sl2) in
+	    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 -> 
+	     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,
@@ -667,14 +845,14 @@ END
 		   | Formlistlist.Cons(fl,fll),
 		    SList.Cons(s1,ll1),
 		    SList.Cons(s2,ll2) ->
-		       let r',((b,_,_,_) as flags) = eval_formlist s1 s2 fl in
+		       let r',((b,_,_,_) as flags) = eval_formlist tag s1 s2 fl in
  		       let _ = btab.(i) <- flags
 		       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 (fll,sl1,sl2) (r,b,btab);
+	       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;
@@ -682,16 +860,16 @@ END
 	in
 
 	let null_result = (pempty,Array.copy rempty) in
-	let rec loop t slist ctx=
+	let rec loop t slist ctx =
 	  if t == Tree.nil then null_result else get_trans t slist (Tree.tag tree t) ctx
 	and loop_tag tag t slist ctx =
 	  if t == Tree.nil then null_result else get_trans t slist tag ctx
 	and loop_no_right t slist ctx = 
 	  if t == Tree.nil then null_result else get_trans ~noright:true t slist (Tree.tag tree t) ctx
-	and get_trans ?(noright=false) t slist tag ctx =	  
+	and get_trans ?(noright=false) t slist tag ctx = 
 	  let cont = 
 	    try
-	      CachedTransTable.find td_trans (tag,slist)
+	      TransCache.find td_trans tag slist
 	    with	
 	      | Not_found ->
 		  let fl_list,llist,rlist,ca,da,sa,fa = 
@@ -705,7 +883,7 @@ END
 				     (ts,t)  ->
 				       if (TagSet.mem tag ts)
 				       then 
-					 let _,_,f,_ = Transition.node t in
+					 let _,_,_,f,_ = Transition.node t in
 					 let (child,desc,below),(sibl,foll,after) = Formula.st f in
 					   (Formlist.cons t fl_acc,
 					    StateSet.union ll_acc below,
@@ -726,75 +904,106 @@ END
 		      slist (Formlistlist.nil,SList.nil,SList.nil,StateSet.empty,StateSet.empty,StateSet.empty,StateSet.empty)
 		  in			
 		    (* Logic to chose the first and next function *)
-		  let _,tags_below,_,tags_after = Tree.tags tree tag in
-(*		  let _ = Printf.eprintf "Tags below %s are : \n" (Tag.to_string tag) in
-		  let _ = Ptset.Int.iter (fun i -> Printf.eprintf "%s " (Tag.to_string i)) tags_below in
-		  let _ = Printf.eprintf "\n%!" in *)
-		  let tags_below = Ptset.Int.remove tag tags_below in
-		  let f_kind,first = choose_jump_down tree tags_below ca da a
+		  let tags_child,tags_below,tags_siblings,tags_after = Tree.tags tree tag in
+		  let d_f = Algebra.decide a tags_child tags_below (StateSet.union ca da) true in
+		  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 tags_after sa fa a in
+		  else choose_jump_next tree d_n in
 		  let empty_res = null_result in
                   let cont =
                     match f_kind,n_kind with
                       | `NIL,`NIL ->
-                          (fun t _ -> eval_fold2_slist fl_list t empty_res empty_res )
-                      |  _,`NIL -> (
+			  (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 empty_res
-                                   (loop_tag tag (first t) llist t))
-                             | `ANY ->
-                                 (fun t _ -> eval_fold2_slist fl_list t empty_res
-                                    (loop (first t) llist t))
-                             | _ -> assert false)
-
+                             |`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_subtree 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 ))
+			 )
                       | `NIL,_ -> (
-                            match n_kind with
-                              |`TAG(tag) ->
-                                 (fun t ctx -> eval_fold2_slist fl_list t
-                                    (loop_tag tag (next t ctx) rlist ctx) empty_res)
-
-                              | `ANY ->
-                                  (fun t ctx -> eval_fold2_slist fl_list t
-                                     (loop (next t ctx) rlist ctx) empty_res)
-
-                              | _ -> assert false)
-
-                      | `TAG(tag1),`TAG(tag2) ->
-                            (fun t ctx -> eval_fold2_slist fl_list t
-                               (loop_tag tag2 (next t ctx) rlist ctx)
-                               (loop_tag tag1 (first t) llist t))
-
-                      | `TAG(tag),`ANY ->
-			  (fun t ctx -> eval_fold2_slist fl_list t
-                               (loop (next t ctx) rlist ctx)
-                               (loop_tag tag (first t) llist t))
-                      | `ANY,`TAG(tag) ->
-                            (fun t ctx ->
-                               eval_fold2_slist fl_list t
-                                 (loop_tag tag (next t ctx) rlist ctx)
-                                 (loop (first t) llist t) )
+                          match n_kind with
+                            |`TAG(tag') ->
+			       if SList.equal rlist slist && tag == tag' then
+			       let rec loop t ctx = 
+				 if t == Tree.nil then empty_res else 
+				 let res2 = loop (next t ctx) ctx in				   
+				 eval_fold2_slist fl_list t tag res2 empty_res		  
+			       in loop
+			       else
+                               (fun t ctx -> eval_fold2_slist fl_list t (Tree.tag tree t)
+                                 (loop_tag tag' (next t ctx) rlist ctx ) empty_res)
+											     
+                            | _ ->
+                                (fun t ctx -> eval_fold2_slist fl_list t (Tree.tag tree t)
+                                   (loop (next t ctx) rlist ctx ) empty_res)
+			)
+			  
+                      | `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 )
+                               (loop_tag tag1 (first t) llist t ))
+ 
+                      | `TAG(tag'),`ANY ->
+			  (fun t ctx ->
+			    eval_fold2_slist fl_list t (Tree.tag tree t)
+                              (loop (next t ctx) rlist ctx )
+                              (loop_tag tag' (first t) llist t ))
+									   
+                      | `ANY,`TAG(tag') ->
+                          (fun t ctx ->
+                            eval_fold2_slist fl_list t (Tree.tag tree t)
+                              (loop_tag tag' (next t ctx) rlist ctx )
+                              (loop (first t) llist t ))
+								   
                       | `ANY,`ANY ->
-                            (fun t ctx ->
-                               eval_fold2_slist fl_list t
-                                 (loop (next t ctx) rlist ctx)
-                                 (loop (first t) llist t) )
-                      | _ -> assert false
-                  in
-                  let cont = D_IF_( (fun t ctx ->
+			  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 
+			    and r2 = loop (next t ctx) ctx
+			    in
+			    eval_fold2_slist fl_list t (Tree.tag tree t) r2 r1
+			  in loop
+			  else 
+                          (fun t ctx ->
+                             eval_fold2_slist fl_list t (Tree.tag tree t)
+                               (loop (next t ctx) rlist ctx )
+                               (loop (first t) llist t ))
+		      | _,_ -> 
+			  (fun t ctx ->
+                             eval_fold2_slist fl_list t (Tree.tag tree t)
+                               (loop (next t ctx) rlist ctx )
+                               (loop (first t) llist t ))
+ 
+		  in
+		  let cont = D_IF_( (fun t ctx ->
                                        let a,b = cont t ctx in
                                        register_trace tree t (slist,a,fl_list,first,next,ctx);
-                                         (a,b)
+                                       (a,b)
                                     ) ,cont)
                   in
-                  (CachedTransTable.add td_trans (tag,slist) cont;cont)
-          in cont t ctx
-	    
-	in
-	(if noright then loop_no_right else loop) t slist ctx
+                  (TransCache.add td_trans tag slist (Obj.repr cont) ;cont)
+	  in (Obj.magic cont) t ctx
+	       
+	in 
+	  (if noright then loop_no_right else loop) t slist ctx
 
-  
 	let run_top_down a tree =
 	  let init = SList.cons a.init SList.nil in
 	  let _,res = top_down a tree Tree.root init Tree.root 1 
@@ -867,7 +1076,8 @@ END
 
 	let h_fold = Hashtbl.create 511 
 
-	let fold_f_conf  t slist fl_list conf dir= 
+	let fold_f_conf  tree t slist fl_list conf dir= 
+	  let tag = Tree.tag tree t in
 	  let rec loop sl fl acc =
 	    match SList.node sl,fl with
 	      |SList.Nil,[] -> acc
@@ -878,8 +1088,8 @@ END
 		     Hashtbl.find h_fold key
 		   with
 		      Not_found -> let res = 
-			if dir then eval_formlist s Ptset.Int.empty formlist
-			else eval_formlist  Ptset.Int.empty s formlist 
+			if dir then eval_formlist tag s Ptset.Int.empty formlist
+			else eval_formlist tag Ptset.Int.empty s formlist 
 		      in (Hashtbl.add h_fold key res;res)
 		 in
 		 if rb && ((dir&&rb1)|| ((not dir) && rb2))
@@ -949,7 +1159,7 @@ END
 	  let slist = Configuration.Ptss.fold (fun e a -> SList.cons e a) conf.Configuration.sets SList.nil in
 	  let fl_list = get_up_trans slist ptag a parent in
 	  let slist = SList.rev (slist) in 
-	  let newconf = fold_f_conf parent slist fl_list conf dir in
+	  let newconf = fold_f_conf tree parent slist fl_list conf dir in
 	  let accu,newconf = Configuration.IMap.fold (fun s res (ar,nc) ->
 							if Ptset.Int.intersect s init then
 							  ( RS.concat res ar ,nc)
@@ -992,7 +1202,7 @@ END
 	  in
 	  let init = List.fold_left 
 	    (fun acc (_,t) ->
-	       let _,_,f,_ = Transition.node t in 
+	       let _,_,_,f,_ = Transition.node t in 
 	       let _,_,l = fst ( Formula.st f ) in
 		 StateSet.union acc l)
 	    StateSet.empty trlist
@@ -1030,3 +1240,9 @@ END
     let bottom_up_count a t k = let module RI = Run(Integer) in Integer.length (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
+