2238 lines
86 KiB
C++
2238 lines
86 KiB
C++
/*
|
|
Copyright (c) 2013 Microsoft Corporation. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
|
|
Author: Leonardo de Moura
|
|
*/
|
|
#ifdef LEAN_USE_READLINE
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <algorithm>
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
#endif
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <vector>
|
|
#include "util/scoped_map.h"
|
|
#include "util/exception.h"
|
|
#include "util/sstream.h"
|
|
#include "util/script_state.h"
|
|
#include "util/script_exception.h"
|
|
#include "util/interrupt.h"
|
|
#include "util/sexpr/option_declarations.h"
|
|
#include "kernel/normalizer.h"
|
|
#include "kernel/type_checker.h"
|
|
#include "kernel/free_vars.h"
|
|
#include "kernel/builtin.h"
|
|
#include "kernel/kernel_exception.h"
|
|
#include "kernel/expr_maps.h"
|
|
#include "kernel/printer.h"
|
|
#include "kernel/metavar.h"
|
|
#include "kernel/for_each_fn.h"
|
|
#include "kernel/type_checker_justification.h"
|
|
#include "library/expr_lt.h"
|
|
#include "library/type_inferer.h"
|
|
#include "library/arith/arith.h"
|
|
#include "library/io_state.h"
|
|
#include "library/placeholder.h"
|
|
#include "library/kernel_bindings.h"
|
|
#include "library/elaborator/elaborator_exception.h"
|
|
#include "library/tactic/proof_state.h"
|
|
#include "library/tactic/tactic.h"
|
|
#include "library/tactic/apply_tactic.h"
|
|
#include "library/elaborator/elaborator.h"
|
|
#include "frontends/lean/frontend.h"
|
|
#include "frontends/lean/frontend_elaborator.h"
|
|
#include "frontends/lean/parser.h"
|
|
#include "frontends/lean/scanner.h"
|
|
#include "frontends/lean/notation.h"
|
|
#include "frontends/lean/pp.h"
|
|
|
|
#ifndef LEAN_DEFAULT_PARSER_SHOW_ERRORS
|
|
#define LEAN_DEFAULT_PARSER_SHOW_ERRORS true
|
|
#endif
|
|
|
|
#ifndef LEAN_DEFAULT_PARSER_VERBOSE
|
|
#define LEAN_DEFAULT_PARSER_VERBOSE true
|
|
#endif
|
|
|
|
namespace lean {
|
|
// ==========================================
|
|
// Parser configuration options
|
|
static name g_parser_verbose {"lean", "parser", "verbose"};
|
|
static name g_parser_show_errors {"lean", "parser", "show_errors"};
|
|
|
|
RegisterBoolOption(g_parser_verbose, LEAN_DEFAULT_PARSER_VERBOSE, "(lean parser) disable/enable parser verbose messages");
|
|
RegisterBoolOption(g_parser_show_errors, LEAN_DEFAULT_PARSER_SHOW_ERRORS, "(lean parser) display error messages in the regular output channel");
|
|
|
|
bool get_parser_verbose(options const & opts) { return opts.get_bool(g_parser_verbose, LEAN_DEFAULT_PARSER_VERBOSE); }
|
|
bool get_parser_show_errors(options const & opts) { return opts.get_bool(g_parser_show_errors, LEAN_DEFAULT_PARSER_SHOW_ERRORS); }
|
|
// ==========================================
|
|
|
|
// ==========================================
|
|
// Builtin commands
|
|
static name g_definition_kwd("Definition");
|
|
static name g_variable_kwd("Variable");
|
|
static name g_variables_kwd("Variables");
|
|
static name g_theorem_kwd("Theorem");
|
|
static name g_axiom_kwd("Axiom");
|
|
static name g_universe_kwd("Universe");
|
|
static name g_eval_kwd("Eval");
|
|
static name g_show_kwd("Show");
|
|
static name g_check_kwd("Check");
|
|
static name g_infix_kwd("Infix");
|
|
static name g_infixl_kwd("Infixl");
|
|
static name g_infixr_kwd("Infixr");
|
|
static name g_notation_kwd("Notation");
|
|
static name g_echo_kwd("Echo");
|
|
static name g_set_kwd("Set");
|
|
static name g_options_kwd("Options");
|
|
static name g_env_kwd("Environment");
|
|
static name g_import_kwd("Import");
|
|
static name g_help_kwd("Help");
|
|
static name g_coercion_kwd("Coercion");
|
|
static name g_exit_kwd("Exit");
|
|
static name g_apply("apply");
|
|
static name g_done("done");
|
|
static name g_back("back");
|
|
static name g_abort("abort");
|
|
static name g_assumption("assumption");
|
|
static list<name> g_tactic_cmds = { g_apply, g_done, g_back, g_abort, g_assumption };
|
|
/** \brief Table/List with all builtin command keywords */
|
|
static list<name> g_command_keywords = {g_definition_kwd, g_variable_kwd, g_variables_kwd, g_theorem_kwd, g_axiom_kwd, g_universe_kwd, g_eval_kwd,
|
|
g_show_kwd, g_check_kwd, g_infix_kwd, g_infixl_kwd, g_infixr_kwd, g_notation_kwd, g_echo_kwd,
|
|
g_set_kwd, g_env_kwd, g_options_kwd, g_import_kwd, g_help_kwd, g_coercion_kwd, g_exit_kwd};
|
|
// ==========================================
|
|
|
|
// ==========================================
|
|
// Support for parsing levels
|
|
static name g_max_name("max");
|
|
static name g_cup_name("\u2294");
|
|
static name g_plus_name("+");
|
|
static unsigned g_level_plus_prec = 10;
|
|
static unsigned g_level_cup_prec = 5;
|
|
// ==========================================
|
|
|
|
// A name that can't be created by the user.
|
|
// It is used as placeholder for parsing A -> B expressions which
|
|
// are syntax sugar for (Pi (_ : A), B)
|
|
static name g_unused = name::mk_internal_unique_name();
|
|
|
|
/**
|
|
\brief Actual implementation for the parser functional object
|
|
|
|
\remark It is an instance of a Pratt parser
|
|
(http://en.wikipedia.org/wiki/Pratt_parser) described in the paper
|
|
"Top down operator precedence". This algorithm is super simple,
|
|
and it is easy to support user-defined infix/prefix/postfix/mixfix
|
|
operators.
|
|
*/
|
|
class parser::imp {
|
|
typedef scoped_map<name, unsigned, name_hash, name_eq> local_decls;
|
|
typedef std::unordered_map<name, expr, name_hash, name_eq> builtins;
|
|
typedef std::pair<unsigned, unsigned> pos_info;
|
|
typedef expr_map<pos_info> expr_pos_info;
|
|
typedef expr_map<tactic> tactic_hints; // a mapping from placeholder to tactic
|
|
typedef buffer<std::tuple<pos_info, name, expr, bool>> bindings_buffer;
|
|
frontend & m_frontend;
|
|
scanner m_scanner;
|
|
frontend_elaborator m_elaborator;
|
|
type_inferer m_type_inferer;
|
|
scanner::token m_curr;
|
|
bool m_use_exceptions;
|
|
bool m_interactive;
|
|
bool m_found_errors;
|
|
local_decls m_local_decls;
|
|
unsigned m_num_local_decls;
|
|
expr_pos_info m_expr_pos_info;
|
|
pos_info m_last_cmd_pos;
|
|
pos_info m_last_script_pos;
|
|
tactic_hints m_tactic_hints;
|
|
|
|
script_state * m_script_state;
|
|
|
|
bool m_verbose;
|
|
bool m_show_errors;
|
|
|
|
/** \brief Exception used to track parsing erros, it does not leak outside of this class. */
|
|
struct parser_error : public exception {
|
|
pos_info m_pos;
|
|
parser_error(char const * msg, pos_info const & p):exception(msg), m_pos(p) {}
|
|
parser_error(sstream const & msg, pos_info const & p):exception(msg), m_pos(p) {}
|
|
virtual exception * clone() const { return new parser_error(m_msg.c_str(), m_pos); }
|
|
virtual void rethrow() const { throw *this; }
|
|
};
|
|
|
|
struct tactic_cmd_error : public parser_error {
|
|
proof_state m_state;
|
|
tactic_cmd_error(char const * msg, pos_info const & p, proof_state const & s):parser_error(msg, p), m_state(s) {}
|
|
tactic_cmd_error(sstream const & msg, pos_info const & p, proof_state const & s):parser_error(msg, p), m_state(s) {}
|
|
virtual exception * clone() const { return new tactic_cmd_error(m_msg.c_str(), m_pos, m_state); }
|
|
virtual void rethrow() const { throw *this; }
|
|
};
|
|
|
|
template<typename F>
|
|
typename std::result_of<F(lua_State * L)>::type using_script(F && f) {
|
|
return m_script_state->apply([&](lua_State * L) {
|
|
set_io_state set1(L, m_frontend.get_state());
|
|
set_environment set2(L, m_frontend.get_environment());
|
|
return f(L);
|
|
});
|
|
}
|
|
|
|
template<typename F>
|
|
void code_with_callbacks(F && f) {
|
|
m_script_state->apply([&](lua_State * L) {
|
|
set_io_state set1(L, m_frontend.get_state());
|
|
set_environment set2(L, m_frontend.get_environment());
|
|
m_script_state->exec_unprotected([&]() {
|
|
f();
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
\brief Auxiliar struct for creating/destroying a new scope for
|
|
local declarations.
|
|
*/
|
|
struct mk_scope {
|
|
imp & m_fn;
|
|
local_decls::mk_scope m_scope;
|
|
unsigned m_old_num_local_decls;
|
|
mk_scope(imp & fn):
|
|
m_fn(fn),
|
|
m_scope(fn.m_local_decls),
|
|
m_old_num_local_decls(fn.m_num_local_decls) {
|
|
}
|
|
~mk_scope() {
|
|
m_fn.m_num_local_decls = m_old_num_local_decls;
|
|
}
|
|
};
|
|
|
|
/** \brief Return the current position information */
|
|
pos_info pos() const { return mk_pair(m_scanner.get_line(), m_scanner.get_pos()); }
|
|
|
|
/** \brief Return the position associated with \c e. If there is none, then return \c default_pos. */
|
|
pos_info pos_of(expr const & e, pos_info default_pos) {
|
|
auto it = m_expr_pos_info.find(e);
|
|
if (it == m_expr_pos_info.end())
|
|
return default_pos;
|
|
else
|
|
return it->second;
|
|
}
|
|
|
|
/** \brief Associate position \c p with \c e and return \c e */
|
|
expr save(expr const & e, pos_info p) { m_expr_pos_info[e] = p; return e; }
|
|
|
|
/** \brief Read the next token. */
|
|
void scan() { m_curr = m_scanner.scan(); }
|
|
/** \brief Return the current token */
|
|
scanner::token curr() const { return m_curr; }
|
|
/** \brief Read the next token if the current one is not End-of-file. */
|
|
void next() { if (m_curr != scanner::token::Eof) scan(); }
|
|
|
|
/** \brief Return the name associated with the current token. */
|
|
name const & curr_name() const { return m_scanner.get_name_val(); }
|
|
/** \brief Return the numeral associated with the current token. */
|
|
mpq const & curr_num() const { return m_scanner.get_num_val(); }
|
|
/** \brief Return the string associated with the current token. */
|
|
std::string const & curr_string() const { return m_scanner.get_str_val(); }
|
|
|
|
/**
|
|
\brief Check if the current token is \c t, and move to the
|
|
next one. If the current token is not \c t, it throws a parser error.
|
|
*/
|
|
void check_next(scanner::token t, char const * msg) {
|
|
if (curr() == t)
|
|
next();
|
|
else
|
|
throw parser_error(msg, pos());
|
|
}
|
|
|
|
/** \brief Return true iff the current token is an identifier */
|
|
bool curr_is_identifier() const { return curr() == scanner::token::Id; }
|
|
/** \brief Return true iff the current token is a '_" */
|
|
bool curr_is_placeholder() const { return curr() == scanner::token::Placeholder; }
|
|
/** \brief Return true iff the current token is a natural number */
|
|
bool curr_is_nat() const { return curr() == scanner::token::NatVal; }
|
|
/** \brief Return true iff the current token is a '(' */
|
|
bool curr_is_lparen() const { return curr() == scanner::token::LeftParen; }
|
|
/** \brief Return true iff the current token is a '{' */
|
|
bool curr_is_lcurly() const { return curr() == scanner::token::LeftCurlyBracket; }
|
|
/** \brief Return true iff the current token is a ':' */
|
|
bool curr_is_colon() const { return curr() == scanner::token::Colon; }
|
|
/** \brief Return true iff the current token is a ':=' */
|
|
bool curr_is_assign() const { return curr() == scanner::token::Assign; }
|
|
/** \brief Return true iff the current token is an 'in' token */
|
|
bool curr_is_in() const { return curr() == scanner::token::In; }
|
|
/** \brief Return true iff the current token is '.' */
|
|
bool curr_is_period() const { return curr() == scanner::token::Period; }
|
|
/** \brief Return true iff the current token is a tactic command */
|
|
bool curr_is_tactic_cmd() const {
|
|
return curr_is_identifier() && std::find(g_tactic_cmds.begin(), g_tactic_cmds.end(), curr_name()) != g_tactic_cmds.end();
|
|
}
|
|
|
|
/** \brief Throws a parser error if the current token is not an identifier. */
|
|
void check_identifier(char const * msg) { if (!curr_is_identifier()) throw parser_error(msg, pos()); }
|
|
/**
|
|
\brief Throws a parser error if the current token is not an
|
|
identifier. If it is, move to the next token.
|
|
*/
|
|
name check_identifier_next(char const * msg) { check_identifier(msg); name r = curr_name(); next(); return r; }
|
|
/** \brief Throws a parser error if the current token is not '_'. If it is, move to the next token. */
|
|
void check_placeholder_next(char const * msg) { check_next(scanner::token::Placeholder, msg); }
|
|
/** \brief Throws a parser error if the current token is not ':'. If it is, move to the next token. */
|
|
void check_colon_next(char const * msg) { check_next(scanner::token::Colon, msg); }
|
|
/** \brief Throws a parser error if the current token is not ','. If it is, move to the next token. */
|
|
void check_comma_next(char const * msg) { check_next(scanner::token::Comma, msg); }
|
|
/** \brief Throws a parser error if the current token is not ')'. If it is, move to the next token. */
|
|
void check_rparen_next(char const * msg) { check_next(scanner::token::RightParen, msg); }
|
|
/** \brief Throws a parser error if the current token is not '}'. If it is, move to the next token. */
|
|
void check_rcurly_next(char const * msg) { check_next(scanner::token::RightCurlyBracket, msg); }
|
|
/** \brief Throws a parser error if the current token is not ':='. If it is, move to the next token. */
|
|
void check_assign_next(char const * msg) { check_next(scanner::token::Assign, msg); }
|
|
/** \brief Throws a parser error if the current token is not '.'. If it is, move to the next token. */
|
|
void check_period_next(char const * msg) { check_next(scanner::token::Period, msg); }
|
|
|
|
/**
|
|
\brief Throws a parser error if the current token is not a
|
|
string. If it is, move to the next token.
|
|
*/
|
|
std::string check_string_next(char const * msg) {
|
|
if (curr() != scanner::token::StringVal)
|
|
throw parser_error(msg, pos());
|
|
std::string r = curr_string();
|
|
next();
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
@name Error handling
|
|
*/
|
|
|
|
/*@{*/
|
|
void display_error_pos(unsigned line, unsigned pos) {
|
|
regular(m_frontend) << "Error (line: " << line;
|
|
if (pos != static_cast<unsigned>(-1))
|
|
regular(m_frontend) << ", pos: " << pos;
|
|
regular(m_frontend) << ")";
|
|
}
|
|
|
|
void display_error_pos(pos_info const & p) { display_error_pos(p.first, p.second); }
|
|
|
|
void display_error_pos(optional<expr> const & e) {
|
|
if (e) {
|
|
auto it = m_expr_pos_info.find(*e);
|
|
if (it == m_expr_pos_info.end())
|
|
return display_error_pos(m_last_cmd_pos);
|
|
else
|
|
return display_error_pos(it->second);
|
|
} else {
|
|
return display_error_pos(m_last_cmd_pos);
|
|
}
|
|
}
|
|
|
|
void display_error(char const * msg, unsigned line, unsigned pos) {
|
|
display_error_pos(line, pos);
|
|
regular(m_frontend) << " " << msg << endl;
|
|
}
|
|
|
|
void display_error(char const * msg) {
|
|
display_error(msg, m_scanner.get_line(), m_scanner.get_pos());
|
|
}
|
|
|
|
void display_error(kernel_exception const & ex) {
|
|
optional<expr> main_expr = ex.get_main_expr();
|
|
if (main_expr)
|
|
display_error_pos(some_expr(m_elaborator.get_original(*main_expr)));
|
|
else
|
|
display_error_pos(main_expr);
|
|
regular(m_frontend) << " " << ex << endl;
|
|
}
|
|
|
|
struct lean_pos_info_provider : public pos_info_provider {
|
|
imp const & m_ref;
|
|
lean_pos_info_provider(imp const & r):m_ref(r) {}
|
|
virtual std::pair<unsigned, unsigned> get_pos_info(expr const & e) const {
|
|
expr const & o = m_ref.m_elaborator.get_original(e);
|
|
auto it = m_ref.m_expr_pos_info.find(o);
|
|
if (it == m_ref.m_expr_pos_info.end())
|
|
throw exception("position is not available"); // information is not available
|
|
return it->second;
|
|
}
|
|
};
|
|
|
|
void display_error(elaborator_exception const & ex) {
|
|
formatter fmt = m_frontend.get_state().get_formatter();
|
|
options opts = m_frontend.get_state().get_options();
|
|
lean_pos_info_provider pos_provider(*this);
|
|
regular(m_frontend) << mk_pair(ex.get_justification().pp(fmt, opts, &pos_provider, true), opts) << endl;
|
|
}
|
|
|
|
void display_error(script_exception const & ex) {
|
|
switch (ex.get_source()) {
|
|
case script_exception::source::String:
|
|
display_error_pos(ex.get_line() + m_last_script_pos.first - 1, static_cast<unsigned>(-1));
|
|
regular(m_frontend) << " executing script," << ex.get_msg() << endl;
|
|
break;
|
|
case script_exception::source::File:
|
|
display_error_pos(m_last_script_pos);
|
|
regular(m_frontend) << " executing external script (" << ex.get_filename() << ":" << ex.get_line() << ")," << ex.get_msg() << endl;
|
|
break;
|
|
case script_exception::source::Unknown:
|
|
display_error_pos(m_last_script_pos);
|
|
regular(m_frontend) << " executing script, but could not decode position information, " << ex.what() << endl;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void display_error(tactic_cmd_error const & ex) {
|
|
display_error(ex.what(), ex.m_pos.first, ex.m_pos.second);
|
|
display_proof_state(ex.m_state);
|
|
}
|
|
|
|
/**
|
|
\brief Execute the given function \c f, and handle exceptions occurring
|
|
when executing \c f.
|
|
The parameter \c s is an error synchronization procedure.
|
|
*/
|
|
template<typename F, typename Sync>
|
|
void protected_call(F && f, Sync && sync) {
|
|
try {
|
|
f();
|
|
} catch (tactic_cmd_error & ex) {
|
|
m_found_errors = true;
|
|
if (m_show_errors)
|
|
display_error(ex);
|
|
sync();
|
|
if (m_use_exceptions)
|
|
throw;
|
|
} catch (parser_error & ex) {
|
|
m_found_errors = true;
|
|
if (m_show_errors)
|
|
display_error(ex.what(), ex.m_pos.first, ex.m_pos.second);
|
|
sync();
|
|
if (m_use_exceptions) {
|
|
throw parser_exception(ex.what(), ex.m_pos.first, ex.m_pos.second);
|
|
}
|
|
} catch (kernel_exception & ex) {
|
|
m_found_errors = true;
|
|
if (m_show_errors)
|
|
display_error(ex);
|
|
sync();
|
|
if (m_use_exceptions)
|
|
throw;
|
|
} catch (elaborator_exception & ex) {
|
|
m_found_errors = true;
|
|
if (m_show_errors)
|
|
display_error(ex);
|
|
sync();
|
|
if (m_use_exceptions)
|
|
throw;
|
|
} catch (script_exception & ex) {
|
|
m_found_errors = true;
|
|
reset_interrupt();
|
|
if (m_show_errors)
|
|
display_error(ex);
|
|
sync();
|
|
if (m_use_exceptions)
|
|
throw;
|
|
} catch (interrupted & ex) {
|
|
if (m_verbose)
|
|
regular(m_frontend) << "!!!Interrupted!!!" << endl;
|
|
reset_interrupt();
|
|
sync();
|
|
if (m_use_exceptions)
|
|
throw;
|
|
} catch (exception & ex) {
|
|
m_found_errors = true;
|
|
if (m_show_errors)
|
|
display_error(ex.what());
|
|
sync();
|
|
if (m_use_exceptions)
|
|
throw;
|
|
}
|
|
}
|
|
/*@}*/
|
|
|
|
unsigned parse_unsigned(char const * msg) {
|
|
lean_assert(curr_is_nat());
|
|
mpz pval = curr_num().get_numerator();
|
|
if (!pval.is_unsigned_int()) {
|
|
throw parser_error(msg, pos());
|
|
} else {
|
|
unsigned r = pval.get_unsigned_int();
|
|
next();
|
|
return r;
|
|
}
|
|
}
|
|
|
|
double parse_double() {
|
|
return 0.0;
|
|
}
|
|
|
|
[[ noreturn ]] void not_implemented_yet() {
|
|
// TODO(Leo)
|
|
throw parser_error("not implemented yet", pos());
|
|
}
|
|
|
|
/**
|
|
@name Parse Universe levels
|
|
*/
|
|
/*@{*/
|
|
level parse_level_max() {
|
|
auto p = pos();
|
|
next();
|
|
buffer<level> lvls;
|
|
while (curr_is_identifier() || curr_is_nat()) {
|
|
lvls.push_back(parse_level());
|
|
}
|
|
if (lvls.size() < 2)
|
|
throw parser_error("invalid level expression, max must have at least two arguments", p);
|
|
level r = lvls[0];
|
|
for (unsigned i = 1; i < lvls.size(); i++)
|
|
r = max(r, lvls[i]);
|
|
return r;
|
|
}
|
|
|
|
level parse_level_nud_id() {
|
|
name id = curr_name();
|
|
if (id == g_max_name) {
|
|
return parse_level_max();
|
|
} else {
|
|
next();
|
|
return m_frontend.get_uvar(id);
|
|
}
|
|
}
|
|
|
|
level parse_level_nud_int() {
|
|
auto p = pos();
|
|
mpz val = curr_num().get_numerator();
|
|
next();
|
|
if (!val.is_unsigned_int())
|
|
throw parser_error("invalid level expression, value does not fit in a machine integer", p);
|
|
return level() + val.get_unsigned_int();
|
|
}
|
|
|
|
level parse_level_nud() {
|
|
switch (curr()) {
|
|
case scanner::token::Id: return parse_level_nud_id();
|
|
case scanner::token::NatVal: return parse_level_nud_int();
|
|
default:
|
|
throw parser_error("invalid level expression", pos());
|
|
}
|
|
}
|
|
|
|
level parse_level_led_plus(level const & left) {
|
|
auto p = pos();
|
|
next();
|
|
level right = parse_level(g_level_plus_prec);
|
|
if (!is_lift(right) || !lift_of(right).is_bottom())
|
|
throw parser_error("invalid level expression, right hand side of '+' (aka universe lift operator) must be a numeral", p);
|
|
return left + lift_offset(right);
|
|
}
|
|
|
|
level parse_level_led_cup(level const & left) {
|
|
next();
|
|
level right = parse_level(g_level_cup_prec);
|
|
return max(left, right);
|
|
}
|
|
|
|
level parse_level_led(level const & left) {
|
|
switch (curr()) {
|
|
case scanner::token::Id:
|
|
if (curr_name() == g_plus_name) return parse_level_led_plus(left);
|
|
else if (curr_name() == g_cup_name) return parse_level_led_cup(left);
|
|
default:
|
|
throw parser_error("invalid level expression", pos());
|
|
}
|
|
}
|
|
|
|
unsigned curr_level_lbp() {
|
|
switch (curr()) {
|
|
case scanner::token::Id: {
|
|
name const & id = curr_name();
|
|
if (id == g_plus_name) return g_level_plus_prec;
|
|
else if (id == g_cup_name) return g_level_cup_prec;
|
|
else return 0;
|
|
}
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
/** \brief Parse a universe level */
|
|
level parse_level(unsigned rbp = 0) {
|
|
level left = parse_level_nud();
|
|
while (rbp < curr_level_lbp()) {
|
|
left = parse_level_led(left);
|
|
}
|
|
return left;
|
|
}
|
|
/*@}*/
|
|
|
|
/**
|
|
@name Parse Expressions
|
|
*/
|
|
/*@{*/
|
|
|
|
/**
|
|
\brief Return the function associated with the given operator.
|
|
If the operator has been overloaded, it returns a choice expression
|
|
of the form <tt>(choice f_1 f_2 ... f_k)</tt> where f_i's are different options.
|
|
After we finish parsing, the elaborator
|
|
resolve/decide which f_i should be used.
|
|
*/
|
|
expr mk_fun(operator_info const & op) {
|
|
list<expr> const & fs = op.get_denotations();
|
|
lean_assert(!is_nil(fs));
|
|
auto it = fs.begin();
|
|
expr r = *it;
|
|
++it;
|
|
if (it == fs.end()) {
|
|
return r;
|
|
} else {
|
|
buffer<expr> alternatives;
|
|
alternatives.push_back(r);
|
|
for (; it != fs.end(); ++it)
|
|
alternatives.push_back(*it);
|
|
return mk_choice(alternatives.size(), alternatives.data());
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Create an application for the given operator and
|
|
(explicit) arguments.
|
|
*/
|
|
expr mk_application(operator_info const & op, pos_info const & pos, unsigned num_args, expr const * args) {
|
|
buffer<expr> new_args;
|
|
expr f = save(mk_fun(op), pos);
|
|
new_args.push_back(f);
|
|
// I'm using the fact that all denotations are compatible.
|
|
// See lean_frontend.cpp for the definition of compatible denotations.
|
|
expr const & d = head(op.get_denotations());
|
|
if (is_constant(d) && m_frontend.has_implicit_arguments(const_name(d))) {
|
|
std::vector<bool> const & imp_args = m_frontend.get_implicit_arguments(const_name(d));
|
|
unsigned i = 0;
|
|
for (unsigned j = 0; j < imp_args.size(); j++) {
|
|
if (imp_args[j]) {
|
|
new_args.push_back(save(mk_placeholder(), pos));
|
|
} else {
|
|
if (i >= num_args)
|
|
throw parser_error(sstream() << "unexpected number of arguments for denotation with implicit arguments, it expects " << num_args << " explicit argument(s)", pos);
|
|
new_args.push_back(args[i]);
|
|
i++;
|
|
}
|
|
}
|
|
for (; i < num_args; i++)
|
|
new_args.push_back(args[i]);
|
|
} else {
|
|
new_args.append(num_args, args);
|
|
}
|
|
return save(mk_app(new_args), pos);
|
|
}
|
|
expr mk_application(operator_info const & op, pos_info const & pos, std::initializer_list<expr> const & l) {
|
|
return mk_application(op, pos, l.size(), l.begin());
|
|
}
|
|
expr mk_application(operator_info const & op, pos_info const & pos, expr const & arg) {
|
|
return mk_application(op, pos, 1, &arg);
|
|
}
|
|
expr mk_application(operator_info const & op, pos_info const & pos, buffer<expr> const & args) {
|
|
return mk_application(op, pos, args.size(), args.data());
|
|
}
|
|
|
|
/** \brief Parse a user defined prefix operator. */
|
|
expr parse_prefix(operator_info const & op) {
|
|
auto p = pos();
|
|
return mk_application(op, p, parse_expr(op.get_precedence()));
|
|
}
|
|
|
|
/** \brief Parse a user defined postfix operator. */
|
|
expr parse_postfix(expr const & left, operator_info const & op) {
|
|
return mk_application(op, pos(), left);
|
|
}
|
|
|
|
/** \brief Parse a user defined infix operator. */
|
|
expr parse_infix(expr const & left, operator_info const & op) {
|
|
auto p = pos();
|
|
return mk_application(op, p, {left, parse_expr(op.get_precedence()+1)});
|
|
}
|
|
|
|
/** \brief Parse a user defined infix-left operator. */
|
|
expr parse_infixl(expr const & left, operator_info const & op) {
|
|
auto p = pos();
|
|
return mk_application(op, p, {left, parse_expr(op.get_precedence())});
|
|
}
|
|
|
|
/** \brief Parse a user defined infix-right operator. */
|
|
expr parse_infixr(expr const & left, operator_info const & op) {
|
|
auto p = pos();
|
|
return mk_application(op, p, {left, parse_expr(op.get_precedence()-1)});
|
|
}
|
|
|
|
/**
|
|
\brief Throws an error if the current token is not an identifier named \c op_part.
|
|
If it is, move to the next toke. The error message assumes
|
|
this method has been used when parsing mixfix operators.
|
|
*/
|
|
void check_op_part(name const & op_part) {
|
|
if (!curr_is_identifier() || curr_name() != op_part)
|
|
throw parser_error(sstream() << "invalid mixfix operator application, '" << op_part << "' expected", pos());
|
|
next();
|
|
}
|
|
|
|
/**
|
|
\brief Auxiliary function for #parse_mixfixl and #parse_mixfixo
|
|
|
|
It parses (ID _)*
|
|
*/
|
|
void parse_mixfix_args(list<name> const & ops, unsigned prec, buffer<expr> & args) {
|
|
auto it = ops.begin();
|
|
++it;
|
|
while (it != ops.end()) {
|
|
check_op_part(*it);
|
|
args.push_back(parse_expr(prec));
|
|
++it;
|
|
}
|
|
}
|
|
|
|
/** \brief Parse user defined mixfixl operator. It has the form: ID _ ... ID _ */
|
|
expr parse_mixfixl(operator_info const & op) {
|
|
auto p = pos();
|
|
buffer<expr> args;
|
|
args.push_back(parse_expr(op.get_precedence()));
|
|
parse_mixfix_args(op.get_op_name_parts(), op.get_precedence(), args);
|
|
return mk_application(op, p, args);
|
|
}
|
|
|
|
/** \brief Parse user defined mixfixr operator. It has the form: _ ID ... _ ID */
|
|
expr parse_mixfixr(expr const & left, operator_info const & op) {
|
|
auto p = pos();
|
|
buffer<expr> args;
|
|
args.push_back(left);
|
|
auto parts = op.get_op_name_parts();
|
|
auto it = parts.begin();
|
|
++it;
|
|
while (it != parts.end()) {
|
|
args.push_back(parse_expr(op.get_precedence()));
|
|
check_op_part(*it);
|
|
++it;
|
|
}
|
|
return mk_application(op, p, args);
|
|
}
|
|
|
|
/** \brief Parse user defined mixfixr operator. It has the form: _ ID ... _ ID _ */
|
|
expr parse_mixfixo(expr const & left, operator_info const & op) {
|
|
auto p = pos();
|
|
buffer<expr> args;
|
|
args.push_back(left);
|
|
args.push_back(parse_expr(op.get_precedence()));
|
|
parse_mixfix_args(op.get_op_name_parts(), op.get_precedence(), args);
|
|
return mk_application(op, p, args);
|
|
}
|
|
|
|
/** \brief Parse user defined mixfixc operator. It has the form: ID _ ID ... _ ID */
|
|
expr parse_mixfixc(operator_info const & op) {
|
|
auto p = pos();
|
|
buffer<expr> args;
|
|
args.push_back(parse_expr(op.get_precedence()));
|
|
list<name> const & ops = op.get_op_name_parts();
|
|
auto it = ops.begin();
|
|
++it;
|
|
while (true) {
|
|
check_op_part(*it);
|
|
++it;
|
|
if (it == ops.end())
|
|
return mk_application(op, p, args);
|
|
args.push_back(parse_expr(op.get_precedence()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Try to find an object (Definition or Postulate) named \c
|
|
id in the frontend/environment. If there isn't one, then tries
|
|
to check if \c id is a builtin symbol. If it is not throws an error.
|
|
*/
|
|
expr get_name_ref(name const & id, pos_info const & p) {
|
|
optional<object> obj = m_frontend.find_object(id);
|
|
if (obj) {
|
|
object_kind k = obj->kind();
|
|
if (k == object_kind::Definition || k == object_kind::Postulate || k == object_kind::Builtin) {
|
|
if (m_frontend.has_implicit_arguments(obj->get_name())) {
|
|
std::vector<bool> const & imp_args = m_frontend.get_implicit_arguments(obj->get_name());
|
|
buffer<expr> args;
|
|
pos_info p = pos();
|
|
expr f = (k == object_kind::Builtin) ? obj->get_value() : mk_constant(obj->get_name());
|
|
args.push_back(save(f, p));
|
|
for (unsigned i = 0; i < imp_args.size(); i++) {
|
|
if (imp_args[i]) {
|
|
args.push_back(save(mk_placeholder(), pos()));
|
|
} else {
|
|
args.push_back(parse_expr(1));
|
|
}
|
|
}
|
|
return mk_app(args);
|
|
} else if (k == object_kind::Builtin) {
|
|
return obj->get_value();
|
|
} else {
|
|
return mk_constant(obj->get_name());
|
|
}
|
|
} else {
|
|
throw parser_error(sstream() << "invalid object reference, object '" << id << "' is not an expression.", p);
|
|
}
|
|
} else {
|
|
throw parser_error(sstream() << "unknown identifier '" << id << "'", p);
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Parse an identifier that has a "null denotation" (See
|
|
paper: "Top down operator precedence"). A nud identifier is a
|
|
token that appears at the beginning of a language construct.
|
|
In Lean, local declarations (i.e., local functions), user
|
|
defined prefix, mixfixl and mixfixc operators, and global
|
|
functions can begin a language construct.
|
|
*/
|
|
expr parse_nud_id() {
|
|
auto p = pos();
|
|
name id = curr_name();
|
|
next();
|
|
auto it = m_local_decls.find(id);
|
|
if (it != m_local_decls.end()) {
|
|
return save(mk_var(m_num_local_decls - it->second - 1), p);
|
|
} else {
|
|
operator_info op = m_frontend.find_nud(id);
|
|
if (op) {
|
|
switch (op.get_fixity()) {
|
|
case fixity::Prefix: return parse_prefix(op);
|
|
case fixity::Mixfixl: return parse_mixfixl(op);
|
|
case fixity::Mixfixc: return parse_mixfixc(op);
|
|
default: lean_unreachable(); // LCOV_EXCL_LINE
|
|
}
|
|
} else {
|
|
return save(get_name_ref(id, p), p);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Parse an identifier that has a "left denotation" (See
|
|
paper: "Top down operator precedence"). A left identifier is a
|
|
token that appears inside of a construct (to left of the rest
|
|
of the construct). In Lean, local declarations (i.e., function
|
|
application arguments), user defined infix, infixl, infixr,
|
|
mixfixr and global values (as function application arguments)
|
|
can appear inside of a construct.
|
|
*/
|
|
expr parse_led_id(expr const & left) {
|
|
auto p = pos();
|
|
auto p2 = pos_of(left, p);
|
|
name id = curr_name();
|
|
next();
|
|
auto it = m_local_decls.find(id);
|
|
if (it != m_local_decls.end()) {
|
|
return save(mk_app(left, save(mk_var(m_num_local_decls - it->second - 1), p)), p2);
|
|
} else {
|
|
operator_info op = m_frontend.find_led(id);
|
|
if (op) {
|
|
switch (op.get_fixity()) {
|
|
case fixity::Infix: return parse_infix(left, op);
|
|
case fixity::Infixl: return parse_infixl(left, op);
|
|
case fixity::Infixr: return parse_infixr(left, op);
|
|
case fixity::Mixfixr: return parse_mixfixr(left, op);
|
|
case fixity::Mixfixo: return parse_mixfixo(left, op);
|
|
case fixity::Postfix: return parse_postfix(left, op);
|
|
default: lean_unreachable(); // LCOV_EXCL_LINE
|
|
}
|
|
} else {
|
|
return save(mk_app(left, save(get_name_ref(id, p), p)), p2);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** \brief Parse <tt>expr '=' expr</tt>. */
|
|
expr parse_eq(expr const & left) {
|
|
auto p = pos();
|
|
next();
|
|
expr right = parse_expr(g_eq_precedence);
|
|
return save(mk_eq(left, right), p);
|
|
}
|
|
|
|
/** \brief Parse <tt>expr '->' expr</tt>. */
|
|
expr parse_arrow(expr const & left) {
|
|
auto p = pos();
|
|
next();
|
|
mk_scope scope(*this);
|
|
register_binding(g_unused);
|
|
// The -1 is a trick to get right associativity in Pratt's parsers
|
|
expr right = parse_expr(g_arrow_precedence-1);
|
|
return save(mk_arrow(left, right), p);
|
|
}
|
|
|
|
/** \brief Parse <tt>'(' expr ')'</tt>. */
|
|
expr parse_lparen() {
|
|
auto p = pos();
|
|
next();
|
|
expr r = save(parse_expr(), p);
|
|
check_rparen_next("invalid expression, ')' expected");
|
|
return r;
|
|
}
|
|
|
|
/**
|
|
\brief Parse a sequence of identifiers <tt>ID*</tt>. Store the
|
|
result in \c result.
|
|
*/
|
|
void parse_names(buffer<std::pair<pos_info, name>> & result) {
|
|
while (curr_is_identifier()) {
|
|
result.emplace_back(pos(), curr_name());
|
|
next();
|
|
}
|
|
}
|
|
|
|
/** \brief Register the name \c n as a local declaration. */
|
|
void register_binding(name const & n) {
|
|
unsigned lvl = m_num_local_decls;
|
|
m_local_decls.insert(n, lvl);
|
|
m_num_local_decls++;
|
|
lean_assert(m_local_decls.find(n)->second == lvl);
|
|
}
|
|
|
|
/**
|
|
\brief Parse <tt>ID ... ID ':' expr</tt>, where the expression
|
|
represents the type of the identifiers.
|
|
|
|
\remark If \c implicit_decl is true, then the bindings should be
|
|
marked as implicit. This flag is set to true, for example,
|
|
when we are parsing definitions such as:
|
|
<code> Definition f {A : Type} (a b : A), A := ... </code>
|
|
The <code>{A : Type}</code> is considered an implicit argument declaration.
|
|
|
|
\remark If \c suppress_type is true, then the type doesn't
|
|
need to be provided. That is, we automatically include a placeholder.
|
|
*/
|
|
void parse_simple_bindings(bindings_buffer & result, bool implicit_decl, bool suppress_type) {
|
|
buffer<std::pair<pos_info, name>> names;
|
|
parse_names(names);
|
|
optional<expr> type;
|
|
if (!suppress_type) {
|
|
check_colon_next("invalid binder, ':' expected");
|
|
type = parse_expr();
|
|
} else if (curr_is_colon()) {
|
|
next();
|
|
type = parse_expr();
|
|
}
|
|
unsigned sz = result.size();
|
|
result.resize(sz + names.size());
|
|
for (std::pair<pos_info, name> const & n : names) register_binding(n.second);
|
|
unsigned i = names.size();
|
|
while (i > 0) {
|
|
--i;
|
|
expr arg_type;
|
|
if (type)
|
|
arg_type = lift_free_vars(*type, i);
|
|
else
|
|
arg_type = save(mk_placeholder(), names[i].first);
|
|
result[sz + i] = std::make_tuple(names[i].first, names[i].second, arg_type, implicit_decl);
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Parse a sequence of <tt>'(' ID ... ID ':' expr ')'</tt>.
|
|
|
|
This is used when parsing lambda, Pi, forall/exists expressions and
|
|
definitions.
|
|
|
|
\remark If implicit_decls is true, then we allow declarations
|
|
with curly braces. These declarations are used to tag implicit
|
|
arguments. Such as:
|
|
<code> Definition f {A : Type} (a b : A), A := ... </code>
|
|
|
|
\see parse_simple_bindings
|
|
*/
|
|
void parse_bindings(bindings_buffer & result, bool implicit_decls, bool suppress_type) {
|
|
if (curr_is_identifier()) {
|
|
parse_simple_bindings(result, false, suppress_type);
|
|
} else {
|
|
// (ID ... ID : type) ... (ID ... ID : type)
|
|
if (implicit_decls) {
|
|
if (!curr_is_lparen() && !curr_is_lcurly())
|
|
throw parser_error("invalid binder, '(', '{' or identifier expected", pos());
|
|
} else {
|
|
if (!curr_is_lparen())
|
|
throw parser_error("invalid binder, '(' or identifier expected", pos());
|
|
}
|
|
bool implicit = curr_is_lcurly();
|
|
next();
|
|
parse_simple_bindings(result, implicit, suppress_type);
|
|
if (!implicit)
|
|
check_rparen_next("invalid binder, ')' expected");
|
|
else
|
|
check_rcurly_next("invalid binder, '}' expected");
|
|
while (curr_is_lparen() || (implicit_decls && curr_is_lcurly())) {
|
|
bool implicit = curr_is_lcurly();
|
|
next();
|
|
parse_simple_bindings(result, implicit, suppress_type);
|
|
if (!implicit)
|
|
check_rparen_next("invalid binder, ')' expected");
|
|
else
|
|
check_rcurly_next("invalid binder, '}' expected");
|
|
}
|
|
}
|
|
}
|
|
|
|
/** \brief Parse bindings for object such as: definitions, theorems, axioms, variables ... */
|
|
void parse_object_bindings(bindings_buffer & result) {
|
|
parse_bindings(result, true, false);
|
|
}
|
|
|
|
/** \brief Parse bindings for expressions such as: lambda, pi, forall, exists */
|
|
void parse_expr_bindings(bindings_buffer & result) {
|
|
parse_bindings(result, false, true);
|
|
}
|
|
|
|
/**
|
|
\brief Create a lambda/Pi abstraction, using the giving binders
|
|
and body.
|
|
*/
|
|
expr mk_abstraction(bool is_lambda, bindings_buffer const & bindings, expr const & body) {
|
|
expr result = body;
|
|
unsigned i = bindings.size();
|
|
while (i > 0) {
|
|
--i;
|
|
pos_info p = std::get<0>(bindings[i]);
|
|
if (is_lambda)
|
|
result = save(mk_lambda(std::get<1>(bindings[i]), std::get<2>(bindings[i]), result), p);
|
|
else
|
|
result = save(mk_pi(std::get<1>(bindings[i]), std::get<2>(bindings[i]), result), p);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/** \brief Parse lambda/Pi abstraction. */
|
|
expr parse_abstraction(bool is_lambda) {
|
|
next();
|
|
mk_scope scope(*this);
|
|
bindings_buffer bindings;
|
|
parse_expr_bindings(bindings);
|
|
check_comma_next("invalid abstraction, ',' expected");
|
|
expr result = parse_expr();
|
|
return mk_abstraction(is_lambda, bindings, result);
|
|
}
|
|
|
|
/** \brief Parse lambda abstraction. */
|
|
expr parse_lambda() {
|
|
return parse_abstraction(true);
|
|
}
|
|
|
|
/** \brief Parse Pi abstraction. */
|
|
expr parse_pi() {
|
|
return parse_abstraction(false);
|
|
}
|
|
|
|
/** \brief Parse forall/exists */
|
|
expr parse_quantifier(bool is_forall) {
|
|
next();
|
|
mk_scope scope(*this);
|
|
bindings_buffer bindings;
|
|
parse_expr_bindings(bindings);
|
|
check_comma_next("invalid quantifier, ',' expected");
|
|
expr result = parse_expr();
|
|
unsigned i = bindings.size();
|
|
while (i > 0) {
|
|
--i;
|
|
pos_info p = std::get<0>(bindings[i]);
|
|
expr lambda = save(mk_lambda(std::get<1>(bindings[i]), std::get<2>(bindings[i]), result), p);
|
|
if (is_forall)
|
|
result = save(mk_forall(std::get<2>(bindings[i]), lambda), p);
|
|
else
|
|
result = save(mk_exists(std::get<2>(bindings[i]), lambda), p);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/** \brief Parse <tt>'forall' bindings ',' expr</tt>. */
|
|
expr parse_forall() {
|
|
return parse_quantifier(true);
|
|
}
|
|
|
|
/** \brief Parse <tt>'exists' bindings ',' expr</tt>. */
|
|
expr parse_exists() {
|
|
return parse_quantifier(false);
|
|
}
|
|
|
|
/** \brief Parse Let expression. */
|
|
expr parse_let() {
|
|
next();
|
|
mk_scope scope(*this);
|
|
buffer<std::tuple<pos_info, name, optional<expr>, expr>> bindings;
|
|
while (true) {
|
|
auto p = pos();
|
|
name id = check_identifier_next("invalid let expression, identifier expected");
|
|
optional<expr> type;
|
|
if (curr_is_colon()) {
|
|
next();
|
|
type = parse_expr();
|
|
}
|
|
check_assign_next("invalid let expression, ':=' expected");
|
|
expr val = parse_expr();
|
|
register_binding(id);
|
|
bindings.emplace_back(p, id, type, val);
|
|
if (curr_is_in()) {
|
|
next();
|
|
expr r = parse_expr();
|
|
unsigned i = bindings.size();
|
|
while (i > 0) {
|
|
--i;
|
|
auto p = std::get<0>(bindings[i]);
|
|
r = save(mk_let(std::get<1>(bindings[i]), std::get<2>(bindings[i]), std::get<3>(bindings[i]), r), p);
|
|
}
|
|
return r;
|
|
} else {
|
|
check_comma_next("invalid let expression, ',' or 'in' expected");
|
|
}
|
|
}
|
|
}
|
|
|
|
/** \brief Parse a natural number value. */
|
|
expr parse_nat() {
|
|
auto p = pos();
|
|
expr r = save(mk_nat_value(m_scanner.get_num_val().get_numerator()), p);
|
|
next();
|
|
return r;
|
|
}
|
|
|
|
expr parse_decimal() {
|
|
auto p = pos();
|
|
expr r = save(mk_real_value(m_scanner.get_num_val()), p);
|
|
next();
|
|
return r;
|
|
}
|
|
|
|
expr parse_string() {
|
|
// TODO(Leo)
|
|
not_implemented_yet();
|
|
}
|
|
|
|
/** \brief Parse <tt>'Type'</tt> and <tt>'Type' level</tt> expressions. */
|
|
expr parse_type() {
|
|
auto p = pos();
|
|
next();
|
|
if (curr_is_identifier() || curr_is_nat()) {
|
|
return save(mk_type(parse_level()), p);
|
|
} else {
|
|
return Type();
|
|
}
|
|
}
|
|
|
|
/** \brief Parse \c _ a hole that must be filled by the elaborator. */
|
|
expr parse_placeholder() {
|
|
auto p = pos();
|
|
next();
|
|
return save(mk_placeholder(), p);
|
|
}
|
|
|
|
/** \brief Parse a tactic expression, it can be
|
|
|
|
1) A Lua Script Block expression that returns a tactic
|
|
2) '(' expr ')' where expr is a proof term
|
|
3) identifier that is the name of a tactic or proof term.
|
|
*/
|
|
tactic parse_tactic_expr() {
|
|
auto p = pos();
|
|
if (curr() == scanner::token::ScriptBlock) {
|
|
parse_script_expr();
|
|
return using_script([&](lua_State * L) {
|
|
try {
|
|
return to_tactic_ext(L, -1);
|
|
} catch (...) {
|
|
throw parser_error("invalid script-block, it must return a tactic", p);
|
|
}
|
|
});
|
|
} else if (curr_is_lparen()) {
|
|
next();
|
|
expr pr = parse_expr();
|
|
check_rparen_next("invalid apply command, ')' expected");
|
|
expr pr_type = m_type_inferer(pr);
|
|
return ::lean::apply_tactic(pr, pr_type);
|
|
} else {
|
|
name n = check_identifier_next("invalid apply command, identifier, '(' expr ')', or 'script-block' expected");
|
|
optional<object> o = m_frontend.find_object(n);
|
|
if (o && (o->is_theorem() || o->is_axiom())) {
|
|
return ::lean::apply_tactic(n);
|
|
} else {
|
|
return using_script([&](lua_State * L) {
|
|
lua_getglobal(L, n.to_string().c_str());
|
|
try {
|
|
tactic t = to_tactic_ext(L, -1);
|
|
lua_pop(L, 1);
|
|
return t;
|
|
} catch (...) {
|
|
lua_pop(L, 1);
|
|
throw parser_error(sstream() << "unknown tactic '" << n << "'", p);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/** \brief Parse <tt>'show' expr 'by' tactic</tt> */
|
|
expr parse_show_expr() {
|
|
auto p = pos();
|
|
next();
|
|
expr t = parse_expr();
|
|
check_next(scanner::token::By, "invalid 'show _ by _' expression, 'by' expected");
|
|
tactic tac = parse_tactic_expr();
|
|
expr r = mk_placeholder(some_expr(t));
|
|
m_tactic_hints.insert(mk_pair(r, tac));
|
|
return save(r, p);
|
|
}
|
|
|
|
/** \brief Parse <tt>'by' tactic</tt> */
|
|
expr parse_by_expr() {
|
|
auto p = pos();
|
|
next();
|
|
tactic tac = parse_tactic_expr();
|
|
expr r = mk_placeholder();
|
|
m_tactic_hints.insert(mk_pair(r, tac));
|
|
return save(r, p);
|
|
}
|
|
|
|
/**
|
|
\brief Auxiliary method used when processing the beginning of an expression.
|
|
*/
|
|
expr parse_nud() {
|
|
switch (curr()) {
|
|
case scanner::token::Id: return parse_nud_id();
|
|
case scanner::token::LeftParen: return parse_lparen();
|
|
case scanner::token::Lambda: return parse_lambda();
|
|
case scanner::token::Pi: return parse_pi();
|
|
case scanner::token::Forall: return parse_forall();
|
|
case scanner::token::Exists: return parse_exists();
|
|
case scanner::token::Let: return parse_let();
|
|
case scanner::token::NatVal: return parse_nat();
|
|
case scanner::token::DecimalVal: return parse_decimal();
|
|
case scanner::token::StringVal: return parse_string();
|
|
case scanner::token::Placeholder: return parse_placeholder();
|
|
case scanner::token::Type: return parse_type();
|
|
case scanner::token::Show: return parse_show_expr();
|
|
case scanner::token::By: return parse_by_expr();
|
|
default:
|
|
throw parser_error("invalid expression, unexpected token", pos());
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Create a new application and associate position of left with the resultant expression.
|
|
*/
|
|
expr mk_app_left(expr const & left, expr const & arg) {
|
|
auto it = m_expr_pos_info.find(left);
|
|
lean_assert(it != m_expr_pos_info.end());
|
|
return save(mk_app(left, arg), it->second);
|
|
}
|
|
|
|
/**
|
|
\brief Auxiliary method used when processing the 'inside' of an expression.
|
|
*/
|
|
expr parse_led(expr const & left) {
|
|
switch (curr()) {
|
|
case scanner::token::Id: return parse_led_id(left);
|
|
case scanner::token::Eq: return parse_eq(left);
|
|
case scanner::token::Arrow: return parse_arrow(left);
|
|
case scanner::token::LeftParen: return mk_app_left(left, parse_lparen());
|
|
case scanner::token::NatVal: return mk_app_left(left, parse_nat());
|
|
case scanner::token::DecimalVal: return mk_app_left(left, parse_decimal());
|
|
case scanner::token::StringVal: return mk_app_left(left, parse_string());
|
|
case scanner::token::Placeholder: return mk_app_left(left, parse_placeholder());
|
|
case scanner::token::Type: return mk_app_left(left, parse_type());
|
|
default: return left;
|
|
}
|
|
}
|
|
|
|
/** \brief Return the binding power of the current token (when parsing expression). */
|
|
unsigned curr_lbp() {
|
|
switch (curr()) {
|
|
case scanner::token::Id: {
|
|
name const & id = curr_name();
|
|
auto it = m_local_decls.find(id);
|
|
if (it != m_local_decls.end()) {
|
|
return 1;
|
|
} else {
|
|
operator_info op = m_frontend.find_led(id);
|
|
if (op)
|
|
return op.get_precedence();
|
|
else
|
|
return 1;
|
|
}
|
|
}
|
|
case scanner::token::Eq : return g_eq_precedence;
|
|
case scanner::token::Arrow : return g_arrow_precedence;
|
|
case scanner::token::LeftParen: case scanner::token::NatVal: case scanner::token::DecimalVal:
|
|
case scanner::token::StringVal: case scanner::token::Type: case scanner::token::Placeholder:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/** \brief Parse an expression */
|
|
expr parse_expr(unsigned rbp = 0) {
|
|
expr left = parse_nud();
|
|
while (rbp < curr_lbp()) {
|
|
left = parse_led(left);
|
|
}
|
|
return left;
|
|
}
|
|
/*@}*/
|
|
|
|
/**
|
|
@name Parse Commands
|
|
*/
|
|
/*@{*/
|
|
|
|
/**
|
|
\brief Register implicit arguments for the definition or
|
|
postulate named \c n. The fourth element in the tuple bindings
|
|
is a flag indiciating whether the argument is implicit or not.
|
|
*/
|
|
void register_implicit_arguments(name const & n, bindings_buffer & bindings) {
|
|
bool found = false;
|
|
buffer<bool> imp_args;
|
|
for (unsigned i = 0; i < bindings.size(); i++) {
|
|
imp_args.push_back(std::get<3>(bindings[i]));
|
|
if (imp_args.back())
|
|
found = true;
|
|
}
|
|
if (found)
|
|
m_frontend.mark_implicit_arguments(n, imp_args.size(), imp_args.data());
|
|
}
|
|
|
|
void display_proof_state(proof_state s) {
|
|
regular(m_frontend) << "Proof state:\n" << s << endl;
|
|
}
|
|
|
|
void display_proof_state_if_interactive(proof_state s) {
|
|
if (m_interactive)
|
|
display_proof_state(s);
|
|
}
|
|
|
|
typedef std::vector<proof_state_seq> proof_state_seq_stack;
|
|
|
|
/**
|
|
\brief Apply tactic \c t to state \c s.
|
|
When \c t succeeds, it returns the head and tail of the output state sequence.
|
|
Throws an exception if the tactic fails, and use \c p to sign the error position.
|
|
*/
|
|
std::pair<proof_state, proof_state_seq> apply_tactic(proof_state const & s, tactic const & t, pos_info const & p) {
|
|
proof_state_seq::maybe_pair r;
|
|
code_with_callbacks([&]() {
|
|
// t may have call-backs we should set ios in the script_state
|
|
proof_state_seq seq = t(m_frontend, m_frontend.get_state(), s);
|
|
r = seq.pull();
|
|
});
|
|
if (r) {
|
|
return mk_pair(r->first, r->second);
|
|
} else {
|
|
throw tactic_cmd_error("tactic failed", p, s);
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Try to create a proof for the input state \c s.
|
|
It basically applies the proof_builder if \c s does not contain
|
|
any goals left. The position information is used to throw an exception
|
|
if \c s is not a final state.
|
|
|
|
The resultant proof must have type \c expected_type in the context \c ctx.
|
|
*/
|
|
expr mk_proof_for(proof_state const & s, pos_info const & p, context const & ctx, expr const & expected_type) {
|
|
if (s.is_proof_final_state()) {
|
|
assignment a(s.get_menv());
|
|
proof_map m;
|
|
expr pr = s.get_proof_builder()(m, a);
|
|
if (has_metavar(pr)) {
|
|
// Some tactics generate metavariables that can only be instantiated by type inference elaboration.
|
|
// Example: apply_tactic.
|
|
metavar_env menv = s.get_menv();
|
|
buffer<unification_constraint> ucs;
|
|
expr pr_type = type_checker(m_frontend).infer_type(pr, ctx, &menv, &ucs);
|
|
ucs.push_back(mk_convertible_constraint(ctx, pr_type, expected_type, mk_type_match_justification(ctx, expected_type, pr)));
|
|
elaborator elb(m_frontend, s.get_menv(), ucs.size(), ucs.data(), m_frontend.get_options());
|
|
metavar_env new_menv = elb.next();
|
|
pr = instantiate_metavars(pr, new_menv);
|
|
if (has_metavar(pr))
|
|
throw exception("synthesized proof object has unsolved metavars");
|
|
}
|
|
return pr;
|
|
} else {
|
|
throw tactic_cmd_error("invalid 'done' command, proof cannot be produced from this state", p, s);
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Execute the \c back (backtrack) tactic command. It
|
|
succeeds if the stack \c stack contains proof states. When it
|
|
succeeds, \c s is updated with the next state in the state
|
|
sequence on the top of \c stack. The new state is also removed
|
|
from the stack.
|
|
*/
|
|
void back_cmd(/* inout */ proof_state_seq_stack & stack, /* inout */ proof_state & s) {
|
|
auto p = pos();
|
|
next();
|
|
while (!stack.empty()) {
|
|
check_interrupted();
|
|
lazy_list<proof_state> seq = stack.back();
|
|
stack.pop_back();
|
|
proof_state_seq::maybe_pair r;
|
|
code_with_callbacks([&]() {
|
|
r = seq.pull();
|
|
});
|
|
if (r) {
|
|
stack.push_back(r->second);
|
|
s = r->first;
|
|
return;
|
|
}
|
|
}
|
|
throw tactic_cmd_error("failed to backtrack", p, s);
|
|
}
|
|
|
|
/**
|
|
\brief Execute the <tt>apply [tactic]</tt> tactic command.
|
|
This command just applies the tactic to the input state \c s.
|
|
If it succeeds, \c s is assigned to the head of the output
|
|
state sequence produced by the tactic. The rest/tail of the
|
|
output state sequence is stored on the top of the stack \c
|
|
stack.
|
|
*/
|
|
void apply_cmd(/* inout */ proof_state_seq_stack & stack, /* inout */ proof_state & s) {
|
|
auto tac_pos = pos();
|
|
next();
|
|
tactic t = parse_tactic_expr();
|
|
auto r = apply_tactic(s, t, tac_pos);
|
|
s = r.first;
|
|
stack.push_back(r.second);
|
|
}
|
|
|
|
/**
|
|
\brief Execute the \c assumption tactic command. This command
|
|
is just syntax sugar for <tt>apply assumption_tac</tt>.
|
|
*/
|
|
void assumption_cmd(/* inout */ proof_state_seq_stack & stack, /* inout */ proof_state & s) {
|
|
auto tac_pos = pos();
|
|
next();
|
|
auto r = apply_tactic(s, assumption_tactic(), tac_pos);
|
|
s = r.first;
|
|
stack.push_back(r.second);
|
|
}
|
|
|
|
/**
|
|
\brief Execute the \c done tactic command. It succeeds if
|
|
a proof for \c s can be built.
|
|
*/
|
|
expr done_cmd(proof_state const & s, context const & ctx, expr const & expected_type) {
|
|
auto p = pos();
|
|
next();
|
|
return mk_proof_for(s, p, ctx, expected_type);
|
|
}
|
|
|
|
/**
|
|
\brief Parse tactic command sequence for solving input state \c s.
|
|
|
|
The proof for \c s must have type \c expected_type in the context \c ctx.
|
|
*/
|
|
expr parse_tactic_cmds(proof_state s, context const & ctx, expr const & expected_type) {
|
|
proof_state_seq_stack stack;
|
|
optional<expr> pr;
|
|
enum class status { Continue, Done, Eof, Abort };
|
|
status st = status::Continue;
|
|
while (st == status::Continue) {
|
|
protected_call(
|
|
[&]() {
|
|
auto p = pos();
|
|
check_interrupted();
|
|
name id;
|
|
switch (curr()) {
|
|
case scanner::token::Period:
|
|
display_proof_state_if_interactive(s);
|
|
show_tactic_prompt();
|
|
next();
|
|
break;
|
|
case scanner::token::Eof:
|
|
st = status::Eof;
|
|
break;
|
|
case scanner::token::Id:
|
|
id = curr_name();
|
|
if (id == g_apply) {
|
|
apply_cmd(stack, s);
|
|
} else if (id == g_back) {
|
|
back_cmd(stack, s);
|
|
} else if (id == g_done) {
|
|
pr = done_cmd(s, ctx, expected_type);
|
|
if (pr)
|
|
st = status::Done;
|
|
} else if (id == g_abort) {
|
|
next();
|
|
st = status::Abort;
|
|
} else if (id == g_assumption) {
|
|
assumption_cmd(stack, s);
|
|
} else {
|
|
next();
|
|
throw tactic_cmd_error(sstream() << "invalid tactic command '" << id << "'", p, s);
|
|
}
|
|
break;
|
|
case scanner::token::CommandId:
|
|
st = status::Abort;
|
|
break;
|
|
default:
|
|
next();
|
|
throw tactic_cmd_error("invalid tactic command, identifier expected", p, s);
|
|
}
|
|
},
|
|
[&]() {
|
|
// Keep consuming tokens until we find a Command or End-of-file or Tactic command
|
|
show_tactic_prompt();
|
|
while (curr() != scanner::token::CommandId && curr() != scanner::token::Eof &&
|
|
curr() != scanner::token::Period && !curr_is_tactic_cmd())
|
|
next();
|
|
if (curr_is_period())
|
|
next();
|
|
});
|
|
}
|
|
switch (st) {
|
|
case status::Done: return *pr;
|
|
case status::Eof: throw parser_error("invalid tactic command, unexpected end of file", pos());
|
|
case status::Abort: throw parser_error("failed to prove theorem, proof has been aborted", pos());
|
|
default: lean_unreachable(); // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Return a 'hint' tactic (if it exists) for the given metavariable.
|
|
If the metavariable is not associated with any hint, then return the
|
|
null tactic. The method also returns the position of the hint.
|
|
*/
|
|
std::pair<optional<tactic>, pos_info> get_tactic_for(expr const & mvar) {
|
|
expr placeholder = m_elaborator.get_original(mvar);
|
|
auto it = m_tactic_hints.find(placeholder);
|
|
if (it != m_tactic_hints.end()) {
|
|
return mk_pair(some_tactic(it->second), pos_of(placeholder, pos()));
|
|
} else {
|
|
return mk_pair(none_tactic(), pos_of(placeholder, pos()));
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Try to fill the 'holes' in \c val using tactics.
|
|
The metavar_env \c menv contains the definition of the metavariables occurring in \c val.
|
|
|
|
If a 'hole' is associated with a "hint tactic" ('show-by' and 'by' constructs),
|
|
then this will be the tactic used to "fill" the hole. Otherwise,
|
|
a tactic command sequence is expected in the input stream being parsed.
|
|
*/
|
|
expr apply_tactics(expr const & val, metavar_env & menv) {
|
|
buffer<expr> mvars;
|
|
for_each(val, [&](expr const & e, unsigned) {
|
|
if (is_metavar(e)) {
|
|
mvars.push_back(e);
|
|
}
|
|
return true;
|
|
});
|
|
std::sort(mvars.begin(), mvars.end(), [](expr const & e1, expr const & e2) { return is_lt(e1, e2, false); });
|
|
for (auto mvar : mvars) {
|
|
expr mvar_type = instantiate_metavars(menv.get_type(mvar), menv);
|
|
if (has_metavar(mvar_type))
|
|
throw exception("failed to synthesize metavar, its type contains metavariables");
|
|
buffer<context_entry> new_entries;
|
|
for (auto e : menv.get_context(mvar)) {
|
|
optional<expr> d = e.get_domain();
|
|
optional<expr> b = e.get_body();
|
|
if (d) d = instantiate_metavars(*d, menv);
|
|
if (b) b = instantiate_metavars(*b, menv);
|
|
if (d)
|
|
new_entries.emplace_back(e.get_name(), *d, b);
|
|
else
|
|
new_entries.emplace_back(e.get_name(), d, *b);
|
|
}
|
|
context mvar_ctx(to_list(new_entries.begin(), new_entries.end()));
|
|
if (!m_type_inferer.is_proposition(mvar_type, mvar_ctx))
|
|
throw exception("failed to synthesize metavar, its type is not a proposition");
|
|
proof_state s = to_proof_state(m_frontend, mvar_ctx, mvar_type);
|
|
std::pair<optional<tactic>, pos_info> hint_and_pos = get_tactic_for(mvar);
|
|
if (hint_and_pos.first) {
|
|
// metavariable has an associated tactic hint
|
|
s = apply_tactic(s, *(hint_and_pos.first), hint_and_pos.second).first;
|
|
menv.assign(mvar, mk_proof_for(s, hint_and_pos.second, mvar_ctx, mvar_type));
|
|
} else {
|
|
if (curr_is_period()) {
|
|
display_proof_state_if_interactive(s);
|
|
show_tactic_prompt();
|
|
next();
|
|
}
|
|
expr mvar_val = parse_tactic_cmds(s, mvar_ctx, mvar_type);
|
|
menv.assign(mvar, mvar_val);
|
|
}
|
|
}
|
|
return instantiate_metavars(val, menv);
|
|
}
|
|
|
|
/** \brief Auxiliary method used for parsing definitions and theorems. */
|
|
void parse_def_core(bool is_definition) {
|
|
next();
|
|
expr pre_type, pre_val;
|
|
name id = check_identifier_next("invalid definition, identifier expected");
|
|
bindings_buffer bindings;
|
|
if (curr_is_colon()) {
|
|
next();
|
|
pre_type = parse_expr();
|
|
if (!is_definition && curr_is_period()) {
|
|
pre_val = save(mk_placeholder(), pos());
|
|
} else {
|
|
check_assign_next("invalid definition, ':=' expected");
|
|
pre_val = parse_expr();
|
|
}
|
|
} else if (is_definition && curr_is_assign()) {
|
|
auto p = pos();
|
|
next();
|
|
pre_type = save(mk_placeholder(), p);
|
|
pre_val = parse_expr();
|
|
} else {
|
|
mk_scope scope(*this);
|
|
parse_object_bindings(bindings);
|
|
check_colon_next("invalid definition, ':' expected");
|
|
expr type_body = parse_expr();
|
|
pre_type = mk_abstraction(false, bindings, type_body);
|
|
if (!is_definition && curr_is_period()) {
|
|
pre_val = mk_abstraction(true, bindings, mk_placeholder());
|
|
} else {
|
|
check_assign_next("invalid definition, ':=' expected");
|
|
expr val_body = parse_expr();
|
|
pre_val = mk_abstraction(true, bindings, val_body);
|
|
}
|
|
}
|
|
auto r = m_elaborator(id, pre_type, pre_val);
|
|
expr type = std::get<0>(r);
|
|
expr val = std::get<1>(r);
|
|
metavar_env menv = std::get<2>(r);
|
|
if (has_metavar(type))
|
|
throw exception("invalid definition, type still contains metavariables after elaboration");
|
|
if (!is_definition && has_metavar(val)) {
|
|
val = apply_tactics(val, menv);
|
|
}
|
|
if (has_metavar(val))
|
|
throw exception("invalid definition, value still contains metavariables after elaboration");
|
|
if (is_definition) {
|
|
m_frontend.add_definition(id, type, val);
|
|
if (m_verbose)
|
|
regular(m_frontend) << " Defined: " << id << endl;
|
|
} else {
|
|
m_frontend.add_theorem(id, type, val);
|
|
if (m_verbose)
|
|
regular(m_frontend) << " Proved: " << id << endl;
|
|
}
|
|
register_implicit_arguments(id, bindings);
|
|
}
|
|
|
|
/**
|
|
\brief Parse a Definition. It has one of the following two forms:
|
|
|
|
1) 'Definition' ID ':' expr ':=' expr
|
|
|
|
2) 'Definition' ID bindings ':' expr ':=' expr
|
|
*/
|
|
void parse_definition() {
|
|
parse_def_core(true);
|
|
}
|
|
|
|
/**
|
|
\brief Parse a Theorem. It has one of the following two forms:
|
|
|
|
1) 'Theorem' ID ':' expr ':=' expr
|
|
|
|
2) 'Theorem' ID bindings ':' expr ':=' expr
|
|
*/
|
|
void parse_theorem() {
|
|
parse_def_core(false);
|
|
}
|
|
|
|
/** \brief Auxiliary method for parsing Variable and axiom declarations. */
|
|
void parse_variable_core(bool is_var) {
|
|
next();
|
|
name id = check_identifier_next("invalid variable/axiom declaration, identifier expected");
|
|
bindings_buffer bindings;
|
|
expr type;
|
|
if (curr_is_colon()) {
|
|
next();
|
|
type = m_elaborator(parse_expr());
|
|
} else {
|
|
mk_scope scope(*this);
|
|
parse_object_bindings(bindings);
|
|
check_colon_next("invalid variable/axiom declaration, ':' expected");
|
|
expr type_body = parse_expr();
|
|
type = m_elaborator(mk_abstraction(false, bindings, type_body));
|
|
}
|
|
if (is_var)
|
|
m_frontend.add_var(id, type);
|
|
else
|
|
m_frontend.add_axiom(id, type);
|
|
if (m_verbose)
|
|
regular(m_frontend) << " Assumed: " << id << endl;
|
|
register_implicit_arguments(id, bindings);
|
|
}
|
|
|
|
/** \brief Parse one of the two forms:
|
|
|
|
1) 'Variable' ID ':' type
|
|
|
|
2) 'Variable' ID bindings ':' type
|
|
*/
|
|
void parse_variable() {
|
|
parse_variable_core(true);
|
|
}
|
|
|
|
/** \brief Parse the form:
|
|
'Variables' ID+ ':' type
|
|
*/
|
|
void parse_variables() {
|
|
next();
|
|
mk_scope scope(*this);
|
|
bindings_buffer bindings;
|
|
parse_simple_bindings(bindings, false, false);
|
|
for (auto b : bindings) {
|
|
name const & id = std::get<1>(b);
|
|
if (m_frontend.find_object(id))
|
|
throw already_declared_exception(m_frontend, id);
|
|
}
|
|
for (auto b : bindings) {
|
|
name const & id = std::get<1>(b);
|
|
expr const & type = std::get<2>(b);
|
|
m_frontend.add_var(id, type);
|
|
if (m_verbose)
|
|
regular(m_frontend) << " Assumed: " << id << endl;
|
|
}
|
|
}
|
|
|
|
/** \brief Parse one of the two forms:
|
|
|
|
1) 'Axiom' ID ':' type
|
|
|
|
2) 'Axiom' ID bindings ':' type
|
|
*/
|
|
void parse_axiom() {
|
|
parse_variable_core(false);
|
|
}
|
|
|
|
/** \brief Parse 'Eval' expr */
|
|
void parse_eval() {
|
|
next();
|
|
expr v = m_elaborator(parse_expr());
|
|
normalizer norm(m_frontend);
|
|
expr r = norm(v);
|
|
regular(m_frontend) << r << endl;
|
|
}
|
|
|
|
/** \brief Parse
|
|
'Show' expr
|
|
'Show' Environment [num]
|
|
'Show' Options
|
|
*/
|
|
void parse_show() {
|
|
next();
|
|
if (curr() == scanner::token::CommandId) {
|
|
name opt_id = curr_name();
|
|
next();
|
|
if (opt_id == g_env_kwd) {
|
|
if (curr_is_nat()) {
|
|
unsigned i = parse_unsigned("invalid argument, value does not fit in a machine integer");
|
|
auto end = m_frontend.end_objects();
|
|
auto beg = m_frontend.begin_objects();
|
|
auto it = end;
|
|
while (it != beg && i != 0) {
|
|
--i;
|
|
--it;
|
|
}
|
|
for (; it != end; ++it) {
|
|
regular(m_frontend) << *it << endl;
|
|
}
|
|
} else {
|
|
regular(m_frontend) << m_frontend << endl;
|
|
}
|
|
} else if (opt_id == g_options_kwd) {
|
|
regular(m_frontend) << pp(m_frontend.get_state().get_options()) << endl;
|
|
} else {
|
|
throw parser_error("invalid Show command, expression, 'Options' or 'Environment' expected", m_last_cmd_pos);
|
|
}
|
|
} else {
|
|
expr v = m_elaborator(parse_expr());
|
|
regular(m_frontend) << v << endl;
|
|
}
|
|
}
|
|
|
|
/** \brief Parse 'Check' expr */
|
|
void parse_check() {
|
|
next();
|
|
expr v = m_elaborator(parse_expr());
|
|
expr t = infer_type(v, m_frontend);
|
|
formatter fmt = m_frontend.get_state().get_formatter();
|
|
options opts = m_frontend.get_state().get_options();
|
|
unsigned indent = get_pp_indent(opts);
|
|
format r = group(format{fmt(v, opts), space(), colon(), nest(indent, compose(line(), fmt(t, opts)))});
|
|
regular(m_frontend) << mk_pair(r, opts) << endl;
|
|
}
|
|
|
|
/** \brief Return the (optional) precedence of a user-defined operator. */
|
|
unsigned parse_precedence() {
|
|
if (curr_is_nat()) {
|
|
return parse_unsigned("invalid operator definition, precedence does not fit in a machine integer");
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/** \brief Throw an error if the current token is not an identifier. If it is, move to next token. */
|
|
name parse_op_id() {
|
|
return check_identifier_next("invalid operator definition, identifier expected");
|
|
}
|
|
|
|
/**
|
|
\brief Parse prefix/postfix/infix/infixl/infixr user operator
|
|
definitions. These definitions have the form:
|
|
|
|
- fixity [Num] ID ':' ID
|
|
*/
|
|
void parse_op(fixity fx) {
|
|
next();
|
|
unsigned prec = parse_precedence();
|
|
name op_id = parse_op_id();
|
|
check_colon_next("invalid operator definition, ':' expected");
|
|
name name_id = check_identifier_next("invalid operator definition, identifier expected");
|
|
expr d = mk_constant(name_id);
|
|
switch (fx) {
|
|
case fixity::Infix: m_frontend.add_infix(op_id, prec, d); break;
|
|
case fixity::Infixl: m_frontend.add_infixl(op_id, prec, d); break;
|
|
case fixity::Infixr: m_frontend.add_infixr(op_id, prec, d); break;
|
|
default: lean_unreachable(); // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
/**
|
|
\brief Parse notation declaration unified format
|
|
|
|
'Notation' [Num] parts ':' ID
|
|
*/
|
|
void parse_notation_decl() {
|
|
auto p = pos();
|
|
next();
|
|
unsigned prec = parse_precedence();
|
|
bool first = true;
|
|
bool prev_placeholder = false;
|
|
bool first_placeholder = false;
|
|
buffer<name> parts;
|
|
while (true) {
|
|
if (first) {
|
|
if (curr_is_placeholder()) {
|
|
prev_placeholder = true;
|
|
first_placeholder = true;
|
|
next();
|
|
} else {
|
|
parts.push_back(check_identifier_next("invalid notation declaration, identifier or '_' expected"));
|
|
prev_placeholder = false;
|
|
first_placeholder = false;
|
|
}
|
|
first = false;
|
|
} else {
|
|
if (curr_is_colon()) {
|
|
next();
|
|
if (parts.size() == 0) {
|
|
throw parser_error("invalid notation declaration, it must have at least one identifier", p);
|
|
}
|
|
name name_id = check_identifier_next("invalid notation declaration, identifier expected");
|
|
expr d = mk_constant(name_id);
|
|
if (parts.size() == 1) {
|
|
if (first_placeholder && prev_placeholder) {
|
|
// infix: _ ID _
|
|
m_frontend.add_infix(parts[0], prec, d);
|
|
} else if (first_placeholder) {
|
|
// postfix: _ ID
|
|
m_frontend.add_postfix(parts[0], prec, d);
|
|
} else if (prev_placeholder) {
|
|
// prefix: ID _
|
|
m_frontend.add_prefix(parts[0], prec, d);
|
|
} else {
|
|
throw parser_error("invalid notation declaration, at least one placeholder expected", p);
|
|
}
|
|
} else {
|
|
if (first_placeholder && prev_placeholder) {
|
|
// mixfixo: _ ID ... ID _
|
|
m_frontend.add_mixfixo(parts.size(), parts.data(), prec, d);
|
|
} else if (first_placeholder) {
|
|
// mixfixr: _ ID ... ID
|
|
m_frontend.add_mixfixr(parts.size(), parts.data(), prec, d);
|
|
} else if (prev_placeholder) {
|
|
// mixfixl: ID _ ... ID _
|
|
m_frontend.add_mixfixl(parts.size(), parts.data(), prec, d);
|
|
} else {
|
|
// mixfixc: ID _ ... _ ID
|
|
m_frontend.add_mixfixc(parts.size(), parts.data(), prec, d);
|
|
}
|
|
}
|
|
return;
|
|
} else {
|
|
if (prev_placeholder) {
|
|
parts.push_back(check_identifier_next("invalid notation declaration, identifier or ':' expected"));
|
|
prev_placeholder = false;
|
|
} else {
|
|
check_placeholder_next("invalid notation declaration, '_' or ':' expected");
|
|
prev_placeholder = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Parse 'Echo' [string] */
|
|
void parse_echo() {
|
|
next();
|
|
std::string msg = check_string_next("invalid echo command, string expected");
|
|
regular(m_frontend) << msg << endl;
|
|
}
|
|
|
|
/** Parse 'Set' [id] [value] */
|
|
void parse_set() {
|
|
next();
|
|
auto id_pos = pos();
|
|
name id = check_identifier_next("invalid set options, identifier (i.e., option name) expected");
|
|
auto decl_it = get_option_declarations().find(id);
|
|
if (decl_it == get_option_declarations().end()) {
|
|
// add "lean" prefix
|
|
name lean_id = name("lean") + id;
|
|
decl_it = get_option_declarations().find(lean_id);
|
|
if (decl_it == get_option_declarations().end()) {
|
|
throw parser_error(sstream() << "unknown option '" << id << "', type 'Help Options.' for list of available options", id_pos);
|
|
} else {
|
|
id = lean_id;
|
|
}
|
|
}
|
|
option_kind k = decl_it->second.kind();
|
|
switch (curr()) {
|
|
case scanner::token::Id:
|
|
if (k != BoolOption)
|
|
throw parser_error(sstream() << "invalid option value, given option is not Boolean", pos());
|
|
if (curr_name() == "true")
|
|
m_frontend.set_option(id, true);
|
|
else if (curr_name() == "false")
|
|
m_frontend.set_option(id, false);
|
|
else
|
|
throw parser_error("invalid Boolean option value, 'true' or 'false' expected", pos());
|
|
next();
|
|
break;
|
|
case scanner::token::StringVal:
|
|
if (k != StringOption)
|
|
throw parser_error("invalid option value, given option is not a string", pos());
|
|
m_frontend.set_option(id, curr_string());
|
|
next();
|
|
break;
|
|
case scanner::token::NatVal:
|
|
if (k != IntOption && k != UnsignedOption)
|
|
throw parser_error("invalid option value, given option is not an integer", pos());
|
|
m_frontend.set_option(id, parse_unsigned("invalid option value, value does not fit in a machine integer"));
|
|
break;
|
|
case scanner::token::DecimalVal:
|
|
if (k != DoubleOption)
|
|
throw parser_error("invalid option value, given option is not floating point value", pos());
|
|
m_frontend.set_option(id, parse_double());
|
|
break;
|
|
default:
|
|
throw parser_error("invalid option value, 'true', 'false', string, integer or decimal value expected", pos());
|
|
}
|
|
updt_options();
|
|
if (m_verbose)
|
|
regular(m_frontend) << " Set: " << id << endl;
|
|
}
|
|
|
|
void parse_import() {
|
|
next();
|
|
std::string fname = check_string_next("invalid import command, string (i.e., file name) expected");
|
|
std::ifstream in(fname);
|
|
if (!in.is_open())
|
|
throw parser_error(sstream() << "invalid import command, failed to open file '" << fname << "'", m_last_cmd_pos);
|
|
if (!m_frontend.get_environment().mark_imported(fname.c_str())) {
|
|
diagnostic(m_frontend) << "Module '" << fname << "' has already been imported" << endl;
|
|
return;
|
|
}
|
|
try {
|
|
if (m_verbose)
|
|
regular(m_frontend) << "Importing file '" << fname << "'" << endl;
|
|
parser import_parser(m_frontend, in, m_script_state, true /* use exceptions */, false /* not interactive */);
|
|
import_parser();
|
|
} catch (interrupted &) {
|
|
throw;
|
|
} catch (exception &) {
|
|
throw parser_error(sstream() << "failed to import file '" << fname << "'", m_last_cmd_pos);
|
|
}
|
|
}
|
|
|
|
void parse_help() {
|
|
next();
|
|
if (curr() == scanner::token::CommandId) {
|
|
name opt_id = curr_name();
|
|
next();
|
|
if (opt_id == g_options_kwd) {
|
|
regular(m_frontend) << "Available options:" << endl;
|
|
for (auto p : get_option_declarations()) {
|
|
auto opt = p.second;
|
|
regular(m_frontend) << " " << opt.get_name() << " (" << opt.kind() << ") "
|
|
<< opt.get_description() << " (default: " << opt.get_default_value() << ")" << endl;
|
|
}
|
|
} else {
|
|
throw parser_error("invalid help command", m_last_cmd_pos);
|
|
}
|
|
} else {
|
|
regular(m_frontend) << "Available commands:" << endl
|
|
<< " Axiom [id] : [type] assert/postulate a new axiom" << endl
|
|
<< " Check [expr] type check the given expression" << endl
|
|
<< " Definition [id] : [type] := [expr] define a new element" << endl
|
|
<< " Theorem [id] : [type] := [expr] define a new theorem" << endl
|
|
<< " Echo [string] display the given string" << endl
|
|
<< " Eval [expr] evaluate the given expression" << endl
|
|
<< " Exit exit" << endl
|
|
<< " Help display this message" << endl
|
|
<< " Help Options display available options" << endl
|
|
<< " Help Notation describe commands for defining infix, mixfix, postfix operators" << endl
|
|
<< " Import [string] load the given file" << endl
|
|
<< " Set [id] [value] set option [id] with value [value]" << endl
|
|
<< " Show [expr] pretty print the given expression" << endl
|
|
<< " Show Options show current the set of assigned options" << endl
|
|
<< " Show Environment show objects in the environment, if [Num] provided, then show only the last [Num] objects" << endl
|
|
<< " Show Environment [num] show the last num objects in the environment" << endl
|
|
<< " Variable [id] : [type] declare/postulate an element of the given type" << endl
|
|
<< " Universe [id] [level] declare a new universe variable that is >= the given level" << endl;
|
|
#if !defined(LEAN_WINDOWS)
|
|
regular(m_frontend) << "Type Ctrl-D to exit" << endl;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/** \brief Parse 'Coercion' expr */
|
|
void parse_coercion() {
|
|
next();
|
|
expr coercion = parse_expr();
|
|
m_frontend.add_coercion(coercion);
|
|
if (m_verbose)
|
|
regular(m_frontend) << " Coercion " << coercion << endl;
|
|
}
|
|
|
|
/** \brief Parse a Lean command. */
|
|
bool parse_command() {
|
|
m_elaborator.clear();
|
|
m_expr_pos_info.clear();
|
|
m_tactic_hints.clear();
|
|
m_last_cmd_pos = pos();
|
|
name const & cmd_id = curr_name();
|
|
if (cmd_id == g_definition_kwd) {
|
|
parse_definition();
|
|
} else if (cmd_id == g_variable_kwd) {
|
|
parse_variable();
|
|
} else if (cmd_id == g_variables_kwd) {
|
|
parse_variables();
|
|
} else if (cmd_id == g_theorem_kwd) {
|
|
parse_theorem();
|
|
} else if (cmd_id == g_axiom_kwd) {
|
|
parse_axiom();
|
|
} else if (cmd_id == g_eval_kwd) {
|
|
parse_eval();
|
|
} else if (cmd_id == g_show_kwd) {
|
|
parse_show();
|
|
} else if (cmd_id == g_check_kwd) {
|
|
parse_check();
|
|
} else if (cmd_id == g_infix_kwd) {
|
|
parse_op(fixity::Infix);
|
|
} else if (cmd_id == g_infixl_kwd) {
|
|
parse_op(fixity::Infixl);
|
|
} else if (cmd_id == g_infixr_kwd) {
|
|
parse_op(fixity::Infixr);
|
|
} else if (cmd_id == g_notation_kwd) {
|
|
parse_notation_decl();
|
|
} else if (cmd_id == g_echo_kwd) {
|
|
parse_echo();
|
|
} else if (cmd_id == g_set_kwd) {
|
|
parse_set();
|
|
} else if (cmd_id == g_import_kwd) {
|
|
parse_import();
|
|
} else if (cmd_id == g_help_kwd) {
|
|
parse_help();
|
|
} else if (cmd_id == g_coercion_kwd) {
|
|
parse_coercion();
|
|
} else if (cmd_id == g_exit_kwd) {
|
|
next();
|
|
return false;
|
|
} else {
|
|
next();
|
|
throw parser_error(sstream() << "invalid command '" << cmd_id << "'", m_last_cmd_pos);
|
|
}
|
|
return true;
|
|
}
|
|
/*@}*/
|
|
|
|
void updt_options() {
|
|
m_verbose = get_parser_verbose(m_frontend.get_state().get_options());
|
|
m_show_errors = get_parser_show_errors(m_frontend.get_state().get_options());
|
|
}
|
|
|
|
/**
|
|
\brief Parse a block of Lua code. If as_expr is true, then
|
|
it appends the string "return " in front of the script.
|
|
*/
|
|
void parse_script(bool as_expr = false) {
|
|
m_last_script_pos = mk_pair(m_scanner.get_script_block_line(), m_scanner.get_script_block_pos());
|
|
if (!m_script_state)
|
|
throw exception("failed to execute Lua script, parser does not have a Lua interpreter");
|
|
std::string script_code = m_scanner.get_str_val();
|
|
if (as_expr) {
|
|
script_code = "return " + script_code;
|
|
}
|
|
next();
|
|
using_script([&](lua_State * L) {
|
|
dostring(L, script_code.c_str());
|
|
});
|
|
}
|
|
|
|
void parse_script_expr() { return parse_script(true); }
|
|
|
|
public:
|
|
imp(frontend & fe, std::istream & in, script_state * S, bool use_exceptions, bool interactive):
|
|
m_frontend(fe),
|
|
m_scanner(in),
|
|
m_elaborator(fe),
|
|
m_type_inferer(fe),
|
|
m_use_exceptions(use_exceptions),
|
|
m_interactive(interactive) {
|
|
m_script_state = S;
|
|
updt_options();
|
|
m_found_errors = false;
|
|
m_num_local_decls = 0;
|
|
m_scanner.set_command_keywords(g_command_keywords);
|
|
scan();
|
|
}
|
|
|
|
static void show_prompt(bool interactive, frontend & fe) {
|
|
if (interactive) {
|
|
regular(fe) << "# ";
|
|
regular(fe).flush();
|
|
}
|
|
}
|
|
|
|
void show_prompt() {
|
|
show_prompt(m_interactive, m_frontend);
|
|
}
|
|
|
|
void show_tactic_prompt() {
|
|
if (m_interactive) {
|
|
regular(m_frontend) << "## ";
|
|
regular(m_frontend).flush();
|
|
}
|
|
}
|
|
|
|
/** \brief Parse a sequence of commands. This method also perform error management. */
|
|
bool parse_commands() {
|
|
bool done = false;
|
|
while (!done) {
|
|
protected_call([&]() {
|
|
check_interrupted();
|
|
switch (curr()) {
|
|
case scanner::token::CommandId: if (!parse_command()) done = true; break;
|
|
case scanner::token::ScriptBlock: parse_script(); break;
|
|
case scanner::token::Period: show_prompt(); next(); break;
|
|
case scanner::token::Eof: done = true; break;
|
|
default:
|
|
throw parser_error("Command expected", pos());
|
|
}
|
|
}, [&]() {
|
|
// Keep consuming tokens until we find a Command or End-of-file
|
|
show_prompt();
|
|
while (curr() != scanner::token::CommandId && curr() != scanner::token::Eof && curr() != scanner::token::Period)
|
|
next();
|
|
if (curr_is_period())
|
|
next();
|
|
});
|
|
}
|
|
return !m_found_errors;
|
|
}
|
|
|
|
/** \brief Parse an expression. */
|
|
expr parse_expr_main() {
|
|
try {
|
|
return m_elaborator(parse_expr());
|
|
} catch (parser_error & ex) {
|
|
throw parser_exception(ex.what(), ex.m_pos.first, ex.m_pos.second);
|
|
}
|
|
}
|
|
};
|
|
|
|
parser::parser(frontend & fe, std::istream & in, script_state * S, bool use_exceptions, bool interactive) {
|
|
parser::imp::show_prompt(interactive, fe);
|
|
m_ptr.reset(new imp(fe, in, S, use_exceptions, interactive));
|
|
}
|
|
|
|
parser::~parser() {
|
|
}
|
|
|
|
bool parser::operator()() {
|
|
return m_ptr->parse_commands();
|
|
}
|
|
|
|
expr parser::parse_expr() {
|
|
return m_ptr->parse_expr_main();
|
|
}
|
|
|
|
shell::shell(frontend & fe, script_state * S):m_frontend(fe), m_script_state(S) {
|
|
}
|
|
|
|
shell::~shell() {
|
|
}
|
|
|
|
bool shell::operator()() {
|
|
#ifdef LEAN_USE_READLINE
|
|
bool errors = false;
|
|
while (true) {
|
|
char * input = readline("# ");
|
|
if (!input)
|
|
return errors;
|
|
add_history(input);
|
|
std::istringstream strm(input);
|
|
{
|
|
parser p(m_frontend, strm, m_script_state, false, false);
|
|
if (!p())
|
|
errors = true;
|
|
}
|
|
free(input);
|
|
}
|
|
#else
|
|
parser p(m_frontend, std::cin, m_script_state, false, true);
|
|
return p();
|
|
#endif
|
|
}
|
|
|
|
bool parse_commands(frontend & fe, std::istream & in, script_state * S, bool use_exceptions, bool interactive) {
|
|
return parser(fe, in, S, use_exceptions, interactive)();
|
|
}
|
|
|
|
bool parse_commands(environment const & env, io_state & st, std::istream & in, script_state * S, bool use_exceptions, bool interactive) {
|
|
frontend f(env, st);
|
|
bool r = parse_commands(f, in, S, use_exceptions, interactive);
|
|
st = f.get_state();
|
|
return r;
|
|
}
|
|
|
|
expr parse_expr(frontend & fe, std::istream & in, script_state * S, bool use_exceptions) {
|
|
return parser(fe, in, S, use_exceptions).parse_expr();
|
|
}
|
|
|
|
expr parse_expr(environment const & env, io_state & st, std::istream & in, script_state * S, bool use_exceptions) {
|
|
frontend f(env, st);
|
|
expr r = parse_expr(f, in, S, use_exceptions);
|
|
st = f.get_state();
|
|
return r;
|
|
}
|
|
}
|