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

add example.cpp to build for VC++, fix minor bug in passing of & parameters to functor<>, move bootstrap functions into bootstrap namespace and clean up function names and add "retro" support for reversing of ranges.

Browse Source
This commit is contained in:
Jason Turner
2009-07-23 04:35:15 +00:00
parent 00ac8113c0
commit 370121a9ff
8 changed files with 851 additions and 580 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -12,139 +12,141 @@
namespace chaiscript namespace chaiscript
{ {
namespace detail namespace bootstrap
{ {
/** namespace detail
* Set of helper functions for common operators {
*/ /**
template<typename Ret, typename P1, typename P2> * Set of helper functions for common operators
*/
template<typename Ret, typename P1, typename P2>
Ret add(P1 p1, P2 p2) Ret add(P1 p1, P2 p2)
{ {
return p1 + p2; return p1 + p2;
} }
template<typename Ret, typename P1, typename P2> template<typename Ret, typename P1, typename P2>
Ret subtract(P1 p1, P2 p2) Ret subtract(P1 p1, P2 p2)
{ {
return p1 - p2; return p1 - p2;
} }
template<typename Ret, typename P1, typename P2> template<typename Ret, typename P1, typename P2>
Ret divide(P1 p1, P2 p2) Ret divide(P1 p1, P2 p2)
{ {
return p1 / p2; return p1 / p2;
} }
template<typename Ret, typename P1, typename P2> template<typename Ret, typename P1, typename P2>
Ret multiply(P1 p1, P2 p2) Ret multiply(P1 p1, P2 p2)
{ {
return p1 * p2; return p1 * p2;
} }
template<typename Ret, typename P1, typename P2> template<typename Ret, typename P1, typename P2>
Ret modulus(P1 p1, P2 p2) Ret modulus(P1 p1, P2 p2)
{ {
return p1 % p2; return p1 % p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
P1 &assign(P1 &p1, const P2 &p2) P1 &assign(P1 &p1, const P2 &p2)
{ {
return (p1 = p2); return (p1 = p2);
} }
template<typename P1, typename P2> template<typename P1, typename P2>
bool equals(P1 p1, P2 p2) bool equals(P1 p1, P2 p2)
{ {
return p1 == p2; return p1 == p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
bool not_equals(P1 p1, P2 p2) bool not_equals(P1 p1, P2 p2)
{ {
return p1 != p2; return p1 != p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
bool less_than(P1 p1, P2 p2) bool less_than(P1 p1, P2 p2)
{ {
return p1 < p2; return p1 < p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
bool greater_than(P1 p1, P2 p2) bool greater_than(P1 p1, P2 p2)
{ {
return p1 > p2; return p1 > p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
bool less_than_equals(P1 p1, P2 p2) bool less_than_equals(P1 p1, P2 p2)
{ {
return p1 <= p2; return p1 <= p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
bool greater_than_equals(P1 p1, P2 p2) bool greater_than_equals(P1 p1, P2 p2)
{ {
return p1 >= p2; return p1 >= p2;
} }
template<typename P1, typename P2> template<typename P1, typename P2>
P1 &timesequal(P1 &p1, const P2 &p2) P1 &timesequal(P1 &p1, const P2 &p2)
{ {
return (p1 *= p2); return (p1 *= p2);
} }
template<typename P1, typename P2> template<typename P1, typename P2>
P1 &dividesequal(P1 &p1, const P2 &p2) P1 &dividesequal(P1 &p1, const P2 &p2)
{ {
return (p1 /= p2); return (p1 /= p2);
} }
template<typename P1, typename P2> template<typename P1, typename P2>
P1 &addsequal(P1 &p1, const P2 &p2) P1 &addsequal(P1 &p1, const P2 &p2)
{ {
return (p1 += p2); return (p1 += p2);
} }
template<typename P1, typename P2> template<typename P1, typename P2>
P1 &subtractsequal(P1 &p1, const P2 &p2) P1 &subtractsequal(P1 &p1, const P2 &p2)
{ {
return (p1 -= p2); return (p1 -= p2);
} }
template<typename P1> template<typename P1>
P1 &prefixincrement(P1 &p1) P1 &prefixincrement(P1 &p1)
{ {
return (++p1); return (++p1);
} }
template<typename P1> template<typename P1>
P1 &prefixdecrement(P1 &p1) P1 &prefixdecrement(P1 &p1)
{ {
return (--p1); return (--p1);
} }
template<typename P1> template<typename P1>
P1 &prefixnegate(P1 &p1) P1 &prefixnegate(P1 &p1)
{ {
return (p1); return (p1);
} }
template<typename P1> template<typename P1>
P1 &prefixnot(P1 &p1) P1 &prefixnot(P1 &p1)
{ {
return (p1); return (p1);
} }
/* Special helpers for generating generic "POD" type operators /* Special helpers for generating generic "POD" type operators
* The POD operators are needed for general support of C++ POD * The POD operators are needed for general support of C++ POD
* types without iterating out all possible combinations of operators * types without iterating out all possible combinations of operators
* (<, >, +, +=, *=, \=, -, <=, >=, ==) and types * (<, >, +, +=, *=, \=, -, <=, >=, ==) and types
* (char, uint8_t, int8_t, uint16_t, int16_t...) * (char, uint8_t, int8_t, uint16_t, int16_t...)
*/ */
template<typename P1> template<typename P1>
P1 &assign_pod(P1 &p1, Boxed_POD_Value v) P1 &assign_pod(P1 &p1, Boxed_POD_Value v)
{ {
if (v.m_isfloat) if (v.m_isfloat)
@@ -155,7 +157,7 @@ namespace chaiscript
} }
} }
template<typename P1> template<typename P1>
P1 construct_pod(Boxed_POD_Value v) P1 construct_pod(Boxed_POD_Value v)
{ {
if (v.m_isfloat) if (v.m_isfloat)
@@ -166,7 +168,7 @@ namespace chaiscript
} }
} }
template<typename P1> template<typename P1>
P1 &timesequal_pod(P1 &p1, Boxed_POD_Value r) P1 &timesequal_pod(P1 &p1, Boxed_POD_Value r)
{ {
if (r.m_isfloat) if (r.m_isfloat)
@@ -177,7 +179,7 @@ namespace chaiscript
} }
} }
template<typename P1> template<typename P1>
P1 &dividesequal_pod(P1 &p1, Boxed_POD_Value r) P1 &dividesequal_pod(P1 &p1, Boxed_POD_Value r)
{ {
if (r.m_isfloat) if (r.m_isfloat)
@@ -188,7 +190,7 @@ namespace chaiscript
} }
} }
template<typename P1> template<typename P1>
P1 &addsequal_pod(P1 &p1, Boxed_POD_Value r) P1 &addsequal_pod(P1 &p1, Boxed_POD_Value r)
{ {
if (r.m_isfloat) if (r.m_isfloat)
@@ -199,7 +201,7 @@ namespace chaiscript
} }
} }
template<typename P1> template<typename P1>
P1 &subtractsequal_pod(P1 &p1, Boxed_POD_Value r) P1 &subtractsequal_pod(P1 &p1, Boxed_POD_Value r)
{ {
if (r.m_isfloat) if (r.m_isfloat)
@@ -209,341 +211,341 @@ namespace chaiscript
return p1 -= P1(r.i); return p1 -= P1(r.i);
} }
} }
} }
/** /**
* Add canonical form of "=" for type T * Add canonical form of "=" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_equals(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_equals(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::equals<const T&, const T&>), "="); m->add(fun(&detail::equals<const T&, const T&>), "=");
return m; return m;
} }
/** /**
* Add canonical form of "+" for type T * Add canonical form of "+" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_add(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_add(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::add<T, const T&, const T&>), "+"); m->add(fun(&detail::add<T, const T&, const T&>), "+");
return m; return m;
} }
/** /**
* Add canonical form of "+=" for type T * Add canonical form of "+=" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_add_equals(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_add_equals(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::addsequal<T, T>), "+="); m->add(fun(&detail::addsequal<T, T>), "+=");
return m; return m;
} }
/** /**
* Add canonical form of "-" for type T * Add canonical form of "-" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_subtract(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_subtract(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::subtract<T, const T&, const T&>), "-"); m->add(fun(&detail::subtract<T, const T&, const T&>), "-");
return m; return m;
} }
/** /**
* Add canonical form of "/" for type T * Add canonical form of "/" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_divide(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_divide(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::divide<T, const T&, const T&>), "/"); m->add(fun(&detail::divide<T, const T&, const T&>), "/");
return m; return m;
} }
/** /**
* Add canonical form of "*" for type T * Add canonical form of "*" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_multiply(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_multiply(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::multiply<T, const T&, const T&>), "*"); m->add(fun(&detail::multiply<T, const T&, const T&>), "*");
return m; return m;
} }
/** /**
* Add canonical form of "!=" for type T * Add canonical form of "!=" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_not_equals(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_not_equals(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::not_equals<const T&, const T&>), "!="); m->add(fun(&detail::not_equals<const T&, const T&>), "!=");
return m; return m;
} }
/** /**
* Add user defined assignment operator for T = U * Add user defined assignment operator for T = U
*/ */
template<typename T, typename U> template<typename T, typename U>
ModulePtr add_oper_assign_overload(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_assign_overload(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::assign<T,U>), "="); m->add(fun(&detail::assign<T,U>), "=");
return m; return m;
} }
/** /**
* Add canonical form of "=" for type T * Add canonical form of "=" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_assign(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_assign(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::assign<T,T>), "="); m->add(fun(&detail::assign<T,T>), "=");
return m; return m;
} }
/** /**
* Add assignment operator for T = POD. * Add assignment operator for T = POD.
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_assign_pod(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_assign_pod(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::assign_pod<T>), "="); m->add(fun(&detail::assign_pod<T>), "=");
return m; return m;
} }
/** /**
* Add canonical form of "<" for type T * Add canonical form of "<" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_less_than(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_less_than(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::less_than<const T&, const T&>), "<"); m->add(fun(&detail::less_than<const T&, const T&>), "<");
return m; return m;
} }
/** /**
* Add canonical form of ">" for type T * Add canonical form of ">" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_greater_than(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_greater_than(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::greater_than<const T&, const T&>), ">"); m->add(fun(&detail::greater_than<const T&, const T&>), ">");
return m; return m;
} }
/** /**
* Add canonical form of "<=" for type T * Add canonical form of "<=" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_less_than_equals(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_less_than_equals(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::less_than_equals<const T&, const T&>), "<="); m->add(fun(&detail::less_than_equals<const T&, const T&>), "<=");
return m; return m;
} }
/** /**
* Add canonical form of ">=" for type T * Add canonical form of ">=" for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_oper_greater_than_equals(ModulePtr m = ModulePtr(new Module())) ModulePtr oper_greater_than_equals(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::greater_than_equals<const T&, const T&>), ">="); m->add(fun(&detail::greater_than_equals<const T&, const T&>), ">=");
return m; return m;
} }
/** /**
* Add user defined comparison operators for T and R. * Add user defined comparison operators for T and R.
* Examples: T < R, T == R, etc. * Examples: T < R, T == R, etc.
*/ */
template<typename T, typename R> template<typename T, typename R>
ModulePtr add_opers_comparison_overload(ModulePtr m = ModulePtr(new Module())) ModulePtr opers_comparison_overload(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::equals<const T&, const R&>), "=="); m->add(fun(&detail::equals<const T&, const R&>), "==");
m->add(fun(&detail::not_equals<const T&, const R&>), "!="); m->add(fun(&detail::not_equals<const T&, const R&>), "!=");
m->add(fun(&detail::less_than<const T&, const R&>), "<"); m->add(fun(&detail::less_than<const T&, const R&>), "<");
m->add(fun(&detail::greater_than<const T&, const R&>), ">"); m->add(fun(&detail::greater_than<const T&, const R&>), ">");
m->add(fun(&detail::less_than_equals<const T&, const R&>), "<="); m->add(fun(&detail::less_than_equals<const T&, const R&>), "<=");
m->add(fun(&detail::greater_than_equals<const T&, const R&>), ">="); m->add(fun(&detail::greater_than_equals<const T&, const R&>), ">=");
return m; return m;
} }
/** /**
* Add canonical forms of all comparison operators for type T * Add canonical forms of all comparison operators for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_opers_comparison(ModulePtr m = ModulePtr(new Module())) ModulePtr opers_comparison(ModulePtr m = ModulePtr(new Module()))
{ {
add_opers_comparison_overload<T, T>(m); opers_comparison_overload<T, T>(m);
return m; return m;
} }
/** /**
* Add all arithmetic operators that return a type of Ret, taking * Add all arithmetic operators that return a type of Ret, taking
* a lhs of T and a rhs of R, when possible. * a lhs of T and a rhs of R, when possible.
* examples: Ret = T + R; * examples: Ret = T + R;
* ++T * ++T
* T *= R; * T *= R;
*/ */
template<typename Ret, typename T, typename R> template<typename Ret, typename T, typename R>
ModulePtr add_opers_arithmetic_overload(ModulePtr m = ModulePtr(new Module())) ModulePtr opers_arithmetic_overload(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::add<Ret, T, R>), "+"); m->add(fun(&detail::add<Ret, T, R>), "+");
m->add(fun(&detail::subtract<Ret, T, R>), "-"); m->add(fun(&detail::subtract<Ret, T, R>), "-");
m->add(fun(&detail::divide<Ret, T, R>), "/"); m->add(fun(&detail::divide<Ret, T, R>), "/");
m->add(fun(&detail::multiply<Ret, T, R>), "*"); m->add(fun(&detail::multiply<Ret, T, R>), "*");
m->add(fun(&detail::timesequal<T, R>), "*="); m->add(fun(&detail::timesequal<T, R>), "*=");
m->add(fun(&detail::dividesequal<T, R>), "/="); m->add(fun(&detail::dividesequal<T, R>), "/=");
m->add(fun(&detail::subtractsequal<T, R>), "-="); m->add(fun(&detail::subtractsequal<T, R>), "-=");
m->add(fun(&detail::addsequal<T, R>), "+="); m->add(fun(&detail::addsequal<T, R>), "+=");
m->add(fun(&detail::prefixincrement<T>), "++"); m->add(fun(&detail::prefixincrement<T>), "++");
m->add(fun(&detail::prefixdecrement<T>), "--"); m->add(fun(&detail::prefixdecrement<T>), "--");
m->add(fun(&detail::prefixnegate<T>), "-"); m->add(fun(&detail::prefixnegate<T>), "-");
m->add(fun(&detail::prefixnot<T>), "!"); m->add(fun(&detail::prefixnot<T>), "!");
return m; return m;
} }
/** /**
* Add arithmetic assign operators for POD types: * Add arithmetic assign operators for POD types:
* example: POD *= T, POD /= T * example: POD *= T, POD /= T
*/ */
template<typename T> template<typename T>
ModulePtr add_opers_arithmetic_modify_pod(ModulePtr m = ModulePtr(new Module())) ModulePtr opers_arithmetic_modify_pod(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::timesequal_pod<T>), "*="); m->add(fun(&detail::timesequal_pod<T>), "*=");
m->add(fun(&detail::dividesequal_pod<T>), "/="); m->add(fun(&detail::dividesequal_pod<T>), "/=");
m->add(fun(&detail::subtractsequal_pod<T>), "-="); m->add(fun(&detail::subtractsequal_pod<T>), "-=");
m->add(fun(&detail::addsequal_pod<T>), "+="); m->add(fun(&detail::addsequal_pod<T>), "+=");
return m; return m;
} }
/** /**
* Add a copy constructor for type T, also creates the standard * Add a copy constructor for type T, also creates the standard
* function "clone" for the type. "clone" is a synonym for * function "clone" for the type. "clone" is a synonym for
* the copy constructor. * the copy constructor.
*/ */
template<typename T> template<typename T>
ModulePtr add_copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr copy_constructor(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(constructor<T (const T &)>(), type); m->add(constructor<T (const T &)>(), type);
m->add(constructor<T (const T &)>(), "clone"); m->add(constructor<T (const T &)>(), "clone");
return m; return m;
} }
/** /**
* Add default and copy constructors (including "clone") for type T * Add default and copy constructors (including "clone") for type T
*/ */
template<typename T> template<typename T>
ModulePtr add_basic_constructors(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr basic_constructors(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
m->add(constructor<T ()>(), type);
add_copy_constructor<T>(type, m);
return m;
}
/**
* Add POD type constructor for type T. ie: T = type(POD)
*/
template<typename T>
ModulePtr add_construct_pod(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
m->add(fun(&detail::construct_pod<T>), type);
return m;
}
/**
* add user defined single parameter constructor for type T.
* T = type(const U &)
*/
template<typename T, typename U>
ModulePtr add_constructor_overload(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
m->add(constructor<T (const U &)>(), type);
return m;
}
/**
* Add canonical forms of all arithmetic operators for type T
*/
template<typename T>
ModulePtr add_opers_arithmetic(ModulePtr m = ModulePtr(new Module()))
{
add_opers_arithmetic_overload<T, T, T>(m);
return m;
}
/**
* to_string function for internal use. Uses ostream operator<<
*/
template<typename Input>
std::string to_string(Input i)
{
return boost::lexical_cast<std::string>(i);
}
/**
* Boolean specialization of internal to_string function
*/
template<> std::string to_string(bool b)
{
if (b)
{ {
return "true"; m->add(constructor<T ()>(), type);
} else { copy_constructor<T>(type, m);
return "false"; return m;
} }
}
/** /**
* Internal function for converting from a string to a value * Add POD type constructor for type T. ie: T = type(POD)
* uses ostream operator >> to perform the conversion */
*/ template<typename T>
template<typename Input> ModulePtr construct_pod(const std::string &type, ModulePtr m = ModulePtr(new Module()))
Input parse_string(const std::string &i) {
{ m->add(fun(&detail::construct_pod<T>), type);
return boost::lexical_cast<Input>(i); return m;
} }
/** /**
* Add all common functions for a POD type. All operators, and * add user defined single parameter constructor for type T.
* common conversions * T = type(const U &)
*/ */
template<typename T> template<typename T, typename U>
ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module())) ModulePtr constructor_overload(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(user_type<T>(), name); m->add(constructor<T (const U &)>(), type);
add_basic_constructors<T>(name, m); return m;
add_oper_assign<T>(m); }
add_oper_assign_pod<T>(m);
add_construct_pod<T>(name, m);
add_opers_arithmetic<T>(m);
add_opers_arithmetic_modify_pod<T>(m);
m->add(fun(&to_string<T>), "to_string");
m->add(fun(&parse_string<T>), "to_" + name);
return m;
}
/** /**
* "clone" function for a shared_ptr type. This is used in the case * Add canonical forms of all arithmetic operators for type T
* where you do not want to make a deep copy of an object during cloning */
* but want to instead maintain the shared_ptr. It is needed internally template<typename T>
* for handling of Proxy_Function object (that is, ModulePtr opers_arithmetic(ModulePtr m = ModulePtr(new Module()))
* function variables. {
*/ opers_arithmetic_overload<T, T, T>(m);
template<typename Type> return m;
}
/**
* to_string function for internal use. Uses ostream operator<<
*/
template<typename Input>
std::string to_string(Input i)
{
return boost::lexical_cast<std::string>(i);
}
/**
* Boolean specialization of internal to_string function
*/
template<> std::string to_string(bool b)
{
if (b)
{
return "true";
} else {
return "false";
}
}
/**
* Internal function for converting from a string to a value
* uses ostream operator >> to perform the conversion
*/
template<typename Input>
Input parse_string(const std::string &i)
{
return boost::lexical_cast<Input>(i);
}
/**
* Add all common functions for a POD type. All operators, and
* common conversions
*/
template<typename T>
ModulePtr bootstrap_pod_type(const std::string &name, ModulePtr m = ModulePtr(new Module()))
{
m->add(user_type<T>(), name);
basic_constructors<T>(name, m);
oper_assign<T>(m);
oper_assign_pod<T>(m);
construct_pod<T>(name, m);
opers_arithmetic<T>(m);
opers_arithmetic_modify_pod<T>(m);
m->add(fun(&to_string<T>), "to_string");
m->add(fun(&parse_string<T>), "to_" + name);
return m;
}
/**
* "clone" function for a shared_ptr type. This is used in the case
* where you do not want to make a deep copy of an object during cloning
* but want to instead maintain the shared_ptr. It is needed internally
* for handling of Proxy_Function object (that is,
* function variables.
*/
template<typename Type>
boost::shared_ptr<Type> shared_ptr_clone(boost::shared_ptr<Type> f) boost::shared_ptr<Type> shared_ptr_clone(boost::shared_ptr<Type> f)
{ {
return f; return f;
} }
/** /**
* Assignment function for shared_ptr objects, does not perform a copy of the * Assignment function for shared_ptr objects, does not perform a copy of the
* object pointed to, instead maintains the shared_ptr concept. * object pointed to, instead maintains the shared_ptr concept.
* Similar to shared_ptr_clone. Used for Proxy_Function. * Similar to shared_ptr_clone. Used for Proxy_Function.
*/ */
template<typename Type> template<typename Type>
Boxed_Value ptr_assign(Boxed_Value lhs, boost::shared_ptr<Type> rhs) Boxed_Value ptr_assign(Boxed_Value lhs, boost::shared_ptr<Type> rhs)
{ {
lhs.assign(Boxed_Value(rhs)); lhs.assign(Boxed_Value(rhs));
@@ -551,16 +553,16 @@ namespace chaiscript
return lhs; return lhs;
} }
/** /**
* Class consisting of only static functions. All default bootstrapping occurs * Class consisting of only static functions. All default bootstrapping occurs
* from this class. * from this class.
*/ */
class Bootstrap class Bootstrap
{ {
private: private:
/** /**
* Function allowing for assignment of an unknown type to any other value * Function allowing for assignment of an unknown type to any other value
*/ */
static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs) static Boxed_Value unknown_assign(Boxed_Value lhs, Boxed_Value rhs)
{ {
if (lhs.is_unknown()) if (lhs.is_unknown())
@@ -582,9 +584,9 @@ namespace chaiscript
} }
/** /**
* Add all comparison operators for POD types * Add all comparison operators for POD types
*/ */
static void add_opers_comparison_pod(ModulePtr m = ModulePtr(new Module())) static void opers_comparison_pod(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::equals<Boxed_POD_Value, Boxed_POD_Value>), "=="); m->add(fun(&detail::equals<Boxed_POD_Value, Boxed_POD_Value>), "==");
m->add(fun(&detail::not_equals<Boxed_POD_Value, Boxed_POD_Value>), "!="); m->add(fun(&detail::not_equals<Boxed_POD_Value, Boxed_POD_Value>), "!=");
@@ -595,9 +597,9 @@ namespace chaiscript
} }
/** /**
* Add all arithmetic operators for PODs * Add all arithmetic operators for PODs
*/ */
static void add_opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module())) static void opers_arithmetic_pod(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(fun(&detail::add<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+"); m->add(fun(&detail::add<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "+");
m->add(fun(&detail::subtract<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-"); m->add(fun(&detail::subtract<Boxed_Value, Boxed_POD_Value, Boxed_POD_Value>), "-");
@@ -606,10 +608,10 @@ namespace chaiscript
} }
/** /**
* Create a bound function object. The first param is the function to bind * Create a bound function object. The first param is the function to bind
* the remaining parameters are the args to bind into the * the remaining parameters are the args to bind into the
* result * result
*/ */
static Boxed_Value bind_function(const std::vector<Boxed_Value> &params) static Boxed_Value bind_function(const std::vector<Boxed_Value> &params)
{ {
if (params.size() < 2) if (params.size() < 2)
@@ -620,13 +622,13 @@ namespace chaiscript
Proxy_Function f = boxed_cast<Proxy_Function >(params[0]); Proxy_Function f = boxed_cast<Proxy_Function >(params[0]);
return Boxed_Value(Proxy_Function(new Bound_Function(f, return Boxed_Value(Proxy_Function(new Bound_Function(f,
std::vector<Boxed_Value>(params.begin() + 1, params.end())))); std::vector<Boxed_Value>(params.begin() + 1, params.end()))));
} }
/** /**
* Returns true if a call can be made that consists of the first parameter * Returns true if a call can be made that consists of the first parameter
* (the function) with the remaining parameters as its arguments. * (the function) with the remaining parameters as its arguments.
*/ */
static Boxed_Value call_exists(const std::vector<Boxed_Value> &params) static Boxed_Value call_exists(const std::vector<Boxed_Value> &params)
{ {
if (params.size() < 1) if (params.size() < 1)
@@ -647,8 +649,8 @@ namespace chaiscript
public: public:
/** /**
* perform all common bootstrap functions for std::string, void and POD types * perform all common bootstrap functions for std::string, void and POD types
*/ */
static ModulePtr bootstrap(ModulePtr m = ModulePtr(new Module())) static ModulePtr bootstrap(ModulePtr m = ModulePtr(new Module()))
{ {
m->add(user_type<void>(), "void"); m->add(user_type<void>(), "void");
@@ -657,9 +659,9 @@ namespace chaiscript
m->add(user_type<Boxed_POD_Value>(), "PODObject"); m->add(user_type<Boxed_POD_Value>(), "PODObject");
m->add(user_type<Proxy_Function>(), "function"); m->add(user_type<Proxy_Function>(), "function");
add_basic_constructors<bool>("bool", m); basic_constructors<bool>("bool", m);
add_oper_assign<std::string>(m); oper_assign<std::string>(m);
add_oper_assign<bool>(m); oper_assign<bool>(m);
m->add(fun(&to_string<const std::string &>), "internal_to_string"); m->add(fun(&to_string<const std::string &>), "internal_to_string");
m->add(fun(&to_string<bool>), "internal_to_string"); m->add(fun(&to_string<bool>), "internal_to_string");
@@ -671,8 +673,8 @@ namespace chaiscript
bootstrap_pod_type<char>("char", m); bootstrap_pod_type<char>("char", m);
bootstrap_pod_type<boost::int64_t>("int64_t", m); bootstrap_pod_type<boost::int64_t>("int64_t", m);
add_opers_comparison_pod(m); opers_comparison_pod(m);
add_opers_arithmetic_pod(m); opers_arithmetic_pod(m);
m->add(fun(&detail::modulus<int, int, int>), "%"); m->add(fun(&detail::modulus<int, int, int>), "%");
@@ -680,19 +682,20 @@ namespace chaiscript
m->add(fun(&println), "println_string"); m->add(fun(&println), "println_string");
m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&bind_function, _1))), m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&bind_function, _1))),
"bind"); "bind");
m->add(fun(&shared_ptr_clone<Proxy_Function_Base>), "clone"); m->add(fun(&shared_ptr_clone<Proxy_Function_Base>), "clone");
m->add(fun(&ptr_assign<Proxy_Function_Base>), "="); m->add(fun(&ptr_assign<Proxy_Function_Base>), "=");
m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&call_exists, _1))), m->add(Proxy_Function(new Dynamic_Proxy_Function(boost::bind(&call_exists, _1))),
"call_exists"); "call_exists");
m->add(fun(&type_match), "type_match"); m->add(fun(&type_match), "type_match");
return m; return m;
} }
}; };
}
} }
#endif #endif

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

@@ -5,13 +5,13 @@
// http://www.chaiscript.com // http://www.chaiscript.com
/** /**
* This file contains utility functions for registration of STL container * This file contains utility functions for registration of STL container
* classes. The methodology used is based on the SGI STL concepts. * classes. The methodology used is based on the SGI STL concepts.
* http://www.sgi.com/tech/stl/table_of_contents.html * http://www.sgi.com/tech/stl/table_of_contents.html
*/ */
#ifndef __stl_hpp_type #ifndef __bootstrap_stl_hpp__
#define __stl_hpp___type #define __bootstrap_stl_hpp__
#include "dispatchkit.hpp" #include "dispatchkit.hpp"
#include "register_function.hpp" #include "register_function.hpp"
@@ -19,25 +19,29 @@
namespace chaiscript namespace chaiscript
{ {
/** namespace bootstrap
* Input_Range, based on the D concept of ranges. {
* \todo Update the Range code to base its capabilities on /**
* the user_typetraits of the iterator passed in * Bidir_Range, based on the D concept of ranges.
*/ * \todo Update the Range code to base its capabilities on
template<typename Container> * the user_typetraits of the iterator passed in
struct Input_Range */
template<typename Container>
struct Bidir_Range
{ {
Input_Range(Container &c) typedef typename std::iterator_traits<typename Container::iterator>::reference reference_type;
Bidir_Range(Container &c)
: m_begin(c.begin()), m_end(c.end()) : m_begin(c.begin()), m_end(c.end())
{ {
} }
Input_Range(typename Container::iterator itr) Bidir_Range(typename Container::iterator itr)
: m_begin(itr), m_end(itr) : m_begin(itr), m_end(itr)
{ {
} }
Input_Range(const std::pair<typename Container::iterator, typename Container::iterator> &t_p) Bidir_Range(const std::pair<typename Container::iterator, typename Container::iterator> &t_p)
: m_begin(t_p.first), m_end(t_p.second) : m_begin(t_p.first), m_end(t_p.second)
{ {
} }
@@ -56,7 +60,16 @@ namespace chaiscript
++m_begin; ++m_begin;
} }
typename std::iterator_traits<typename Container::iterator>::reference front() const void pop_back()
{
if (empty())
{
throw std::range_error("Range empty");
}
--m_end;
}
reference_type front() const
{ {
if (empty()) if (empty())
{ {
@@ -65,127 +78,170 @@ namespace chaiscript
return *m_begin; return *m_begin;
} }
reference_type back() const
{
if (empty())
{
throw std::range_error("Range empty");
}
Container::iterator pos = m_end;
--pos;
return *(pos);
}
typename Container::iterator m_begin; typename Container::iterator m_begin;
typename Container::iterator m_end; typename Container::iterator m_end;
}; };
template<typename Range>
/** struct Retro
* Add Input_Range support for the given ContainerType {
*/ Retro(const Range &r)
template<typename ContainerType> : m_r(r)
{}
bool empty() { return m_r.empty(); }
void pop_front() { m_r.pop_back(); }
void pop_back() { m_r.pop_front(); }
typename Range::reference_type front() { return m_r.back(); }
typename Range::reference_type back() { return m_r.front(); }
private:
Range m_r;
};
/**
* Add Bidir_Range support for the given ContainerType
*/
template<typename ContainerType>
ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr input_range_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(user_type<Input_Range<ContainerType> >(), type + "_Range"); m->add(user_type<Bidir_Range<ContainerType> >(), type + "_Range");
m->add(user_type<Retro<Bidir_Range<ContainerType> > >(), type + "_Retro_Range");
m->add(user_type<typename ContainerType::iterator>(), type+"_Iterator"); m->add(user_type<typename ContainerType::iterator>(), type+"_Iterator");
m->add(constructor<Input_Range<ContainerType> (ContainerType &)>(), "range"); m->add(constructor<Bidir_Range<ContainerType> (ContainerType &)>(), "range");
m->add(constructor<Input_Range<ContainerType> (typename ContainerType::iterator)>(), "range"); m->add(constructor<Bidir_Range<ContainerType> (typename ContainerType::iterator)>(), "range");
typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> ItrPair; typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> ItrPair;
m->add(constructor<Input_Range<ContainerType> (const ItrPair &)>(), "range"); m->add(constructor<Bidir_Range<ContainerType> (const ItrPair &)>(), "range");
m->add(user_type<ItrPair>(), type+"_Iterator_Pair"); m->add(user_type<ItrPair>(), type+"_Iterator_Pair");
m->add(fun(&Input_Range<ContainerType>::empty), "empty"); m->add(fun(&Bidir_Range<ContainerType>::empty), "empty");
m->add(fun(&Input_Range<ContainerType>::pop_front), "pop_front"); m->add(fun(&Bidir_Range<ContainerType>::pop_front), "pop_front");
m->add(fun(&Input_Range<ContainerType>::front), "front"); m->add(fun(&Bidir_Range<ContainerType>::front), "front");
m->add(constructor<Input_Range<ContainerType> (const Input_Range<ContainerType> &)>(), "clone"); m->add(fun(&Bidir_Range<ContainerType>::pop_back), "pop_back");
m->add(fun(&Bidir_Range<ContainerType>::back), "back");
m->add(fun(&Retro<Bidir_Range<ContainerType> >::empty), "empty");
m->add(fun(&Retro<Bidir_Range<ContainerType> >::pop_front), "pop_front");
m->add(fun(&Retro<Bidir_Range<ContainerType> >::front), "front");
m->add(fun(&Retro<Bidir_Range<ContainerType> >::pop_back), "pop_back");
m->add(fun(&Retro<Bidir_Range<ContainerType> >::back), "back");
m->add(constructor<Retro<Bidir_Range<ContainerType> > (const Bidir_Range<ContainerType> &)>(), "retro");
m->add(constructor<Bidir_Range<ContainerType> (const Bidir_Range<ContainerType> &)>(), "clone");
m->add(constructor<Retro<Bidir_Range<ContainerType> > (const Retro<Bidir_Range<ContainerType> > &)>(), "clone");
return m; return m;
} }
/**
* Add reversible_container concept to the given ContainerType
* http://www.sgi.com/tech/stl/ReversibleContainer.html
*/
template<typename ContainerType>
ModulePtr reversible_container_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
{
return m;
}
/** /**
* Add random_access_container concept to the given ContainerType * Add reversible_container concept to the given ContainerType
* http://www.sgi.com/tech/stl/RandomAccessContainer.html * http://www.sgi.com/tech/stl/ReversibleContainer.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr random_access_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr reversible_container_type(const std::string &, ModulePtr m = ModulePtr(new Module()))
{ {
reversible_container_type<ContainerType>(type, m); return m;
typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t); }
//In the interest of runtime safety for the m, we prefer the at() method for [] access, /**
//to throw an exception in an out of bounds condition. * Add random_access_container concept to the given ContainerType
m->add( * http://www.sgi.com/tech/stl/RandomAccessContainer.html
*/
template<typename ContainerType>
ModulePtr random_access_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
reversible_container_type<ContainerType>(type, m);
typedef typename ContainerType::reference(ContainerType::*indexoper)(size_t);
//In the interest of runtime safety for the m, we prefer the at() method for [] access,
//to throw an exception in an out of bounds condition.
m->add(
fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::at))), "[]"); fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::at))), "[]");
m->add( m->add(
fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::operator[]))), "at"); fun(boost::function<typename ContainerType::reference (ContainerType *, int)>(indexoper(&ContainerType::operator[]))), "at");
return m; return m;
} }
/** /**
* Add assignable concept to the given ContainerType * Add assignable concept to the given ContainerType
* http://www.sgi.com/tech/stl/Assignable.html * http://www.sgi.com/tech/stl/Assignable.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr assignable_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
add_basic_constructors<ContainerType>(type, m); basic_constructors<ContainerType>(type, m);
add_oper_assign<ContainerType>(m); oper_assign<ContainerType>(m);
return m; return m;
} }
/** /**
* Add container concept to the given ContainerType * Add container concept to the given ContainerType
* http://www.sgi.com/tech/stl/Container.html * http://www.sgi.com/tech/stl/Container.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
assignable_type<ContainerType>(type, m); assignable_type<ContainerType>(type, m);
m->add(fun(&ContainerType::size), "size"); m->add(fun(&ContainerType::size), "size");
m->add(fun(&ContainerType::max_size), "max_size"); m->add(fun(&ContainerType::max_size), "max_size");
m->add(fun(&ContainerType::empty), "empty"); m->add(fun(&ContainerType::empty), "empty");
return m; return m;
} }
/** /**
* Add forward container concept to the given ContainerType * Add forward container concept to the given ContainerType
* http://www.sgi.com/tech/stl/ForwardContainer.html * http://www.sgi.com/tech/stl/ForwardContainer.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr forward_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr forward_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
input_range_type<ContainerType>(type, m); input_range_type<ContainerType>(type, m);
container_type<ContainerType>(type, m); container_type<ContainerType>(type, m);
return m; return m;
} }
/** /**
* Add default constructable concept to the given Type * Add default constructable concept to the given Type
* http://www.sgi.com/tech/stl/DefaultConstructible.html * http://www.sgi.com/tech/stl/DefaultConstructible.html
*/ */
template<typename Type> template<typename Type>
ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr default_constructible_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(constructor<Type ()>(), type); m->add(constructor<Type ()>(), type);
return m; return m;
} }
/** /**
* Algorithm for inserting at a specific position into a container * Algorithm for inserting at a specific position into a container
*/ */
template<typename Type> template<typename Type>
void insert_at(Type &container, int pos, const typename Type::value_type &v) void insert_at(Type &container, int pos, const typename Type::value_type &v)
{ {
typename Type::iterator itr = container.begin(); typename Type::iterator itr = container.begin();
typename Type::iterator end = container.end(); typename Type::iterator end = container.end();
if (pos < 0 || std::distance(itr, end) < pos) if (pos < 0 || std::distance(itr, end) < pos)
{ {
throw std::range_error("Cannot insert past end of range"); throw std::range_error("Cannot insert past end of range");
@@ -195,15 +251,15 @@ namespace chaiscript
container.insert(itr, v); container.insert(itr, v);
} }
/** /**
* Algorithm for erasing a specific position from a container * Algorithm for erasing a specific position from a container
*/ */
template<typename Type> template<typename Type>
void erase_at(Type &container, int pos) void erase_at(Type &container, int pos)
{ {
typename Type::iterator itr = container.begin(); typename Type::iterator itr = container.begin();
typename Type::iterator end = container.end(); typename Type::iterator end = container.end();
if (pos < 0 || std::distance(itr, end) < (pos-1)) if (pos < 0 || std::distance(itr, end) < (pos-1))
{ {
throw std::range_error("Cannot erase past end of range"); throw std::range_error("Cannot erase past end of range");
@@ -213,75 +269,75 @@ namespace chaiscript
container.erase(itr); container.erase(itr);
} }
/** /**
* Add sequence concept to the given ContainerType * Add sequence concept to the given ContainerType
* http://www.sgi.com/tech/stl/Sequence.html * http://www.sgi.com/tech/stl/Sequence.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
forward_container_type<ContainerType>(type, m);
default_constructible_type<ContainerType>(type, m);
std::string insert_name;
if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
{ {
insert_name = "insert_ref_at"; forward_container_type<ContainerType>(type, m);
} else { default_constructible_type<ContainerType>(type, m);
insert_name = "insert_at";
std::string insert_name;
if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
{
insert_name = "insert_ref_at";
} else {
insert_name = "insert_at";
}
m->add(fun(&insert_at<ContainerType>), insert_name);
m->add(fun(&erase_at<ContainerType>), "erase_at");
return m;
} }
m->add(fun(&insert_at<ContainerType>), insert_name); /**
m->add(fun(&erase_at<ContainerType>), "erase_at"); * Add back insertion sequence concept to the given ContainerType
* http://www.sgi.com/tech/stl/BackInsertionSequence.html
return m; */
} template<typename ContainerType>
ModulePtr back_insertion_sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
/**
* Add back insertion sequence concept to the given ContainerType
* http://www.sgi.com/tech/stl/BackInsertionSequence.html
*/
template<typename ContainerType>
ModulePtr back_insertion_sequence_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
sequence_type<ContainerType>(type, m);
typedef typename ContainerType::reference (ContainerType::*backptr)();
m->add(fun(backptr(&ContainerType::back)), "back");
std::string push_back_name;
if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
{ {
push_back_name = "push_back_ref"; sequence_type<ContainerType>(type, m);
} else {
push_back_name = "push_back";
typedef typename ContainerType::reference (ContainerType::*backptr)();
m->add(fun(backptr(&ContainerType::back)), "back");
std::string push_back_name;
if (typeid(typename ContainerType::value_type) == typeid(Boxed_Value))
{
push_back_name = "push_back_ref";
} else {
push_back_name = "push_back";
}
m->add(fun(&ContainerType::push_back), push_back_name);
m->add(fun(&ContainerType::pop_back), "pop_back");
return m;
} }
m->add(fun(&ContainerType::push_back), push_back_name); /**
m->add(fun(&ContainerType::pop_back), "pop_back"); * Create a vector type with associated concepts
return m; * http://www.sgi.com/tech/stl/Vector.html
} */
template<typename VectorType>
ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
m->add(user_type<VectorType>(), type);
random_access_container_type<VectorType>(type, m);
back_insertion_sequence_type<VectorType>(type, m);
return m;
}
/** /**
* Create a vector type with associated concepts * Create a vector type with associated concepts
* http://www.sgi.com/tech/stl/Vector.html * http://www.sgi.com/tech/stl/Vector.html
*/ */
template<typename VectorType> template<typename ContainerType>
ModulePtr vector_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{
m->add(user_type<VectorType>(), type);
random_access_container_type<VectorType>(type, m);
back_insertion_sequence_type<VectorType>(type, m);
return m;
}
/**
* Create a vector type with associated concepts
* http://www.sgi.com/tech/stl/Vector.html
*/
template<typename ContainerType>
ModulePtr associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
forward_container_type<ContainerType>(type, m); forward_container_type<ContainerType>(type, m);
@@ -289,11 +345,11 @@ namespace chaiscript
return m; return m;
} }
/** /**
* bootstrap a given PairType * bootstrap a given PairType
* http://www.sgi.com/tech/stl/pair.html * http://www.sgi.com/tech/stl/pair.html
*/ */
template<typename PairType> template<typename PairType>
ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr pair_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(user_type<PairType>(), type); m->add(user_type<PairType>(), type);
@@ -310,11 +366,11 @@ namespace chaiscript
} }
/** /**
* Add pair associative container concept to the given ContainerType * Add pair associative container concept to the given ContainerType
* http://www.sgi.com/tech/stl/PairAssociativeContainer.html * http://www.sgi.com/tech/stl/PairAssociativeContainer.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr pair_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
associative_container_type<ContainerType>(type, m); associative_container_type<ContainerType>(type, m);
@@ -323,11 +379,11 @@ namespace chaiscript
return m; return m;
} }
/** /**
* Add unique associative container concept to the given ContainerType * Add unique associative container concept to the given ContainerType
* http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html * http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr unique_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr unique_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
associative_container_type<ContainerType>(type, m); associative_container_type<ContainerType>(type, m);
@@ -336,28 +392,28 @@ namespace chaiscript
return m; return m;
} }
/** /**
* Add sorted associative container concept to the given ContainerType * Add sorted associative container concept to the given ContainerType
* http://www.sgi.com/tech/stl/SortedAssociativeContainer.html * http://www.sgi.com/tech/stl/SortedAssociativeContainer.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator> typedef std::pair<typename ContainerType::iterator, typename ContainerType::iterator>
(ContainerType::*eq_range)(const typename ContainerType::key_type &); (ContainerType::*eq_range)(const typename ContainerType::key_type &);
reversible_container_type<ContainerType>(type, m); reversible_container_type<ContainerType>(type, m);
associative_container_type<ContainerType>(type, m); associative_container_type<ContainerType>(type, m);
m->add(fun(eq_range(&ContainerType::equal_range)), "equal_range"); m->add(fun(eq_range(&ContainerType::equal_range)), "equal_range");
return m; return m;
} }
/** /**
* Add unique sorted associative container concept to the given ContainerType * Add unique sorted associative container concept to the given ContainerType
* http://www.sgi.com/tech/stl/UniqueSortedAssociativeContainer.html * http://www.sgi.com/tech/stl/UniqueSortedAssociativeContainer.html
*/ */
template<typename ContainerType> template<typename ContainerType>
ModulePtr unique_sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr unique_sorted_associative_container_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
sorted_associative_container_type<ContainerType>(type, m); sorted_associative_container_type<ContainerType>(type, m);
@@ -366,11 +422,11 @@ namespace chaiscript
return m; return m;
} }
/** /**
* Add a MapType container * Add a MapType container
* http://www.sgi.com/tech/stl/Map.html * http://www.sgi.com/tech/stl/Map.html
*/ */
template<typename MapType> template<typename MapType>
ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr map_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(user_type<MapType>(), type); m->add(user_type<MapType>(), type);
@@ -381,17 +437,17 @@ namespace chaiscript
return m; return m;
} }
/** /**
* Add a String container * Add a String container
* http://www.sgi.com/tech/stl/basic_string.html * http://www.sgi.com/tech/stl/basic_string.html
*/ */
template<typename String> template<typename String>
ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module())) ModulePtr string_type(const std::string &type, ModulePtr m = ModulePtr(new Module()))
{ {
m->add(user_type<String>(), type); m->add(user_type<String>(), type);
add_oper_add<String>(m); oper_add<String>(m);
add_oper_add_equals<String>(m); oper_add_equals<String>(m);
add_opers_comparison<String>(m); opers_comparison<String>(m);
random_access_container_type<String>(type, m); random_access_container_type<String>(type, m);
sequence_type<String>(type, m); sequence_type<String>(type, m);
typedef typename String::size_type (String::*find_func)(const String &, typename String::size_type) const; typedef typename String::size_type (String::*find_func)(const String &, typename String::size_type) const;
@@ -404,6 +460,7 @@ namespace chaiscript
return m; return m;
} }
}
} }
#endif #endif

4
include/chaiscript/dispatchkit/function_call.hpp
View File

@@ -6,7 +6,7 @@
#include <boost/preprocessor.hpp> #include <boost/preprocessor.hpp>
#define addparam(z,n,text) params.push_back(Boxed_Value(BOOST_PP_CAT(p, n) )); #define addparam(z,n,text) params.push_back(boost::is_reference<Param ## n>::value?Boxed_Value(boost::ref(BOOST_PP_CAT(p, n))):Boxed_Value(BOOST_PP_CAT(p, n) ));
#define curry(z,n,text) BOOST_PP_CAT(_, BOOST_PP_INC(n)) #define curry(z,n,text) BOOST_PP_CAT(_, BOOST_PP_INC(n))
@@ -79,7 +79,7 @@ namespace chaiscript
boost::function<FunctionType> boost::function<FunctionType>
functor(const std::vector<std::pair<std::string, Proxy_Function > > &funcs) functor(const std::vector<std::pair<std::string, Proxy_Function > > &funcs)
{ {
FunctionType *p; FunctionType *p=0;
return build_function_caller_helper(p, funcs); return build_function_caller_helper(p, funcs);
} }

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

@@ -140,6 +140,7 @@ namespace chaiscript
* Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude. * Builds all the requirements for ChaiScript, including its evaluator and a run of its prelude.
*/ */
void build_eval_system() { void build_eval_system() {
using namespace bootstrap;
engine.add(Bootstrap::bootstrap()); engine.add(Bootstrap::bootstrap());
engine.add(fun(boost::function<void ()>(boost::bind(&dump_system, boost::ref(engine)))), "dump_system"); engine.add(fun(boost::function<void ()>(boost::bind(&dump_system, boost::ref(engine)))), "dump_system");

196
msvc/chai-example/chai-example.vcproj Normal file
View File

@@ -0,0 +1,196 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="chai-example"
ProjectGUID="{CE422E94-B360-4588-8C65-6A9BE80798F9}"
RootNamespace="chaiexample"
Keyword="Win32Proj"
TargetFrameworkVersion="196613"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="..\chaiscript\Boost.vsprops"
CharacterSet="0"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="C:\Programming\chaiscript\trunk\include"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
MinimalRebuild="true"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="4"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
LinkIncremental="2"
GenerateDebugInformation="true"
SubSystem="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="..\chaiscript\Boost.vsprops"
CharacterSet="0"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
EnableIntrinsicFunctions="true"
PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
RuntimeLibrary="2"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
LinkIncremental="1"
GenerateDebugInformation="true"
SubSystem="1"
OptimizeReferences="2"
EnableCOMDATFolding="2"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath="..\..\src\example.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

8
msvc/chaiscript/Boost.vsprops
View File

@@ -8,4 +8,12 @@
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
AdditionalIncludeDirectories="&quot;C:\Programming\Boost\include\boost-1_38&quot;" AdditionalIncludeDirectories="&quot;C:\Programming\Boost\include\boost-1_38&quot;"
/> />
<Tool
Name="VCLibrarianTool"
AdditionalLibraryDirectories="C:\Programming\Boost\lib"
/>
<Tool
Name="VCLinkerTool"
AdditionalLibraryDirectories="C:\Programming\Boost\lib"
/>
</VisualStudioPropertySheet> </VisualStudioPropertySheet>

6
msvc/chaiscript/chaiscript.sln
View File

@@ -3,6 +3,8 @@ Microsoft Visual Studio Solution File, Format Version 10.00
# Visual C++ Express 2008 # Visual C++ Express 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chaiscript", "chaiscript.vcproj", "{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}" Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chaiscript", "chaiscript.vcproj", "{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}"
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "chai-example", "..\chai-example\chai-example.vcproj", "{CE422E94-B360-4588-8C65-6A9BE80798F9}"
EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32 Debug|Win32 = Debug|Win32
@@ -13,6 +15,10 @@ Global
{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.Build.0 = Debug|Win32 {46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Debug|Win32.Build.0 = Debug|Win32
{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.ActiveCfg = Release|Win32 {46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.ActiveCfg = Release|Win32
{46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.Build.0 = Release|Win32 {46FD9DC7-2DA9-4C17-ADE4-E3A18C46E87B}.Release|Win32.Build.0 = Release|Win32
{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.ActiveCfg = Debug|Win32
{CE422E94-B360-4588-8C65-6A9BE80798F9}.Debug|Win32.Build.0 = Debug|Win32
{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.ActiveCfg = Release|Win32
{CE422E94-B360-4588-8C65-6A9BE80798F9}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection EndGlobalSection
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE

2
src/example.cpp
View File

@@ -125,7 +125,7 @@ int main(int argc, char *argv[]) {
//Ability to create our own container types when needed. std::vector and std::map are //Ability to create our own container types when needed. std::vector and std::map are
//mostly supported currently //mostly supported currently
chai.add(vector_type<std::vector<int> >("IntVector")); chai.add(bootstrap::vector_type<std::vector<int> >("IntVector"));
} }