C++程序中嵌入Ruby脚本系统

#if _MSC_VER != 1200
#error MSC version unmatch
#endif

#ifndef __RubyInterpreter_H__
#define __RubyInterpreter_H__


#include < string>

typedef unsigned  long    VALUE;
typedef std:: string        String;

typedef VALUE(*staticValueMethod)( );
typedef VALUE(*ProtectedMethod)(VALUE);

class RubyInterpreter
{
public:
    RubyInterpreter();
    virtual ~RubyInterpreter();

public:
    /// 初始化解释器
    void initializeInterpreter();

    /// 终止解释器
    void finalizeInterpreter();

    /// 设置
    void setOutputFunction(staticValueMethod func);

    /// 加入引用库的搜索路径
    void addSearchPath(const String& path);

public:
    /// 执行语句
    bool execute(const String& command);
    
    /// 执行文件
    bool executeFile(String rubyfile);

private:
    /// 记录错误日志
    void logRubyErrors(const std::string& intro, int errorcode);
    
    /// 
    void loadProtected(ProtectedMethod func, VALUE args,
        const std::string& msg, bool exitOnFail = false);

    /// 
    static VALUE loadDlls(VALUE);
};


#endif

#include "StdAfx.h"
#include "RubyInterpreter.h"

#include "FixRubyHeaders.h"
#include <ruby.h>
#include "FixRubyHeaders.h"


RubyInterpreter::RubyInterpreter()
{

}

RubyInterpreter::~RubyInterpreter()
{

}

void RubyInterpreter::initializeInterpreter()
{
#if defined(NT)
    static int dummyargc(0);
    static char** vec;
    NtInitialize(&dummyargc, &vec);
#endif

    // 初始化Ruby
    ruby_init();

    // 使用UTF8编码
    execute( "$KCODE = 'u'" );

    // addSearchPath();

    // 初始化脚本加载路径
    ruby_init_loadpath();

    // 设置安全级别
    rb_set_safe_level(0);

    // 
    ruby_script("ruby");

    //loadProtected(&RubyInterpreter::loadDlls, 0, "Ruby error while loading dlls");
}

void RubyInterpreter::finalizeInterpreter()
{
    ruby_finalize();
}

void RubyInterpreter::setOutputFunction(staticValueMethod func)
{
    rb_defout = rb_str_new("", 0);

    // 定义一个虚拟类的方法
    rb_define_singleton_method(rb_defout, "write", func, 1);
}

void RubyInterpreter::addSearchPath( const String& path)
{
    ruby_incpush(path.c_str());
}

VALUE RubyInterpreter::loadDlls(VALUE val)
{
    String lib;

    // 
    return rb_require(lib.c_str());
}

void RubyInterpreter::loadProtected(ProtectedMethod func,
                                    VALUE val, 
                                     const std:: string& msg, 
                                     bool exitOnFail)
{
    int error = 0;
    rb_protect(func, val, &error);
    logRubyErrors("Ruby error while initializing", error);
}

void RubyInterpreter::logRubyErrors( const std:: string& intro,  int errorcode)
{
    if (errorcode != 0)
    {
        VALUE info = rb_inspect(ruby_errinfo);
        rb_backtrace();
        if (intro.length() > 0)
        {
        }
    }
}

bool RubyInterpreter::execute( const String& command)
{
    int status = -1;

    rb_eval_string_protect(command.c_str(), &status);

    logRubyErrors("", status);

    if ( status )
    {
        rb_eval_string_protect("print $!", &status);
        return false;
    }

    return true;
}

bool RubyInterpreter::executeFile(String rubyfile)
{
    bool error = execute("load '" + rubyfile + "'");
    return error;
}

% module Export4ScriptLib
% {
#include "Player.h"
%}


% include  " stl.i "
% include  " Player.h "

swig.exe -c++ -ruby Exports.i

require  ' Export4ScriptLib '

print  " hello 你好!\n "


ply = Export4ScriptLib::Player.new
ply.Jump();
ply.Move(100, 2000);

class testClient
{
public:
    testClient()
    {
        mRubyInterpreter = new RubyInterpreter();
        mRubyInterpreter->initializeInterpreter();
    }
    
    ~testClient()
    {
        delete mRubyInterpreter;
    }

    void  exec()
    {
        // 执行语句
        mRubyInterpreter->execute( " print \ "This  is C++ call Ruby  print funtion!\n\ "");
        
        // 执行文件
        mRubyInterpreter->executeFile( " test.rb ");
    }

private:
    RubyInterpreter* mRubyInterpreter;
};