generic-library/ChaiScript
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'develop' into method_missing

Browse Source
This commit is contained in:
Andreas Reischuck
2015-04-08 16:52:34 +02:00
parent b67dc4e09a 63684d0042
commit cbeeadd6f3
22 changed files with 651 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/chaiscript/chaiscript_threading.hpp
View File

@@ -7,6 +7,7 @@
#ifndef CHAISCRIPT_THREADING_HPP_
#define CHAISCRIPT_THREADING_HPP_
#include <unordered_map>
#ifndef CHAISCRIPT_NO_THREADS
@@ -16,6 +17,8 @@
#pragma message ("ChaiScript is compiling without thread safety.")
#endif
#include "chaiscript_defines.hpp"
/// \file
///
/// This file contains code necessary for thread support in ChaiScript.

9
include/chaiscript/dispatchkit/bootstrap.hpp
View File

@@ -136,10 +136,14 @@ namespace chaiscript
ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
{
m->add(user_type<T>(), name);
m->add(constructor<T ()>(), name);
m->add(constructor<T()>(), name);
construct_pod<T>(name, m);
m->add(fun(&to_string<T>), "to_string");
auto to_s = fun(&to_string<T>);
if (!m->has_function(to_s, "to_string")) {
m->add(to_s, "to_string");
}
m->add(fun(&parse_string<T>), "to_" + name);
return m;
}
@@ -471,7 +475,6 @@ namespace chaiscript
m->add(chaiscript::fun(&has_parse_tree), "has_parse_tree");
m->add(chaiscript::fun(&get_parse_tree), "get_parse_tree");
m->add(chaiscript::user_type<chaiscript::exception::eval_error>(), "eval_error");
m->add(chaiscript::base_class<std::runtime_error, chaiscript::exception::eval_error>());
m->add(chaiscript::user_type<chaiscript::exception::arithmetic_error>(), "arithmetic_error");

3
include/chaiscript/dispatchkit/bootstrap_stl.hpp
View File

@@ -267,7 +267,7 @@ namespace chaiscript
template<typename ContainerType>
ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
basic_constructors<ContainerType>(type, m);
copy_constructor<ContainerType>(type, m);
operators::assign<ContainerType>(m);
return m;
}
@@ -443,6 +443,7 @@ namespace chaiscript
m->add(fun(static_cast<elemaccess>(&MapType::operator[])), "[]");
container_type<MapType>(type, m);
default_constructible_type<MapType>(type, m);
assignable_type<MapType>(type, m);
unique_associative_container_type<MapType>(type, m);
pair_associative_container_type<MapType>(type, m);

17
include/chaiscript/dispatchkit/boxed_cast_helper.hpp
View File

@@ -65,21 +65,11 @@ namespace chaiscript
typedef const Result * Result_Type;
static Result_Type cast(const Boxed_Value &ob, const Type_Conversions *)
{
if (ob.is_ref())
if (ob.get_type_info().bare_equal_type_info(typeid(Result)))
{
if (!ob.get_type_info().is_const())
{
return &(ob.get().cast<std::reference_wrapper<Result> >()).get();
} else {
return &(ob.get().cast<std::reference_wrapper<const Result> >()).get();
}
return static_cast<const Result *>(throw_if_null(ob.get_const_ptr()));
} else {
if (!ob.get_type_info().is_const())
{
return (ob.get().cast<std::shared_ptr<Result> >()).get();
} else {
return (ob.get().cast<std::shared_ptr<const Result> >()).get();
}
throw chaiscript::detail::exception::bad_any_cast();
}
}
};
@@ -101,6 +91,7 @@ namespace chaiscript
};
/// Cast_Helper_Inner for casting to a & type
template<typename Result>
struct Cast_Helper_Inner<Result &>

32
include/chaiscript/dispatchkit/dispatchkit.hpp
View File

@@ -199,6 +199,14 @@ namespace chaiscript
{
}
bool has_function(const Proxy_Function &new_f, const std::string &name)
{
return std::any_of(m_funcs.begin(), m_funcs.end(), [&](const std::pair<Proxy_Function, std::string> &existing_f) {
return existing_f.second == name && *(existing_f.first) == *(new_f);
});
}
private:
std::vector<std::pair<Type_Info, std::string> > m_typeinfos;
std::vector<std::pair<Proxy_Function, std::string> > m_funcs;
@@ -580,7 +588,7 @@ namespace chaiscript
}
/// Returns the type info for a named type
Type_Info get_type(const std::string &name) const
Type_Info get_type(const std::string &name, bool t_throw = true) const
{
chaiscript::detail::threading::shared_lock<chaiscript::detail::threading::shared_mutex> l(m_mutex);
@@ -591,7 +599,11 @@ namespace chaiscript
return itr->second;
}
throw std::range_error("Type Not Known");
if (t_throw) {
throw std::range_error("Type Not Known");
} else {
return Type_Info();
}
}
/// Returns the registered name of a known type_info object
@@ -1018,14 +1030,6 @@ namespace chaiscript
static bool function_less_than(const Proxy_Function &lhs, const Proxy_Function &rhs)
{
const auto &lhsparamtypes = lhs->get_param_types();
const auto &rhsparamtypes = rhs->get_param_types();
const auto lhssize = lhsparamtypes.size();
const auto rhssize = rhsparamtypes.size();
CHAISCRIPT_CONSTEXPR auto boxed_type = user_type<Boxed_Value>();
CHAISCRIPT_CONSTEXPR auto boxed_pod_type = user_type<Boxed_Number>();
auto dynamic_lhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(lhs));
auto dynamic_rhs(std::dynamic_pointer_cast<const dispatch::Dynamic_Proxy_Function>(rhs));
@@ -1055,6 +1059,14 @@ namespace chaiscript
return true;
}
const auto &lhsparamtypes = lhs->get_param_types();
const auto &rhsparamtypes = rhs->get_param_types();
const auto lhssize = lhsparamtypes.size();
const auto rhssize = rhsparamtypes.size();
CHAISCRIPT_CONSTEXPR auto boxed_type = user_type<Boxed_Value>();
CHAISCRIPT_CONSTEXPR auto boxed_pod_type = user_type<Boxed_Number>();
for (size_t i = 1; i < lhssize && i < rhssize; ++i)
{

2
include/chaiscript/dispatchkit/dynamic_object_detail.hpp
View File

@@ -57,7 +57,7 @@ namespace chaiscript
const Proxy_Function &t_func,
const Type_Info &t_ti)
: Proxy_Function_Base(build_param_types(t_func->get_param_types(), t_ti), t_func->get_arity()),
m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>())
m_type_name(std::move(t_type_name)), m_func(t_func), m_ti(t_ti.is_undef()?nullptr:new Type_Info(t_ti)), m_doti(user_type<Dynamic_Object>())
{
assert( (t_func->get_arity() > 0 || t_func->get_arity() < 0)
&& "Programming error, Dynamic_Object_Function must have at least one parameter (this)");

17
include/chaiscript/dispatchkit/handle_return.hpp
View File

@@ -12,6 +12,7 @@
#include <stdexcept>
#include <string>
#include <vector>
#include <type_traits>
#include "boxed_number.hpp"
#include "boxed_value.hpp"
@@ -33,15 +34,19 @@ namespace chaiscript
template<typename Ret>
struct Handle_Return
{
static Boxed_Value handle(const Ret &r)
{
return const_var(r);
}
static Boxed_Value handle(Ret &&r)
template<typename T,
typename = typename std::enable_if<std::is_pod<typename std::decay<T>::type>::value>::type>
static Boxed_Value handle(T r)
{
return Boxed_Value(std::move(r));
}
template<typename T,
typename = typename std::enable_if<!std::is_pod<typename std::decay<T>::type>::value>::type>
static Boxed_Value handle(T &&r)
{
return Boxed_Value(std::make_shared<T>(std::forward<T>(r)));
}
};
template<typename Ret>

27
include/chaiscript/dispatchkit/proxy_functions.hpp
View File

@@ -529,12 +529,7 @@ namespace chaiscript
virtual bool call_match(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const CHAISCRIPT_OVERRIDE
{
if (static_cast<int>(vals.size()) != get_arity())
{
return false;
}
return compare_types(m_types, vals) || compare_types_with_cast(vals, t_conversions);
return static_cast<int>(vals.size()) == get_arity() && (compare_types(m_types, vals) || compare_types_with_cast(vals, t_conversions));
}
virtual bool compare_types_with_cast(const std::vector<Boxed_Value> &vals, const Type_Conversions &t_conversions) const = 0;
@@ -722,8 +717,18 @@ namespace chaiscript
{
matching_func = begin;
} else {
// More than one function matches, not attempting
throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
// handle const members vs non-const member, which is not really ambiguous
const auto &mat_fun_param_types = (*matching_func)->get_param_types();
const auto &next_fun_param_types = (*begin)->get_param_types();
if (plist[0].is_const() && !mat_fun_param_types[1].is_const() && next_fun_param_types[1].is_const()) {
matching_func = begin; // keep the new one, the const/non-const matchup is correct
} else if (!plist[0].is_const() && !mat_fun_param_types[1].is_const() && next_fun_param_types[1].is_const()) {
// keep the old one, it has a better const/non-const matchup
} else {
// ambiguous function call
throw exception::dispatch_error(plist, std::vector<Const_Proxy_Function>(orig, end));
}
}
}
@@ -808,12 +813,6 @@ namespace chaiscript
return (*(func.second))(plist, t_conversions);
}
} catch (const exception::bad_boxed_cast &) {
//std::cout << "Bad Boxed Cast: " << func.second->get_arity() << '(';
//for (const auto &p : plist) {
// std::cout << p.get_type_info().name() << ',';
//}
//std::cout << ")\n";
//parameter failed to cast, try again
} catch (const exception::arity_error &) {
//invalid num params, try again

41
include/chaiscript/dispatchkit/type_conversions.hpp
View File

@@ -119,24 +119,27 @@ namespace chaiscript
// Dynamic cast out the contained boxed value, which we know is the type we want
if (t_from.is_const())
{
std::shared_ptr<const To> data
= std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr));
if (!data)
{
throw std::bad_cast();
}
return Boxed_Value(data);
return Boxed_Value(
[&]()->std::shared_ptr<const To>{
if (auto data = std::dynamic_pointer_cast<const To>(detail::Cast_Helper<std::shared_ptr<const From> >::cast(t_from, nullptr)))
{
return data;
} else {
throw std::bad_cast();
}
}()
);
} else {
std::shared_ptr<To> data
= std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr));
if (!data)
{
throw std::bad_cast();
}
return Boxed_Value(data);
return Boxed_Value(
[&]()->std::shared_ptr<To>{
if (auto data = std::dynamic_pointer_cast<To>(detail::Cast_Helper<std::shared_ptr<From> >::cast(t_from, nullptr)))
{
return data;
} else {
throw std::bad_cast();
}
}()
);
}
} else {
// Pull the reference out of the contained boxed value, which we know is the type we want
@@ -439,9 +442,7 @@ namespace chaiscript
static_assert(std::is_convertible<From, To>::value, "Types are not automatically convertible");
auto func = [](const Boxed_Value &t_bv) -> Boxed_Value {
// not even attempting to call boxed_cast so that we don't get caught in some call recursion
auto &&from = detail::Cast_Helper<From>::cast(t_bv, nullptr);
To to(from);
return chaiscript::Boxed_Value(to);
return chaiscript::Boxed_Value(To(detail::Cast_Helper<From>::cast(t_bv, nullptr)));
};
return std::make_shared<detail::Type_Conversion_Impl<decltype(func)>>(user_type<From>(), user_type<To>(), func);

2
include/chaiscript/language/chaiscript_common.hpp
View File

@@ -499,7 +499,7 @@ namespace chaiscript
struct Return_Value {
Boxed_Value retval;
Return_Value(const Boxed_Value &t_return_value) : retval(t_return_value) { }
Return_Value(Boxed_Value t_return_value) : retval(std::move(t_return_value)) { }
};

26
include/chaiscript/language/chaiscript_engine.hpp
View File

@@ -297,6 +297,15 @@ namespace chaiscript
}
}
/// Evaluates the given string, used during eval() inside of a script
const Boxed_Value internal_eval_file(const std::string &t_filename) {
try {
return do_eval(load_file(t_filename), t_filename, true);
} catch (const exception::eval_error &t_ee) {
throw Boxed_Value(t_ee);
}
}
/// Evaluates the given string, used during eval() inside of a script
@@ -353,7 +362,9 @@ namespace chaiscript
m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type_name, std::ref(m_engine)), "name");
m_engine.add(fun(&chaiscript::detail::Dispatch_Engine::get_type, std::ref(m_engine)), "type");
m_engine.add(fun<void (const Type_Info &, const Type_Info &, const std::function<Boxed_Value (const Boxed_Value &)> &)> (
m_engine.add(fun<chaiscript::Type_Info (const std::string &)>([this](const std::string &t_type_name){ return this->m_engine.get_type(t_type_name, true); }), "type");
m_engine.add(fun<void(const Type_Info &, const Type_Info &, const std::function<Boxed_Value(const Boxed_Value &)> &)>(
[=](const Type_Info &t_from, const Type_Info &t_to, const std::function<Boxed_Value (const Boxed_Value &)> &t_func) {
m_engine.add(chaiscript::type_conversion(t_from, t_to, t_func));
}
@@ -367,6 +378,7 @@ namespace chaiscript
m_engine.add(fun(static_cast<load_mod_2>(&ChaiScript::load_module), this), "load_module");
m_engine.add(fun(&ChaiScript::use, this), "use");
m_engine.add(fun(&ChaiScript::internal_eval_file, this), "eval_file");
m_engine.add(fun(&ChaiScript::internal_eval, this), "eval");
m_engine.add(fun(&ChaiScript::internal_eval_ast, this), "eval");
@@ -455,7 +467,7 @@ namespace chaiscript
union cast_union
{
void (ChaiScript::*in_ptr)(const std::string&);
Boxed_Value (ChaiScript::*in_ptr)(const std::string&);
void *out_ptr;
};
@@ -529,7 +541,7 @@ namespace chaiscript
/// requested file.
///
/// \param[in] t_filename Filename to load and evaluate
void use(const std::string &t_filename)
Boxed_Value use(const std::string &t_filename)
{
for (const auto &path : m_usepaths)
{
@@ -539,15 +551,17 @@ namespace chaiscript
chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::recursive_mutex> l(m_use_mutex);
chaiscript::detail::threading::unique_lock<chaiscript::detail::threading::shared_mutex> l2(m_mutex);
Boxed_Value retval;
if (m_used_files.count(appendedpath) == 0)
{
l2.unlock();
eval_file(appendedpath);
retval = eval_file(appendedpath);
l2.lock();
m_used_files.insert(appendedpath);
}
}
return; // return, we loaded it, or it was already loaded
return retval; // return, we loaded it, or it was already loaded
} catch (const exception::file_not_found_error &) {
// failed to load, try the next path
}

71
include/chaiscript/language/chaiscript_eval.hpp
View File

@@ -61,7 +61,7 @@ namespace chaiscript
try {
return t_node->eval(t_ss);
} catch (detail::Return_Value &rv) {
return rv.retval;
return std::move(rv.retval);
}
}
}
@@ -517,11 +517,7 @@ namespace chaiscript
{
return std::pair<std::string, Type_Info>();
} else {
try {
return std::pair<std::string, Type_Info>(t_node->children[0]->text, t_ss.get_type(t_node->children[0]->text));
} catch (const std::range_error &) {
return std::pair<std::string, Type_Info>(t_node->children[0]->text, Type_Info());
}
return std::pair<std::string, Type_Info>(t_node->children[0]->text, t_ss.get_type(t_node->children[0]->text, false));
}
}
@@ -707,13 +703,14 @@ namespace chaiscript
fpp.save_params(params);
std::string fun_name;
if ((this->children[i]->identifier == AST_Node_Type::Fun_Call) || (this->children[i]->identifier == AST_Node_Type::Array_Call)) {
fun_name = this->children[i]->children[0]->text;
}
else {
fun_name = this->children[i]->text;
}
std::string fun_name = [&](){
if ((this->children[i]->identifier == AST_Node_Type::Fun_Call) || (this->children[i]->identifier == AST_Node_Type::Array_Call)) {
return this->children[i]->children[0]->text;
}
else {
return this->children[i]->text;
}
}();
try {
chaiscript::eval::detail::Stack_Push_Pop spp(t_ss);
@@ -728,7 +725,7 @@ namespace chaiscript
}
}
catch(detail::Return_Value &rv) {
retval = rv.retval;
retval = std::move(rv.retval);
}
if (this->children[i]->identifier == AST_Node_Type::Array_Call) {
@@ -1171,14 +1168,11 @@ namespace chaiscript
AST_Node(std::move(t_ast_node_text), AST_Node_Type::File, t_fname, t_start_line, t_start_col, t_end_line, t_end_col) { }
virtual ~File_AST_Node() {}
virtual Boxed_Value eval_internal(chaiscript::detail::Dispatch_Engine &t_ss) const CHAISCRIPT_OVERRIDE {
const size_t size = this->children.size();
for (size_t i = 0; i < size; ++i) {
Boxed_Value retval(this->children[i]->eval(t_ss));
if (i + 1 == size) {
return retval;
}
const auto num_children = children.size();
for (size_t i = 0; i < num_children-1; ++i) {
children[i]->eval(t_ss);
}
return Boxed_Value();
return children.back()->eval(t_ss);
}
};
@@ -1486,30 +1480,19 @@ namespace chaiscript
static_cast<int>(numparams), this->children.back(), param_types, l_annotation, guard)),
function_name);
}
else {
try {
// Do know type name (if this line fails, the catch block is called and the
// other version is called, with no Type_Info object known)
auto type = t_ss.get_type(class_name);
param_types.push_front(class_name, type);
} else {
t_ss.add(
std::make_shared<dispatch::detail::Dynamic_Object_Function>(class_name,
std::make_shared<dispatch::Dynamic_Proxy_Function>(std::bind(chaiscript::eval::detail::eval_function,
std::ref(t_ss), this->children.back(),
t_param_names, std::placeholders::_1, std::map<std::string, Boxed_Value>()), static_cast<int>(numparams), this->children.back(),
param_types, l_annotation, guard), type), function_name);
} catch (const std::range_error &) {
param_types.push_front(class_name, Type_Info());
// Do not know type name
t_ss.add(
std::make_shared<dispatch::detail::Dynamic_Object_Function>(class_name,
std::make_shared<dispatch::Dynamic_Proxy_Function>(std::bind(chaiscript::eval::detail::eval_function,
std::ref(t_ss), this->children.back(),
t_param_names, std::placeholders::_1, std::map<std::string, Boxed_Value>()), static_cast<int>(numparams), this->children.back(),
param_types, l_annotation, guard)), function_name);
}
// if the type is unknown, then this generates a function that looks up the type
// at runtime. Defining the type first before this is called is better
auto type = t_ss.get_type(class_name, false);
param_types.push_front(class_name, type);
t_ss.add(
std::make_shared<dispatch::detail::Dynamic_Object_Function>(class_name,
std::make_shared<dispatch::Dynamic_Proxy_Function>(std::bind(chaiscript::eval::detail::eval_function,
std::ref(t_ss), this->children.back(),
t_param_names, std::placeholders::_1, std::map<std::string, Boxed_Value>()), static_cast<int>(numparams), this->children.back(),
param_types, l_annotation, guard), type), function_name);
}
}
catch (const exception::reserved_word_error &e) {

56
include/chaiscript/language/chaiscript_parser.hpp
View File

@@ -617,14 +617,16 @@ namespace chaiscript
}
size_t size = sizeof(int) * 8;
if (longlong_)
{
size = sizeof(int64_t) * 8;
} else if (long_) {
size = sizeof(long) * 8;
}
const size_t size = [&](){
if (longlong_)
{
return sizeof(int64_t) * 8;
} else if (long_) {
return sizeof(long) * 8;
} else {
return sizeof(int) * 8;
}
}();
if ( (u >> (size - 1)) > 0)
{
@@ -794,17 +796,19 @@ namespace chaiscript
return Id_();
} else {
const auto start = m_input_pos;
const int prev_col = m_col;
const int prev_line = m_line;
const auto prev_col = m_col;
const auto prev_line = m_line;
if (Id_()) {
std::string match;
if (*start == '`') {
//Id Literal
match = std::string(start+1, m_input_pos-1);
} else {
match = std::string(start, m_input_pos);
}
m_match_stack.push_back(std::make_shared<eval::Id_AST_Node>(std::move(match), m_filename, prev_line, prev_col, m_line, m_col));
m_match_stack.push_back(std::make_shared<eval::Id_AST_Node>(
[&](){
if (*start == '`') {
//Id Literal
return std::string(start+1, m_input_pos-1);
} else {
return std::string(start, m_input_pos);
}
}(),
m_filename, prev_line, prev_col, m_line, m_col));
return true;
} else {
return false;
@@ -1114,8 +1118,8 @@ namespace chaiscript
const auto prev_col = m_col;
const auto prev_line = m_line;
if (Char_(t_c)) {
std::string match(start, m_input_pos);
m_match_stack.push_back(std::make_shared<eval::Char_AST_Node>(std::move(match), m_filename, prev_line, prev_col, m_line, m_col));
m_match_stack.push_back(
std::make_shared<eval::Char_AST_Node>(std::string(start, m_input_pos), m_filename, prev_line, prev_col, m_line, m_col));
return true;
} else {
return false;
@@ -1159,8 +1163,8 @@ namespace chaiscript
}
if ( t_capture && retval ) {
std::string match(start, m_input_pos);
m_match_stack.push_back(std::make_shared<eval::Str_AST_Node>(std::move(match), m_filename, prev_line, prev_col, m_line, m_col));
m_match_stack.push_back(std::make_shared<eval::Str_AST_Node>(
std::string(start, m_input_pos), m_filename, prev_line, prev_col, m_line, m_col));
}
return retval;
}
@@ -1202,8 +1206,8 @@ namespace chaiscript
}
if ( t_capture && retval ) {
std::string match(start, m_input_pos);
m_match_stack.push_back(std::make_shared<eval::Str_AST_Node>(std::move(match), m_filename, prev_line, prev_col, m_line, m_col));
m_match_stack.push_back(std::make_shared<eval::Str_AST_Node>(
std::string(start, m_input_pos), m_filename, prev_line, prev_col, m_line, m_col));
}
return retval;
@@ -1235,8 +1239,8 @@ namespace chaiscript
const auto prev_col = m_col;
const auto prev_line = m_line;
if (Eol_()) {
std::string match(start, m_input_pos);
m_match_stack.push_back(std::make_shared<eval::Eol_AST_Node>(std::move(match), m_filename, prev_line, prev_col, m_line, m_col));
m_match_stack.push_back(std::make_shared<eval::Eol_AST_Node>(
std::string(start, m_input_pos), m_filename, prev_line, prev_col, m_line, m_col));
return true;
} else {
return false;