Master needs to becoming the Cx branch, while the current master needs to be the pre-C++11 work.

Make sure links between documentation / github / chaiscript.com are correct and make sense.

Allow the user to define new enums inside of ChaiScript.

The Stack is not saved and restored when the state of a chaiscript instance is changed.

This way different chaiscripts share the same variables, which IMHO should not be the case.

The readme.txt for Cx uses an example that's out of date for the Cx branch. Needs to be updated to include using the stdlib.

I've been trying to use ChaiScript when compiling for x64 with Windows SDK 7.1

I have been getting numinous warning such as:

1> d:\users\cameron garnham\documents\dev\open-transactions\include\chaiscript\dispatchkit/boxed_number.hpp(185) : see reference to function template instantiation 'chaiscript::Boxed_Value chaiscript::Boxed_Number::const_binary::go<LHS,RHS>(chaiscript::Operators::Opers,const T &,const U &,const chaiscript::Boxed_Value &)' being compiled
1> with
1> [
1> LHS=uint64_t,
1> RHS=char,
1> T=uint64_t,
1> U=char
1> ]
1> d:\users\cameron garnham\documents\dev\open-transactions\include\chaiscript\dispatchkit/boxed_number.hpp(174) : while compiling class template member function 'chaiscript::Boxed_Value chaiscript::Boxed_Number::Go<LHS,RHS,Float>::go(chaiscript::Operators::Opers,const chaiscript::Boxed_Value &,const chaiscript::Boxed_Value &)'
1> with
1> [
1> LHS=uint64_t,
1> RHS=char,
1> Float=false
1> ]
1> d:\users\cameron garnham\documents\dev\open-transactions\include\chaiscript\dispatchkit/boxed_number.hpp(228) : see reference to class template instantiation 'chaiscript::Boxed_Number::Go<LHS,RHS,Float>' being compiled
1> with
1> [
1> LHS=uint64_t,
1> RHS=char,
1> Float=false
1> ]

Can I please have some help with this error.

problem

In case there is two different objects with same attribute name the engine ignore the second one.

diagnosis:

It seems like there is bug in Attr_Decl_AST_Node.
Attr_Decl_AST_Node add the attribute as Proxy_Function_Impl so it looks like the operator == return true(ignore the object type name).

in the function bool add_function(const Proxy_Function &t_f, const std::string &t_name) under dispatchkit
((_t_f) == *(_itr2)) return true without

Hope my diagnosis is correct.

example:

//obj1
attr obj1::Height;
def obj1::obj1() {
this.reset();
}
def obj1::reset() {
this.Height = 0;
}

//obj2
attr obj2::Height;
def obj2::reset() {
this.Height = 0;
}
def obj2::obj2() {
this.reset();
}
var c6 := obj1();
var c7 := obj2();

std::move could be used to move Boxed_Value objects around and prevent copies in some places. Also, it could be used for moving the vector of arguments for function calls.

Example:

Currently this does not work:

var f = `+`.get_contained_functions()[0];

No errors are thrown when redefining a variable. It simply acts (as far as I can tell) as a normal assignment. I would expect an error here:

eval> auto y = 10;
10
eval> y
10
eval> auto y = 20;
20
eval> y
20

Interestingly, function definitions have a similar problem. No error is thrown, but instead of acting as a new definition, it's silently ignored:

eval> def foo(x) { return x + 1; }
eval> foo(4)
5
eval> def foo(x) { return x + 2; }
eval> foo(4)
5

If the Proxy_Function subclasses have virtual call(Boxed_Value), call(Boxed_Value, Boxed_Value) overloads for unary and binary functions it might avoid some copies / vector construction.

Currently I can't find any resources on how to use reflection in Chaiscript. Could you please write up some?

Allow the following:

switch (myvalue)
{
   case 1:
     // do something
     break;
   case 2:
     // do something else
    break;
};

To be consistent with C++, this would require support for labels and break statements. The labels can be emulated, but the break statements and fall through would have to actually be supported.

Get examples from documentation into the Git repository and building when "BUILD_SAMPLES" is enabled in cmake.

See comment:

http://www.chaiscript.com/node/80#comment-235

Support this:

std::vector<int> vec = m_chai<std::vector<int> >("[1,2,3,4]");

It will require tests in boxed_cast, but should be possible. Might be doable by using ranges somehow.

After I do "cmake .." and "make" I am getting:

shlomif@telaviv1:~/Download/unpack/prog/chai-script/ChaiScript/build$ make 
Scanning dependencies of target boxed_cast_test
[  5%] Building CXX object CMakeFiles/boxed_cast_test.dir/unittests/boxed_cast_test.cpp.o
Linking CXX executable boxed_cast_test
[  5%] Built target boxed_cast_test
Scanning dependencies of target chai
[ 11%] Building CXX object CMakeFiles/chai.dir/src/main.cpp.o
Linking CXX executable chai
/usr/bin/ld: CMakeFiles/chai.dir/src/main.cpp.o: undefined reference to symbol 'pthread_mutexattr_settype@@GLIBC_2.2.5'
/usr/bin/ld: note: 'pthread_mutexattr_settype@@GLIBC_2.2.5' is defined in DSO /lib64/libpthread.so.0 so try adding it to the linker command line
/lib64/libpthread.so.0: could not read symbols: Invalid operation
collect2: ld returned 1 exit status
make[2]: *** [chai] Error 1
make[1]: *** [CMakeFiles/chai.dir/all] Error 2
make: *** [all] Error 2

The "make VERBOSE=1" command line is:

/usr/bin/c++       CMakeFiles/chai.dir/src/main.cpp.o  -o chai -rdynamic -ldl -lboost_thread-mt -lreadline 

This is on the trunk in commit d2aba2e .

I am on Mageia Linux Cauldron (what will become Mageia Linux 3).

Regards,

-- Shlomi Fish

We should be able to speed up variable lookup dramatically in some cases by caching the def of identifiers we know statically at parse time. It may be as simple as a double-pointer to the currently definition of the variable (def's of variables aren't unique based on AST location, as in the case of var decls inside of loops).

If a variable is defined twice in the same scope (not a nested scope, with shadowing, that should be allowed?). Throw an error.

provide way to specify types of exceptions to catch and unwrap during eval, to shorten exception handling code in the C++ side.

This should just work:

chai.add(fun([](){ dostuff }), "dostuff");

It currently cannot have its type deduced.

try {
 eval("2 + \"bob\"");
}
catch (e) {
  print("got an exception!");
}

Currently, this prints out:

Error: "Can not find appropriate '+'" during evaluation at (EVAL 1, 1)
from break.chai (2, 3)
from break.chai (2, 3)

Despite the eyesore of the location being printed twice, it's clear we don't have enough control to grab the exception and handle it from inside ChaiScript itself.

The chai interpreter should allow the first line of a passed script file to be a Hashbang. An example such line:

#!/usr/bin/env chai

This works without modification for many languages, since the octothorpe is a common character to indicate comments. This could be supported by ChaiScript in a number of ways:

1. Allow comments to start with # in addition to // (this is probably not desired, given the goals of the language)
2. Modify either load_file or do_eval in chaiscript_engine.hpp to check the first two characters in the file for #! and replace them with // .
3. Modify main.cpp to do the same string modification as in 2, loading its own file and using chai.eval() instead of chai.eval_file().

Solution 3 here is the only solution that keeps the change entirely within the command-line interpreter, which might be desired.

The forums point to some lack of documentation, make sure the docs do cover the questions posed in the forums.

Make sure there are example scripts for common use cases. Unit tests count as well, but it might make sense to add new examples.

Make sure examples run during "make test" probably utilizing the same mechanism as the existing unit tests, in the CMakeLists.txt

Use the new C++11 feature for raw strings to embed the ChaiScript prelude code.

Some constructs used in the library break standards conventions but could be worked around. For instance, the dlsym problem could be worked around by using reinterpret_cast(reinterpret_cast<intptr_t>(dlsym(...))).

The goal is for C++11 branch to be backward compatible with Mainline branch.

http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/index.jsp?topic=/com.ibm.vacpp7a.doc/language/ref/clrc02reserved_identifiers.htm

http://chaiscript.com/chaiscript_development points to googlecode but it really should point to this github repo.

This can reduce the number of methods for POD Numeric types to only 1 per operator and can be used as a shortcut handler to bypass dispatch on common operators. Should provide a large performance and compile time boost.

Note: this has to be done in such a way that it is both a shortcircuiting of dispatch, and available for dispatch so that - type operations are not broken.

The C++11 branch has better error reporting than the master branch, this should be back ported for consistency.

Initial thoughts are that at least the user_type<>() function could make use of constexpr to inform the compiler the value will always be the same and can be compiled.

An error in OpenTransactions fails to report a proper error.

The gist of it is ChaiScript Function->ChaiScript Function->ChaiScript Method->ChaiScript Method->C++ Function call failure.

This error failed to report the c++ function and stopped at the method call.

There are many string comparisons that happen repeatedly (and needlessly) in chaiscript_eval.hpp. Consider them for construction time constants. (see Int_Node).

See user comment:

http://chaiscript.com/node/80

Problem :

Comparison of two short(uint16_t) numbers returns an incorrect result.

diagnosis:

It seems like it copy/paste issue.
file : chaiscript\include\chaiscript\dispatchkit\boxed_number.hpp
function: static Boxed_Value oper(Operators::Opers t_oper, const Boxed_Value &t_lhs, const Boxed_Value &t_rhs)
...
} else if (inp_ == typeid(boost::int16_t)) {
return oper_rhs<boost::int32_t, false>(t_oper, t_lhs, t_rhs);
.....

Should be changed to : oper_rhs<boost::int16_t, false>(t_oper, t_lhs, t_rhs);

sample:

#include <chaiscript/utility/utility.hpp>

class Test {
 public:
  Test() : value_(5) {}

  short get_value() { return value_; }

  short value_;
};

int main()
{

  chaiscript::ChaiScript chai;
  chai.add(chaiscript::user_type<Test>(), "Test");
  chai.add(chaiscript::constructor<Test()>(), "Test");

  chai.add(chaiscript::fun(&Test::get_value), "get_value");

  chai.eval("var t := Test();");
  chai.eval("if(t.get_value() == 5 ) { print(\"TRUE\"); } else { print(\"FALSE\"); } ");
}

Thanks Rafi

Apply any corrections as necessary.

Add new unit tests which tests threading execution for safety.

pScript->chai.add(fun(&OT_API_CreateNym), "OT_API_CreateNym");
    pScript->chai.add(fun(&OT_API_AddServerContract), "OT_API_AddServerContract");
    pScript->chai.add(fun(&OT_API_AddAssetContract), "OT_API_AddAssetContract");

While trying to add functions declared as extern "C", I get this linker error:

Undefined symbols for architecture x86_64:
"_OT_API_CreateNym", referenced from:
RegisterAPIWithScript(OTScript&) in xmlrpcxx_client.o
"_OT_API_AddServerContract", referenced from:
RegisterAPIWithScript(OTScript&) in xmlrpcxx_client.o
"_OT_API_AddAssetContract", referenced from:
RegisterAPIWithScript(OTScript&) in xmlrpcxx_client.o

The problem doesn't occur with normal C++ functions, only C functions.

Hi,

right now if one uses eval_file to execute a chai script and an eval_error occurs,
the variables filename, start_position and end_position are always empty.
Although it would be extremely helpful to know in which file and line the error occurred.

Is this planned in the future or did I miss some existing functionality?

Cheers
Markus

Massive improvement!

However it is still not compiling cleanly.

https://gist.github.com/2856940

This is open for discussion. It might be a good feature for the next version of 3.x/4.x

Currently, in ChaiScript, there is no way to specify a variable as const.

const var myvalue = 5;

This feature should be added.