X-Git-Url: http://git.nguyen.vg/gitweb/?a=blobdiff_plain;f=ata.ml;h=eed81bc3d6d368a919e91841a449ea0a884a3115;hb=329088598ab63bc2d67ff0dfc4f54e90f5d4f283;hp=eb4f39484897b0043845d0f3f08c532726bce9ab;hpb=9728f46b5f256250a4451c0a9bda30ce81be5b8b;p=SXSI%2Fxpathcomp.git

diff --git a/ata.ml b/ata.ml
index eb4f394..eed81bc 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 *)
@@ -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,39 +328,66 @@ 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 
+type merge_conf = NO | MARK | ONLY1 | ONLY2 | ONLY12 | MARK1 | MARK2 | MARK12
 
-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
-	      
+  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 -> 
        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 +411,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
@@ -390,13 +419,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
@@ -404,7 +436,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
@@ -412,9 +445,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
+	  | ONLY12 -> res1+res2
+	  | ONLY1 -> res1
+	  | ONLY2 -> res2
+	  | MARK12 -> res1+res2+1
+	  | MARK1 -> res1+1
+	  | MARK2 -> 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 
@@ -456,45 +507,150 @@ 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"
+      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"
+      external set_tag_bits : bits -> Tag.t -> Tree.t -> elt -> elt = "caml_set_tag_bits"
+      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
+      let length t = let cpt = ref 0 in
       iter (fun _ -> incr cpt) t; !cpt
       
+      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
@@ -518,107 +674,6 @@ END
       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) = 
-	    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)
-
-	  let merge_jump_list = function 
-	    | [] -> `NIL,Ptset.Int.empty
-	    | p::r -> List.fold_left (merge_jump) p r
-	      
-	  let labels a s = 
-	    Hashtbl.fold 
-	    (
-	      fun q l acc -> 
-		if (q == s)
-		then 
-
-		  (List.fold_left 
-		      (fun acc (ts,f) ->
-			let _,_,_,bur = Transition.node f in
-			if bur then acc else TagSet.cup acc ts) 
-		    acc l)
-		else acc ) a.trans TagSet.empty
-	  exception Found
-	    
-	  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) 
-		     
-
-	  let decide a c_label l_label dir_states access =
-			
-	    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))
-		 in
-		   (if Ptset.Int.is_empty slabels
-		    then `NIL,Ptset.Int.empty
-		    else  jmp,slabels)::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_down tree a b c d = 
-	choose_jump a b c 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 (Tree.first_element tree) "Tree.first_element")
-	  (mk_fun (Tree.first_child tree) "Tree.first_child")
-
-      let choose_jump_next tree a b c d = 
-	choose_jump a b c 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 (Tree.next_sibling_ctx tree) "Tree.node_sibling_ctx")	  
-*)
       module Algebra =
 	struct
 	  type jump = [ `NIL | `ANY |`ANYNOTEXT | `JUMP ]
@@ -660,7 +715,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
@@ -668,10 +723,14 @@ END
 	    
 	  let is_rec a s access = 
 	    List.exists
-	      (fun (_,t) -> let _,_,f,_ = Transition.node t in
+	      (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 
@@ -718,13 +777,13 @@ END
 	      let tag = Ptset.Int.choose ll in 
 	      (`TAG(tag),mk_app_fun f_tn tag (Tag.to_string tag))
 	      else
-	      (`ANY,mk_app_fun f_sn ll (string_of_ts ll))
+	      (`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
-	      (`ANY,mk_app_fun f_s1 cl (string_of_ts cl))
+	      (`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)))
 
@@ -752,48 +811,187 @@ END
 	  (mk_fun (Tree.next_element_ctx tree) "Tree.next_element_ctx")	  
 	  (mk_fun (Tree.next_sibling_ctx tree) "Tree.node_sibling_ctx")	  
 			  
-      module SetTagKey =
+	  
+      module SListTable = Hashtbl.Make(struct type t = SList.t
+					      let equal = (==)
+					      let hash t = t.SList.Node.id 
+				       end)
+
+
+      module TransCacheOld = 
+      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 TransCache = 
       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)
+	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 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 slist.SList.Node.id in
+	  let tab = if tab == dummy_cell then
+	    let x = Array.create 10000 dummy in
+	    (set h slist.SList.Node.id  x;x)
+	  else tab
+	  in
+	  set tab tag 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 FllTable = Hashtbl.Make (struct type t = Formlistlist.t
+					     let equal = (==)
+					     let hash t = t.Formlistlist.Node.id
+				      end)
+	
+      module Fold2ResOld =
+      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
+
+      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 fl.Formlistlist.Node.id in
+	  if as1 == dummy then raise Not_found
+	  else 
+	  let as2 = get as1 s1.SList.Node.id in
+	  if as2 == dummy then raise Not_found 
+	  else let v = get as2 s2.SList.Node.id in
+	  if field1 v == 2 then raise Not_found 
+	  else v
+	
+	let add h tag fl s1 s2 data = 
+	  let af =
+	    let x = get h tag in
+	    if x == dummy then 
+	    begin
+	      let y = Array.make 10000 dummy in
+	      set h tag y;y
+	    end
+	    else x
+	  in
+	  let as1 = 
+	    let x = get af fl.Formlistlist.Node.id in 
+	    if x == dummy then
+	    begin
+	      let y = Array.make 10000 dummy in
+	      set af fl.Formlistlist.Node.id y;y
+	    end
+	    else x
+	  in
+	  let as2 = 
+	    let x = get as1 s1.SList.Node.id in 
+	    if x == dummy then 
+	    begin
+	      let y = Array.make 10000 dummy_val in
+	      set as1 s1.SList.Node.id y;y
+	    end
+	    else x
+	  in
+	  set as2 s2.SList.Node.id data    
+      end
 
-      module Fold2Res = 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)
 
-      let h_fold2 = Fold2Res.create BIG_H_SIZE
+      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	
 	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 -> 
-	       let btab = Array.make slot_size (false,false,false,false) in	    
+	     Not_found ->
+	       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,
@@ -802,14 +1000,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 _ = btab.(i) <- flags
+		       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)
+		       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 (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;
@@ -817,16 +1015,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 = 
@@ -840,7 +1038,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,
@@ -864,10 +1062,6 @@ END
 		  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 _ = 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 d_f
 		  and n_kind,next = if noright then (`NIL, fun _ _ -> Tree.nil )
 		  else choose_jump_next tree d_n in
@@ -875,63 +1069,117 @@ END
                   let cont =
                     match f_kind,n_kind with
                       | `NIL,`NIL ->
-                          (fun t _ -> eval_fold2_slist fl_list t empty_res empty_res )
-                      |  _,`NIL -> (
+			  Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__);
+			  (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 
+				let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+				RS.mk_quick_tag_loop default llist 1 tree tag' 
+				else 
+				let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+				default
+				else
+				let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+				default
+			     | _ ->
+				 let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in	
+				 (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)
-
+                          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 Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__);loop
+			       else
+			       let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+                               (fun t ctx -> eval_fold2_slist fl_list t (Tree.tag tree t)
+                                 (loop_tag tag' (next t ctx) rlist ctx ) empty_res)
+											     
+                            | _ ->
+				let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+                                (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
-                               (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) )
+			  let _ = Printf.eprintf "Using %i %s %s\n" (Loc.start_line  __LOCATION__)
+			    (Tag.to_string tag1)
+			  (Tag.to_string tag2) 
+			  in
+                          (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 ->
+			  let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+			  (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') ->
+			  let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+                          (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 ->
+			  let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+			  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 
+			  let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+			  loop
+			  else
+			  let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+                          (fun t ctx ->
+                             eval_fold2_slist fl_list t (Tree.tag tree t)
+                               (loop (next t ctx) rlist ctx )
+                               (loop (first t) llist t ))
+		      | _,_ -> 
+			  let _ = Printf.eprintf "Using %i\n" (Loc.start_line  __LOCATION__) in
+			  (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 cont ;cont)
+	  in 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 
@@ -1004,21 +1252,23 @@ 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
 	      |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
 		   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
+		 let (rb,rb1,rb2,mark) = bool_of_merge mcnf in
 		 if rb && ((dir&&rb1)|| ((not dir) && rb2))
 		 then 
 		 let acc = 
@@ -1086,7 +1336,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)
@@ -1129,7 +1379,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
@@ -1167,3 +1417,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
+