source: nrEngine/src/ScriptEngine.cpp @ 1

Revision 1, 8.2 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13
14//----------------------------------------------------------------------------------
15// Includes
16//----------------------------------------------------------------------------------
17#include "ScriptEngine.h"
18#include "Log.h"
19#include "events/EngineEvent.h"
20#include "EventManager.h"
21#include "VariadicArgument.h"
22#include "IScript.h"
23
24namespace nrEngine{
25
26        //----------------------------------------------------------------------------------
27        ScriptFunctionDec(scriptLoad, ScriptEngine)
28        {
29                // check parameter count
30                if (args.size() < 2){
31                        return ScriptResult(std::string("Not valid parameter count! Parameters (name, filename)"));
32                }
33
34                // get parameters
35                IResourcePtr ptr = Engine::sScriptEngine()->load(args[1], args[2]);
36
37                if (ptr.isNull())
38                {
39                        return ScriptResult(std::string("Can not load script ") + args[1] + " from file " + args[2]);
40                }
41
42                return ScriptResult();
43        }
44
45        //----------------------------------------------------------------------------------
46        ScriptFunctionDec(scriptRun, ScriptEngine)
47        {
48                // check parameter count
49                if (args.size() < 1){
50                        return ScriptResult(std::string("Not valid parameter count! Parameters (name [, runonce = true [, immediate = false]])"));
51                }
52
53                // get parameters
54                try{
55                        const std::string& name = args[1];
56                        bool once = true;
57                        if (args.size() > 2) boost::lexical_cast<bool>(args[2]);
58                        bool force = false;
59                        if (args.size() > 3) boost::lexical_cast<bool>(args[3]);
60
61                        // run
62                        if (!Engine::sScriptEngine()->execute(name, once, force))
63                                return ScriptResult(std::string("Can not execute script ") + name);
64                }catch(boost::bad_lexical_cast s){
65                        return ScriptResult(std::string("Wrong parameter value! "));
66                }
67               
68                return ScriptResult();
69        }
70
71        //----------------------------------------------------------------------------------
72        ScriptFunctionDec(scriptCall, ScriptEngine)
73        {
74                // check parameter count
75                if (args.size() < 2){
76                        return ScriptResult(std::string("Not valid parameter count! Parameters (name, funcname, [, param1, ..., paramn])"));
77                }
78       
79                // get parameters in a value
80                IScript::ArgumentList ar;
81                for (uint32 i=3; i < args.size(); i++) ar.push_back(std::pair<std::string, std::string>("string", args[i]));
82
83                // get resource
84                ResourcePtr<IScript> ptr = Engine::sResourceManager()->getByName(args[1]);
85                if (ptr.isNull())
86                        return ScriptResult(std::string("Can not find script ") + args[1]);
87
88                // now prepare arguments
89                ptr->setArguments(args[2], ar);
90                ScriptResult res;
91                ptr->call(args[2]);
92               
93                // call a specific function
94                return res;
95        }
96       
97        //----------------------------------------------------------------------------------
98        ScriptEngine::ScriptEngine(){
99                mDatabase["scriptLoad"].first = scriptLoad;
100                mDatabase["scriptRun"].first = scriptRun;
101                mDatabase["scriptExecute"].first = scriptRun;
102                mDatabase["scriptCall"].first = scriptCall;
103        }
104
105        //----------------------------------------------------------------------------------
106        ScriptEngine::~ScriptEngine(){
107
108                // empty the database
109                mDatabase.clear();
110
111        }
112
113        //----------------------------------------------------------------------------------
114        Result ScriptEngine::add(const std::string& name, ScriptFunctor func, const std::vector<ScriptParam>& param)
115        {
116                // first check whenever such function already registered
117                if (isRegistered(name))
118                        return SCRIPT_FUNCTION_REGISTERED;
119
120                // now add the function to the database
121                mDatabase[name].first = func;
122                mDatabase[name].second = param;
123
124                // some statistical information
125                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ScriptEngine: New function \"%s\" registered", name.c_str());
126
127                // emit a new event
128                SharedPtr<Event> msg(new ScriptRegisterFunctionEvent(name, func));
129                Engine::sEventManager()->emitSystem(msg);
130               
131                return OK;
132        }
133
134        //----------------------------------------------------------------------------------
135        Result ScriptEngine::add(const std::string& name, ScriptFunctor func, const VarArg& v){
136
137                // get the elements and store them in vector
138                std::vector<ScriptParam> p;
139                v.convert<ScriptParam>(p);
140
141                // OK
142                return add(name, func, p);
143        }
144
145        //----------------------------------------------------------------------------------
146        Result ScriptEngine::del(const std::string& name)
147        {
148                // get the function
149                FunctionDatabase::iterator it = mDatabase.find(name);
150                if (it == mDatabase.end()) return SCRIPT_FUNCTION_NOT_REGISTERED;
151
152                mDatabase.erase(it);
153
154                // some statistical information
155                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ScriptEngine: Function \"%s\" was removed", name.c_str());
156
157                // emit a new event
158                SharedPtr<Event> msg(new ScriptRemoveFunctionEvent(name));
159                Engine::sEventManager()->emitSystem(msg);
160
161                return OK;
162        }
163
164        //----------------------------------------------------------------------------------
165        ScriptResult ScriptEngine::call(const std::string& name, const std::vector<std::string>& args)
166        {
167                // if no such function was found
168                FunctionDatabase::iterator f = get(name);
169                if (f == mDatabase.end()){
170                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "ScriptEngine: Function \"%s\" was not found!", name.c_str());
171                        return ScriptResult();
172                }
173
174                // call the function
175                return ((*f).second).first(args, (*f).second.second);
176        }
177
178        //----------------------------------------------------------------------------------
179        bool ScriptEngine::isRegistered(const std::string& name)
180        {
181                // search for that name in the database
182                FunctionDatabase::const_iterator it = mDatabase.find(name);
183                return it != mDatabase.end();
184        }
185
186        //----------------------------------------------------------------------------------
187        ScriptEngine::FunctionDatabase::iterator ScriptEngine::get(const std::string& name)
188        {
189                // search for that name in the database
190                FunctionDatabase::iterator it = mDatabase.find(name);
191
192                return it;
193        }
194
195        //------------------------------------------------------------------------
196        ResourcePtr<IScript> ScriptEngine::load(const std::string& name, const std::string& file)
197        {
198                // try to load the resource and check for the error code
199                ResourcePtr<IScript> plg = Engine::sResourceManager()->loadResource(name, "Scripts", file);
200
201                if (plg.isNull()){
202                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Can not load the script %s from %s", name.c_str(), file.c_str());
203                }
204                return plg;
205        }
206
207
208        //------------------------------------------------------------------------
209        Result ScriptEngine::execute(const std::string& name, bool runOnce, bool immediate)
210        {
211                // get the pointer to the script resource
212                ResourcePtr<IScript> scr = Engine::sResourceManager()->getByName(name);
213                return _execute(scr, runOnce, immediate);               
214        }
215
216        //------------------------------------------------------------------------
217        Result ScriptEngine::execute(const std::string& name, const std::string& fileName, bool runOnce, bool immediate)
218        {
219                ResourcePtr<IScript> scr = load(name, fileName);
220                return _execute(scr, runOnce, immediate);
221        }
222
223        //------------------------------------------------------------------------
224        Result ScriptEngine::_execute(const ResourcePtr<IScript>& ptr, bool runOnce, bool immediate)
225        {
226                if (ptr.isNull()) return RES_NOT_FOUND;
227                if (immediate) return ptr->forceExecute(runOnce);
228                return ptr->execute(runOnce);
229        }
230
231        //------------------------------------------------------------------------
232        const std::string& ScriptEngine::getFunction(uint32 index, ScriptFunctor& functor)
233        {
234                NR_ASSERT(index < getFunctionCount());
235                FunctionDatabase::const_iterator it = mDatabase.begin();
236                for (uint32 i = 0; i < index; i++, it++){}
237
238                functor = it->second.first;
239                return it->first;
240        }
241
242};
243
Note: See TracBrowser for help on using the repository browser.