X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;ds=sidebyside;f=helm%2Focaml%2Fmathql_interpreter%2Fmqint.ml;h=95d3c8f2e47f9b5aa37e17e000a87b49ab508630;hb=4ac188650f64fb947c5d87dcf3c932a4d013d842;hp=a0c56e3848835e0cc8a65212d8227ae87e28008c;hpb=e28b32104f8d3b3ce1c44fdde94d64d02f119287;p=helm.git

diff --git a/helm/ocaml/mathql_interpreter/mqint.ml b/helm/ocaml/mathql_interpreter/mqint.ml
index a0c56e384..95d3c8f2e 100644
--- a/helm/ocaml/mathql_interpreter/mqint.ml
+++ b/helm/ocaml/mathql_interpreter/mqint.ml
@@ -34,11 +34,15 @@ open MathQL;;
 open Eval;;
 open Utility;;
 open Dbconn;;
-open Pattern;;
-open Union;;*)
+open Pattern;;*)
+open Union;;
 open Intersect;;
-(*open Diff;;
-open Sortedby;;
+open Meet;;
+open Sub;;
+open Context;;
+open Diff;;
+open Relation;;
+(*open Sortedby;;
 open Use;;
 open Select;;
 open Letin;;
@@ -257,51 +261,83 @@ let init () = () (* FG: implementare l'apertura del database *)
 let close () = () (* FG: implementare la chiusura del database *)
 
 
-(* contexts *****************************************************************)
 
-type svar_context = (MathQL.svar * MathQL.resource_set) list
-
-type rvar_context = (MathQL.rvar * MathQL.resource) list
-
-type group_context = (MathQL.rvar * MathQL.attribute_group) list
-
-type vvar_context = (MathQL.vvar * MathQL.value) list
-
-
-let svars = ref [] (* contesto delle svar *)
-
-let rvars = ref [] (* contesto delle rvar *)
-
-let groups = ref [] (* contesto dei gruppi *)
-
-let vvars = ref [] (* contesto delle vvar introdotte con let-in *)
+exception BooleExpTrue
 
+(* valuta una MathQL.set_exp e ritorna un MathQL.resource_set *)
 
-let rec exec_set_exp = function 
-   | MathQL.Ref vexp -> List.map (fun s -> (s,[])) (exec_val_exp vexp)
-   | MathQL.Intersect sexp1 sexp2 -> intersect_ex (exec_set_exp sexp1) (exec_set_exp sexp2)    
+let rec exec_set_exp c = function
+   |MathQL.SVar svar -> List.assoc svar c.svars
+   |MathQL.RVar rvar -> [List.assoc rvar c.rvars]  
+   | MathQL.Ref vexp -> List.map (fun s -> (s,[])) (exec_val_exp c vexp)
+   | MathQL.Intersect (sexp1, sexp2) -> intersect_ex (exec_set_exp c sexp1) (exec_set_exp c sexp2)    
+   | MathQL.Union (sexp1, sexp2) -> union_ex (exec_set_exp c sexp1) (exec_set_exp c sexp2)
+   | MathQL.LetSVar (svar, sexp1, sexp2) -> let _ = (svar, (exec_set_exp c sexp1)):: (List.remove_assoc svar c.svars) 
+   					in (exec_set_exp c sexp2)
+   | MathQL.LetVVar (vvar, vexp, sexp) -> let _ = (vvar, (exec_val_exp c vexp)):: (List.remove_assoc vvar c.vvars)
+   					in (exec_set_exp c sexp)
+   | MathQL.Relation (rop, path, sexp, attl) -> relation_ex rop path (exec_set_exp c sexp) attl
+   | MathQL.Select (rvar, sexp, bexp) -> let rset = (exec_set_exp c sexp) in
+                                          let rec select_ex rset =
+					    match rset with 
+						      [] -> []
+					    | r::tl -> upd_rvars c ((rvar,r)::c.rvars);                     
+	                                       if (exec_boole_exp c bexp) then r::(select_ex tl)
+   		                               else select_ex tl
+                                          in select_ex rset
+					               
+   					   			                   
+   
+   | MathQL.Diff (sexp1, sexp2) -> diff_ex (exec_set_exp c sexp1) (exec_set_exp c sexp2)
    | _ -> assert false
    
 (* valuta una MathQL.boole_exp e ritorna un boole *)
 
-and exec_boole_exp = function
+and exec_boole_exp c = function
    | MathQL.False      -> false
    | MathQL.True       -> true
-   | MathQL.Not x      -> not (exec_boole_exp x)
-   | MathQL.And (x, y) -> (exec_boole_exp x) && (exec_boole_exp y)
-   | MathQL.Or (x, y)  -> (exec_boole_exp x) || (exec_boole_exp y)   
-   | _ -> assert false
+   | MathQL.Not x      -> not (exec_boole_exp c x)
+   | MathQL.And (x, y) -> (exec_boole_exp c x) && (exec_boole_exp c y)
+   | MathQL.Or (x, y)  -> (exec_boole_exp c x) || (exec_boole_exp c y)
+   | MathQL.Sub (vexp1, vexp2) -> sub_ex (exec_val_exp c vexp1) (exec_val_exp c vexp2)
+   | MathQL.Meet (vexp1, vexp2) -> meet_ex (exec_val_exp c vexp1) (exec_val_exp c vexp2)
+   | MathQL.Eq (vexp1, vexp2) -> (exec_val_exp c vexp1) = (exec_val_exp c vexp2)
+   | MathQL.Ex l bexp -> 
+   	if l = [] then (exec_boole_exp c bexp)
+   	else
+   	  let latt = List.map (fun uri -> 
+                                       let (r,attl) = List.assoc uri c.rvars 
+				       in (uri,attl)) l (*latt = l + attributi*)
+	  in
+	   try
+	     let rec prod c = function
+	       	[] -> if (exec_boole_exp c bexp) then raise BooleExpTrue 
+	      | (uri,attl)::tail1 -> let rec sub_prod attl =
+			     	      match attl with
+(*per ogni el. di attl  *)		[] -> () 
+(*devo andare in ric. su tail1*)      | att::tail2 -> upd_groups c ((uri,att)::c.groups);             
+						       prod c tail1; sub_prod tail2 
+				     in	      
+			              sub_prod attl 
+   	     in
+	      prod c latt; false
+	   with BooleExpTrue -> true  
+   | _ -> assert false    
 
 (* valuta una MathQL.val_exp e ritorna un MathQL.value *)
 
-and exec_val_exp = function
-   | MathQL.Const x -> x
+and exec_val_exp c = function
+   | MathQL.Const x -> List.sort compare x
+   | MathQL.Record (rvar, vvar) -> List.assoc vvar (List.assoc rvar c.groups) 
+				  
+   | MathQL.VVar s -> List.assoc s c.vvars				  
+   | MathQL.RefOf sexp -> List.map (fun (s,_) -> s) (exec_set_exp c sexp)
+   
    | _ -> assert false
 
+
 (* valuta una MathQL.set_exp nel contesto vuoto e ritorna un MathQL.resource_set *)
 
-(* valuta una MathQL.set_exp e ritorna un MathQL.resource_set *)
-let execute x =
-   svars := []; rvars := []; groups := []; vvars := [];
-   exec_set_exp x
+and execute x =
+   exec_set_exp {svars = []; rvars = []; groups = []; vvars = []} x