scriptserver.cpp

ROBOCUP 仿真3D server 源码

/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*-

   this file is part of rcssserver3D
   Fri May 9 2003
   Copyright (C) 2002,2003 Koblenz University
   Copyright (C) 2003 RoboCup Soccer Server 3D Maintenance Group
   $Id: scriptserver.cpp,v 1.24 2006/05/16 10:07:03 jamu Exp $

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <boost/any.hpp>
#include <boost/scoped_array.hpp>
#include <sstream>
#include "scriptserver.h"
#include <zeitgeist/corecontext.h>
#include <zeitgeist/core.h>
#include <zeitgeist/logserver/logserver.h>
#include <zeitgeist/fileserver/fileserver.h>
#include <sys/stat.h>

using namespace boost;
using namespace std;
using namespace zeitgeist;

boost::shared_ptr<CoreContext> gMyPrivateContext;

void
getParameterList(VALUE args, ParameterList& params)
{
    int argc = RARRAY(args)->len;

    for (int i = 0; i<argc; ++i)
    {
        VALUE argument = rb_ary_entry(args, i);
        boost::any var;

        // do type conversion
        switch (TYPE(argument))
        {
        case T_STRING:
        {
            char *c = STR2CSTR(argument);
            var = c;
            //printf("string: '%s'\n",boost::any_cast<char*>(var));
        }
        break;
        case T_FIXNUM:
        {
            int i = FIX2INT(argument);
            var = i;
            //printf("int: '%d'\n", boost::any_cast<int>(var));
        }
        break;
        case T_FLOAT:
        {
            float f = (float)NUM2DBL(argument);
            var = f;
            //printf("float: '%f'\n", boost::any_cast<float>(var));
        }
        break;
        case T_TRUE:
        {
            var = true;
            //printf("bool: 'true'\n");
        }
        break;
        case T_FALSE:
        {
            var = false;
            //printf("bool: 'false'\n");
        }
        break;
        }

        params.AddValue(var);
    }
}

GCValue
ScriptServer::GetZeitgeistObject(boost::shared_ptr<Leaf> leaf)
{
    GCValue v;

    if (leaf.get() != 0)
    {
        stringstream ss;
        ss << "ZeitgeistObject.new(" << (unsigned long) leaf.get() <<")";
        v = RbEvalStringWrap(ss.str());
    }

    return v;
}


VALUE
selectObject(VALUE /*self*/, VALUE path)
{
    shared_ptr<Leaf> leaf = gMyPrivateContext->Select(STR2CSTR(path));
    return ScriptServer::GetZeitgeistObject(leaf).Get();
}

VALUE
selectCall(VALUE /*self*/, VALUE functionName, VALUE args)
{
    ParameterList in;
    getParameterList(args, in);

    Class::TCmdProc cmd =
        gMyPrivateContext->GetObject()->GetClass()->GetCmdProc
        (STR2CSTR(functionName));

    GCValue out;

    if (cmd != 0)
    {
        out = cmd(static_cast<Object*>(gMyPrivateContext->GetObject().get()), in);
    } else
    {
        gMyPrivateContext->GetCore()->GetLogServer()->Error()
            << "(ScriptServer) ERROR: Unknown function '"
            << STR2CSTR(functionName) << "'" << endl;
    }

    return out.Get();
}

VALUE
thisCall(VALUE /*self*/, VALUE objPointer, VALUE functionName, VALUE args)
{
    ParameterList in;
    getParameterList(args, in);

    Object *obj = (Object*)NUM2INT(objPointer);
    Class::TCmdProc cmd =
        obj->GetClass()->GetCmdProc(STR2CSTR(functionName));

    GCValue out;

    if (cmd != 0)
    {
        out = cmd(obj, in);
    } else
    {
        gMyPrivateContext->GetCore()->GetLogServer()->Error()
            << "(ScriptServer) ERROR: Unknown function '"
            << STR2CSTR(functionName) << "'" << endl;
    }

    return out.Get();
}

VALUE
importBundle(VALUE /*self*/, VALUE path)
{
    gMyPrivateContext->GetCore()->ImportBundle(STR2CSTR(path));
    return Qnil;
}

VALUE
run (VALUE /*self*/, VALUE file)
{
    gMyPrivateContext->GetCore()->GetScriptServer()->Run(STR2CSTR(file));
    return Qnil;
}

VALUE
newObject(VALUE /*self*/, VALUE className, VALUE pathStr)
{
    shared_ptr<Leaf> leaf =
        gMyPrivateContext->New(STR2CSTR(className), STR2CSTR(pathStr));
    return ScriptServer::GetZeitgeistObject(leaf).Get();
}

VALUE
deleteObject(VALUE /*self*/, VALUE name)
{
    gMyPrivateContext->Delete(STR2CSTR(name));
    return Qnil;
}

VALUE
getObject(VALUE /*self*/, VALUE path)
{
    shared_ptr<Leaf> leaf = gMyPrivateContext->Get(STR2CSTR(path));
    return ScriptServer::GetZeitgeistObject(leaf).Get();
}

VALUE
listObjects(VALUE /*self*/)
{
    gMyPrivateContext->ListObjects();
    return Qnil;
}

VALUE
pushd(VALUE /*self*/)
{
    gMyPrivateContext->Push();
    return Qnil;
}

VALUE
popd(VALUE /*self*/)
{
    gMyPrivateContext->Pop();
    return Qnil;
}

VALUE
dirs(VALUE /*self*/)
{
    gMyPrivateContext->Dir();
    return Qnil;
}

ScriptServer::ScriptServer()
{
    ruby_init();

    // register built-in commands
    rb_define_global_function("selectObject", RUBY_METHOD_FUNC(selectObject), 1);
    rb_define_global_function("selectCall",   RUBY_METHOD_FUNC(selectCall), 2);
    rb_define_global_function("thisCall",     RUBY_METHOD_FUNC(thisCall), 3);
    rb_define_global_function("importBundle", RUBY_METHOD_FUNC(importBundle), 1);
    rb_define_global_function("run",          RUBY_METHOD_FUNC(run), 1);
    rb_define_global_function("new",          RUBY_METHOD_FUNC(newObject), 2);
    rb_define_global_function("delete",       RUBY_METHOD_FUNC(deleteObject), 1);
    rb_define_global_function("get",          RUBY_METHOD_FUNC(getObject), 1);
    rb_define_global_function("ls",           RUBY_METHOD_FUNC(listObjects), 0);
    rb_define_global_function("pushd",        RUBY_METHOD_FUNC(pushd), 0);
    rb_define_global_function("popd",         RUBY_METHOD_FUNC(popd), 0);
    rb_define_global_function("dirs",         RUBY_METHOD_FUNC(dirs), 0);

    mRelPathPrefix = "../../";
}

ScriptServer::~ScriptServer()
{
}

void
ScriptServer::UpdateCachedAllNodes()
{
    GetLog()->Debug() << "(ScriptServer) updating cached script variables\n";
    GetCore()->GetRoot()->UpdateCached();
}

bool
ScriptServer::Run(shared_ptr<salt::RFile> file)
{
    if (file.get() == 0)
    {
        return false;
    }

    boost::scoped_array<char> buffer(new char[file->Size() + 1]);
    file->Read(buffer.get(), file->Size());
    buffer[file->Size()] = 0;

    bool ok = Eval(buffer.get());
    UpdateCachedAllNodes();
    return ok;
}

bool
ScriptServer::Run(const string &fileName)
{
    shared_ptr<salt::RFile> file = GetFile()->Open(fileName.c_str());
    if (file.get() == 0)
    {
        GetLog()->Error() << "(ScriptServer) ERROR: Cannot locate file '"
                          << fileName << "'\n";
        return false;
    }

    GetLog()->Debug() << "(ScriptServer) Running " << fileName << endl;

    return Run(file);
}

bool
ScriptServer::Eval(const string &command)
{
    int error;
    RbEvalStringWrap(command,error);
    return (error == 0);
}

bool
ScriptServer::Eval(const std::string &command, GCValue& value)
{
    int error;
    value = RbEvalStringWrap(command,error);
    return (error == 0);
}

void
ScriptServer::CreateVariable(const string &varName, int value)
{
    // create a string with: "createVariable 'varName', value"
    stringstream s;
    s << "createVariable('" << varName << "', " << value << ")";
    Eval(s.str());
}

void
ScriptServer::CreateVariable(const string &varName, float value)
{
    // create a string with: "createVariable 'ns', 'varName', value"
    stringstream s;
    s << "createVariable('" << varName << "', " << value << ")";