- List.fold_left (fun status sort -> elim sort status) status
- [ Cic.Prop; Cic.Set; (Cic.Type (CicUniv.fresh ())) ]
-
-let generate_projections uri fields status =
- let projections = CicRecord.projections_of uri fields in
- List.fold_left
- (fun status (uri, name, bo) ->
- try
- let ty, ugraph =
- CicTypeChecker.type_of_aux' [] [] bo CicUniv.empty_ugraph in
- let bo = Unshare.unshare bo in
- let ty = Unshare.unshare ty in
- let attrs = [`Class `Projection; `Generated] in
- let obj = Cic.Constant (name,Some bo,ty,[],attrs) in
- MatitaSync.add_obj uri obj status
- with
- CicTypeChecker.TypeCheckerFailure s ->
- MatitaLog.message
- ("Unable to create projection " ^ name ^ " cause: " ^ s);
- status
- | CicEnvironment.Object_not_found uri ->
- let depend = UriManager.name_of_uri uri in
- MatitaLog.message
- ("Unable to create projection " ^ name ^ " because it requires " ^ depend);
- status
- ) status projections
-
-let eval_command status cmd =
- match cmd with
- | TacticAst.Set (loc, name, value) ->
- let value =
- if name = "baseuri" then
- MatitaMisc.strip_trailing_slash value
- else
- value
- in
- set_option status name value
- | TacticAst.Drop loc -> raise Drop
- | TacticAst.Qed loc ->
- let uri, metasenv, bo, ty =
- match status.proof_status with
- | Proof (Some uri, metasenv, body, ty) ->
- uri, metasenv, body, ty
- | Proof (None, metasenv, body, ty) ->
- command_error
- ("Someone allows to start a thm without giving the "^
- "name/uri. This should be fixed!")
- | _-> command_error "You can't qed an uncomplete theorem"
- in
- let suri = UriManager.string_of_uri uri in
- if metasenv <> [] then
- command_error "Proof not completed! metasenv is not empty!";
- let name = UriManager.name_of_uri uri in
- let obj = Cic.Constant (name,Some bo,ty,[],[]) in
- MatitaSync.add_obj uri obj status
- | TacticAst.Coercion (loc, coercion) ->
- eval_coercion status coercion
- | TacticAst.Alias (loc, spec) ->
- (match spec with
- | TacticAst.Ident_alias (id,uri) ->
- {status with aliases =
- DisambiguateTypes.Environment.add
- (DisambiguateTypes.Id id)
- ("boh?",(fun _ _ _ -> CicUtil.term_of_uri (UriManager.uri_of_string uri)))
- status.aliases }
- | TacticAst.Symbol_alias (symb, instance, desc) ->
- {status with aliases =
- DisambiguateTypes.Environment.add
- (DisambiguateTypes.Symbol (symb,instance))
- (DisambiguateChoices.lookup_symbol_by_dsc symb desc)
- status.aliases }
- | TacticAst.Number_alias (instance,desc) ->
- {status with aliases =
- DisambiguateTypes.Environment.add
- (DisambiguateTypes.Num instance)
- (DisambiguateChoices.lookup_num_by_dsc desc) status.aliases })
- | TacticAst.Obj (loc,obj) ->
- let ext,name =
- match obj with
- Cic.Constant (name,_,_,_,_)
- | Cic.CurrentProof (name,_,_,_,_,_) -> ".con",name
- | Cic.InductiveDefinition (types,_,_,_) ->
- ".ind",
- (match types with (name,_,_,_)::_ -> name | _ -> assert false)
- | _ -> assert false in
- let uri =
- UriManager.uri_of_string (MatitaMisc.qualify status name ^ ext)
- in
- let metasenv = MatitaMisc.get_proof_metasenv status in
- match obj with
- Cic.CurrentProof (_,metasenv',bo,ty,_,_) ->
- assert (metasenv = metasenv');
- let goalno =
- match metasenv' with (goalno,_,_)::_ -> goalno | _ -> assert false in
- let initial_proof = (Some uri, metasenv, bo, ty) in
- { status with proof_status = Incomplete_proof (initial_proof,goalno)}
- | _ ->
- if metasenv <> [] then
- command_error (
- "metasenv not empty while giving a definition with body: " ^
- CicMetaSubst.ppmetasenv metasenv []);
- let status = MatitaSync.add_obj uri obj status in
- match obj with
- Cic.Constant _ -> status
- | Cic.InductiveDefinition (_,_,_,attrs) ->
- let status = generate_elimination_principles uri status in
- let rec get_record_attrs =
- function
- [] -> None
- | (`Class (`Record fields))::_ -> Some fields
- | _::tl -> get_record_attrs tl
- in
- (match get_record_attrs attrs with
- None -> status (* not a record *)
- | Some fields -> generate_projections uri fields status)
- | Cic.CurrentProof _
- | Cic.Variable _ -> assert false
-
-let eval_executable status ex =
- match ex with
- | TacticAst.Tactical (_, tac) -> eval_tactical status tac
- | TacticAst.Command (_, cmd) -> eval_command status cmd
- | TacticAst.Macro (_, mac) ->
- command_error (sprintf "The macro %s can't be in a script"
- (TacticAstPp.pp_macro_cic mac))
-
-let eval_comment status c = status
-
-let eval status st =
- match st with
- | TacticAst.Executable (_,ex) -> eval_executable status ex
- | TacticAst.Comment (_,c) -> eval_comment status c
-
-let disambiguate_term status term =
- let (aliases, metasenv, cic, _) =
- match
- MatitaDisambiguator.disambiguate_term ~dbd:(MatitaDb.instance ())
- ~aliases:(status.aliases) ~context:(MatitaMisc.get_proof_context status)
- ~metasenv:(MatitaMisc.get_proof_metasenv status) term
- with
- | [x] -> x
- | _ -> assert false
- in
- let proof_status =
- match status.proof_status with
- | No_proof -> Intermediate metasenv
- | Incomplete_proof ((uri, _, proof, ty), goal) ->
- Incomplete_proof ((uri, metasenv, proof, ty), goal)
- | Intermediate _ -> Intermediate metasenv
- | Proof _ -> assert false
- in
- let status =
- { status with
- aliases = aliases;
- proof_status = proof_status }
- in
- status, cic
-
-let disambiguate_obj status obj =
- let uri =
- match obj with
- TacticAst.Inductive (_,(name,_,_,_)::_)
- | TacticAst.Record (_,name,_,_) ->
- Some (UriManager.uri_of_string (MatitaMisc.qualify status name ^ ".ind"))
- | TacticAst.Inductive _ -> assert false
- | _ -> None in
- let (aliases, metasenv, cic, _) =
- match
- MatitaDisambiguator.disambiguate_obj ~dbd:(MatitaDb.instance ())
- ~aliases:(status.aliases) ~uri obj
- with
- | [x] -> x
- | _ -> assert false
- in
- let proof_status =
- match status.proof_status with
- | No_proof -> Intermediate metasenv
- | Incomplete_proof _
- | Intermediate _
- | Proof _ -> assert false
- in
- let status =
- { status with
- aliases = aliases;
- proof_status = proof_status }
- in
- status, cic
-
-let disambiguate_pattern status (wanted, hyp_paths, goal_path) =
- let interp path = Disambiguate.interpretate_path [] status.aliases path in
- let goal_path = interp goal_path in
- let hyp_paths = List.map (fun (name, path) -> name, interp path) hyp_paths in
- let status,wanted =
- match wanted with
- None -> status,None
- | Some wanted ->
- let status,wanted = disambiguate_term status wanted in
- status, Some wanted
- in
- status, (wanted, hyp_paths ,goal_path)
-
-let disambiguate_tactic status = function
- | TacticAst.Apply (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Apply (loc, cic)
- | TacticAst.Absurd (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Absurd (loc, cic)
- | TacticAst.Assumption loc -> status, TacticAst.Assumption loc
- | TacticAst.Auto (loc,depth,width) -> status, TacticAst.Auto (loc,depth,width)
- | TacticAst.Change (loc, pattern, with_what) ->
- let status, with_what = disambiguate_term status with_what in
- let status, pattern = disambiguate_pattern status pattern in
- status, TacticAst.Change (loc, pattern, with_what)
- | TacticAst.Clear (loc,id) -> status,TacticAst.Clear (loc,id)
- | TacticAst.ClearBody (loc,id) -> status,TacticAst.ClearBody (loc,id)
- | TacticAst.Compare (loc,term) ->
- let status, term = disambiguate_term status term in
- status, TacticAst.Compare (loc,term)
- | TacticAst.Constructor (loc,n) ->
- status, TacticAst.Constructor (loc,n)
- | TacticAst.Contradiction loc ->
- status, TacticAst.Contradiction loc
- | TacticAst.Cut (loc, ident, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Cut (loc, ident, cic)
- | TacticAst.DecideEquality loc ->
- status, TacticAst.DecideEquality loc
- | TacticAst.Decompose (loc,term) ->
- let status,term = disambiguate_term status term in
- status, TacticAst.Decompose(loc,term)
- | TacticAst.Discriminate (loc,term) ->
- let status,term = disambiguate_term status term in
- status, TacticAst.Discriminate(loc,term)
- | TacticAst.Exact (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Exact (loc, cic)
- | TacticAst.Elim (loc, term, Some term') ->
- let status, cic1 = disambiguate_term status term in
- let status, cic2 = disambiguate_term status term' in
- status, TacticAst.Elim (loc, cic1, Some cic2)
- | TacticAst.Elim (loc, term, None) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Elim (loc, cic, None)
- | TacticAst.ElimType (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.ElimType (loc, cic)
- | TacticAst.Exists loc -> status, TacticAst.Exists loc
- | TacticAst.Fail loc -> status,TacticAst.Fail loc
- | TacticAst.Fold (loc,reduction_kind, pattern) ->
- let status, pattern = disambiguate_pattern status pattern in
- status, TacticAst.Fold (loc,reduction_kind, pattern)
- | TacticAst.FwdSimpl (loc, term) ->
- let status, term = disambiguate_term status term in
- status, TacticAst.FwdSimpl (loc, term)
- | TacticAst.Fourier loc -> status, TacticAst.Fourier loc
- | TacticAst.Generalize (loc,pattern,ident) ->
- let status, pattern = disambiguate_pattern status pattern in
- status, TacticAst.Generalize(loc,pattern,ident)
- | TacticAst.Goal (loc, g) -> status, TacticAst.Goal (loc, g)
- | TacticAst.IdTac loc -> status,TacticAst.IdTac loc
- | TacticAst.Injection (loc,term) ->
- let status, term = disambiguate_term status term in
- status, TacticAst.Injection (loc,term)
- | TacticAst.Intros (loc, num, names) ->
- status, TacticAst.Intros (loc, num, names)
- | TacticAst.LApply (loc, to_what, what, ident) ->
- let status, to_what =
- match to_what with
- None -> status,None
- | Some to_what ->
- let status, to_what = disambiguate_term status to_what in
- status, Some to_what
- in
- let status, what = disambiguate_term status what in
- status, TacticAst.LApply (loc, to_what, what, ident)
- | TacticAst.Left loc -> status, TacticAst.Left loc
- | TacticAst.LetIn (loc, term, name) ->
- let status, term = disambiguate_term status term in
- status, TacticAst.LetIn (loc,term,name)
- | TacticAst.Reduce (loc, reduction_kind, pattern) ->
- let status, pattern = disambiguate_pattern status pattern in
- status, TacticAst.Reduce(loc, reduction_kind, pattern)
- | TacticAst.Reflexivity loc -> status, TacticAst.Reflexivity loc
- | TacticAst.Replace (loc, pattern, with_what) ->
- let status, pattern = disambiguate_pattern status pattern in
- let status, with_what = disambiguate_term status with_what in
- status, TacticAst.Replace (loc, pattern, with_what)
- | TacticAst.Rewrite (loc, dir, t, pattern) ->
- let status, term = disambiguate_term status t in
- let status, pattern = disambiguate_pattern status pattern in
- status, TacticAst.Rewrite (loc, dir, term, pattern)
- | TacticAst.Right loc -> status, TacticAst.Right loc
- | TacticAst.Ring loc -> status, TacticAst.Ring loc
- | TacticAst.Split loc -> status, TacticAst.Split loc
- | TacticAst.Symmetry loc -> status, TacticAst.Symmetry loc
- | TacticAst.Transitivity (loc, term) ->
- let status, cic = disambiguate_term status term in
- status, TacticAst.Transitivity (loc, cic)
-
-let rec disambiguate_tactical status = function
- | TacticAst.Tactic (loc, tactic) ->
- let status, tac = disambiguate_tactic status tactic in
- status, TacticAst.Tactic (loc, tac)
- | TacticAst.Do (loc, num, tactical) ->
- let status, tac = disambiguate_tactical status tactical in
- status, TacticAst.Do (loc, num, tac)
- | TacticAst.Repeat (loc, tactical) ->
- let status, tac = disambiguate_tactical status tactical in
- status, TacticAst.Repeat (loc, tac)
- | TacticAst.Seq (loc, tacticals) -> (* tac1; tac2; ... *)
- let status, tacticals = disambiguate_tacticals status tacticals in
- let tacticals = List.rev tacticals in
- status, TacticAst.Seq (loc, tacticals)
- | TacticAst.Then (loc, tactical, tacticals) -> (* tac; [ tac1 | ... ] *)
- let status, tactical = disambiguate_tactical status tactical in
- let status, tacticals = disambiguate_tacticals status tacticals in
- status, TacticAst.Then (loc, tactical, tacticals)
- | TacticAst.Tries (loc, tacticals) ->
- let status, tacticals = disambiguate_tacticals status tacticals in
- status, TacticAst.Tries (loc, tacticals)
- | TacticAst.Try (loc, tactical) ->
- let status, tactical = disambiguate_tactical status tactical in
- status, TacticAst.Try (loc, tactical)
-
-and disambiguate_tacticals status tacticals =
- let status, tacticals =
- List.fold_left
- (fun (status, tacticals) tactical ->
- let status, tac = disambiguate_tactical status tactical in
- status, tac :: tacticals)
- (status, [])
- tacticals
- in
- let tacticals = List.rev tacticals in
- status, tacticals
-
-let disambiguate_command status = function
- | TacticAst.Coercion (loc, term) ->
- let status, term = disambiguate_term status term in
- status, TacticAst.Coercion (loc,term)
- | (TacticAst.Set _ | TacticAst.Qed _ | TacticAst.Drop _ ) as cmd ->
- status, cmd
- | TacticAst.Alias _ as x -> status, x
- | TacticAst.Obj (loc,obj) ->
- let status,obj = disambiguate_obj status obj in
- status, TacticAst.Obj (loc,obj)
-
-let disambiguate_executable status ex =
- match ex with
- | TacticAst.Tactical (loc, tac) ->
- let status, tac = disambiguate_tactical status tac in
- status, (TacticAst.Tactical (loc, tac))
- | TacticAst.Command (loc, cmd) ->
- let status, cmd = disambiguate_command status cmd in
- status, (TacticAst.Command (loc, cmd))
- | TacticAst.Macro (_, mac) ->
- command_error (sprintf "The macro %s can't be in a script"
- (TacticAstPp.pp_macro_ast mac))
-
-let disambiguate_comment status c =
- match c with
- | TacticAst.Note (loc,n) -> status, TacticAst.Note (loc,n)
- | TacticAst.Code (loc,ex) ->
- let status, ex = disambiguate_executable status ex in
- status, TacticAst.Code (loc,ex)
-
-let disambiguate_statement status statement =
- match statement with
- | TacticAst.Comment (loc,c) ->
- let status, c = disambiguate_comment status c in
- status, TacticAst.Comment (loc,c)
- | TacticAst.Executable (loc,ex) ->
- let status, ex = disambiguate_executable status ex in
- status, TacticAst.Executable (loc,ex)
-
-let eval_ast status ast =
- let status,st = disambiguate_statement status ast in
- (* this disambiguation step should be deferred to support tacticals *)
- eval status st
-
-let eval_from_stream status str cb =
- let stl = CicTextualParser2.parse_statements str in
- List.iter (fun ast -> cb !status ast;status := eval_ast !status ast) stl
-
-let eval_from_stream_greedy status str cb =
- while true do
- print_string "matita> ";
- flush stdout;
- let ast = CicTextualParser2.parse_statement str in
- cb !status ast;
- status := eval_ast !status ast
- done
-
-let eval_string status str =
- eval_from_stream status (Stream.of_string str) (fun _ _ -> ())
-
-let default_options () =
-(*
- let options =
- StringMap.add "baseuri"
- (String
- (Helm_registry.get "matita.baseuri" ^ Helm_registry.get "matita.owner"))
- no_options
- in
-*)
- let options =
- StringMap.add "basedir"
- (String (Helm_registry.get "matita.basedir" ))
- no_options
- in
- options
-
-let initial_status =
- lazy {
- aliases = DisambiguateTypes.empty_environment;
- proof_status = No_proof;
- options = default_options ();
- objects = [];
- }
-
-