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 "")
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
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 "") ^" }"
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);;
+ 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
(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
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
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 ]
(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
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 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)))
(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,
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,
| 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;
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 =
(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,
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
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') ->
+ (fun t _ -> eval_fold2_slist fl_list t (Tree.tag tree t) empty_res
+ (loop_tag tag' (first t) llist t ))
+ | `ANY ->
+ (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) ->
- (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)
+
+ | `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) ->
+ (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) )
+ 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 ))
| _ -> assert false
- in
- let cont = D_IF_( (fun t ctx ->
+ 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
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
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))
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)
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
projects / SXSI / xpathcomp.git / blobdiff