X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Flexicon%2FlexiconEngine.ml;h=39d95a7f2cd02c5f503390286c502a08e7e09d08;hb=e83cd27fc0694c34baf35c8b80d32317e51be707;hp=6e3c1b53d2c5aff600c98ea970689c493dc737e1;hpb=ee3f8d6fa92b051394a2ff7c71c03ac33a05182b;p=helm.git

diff --git a/helm/software/components/lexicon/lexiconEngine.ml b/helm/software/components/lexicon/lexiconEngine.ml
index 6e3c1b53d..39d95a7f2 100644
--- a/helm/software/components/lexicon/lexiconEngine.ml
+++ b/helm/software/components/lexicon/lexiconEngine.ml
@@ -25,15 +25,19 @@
 
 (* $Id$ *)
 
-exception IncludedFileNotCompiled of string (* file name *)
+module L = LexiconAst
+
+let debug = ref false
+
+(* lexicon file name * ma file name *)
+exception IncludedFileNotCompiled of string * string 
 exception MetadataNotFound of string        (* file name *)
 
-type status = {
-  aliases: DisambiguateTypes.environment;         (** disambiguation aliases *)
-  multi_aliases: DisambiguateTypes.multiple_environment;
+type lexicon_status = {
+  aliases: L.alias_spec DisambiguateTypes.Environment.t;
+  multi_aliases: L.alias_spec list DisambiguateTypes.Environment.t;
   lexicon_content_rev: LexiconMarshal.lexicon;
   notation_ids: CicNotation.notation_id list;      (** in-scope notation ids *)
-  metadata: LibraryNoDb.metadata list;
 }
 
 let initial_status = {
@@ -41,128 +45,173 @@ let initial_status = {
   multi_aliases = DisambiguateTypes.Environment.empty;
   lexicon_content_rev = [];
   notation_ids = [];
-  metadata = [];
 }
 
+class type g_status =
+ object
+  method lstatus: lexicon_status
+ end
+
+class status =
+ object(self)
+  val lstatus = initial_status
+  method lstatus = lstatus
+  method set_lstatus v = {< lstatus = v >}
+  method set_lexicon_engine_status : 'status. #g_status as 'status -> 'self
+   = fun o -> self#set_lstatus o#lstatus
+ end
+
+let dump_aliases out msg status =
+   out (if msg = "" then "aliases dump:" else msg ^ ": aliases dump:");
+   DisambiguateTypes.Environment.iter
+      (fun _ x -> out (LexiconAstPp.pp_alias x))
+      status#lstatus.aliases
+   
 let add_lexicon_content cmds status =
-  let content = status.lexicon_content_rev in
+  let content = status#lstatus.lexicon_content_rev in
   let content' =
     List.fold_right
-     (fun cmd acc -> cmd :: (List.filter ((<>) cmd) acc))
+     (fun cmd acc -> 
+        match cmd with
+        | L.Alias _ 
+        | L.Include _ 
+        | L.Notation _ -> cmd :: (List.filter ((<>) cmd) acc)
+        | L.Interpretation _ -> if List.exists ((=) cmd) acc then acc else cmd::acc)
      cmds content
   in
-(*   prerr_endline ("new lexicon content: " ^ String.concat " " (List.map
-    LexiconAstPp.pp_command content')); *)
-  { status with lexicon_content_rev = content' }
-
-let add_metadata new_metadata status =
-  if Helm_registry.get_bool "db.nodb" then
-    let metadata = status.metadata in
-    let metadata' =
-      List.fold_left
-        (fun acc m ->
-          match m with
-          | LibraryNoDb.Dependency buri ->
-              if List.exists (LibraryNoDb.eq_metadata m) metadata
-              then acc
-              else m :: acc)
-        metadata new_metadata
-    in
-    { status with metadata = metadata' }
-  else
-    status
+(*   
+  prerr_endline ("new lexicon content: " ^ 
+     String.concat "; " (List.map LexiconAstPp.pp_command content')
+  );
+*)
+  status#set_lstatus
+   { status#lstatus with lexicon_content_rev = content' }
 
-let set_proof_aliases status new_aliases =
- let commands_of_aliases =
-   List.map
-    (fun alias -> LexiconAst.Alias (HExtlib.dummy_floc, alias))
- in
- let deps_of_aliases =
-   HExtlib.filter_map
-    (function
-    | LexiconAst.Ident_alias (_, suri) ->
-        let buri = UriManager.buri_of_uri (UriManager.uri_of_string suri) in
-        Some (LibraryNoDb.Dependency buri)
-    | _ -> None)
- in
- let aliases =
-  List.fold_left (fun acc (d,c) -> DisambiguateTypes.Environment.add d c acc)
-   status.aliases new_aliases in
- let multi_aliases =
-  List.fold_left (fun acc (d,c) -> DisambiguateTypes.Environment.cons d c acc)
-   status.multi_aliases new_aliases in
- let new_status =
-   { status with multi_aliases = multi_aliases ; aliases = aliases}
- in
- if new_aliases = [] then
-   new_status
+let set_proof_aliases mode status new_aliases =
+ if mode = L.WithoutPreferences then
+   status 
  else
-   let aliases = 
-     DisambiguatePp.aliases_of_domain_and_codomain_items_list new_aliases
+   let commands_of_aliases =
+     List.map
+      (fun _,alias -> L.Alias (HExtlib.dummy_floc, alias))
    in
-   let status = add_lexicon_content (commands_of_aliases aliases) new_status in
-   let status = add_metadata (deps_of_aliases aliases) status in
-   status
+   let aliases =
+    List.fold_left (fun acc (d,c) -> DisambiguateTypes.Environment.add d c acc)
+     status#lstatus.aliases new_aliases in
+   let multi_aliases =
+    List.fold_left (fun acc (d,c) -> 
+      DisambiguateTypes.Environment.cons L.description_of_alias 
+         d c acc)
+     status#lstatus.multi_aliases new_aliases
+   in
+   let new_status =
+     { status#lstatus with
+        multi_aliases = multi_aliases ; aliases = aliases} in
+   let new_status = status#set_lstatus new_status in
+    if new_aliases = [] then
+      new_status
+    else
+      add_lexicon_content (commands_of_aliases new_aliases) new_status 
 
-let rec eval_command status cmd =
+let rec eval_command ?(mode=L.WithPreferences) sstatus cmd =
+(*
+ let bmode = match mode with L.WithPreferences -> true | _ -> false in
+ Printf.eprintf "Include preferences: %b\n" bmode;
+*) 
+ let status = sstatus#lstatus in
+ let cmd =
+  match cmd with
+  | L.Interpretation (loc, dsc, (symbol, args), cic_appl_pattern) ->
+     let rec disambiguate =
+      function
+         CicNotationPt.ApplPattern l ->
+          CicNotationPt.ApplPattern (List.map disambiguate l)
+       | CicNotationPt.VarPattern id
+          when not
+           (List.exists
+            (function (CicNotationPt.IdentArg (_,id')) -> id'=id) args)
+          ->
+           let item = DisambiguateTypes.Id id in
+            begin try
+              match DisambiguateTypes.Environment.find item status.aliases with
+                 L.Ident_alias (_, uri) ->
+                  (try
+                    CicNotationPt.NRefPattern
+                     (NReference.reference_of_string uri)
+                   with
+                    NReference.IllFormedReference _ ->
+                     CicNotationPt.UriPattern (UriManager.uri_of_string uri))
+               | _ -> assert false
+             with Not_found -> 
+              prerr_endline ("LexiconEngine.eval_command: domain item not found: " ^ 
+               (DisambiguateTypes.string_of_domain_item item));
+	      dump_aliases prerr_endline "" sstatus;
+              raise (Failure (
+                      (DisambiguateTypes.string_of_domain_item item) ^ 
+                      " not found"));
+	    end
+       | p -> p
+     in
+      L.Interpretation
+       (loc, dsc, (symbol, args), disambiguate cic_appl_pattern)
+  | _-> cmd
+ in
  let notation_ids' = CicNotation.process_notation cmd in
  let status =
    { status with notation_ids = notation_ids' @ status.notation_ids } in
+ let sstatus = sstatus#set_lstatus status in
   match cmd with
-  | LexiconAst.Include (loc, baseuri) ->
+  | L.Include (loc, baseuri, mode, fullpath) ->
      let lexiconpath_rw, lexiconpath_r = 
-       LibraryMisc.lexicon_file_of_baseuri ~writable:true ~baseuri,
-       LibraryMisc.lexicon_file_of_baseuri ~writable:false ~baseuri
+       LibraryMisc.lexicon_file_of_baseuri 
+         ~must_exist:false ~writable:true ~baseuri,
+       LibraryMisc.lexicon_file_of_baseuri 
+         ~must_exist:false ~writable:false ~baseuri
      in
      let lexiconpath = 
        if Sys.file_exists lexiconpath_rw then lexiconpath_rw else
          if Sys.file_exists lexiconpath_r then lexiconpath_r else
-          raise (IncludedFileNotCompiled lexiconpath_rw)
+          raise (IncludedFileNotCompiled (lexiconpath_rw,fullpath))
      in
      let lexicon = LexiconMarshal.load_lexicon lexiconpath in
-     let status = List.fold_left eval_command status lexicon in
-      if Helm_registry.get_bool "db.nodb" then
-       let metadatapath_rw, metadatapath_r = 
-         LibraryMisc.metadata_file_of_baseuri ~baseuri ~writable:true,
-         LibraryMisc.metadata_file_of_baseuri ~baseuri ~writable:false
-       in
-       let metadatapath =
-        if Sys.file_exists metadatapath_rw then metadatapath_rw else
-         if Sys.file_exists metadatapath_r then metadatapath_r else
-           raise (MetadataNotFound metadatapath_rw)
-       in
-         add_metadata (LibraryNoDb.load_metadata ~fname:metadatapath) status
-      else
-         status
-  | LexiconAst.Alias (loc, spec) -> 
+      List.fold_left (eval_command ~mode) sstatus lexicon
+  | L.Alias (loc, spec) -> 
      let diff =
       (*CSC: Warning: this code should be factorized with the corresponding
              code in DisambiguatePp *)
       match spec with
-      | LexiconAst.Ident_alias (id,uri) -> 
-         [DisambiguateTypes.Id id,
-          (uri,(fun _ _ _-> CicUtil.term_of_uri(UriManager.uri_of_string uri)))]
-      | LexiconAst.Symbol_alias (symb, instance, desc) ->
-         [DisambiguateTypes.Symbol (symb,instance),
-          DisambiguateChoices.lookup_symbol_by_dsc symb desc]
-      | LexiconAst.Number_alias (instance,desc) ->
-         [DisambiguateTypes.Num instance,
-          DisambiguateChoices.lookup_num_by_dsc desc]
+      | L.Ident_alias (id,uri) -> 
+         [DisambiguateTypes.Id id,spec]
+      | L.Symbol_alias (symb, instance, desc) ->
+         [DisambiguateTypes.Symbol (symb,instance),spec]
+      | L.Number_alias (instance,desc) ->
+         [DisambiguateTypes.Num instance,spec]
      in
-      set_proof_aliases status diff
-  | LexiconAst.Interpretation (_, dsc, (symbol, _), cic_appl_pattern) as stm ->
-      let status = add_lexicon_content [stm] status in
-      let uris =
-        List.map
-          (fun uri -> LibraryNoDb.Dependency (UriManager.buri_of_uri uri))
-          (CicNotationUtil.find_appl_pattern_uris cic_appl_pattern)
-      in
+      set_proof_aliases mode sstatus diff
+  | L.Interpretation (_, dsc, (symbol, _), _) as stm ->
+      let sstatus = add_lexicon_content [stm] sstatus in
       let diff =
-       [DisambiguateTypes.Symbol (symbol, 0),
-         DisambiguateChoices.lookup_symbol_by_dsc symbol dsc]
+       try
+        [DisambiguateTypes.Symbol (symbol, 0),
+          L.Symbol_alias (symbol,0,dsc)]
+       with
+        DisambiguateChoices.Choice_not_found msg ->
+          prerr_endline (Lazy.force msg);
+          assert false
       in
-      let status = set_proof_aliases status diff in
-      let status = add_metadata uris status in
-      status
-  | LexiconAst.Notation _ as stm -> add_lexicon_content [stm] status
+      let sstatus = set_proof_aliases mode sstatus diff in
+      sstatus
+  | L.Notation _ as stm ->
+      add_lexicon_content [stm] sstatus
+
+let eval_command status cmd = 
+   if !debug then dump_aliases prerr_endline "before eval_command" status;
+   let status = eval_command ?mode:None status cmd in
+   if !debug then dump_aliases prerr_endline "after eval_command" status;
+   status
 
+let set_proof_aliases status aliases =
+   if !debug then dump_aliases prerr_endline "before set_proof_aliases" status;
+   let status = set_proof_aliases L.WithPreferences status aliases in
+   if !debug then dump_aliases prerr_endline "after set_proof_aliases" status;
+   status