103 lines
4.1 KiB
C++
103 lines
4.1 KiB
C++
/*
|
|
Copyright (c) 2014 Microsoft Corporation. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
|
|
Author: Leonardo de Moura
|
|
*/
|
|
#pragma once
|
|
#include "kernel/pos_info_provider.h"
|
|
#include "library/tactic/tactic.h"
|
|
#include "library/tactic/elaborate.h"
|
|
|
|
namespace lean {
|
|
/**
|
|
\brief Return true iff the environment \c env contains the following declarations
|
|
in the namespace 'tactic'
|
|
tactic.builtin : tactic
|
|
and_then : tactic -> tactic -> tactic
|
|
or_else : tactic -> tactic -> tactic
|
|
repeat : tactic -> tactic
|
|
*/
|
|
bool has_tactic_decls(environment const & env);
|
|
|
|
/**
|
|
\brief Creates a tactic by 'executing' \c e. Definitions are unfolded, whnf procedure is invoked,
|
|
and definitions marked as 'tactic.builtin' are handled by the code registered using
|
|
\c register_expr_to_tactic.
|
|
*/
|
|
tactic expr_to_tactic(environment const & env, elaborate_fn const & fn, expr const & e, pos_info_provider const * p);
|
|
// auxiliary procedure used to compile nested tactic in tacticals
|
|
tactic expr_to_tactic(type_checker & tc, elaborate_fn const & fn, expr e, pos_info_provider const * p);
|
|
|
|
name const & get_tactic_name();
|
|
|
|
unsigned get_unsigned_arg(type_checker & tc, expr const & e, unsigned i);
|
|
optional<unsigned> get_optional_unsigned(type_checker & tc, expr const & e);
|
|
|
|
expr const & get_tactic_expr_type();
|
|
expr const & get_tactic_identifier_type();
|
|
expr mk_tactic_expr(expr const & e);
|
|
bool is_tactic_expr(expr const & e);
|
|
expr const & get_tactic_expr_expr(expr const & e);
|
|
void check_tactic_expr(expr const & e, char const * msg);
|
|
expr const & get_tactic_expr_list_type();
|
|
expr const & get_tactic_using_expr_type();
|
|
|
|
expr mk_expr_list(unsigned num, expr const * args);
|
|
|
|
name const & tactic_expr_to_id(expr e, char const * error_msg);
|
|
void get_tactic_expr_list_elements(expr l, buffer<expr> & r, char const * error_msg);
|
|
void get_tactic_id_list_elements(expr l, buffer<name> & r, char const * error_msg);
|
|
expr ids_to_tactic_expr(buffer<name> const & ids);
|
|
|
|
/**
|
|
\brief Create an expression `by t`, where \c t is an expression of type `tactic`.
|
|
This kind of expression only affects the elaborator, the kernel will reject
|
|
any declaration that contains it.
|
|
|
|
\post get_by_arg(mk_by(t)) == t
|
|
\post is_by(mk_by(t))
|
|
*/
|
|
expr mk_by(expr const & t);
|
|
/** \brief Return true iff \c t is an expression created using \c mk_by */
|
|
bool is_by(expr const & t);
|
|
/** \see mk_by */
|
|
expr const & get_by_arg(expr const & t);
|
|
|
|
// Similar to mk_by, but instructs the elaborator to include the whole context
|
|
expr mk_by_plus(expr const & t);
|
|
bool is_by_plus(expr const & t);
|
|
expr const & get_by_plus_arg(expr const & t);
|
|
|
|
expr const & get_tactic_type();
|
|
expr const & get_and_then_tac_fn();
|
|
expr const & get_or_else_tac_fn();
|
|
expr const & get_id_tac_fn();
|
|
expr const & get_repeat_tac_fn();
|
|
expr const & get_determ_tac_fn();
|
|
|
|
/** \brief Exception used to report a problem when an expression is being converted into a tactic. */
|
|
class expr_to_tactic_exception : public exception {
|
|
expr m_expr;
|
|
public:
|
|
expr_to_tactic_exception(expr const & e, char const * msg):exception(msg), m_expr(e) {}
|
|
expr_to_tactic_exception(expr const & e, sstream const & strm):exception(strm), m_expr(e) {}
|
|
expr const & get_expr() const { return m_expr; }
|
|
};
|
|
|
|
typedef std::function<tactic(type_checker &, elaborate_fn const & fn, expr const &, pos_info_provider const *)>
|
|
expr_to_tactic_fn;
|
|
|
|
/** \brief Register a new "procedural attachment" for expr_to_tactic. */
|
|
void register_tac(name const & n, expr_to_tactic_fn const & fn);
|
|
// remark: we cannot use "std::function <...> const &" in the following procedures, for some obscure reason it produces
|
|
// memory leaks when we compile using clang 3.3
|
|
void register_simple_tac(name const & n, std::function<tactic()> f);
|
|
void register_bin_tac(name const & n, std::function<tactic(tactic const &, tactic const &)> f);
|
|
void register_unary_tac(name const & n, std::function<tactic(tactic const &)> f);
|
|
void register_unary_num_tac(name const & n, std::function<tactic(tactic const &, unsigned)> f);
|
|
void register_num_tac(name const & n, std::function<tactic(unsigned k)> f);
|
|
|
|
void initialize_expr_to_tactic();
|
|
void finalize_expr_to_tactic();
|
|
}
|