Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/core/TclThreadManager.cc @ 6839

Last change on this file since 6839 was 6417, checked in by rgrieder, 15 years ago

Merged presentation2 branch back to trunk.
Major new features:

  • Actual GUI with settings, etc.
  • Improved space ship steering (human interaction)
  • Rocket fire and more particle effects
  • Advanced sound framework
  • Property svn:eol-style set to native
File size: 28.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "TclThreadManager.h"
30
31#include <boost/bind.hpp>
32#include <boost/thread/thread.hpp>
33#include <boost/thread/locks.hpp>
34#include <boost/thread/shared_mutex.hpp>
35#include <OgreTimer.h>
36#include <cpptcl/cpptcl.h>
37
38#include "util/Clock.h"
39#include "util/Convert.h"
40#include "util/Exception.h"
41#include "util/StringUtils.h"
42#include "CommandExecutor.h"
43#include "ConsoleCommand.h"
44#include "CoreIncludes.h"
45#include "TclBind.h"
46#include "TclThreadList.h"
47
48namespace orxonox
49{
50    const float TCLTHREADMANAGER_MAX_CPU_USAGE = 0.50f;
51
52    SetConsoleCommandShortcutAlias(TclThreadManager, execute, "tclexecute").argumentCompleter(0, autocompletion::tclthreads());
53    SetConsoleCommandShortcutAlias(TclThreadManager, query,   "tclquery"  ).argumentCompleter(0, autocompletion::tclthreads());
54    SetConsoleCommand(TclThreadManager, create,  false);
55    SetConsoleCommand(TclThreadManager, destroy, false).argumentCompleter(0, autocompletion::tclthreads());
56    SetConsoleCommand(TclThreadManager, execute, false).argumentCompleter(0, autocompletion::tclthreads());
57    SetConsoleCommand(TclThreadManager, query,   false).argumentCompleter(0, autocompletion::tclthreads());
58    SetConsoleCommand(TclThreadManager, source,  false).argumentCompleter(0, autocompletion::tclthreads());
59
60    /**
61        @brief A struct containing all information about a Tcl-interpreter
62    */
63    struct TclInterpreterBundle
64    {
65        TclInterpreterBundle()
66        {
67            this->lock_ = new boost::unique_lock<boost::mutex>(this->mutex_, boost::defer_lock);
68            this->bRunning_ = true;
69        }
70
71        ~TclInterpreterBundle()
72        {
73            delete this->lock_;
74        }
75
76        unsigned int                      id_;             ///< The id of the interpreter
77        Tcl::interpreter*                 interpreter_;    ///< The Tcl-interpreter
78        boost::mutex                      mutex_;          ///< A mutex to lock the interpreter while it's being used
79        boost::unique_lock<boost::mutex>* lock_;           ///< The corresponding lock for the mutex
80        TclThreadList<std::string>        queue_;          ///< The command queue for commands passed by execute(command)
81        TclThreadList<unsigned int>       queriers_;       ///< A list containing the id's of all other threads sending a query to this interpreter (to avoid circular queries and deadlocks)
82        bool                              bRunning_;       ///< This variable stays true until destroy() gets called
83    };
84
85    TclThreadManager* TclThreadManager::singletonPtr_s = 0;
86
87    /**
88        @brief Constructor
89        @param interpreter A pointer to the standard Tcl-interpreter (see @ref TclBind)
90    */
91    TclThreadManager::TclThreadManager(Tcl::interpreter* interpreter)
92    {
93        RegisterRootObject(TclThreadManager);
94
95        this->numInterpreterBundles_ = 0;
96
97        this->interpreterBundlesMutex_ = new boost::shared_mutex();
98        this->mainInterpreterMutex_ = new boost::mutex();
99        this->messageQueue_ = new TclThreadList<std::string>();
100
101        TclInterpreterBundle* newbundle = new TclInterpreterBundle();
102        newbundle->id_ = 0;
103        newbundle->interpreter_ = interpreter;
104        newbundle->lock_->lock();
105
106        {
107            boost::unique_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
108            this->interpreterBundles_[0] = newbundle;
109        }
110    }
111
112    /**
113        @brief Destructor
114    */
115    TclThreadManager::~TclThreadManager()
116    {
117        delete this->interpreterBundlesMutex_;
118//        delete this->mainInterpreterMutex_; // <-- temporary disabled to avoid crash if a thread is still actively queriyng
119        delete this->messageQueue_;
120    }
121
122    /**
123        @brief The "main loop" of the TclThreadManager. Creates new threads if needed and handles queries and queued commands for the main interpreter.
124    */
125    void TclThreadManager::preUpdate(const Clock& time)
126    {
127        // Get the bundle of the main interpreter (0)
128        TclInterpreterBundle* bundle = this->getInterpreterBundle(0);
129        if (bundle)
130        {
131            // Unlock the mutex to allow other threads accessing the main interpreter
132            bundle->lock_->unlock();
133
134            // Lock the main interpreter mutex once to synchronize with threads that want to query the main interpreter
135            {
136                boost::unique_lock<boost::mutex> lock(*this->mainInterpreterMutex_);
137            }
138
139            // Lock the mutex again to gain exclusive access to the interpreter for the rest of the mainloop
140            bundle->lock_->lock();
141
142            // Execute commands in the queues of the threaded interpreters
143            {
144                boost::shared_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
145                for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
146                {
147                    if (it->first == 0)
148                        continue; // We'll handle the default interpreter later (and without threads of course)
149
150                    TclInterpreterBundle* bundle = it->second;
151                    if (!bundle->queue_.empty())
152                    {
153                        // There are commands in the queue
154                        try
155                        {
156                            if (!bundle->lock_->owns_lock() && bundle->lock_->try_lock())
157                            {
158                                // We sucessfully obtained a lock for the interpreter
159                                std::string command;
160                                if (bundle->queue_.try_pop_front(&command))
161                                {
162                                    // Start a thread to execute the command
163                                    boost::thread(boost::bind(&tclThread, bundle, command));
164                                }
165                                else
166                                {
167                                    // Somehow the queue become empty (maybe multiple consumers) - unlock the mutex
168                                    bundle->lock_->unlock();
169                                }
170                            }
171                        }
172                        catch (...)
173                        {
174                            // A lock error occurred - this is possible if the lock gets locked between !bundle->lock_->owns_lock() and bundle->lock_->try_lock()
175                            // This isn't too bad, just continue
176                        }
177                    }
178                }
179            }
180
181            // Execute commands in the message queue
182            if (!this->messageQueue_->empty())
183            {
184                std::string command;
185                while (true)
186                {
187                    // Pop the front value from the list (break the loop if there are no elements in the list)
188                    if (!this->messageQueue_->try_pop_front(&command))
189                        break;
190
191                    // Execute the command
192                    CommandExecutor::execute(command, false);
193                }
194            }
195
196            // Execute commands in the queue of the main interpreter
197            if (!bundle->queue_.empty())
198            {
199                // Calculate the time we have until we reach the maximal cpu usage
200                unsigned long maxtime = (unsigned long)(time.getDeltaTime() * 1000000 * TCLTHREADMANAGER_MAX_CPU_USAGE);
201
202                Ogre::Timer timer;
203                std::string command;
204
205                while (timer.getMicroseconds() < maxtime)
206                {
207                    // Pop the front value from the list (break the loop if there are no elements in the list)
208                    if (!bundle->queue_.try_pop_front(&command))
209                        break;
210
211                    // Execute the command
212                    CommandExecutor::execute(command, false);
213                }
214            }
215        }
216    }
217
218    /**
219        @brief Creates a new Tcl-interpreter.
220    */
221    unsigned int TclThreadManager::create()
222    {
223        TclThreadManager::getInstance().numInterpreterBundles_++;
224        TclThreadManager::createWithId(TclThreadManager::getInstance().numInterpreterBundles_);
225        COUT(0) << "Created new Tcl-interpreter with ID " << TclThreadManager::getInstance().numInterpreterBundles_ << std::endl;
226        return TclThreadManager::getInstance().numInterpreterBundles_;
227    }
228
229    /**
230        @brief Creates a new Tcl-interpreter with a given id.
231
232        Use with caution - if the id collides with an already existing interpreter, this call will fail.
233        This will also be a problem, if the auto-numbered interpreters (by using create()) reach an id
234        which was previously used in this function. Use high numbers to be safe.
235    */
236    Tcl::interpreter* TclThreadManager::createWithId(unsigned int id)
237    {
238        TclInterpreterBundle* newbundle = new TclInterpreterBundle();
239        newbundle->id_ = id;
240        newbundle->interpreter_ = TclBind::createTclInterpreter();
241
242        TclThreadManager::initialize(newbundle);
243
244        {
245            // Add the new bundle to the map
246            boost::unique_lock<boost::shared_mutex> lock(*TclThreadManager::getInstance().interpreterBundlesMutex_);
247            TclThreadManager::getInstance().interpreterBundles_[id] = newbundle;
248        }
249
250        return newbundle->interpreter_;
251    }
252
253    void TclThreadManager::initialize(TclInterpreterBundle* bundle)
254    {
255        const std::string& id_string = getConvertedValue<unsigned int, std::string>(bundle->id_);
256
257        // Initialize the new interpreter
258        try
259        {
260            // Define the functions which are implemented in C++
261            bundle->interpreter_->def("::orxonox::execute",      TclThreadManager::tcl_execute,      Tcl::variadic());
262            bundle->interpreter_->def("::orxonox::crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
263            bundle->interpreter_->def("::orxonox::query",        TclThreadManager::tcl_query,        Tcl::variadic());
264            bundle->interpreter_->def("::orxonox::crossquery",   TclThreadManager::tcl_crossquery,   Tcl::variadic());
265            bundle->interpreter_->def("::orxonox::running",      TclThreadManager::tcl_running);
266
267            // Create threadspecific shortcuts for the functions above
268            bundle->interpreter_->def("execute",      TclThreadManager::tcl_execute,      Tcl::variadic());
269            bundle->interpreter_->def("crossexecute", TclThreadManager::tcl_crossexecute, Tcl::variadic());
270            bundle->interpreter_->eval("proc query      {args}    { ::orxonox::query " + id_string + " $args }");
271            bundle->interpreter_->eval("proc crossquery {id args} { ::orxonox::crossquery " + id_string + " $id $args }");
272            bundle->interpreter_->eval("proc running    {}        { return [::orxonox::running " + id_string + "] }");
273
274            // Define a variable containing the thread id
275            bundle->interpreter_->eval("set id " + id_string);
276
277            // Use our own exit function to avoid shutting down the whole program instead of just the interpreter
278            bundle->interpreter_->eval("rename exit ::tcl::exit");
279            bundle->interpreter_->eval("proc exit {} { execute TclThreadManager destroy " + id_string + " }");
280
281            // Redefine some native functions
282            bundle->interpreter_->eval("rename while ::tcl::while");
283            bundle->interpreter_->eval("rename ::orxonox::while while");
284            bundle->interpreter_->eval("rename for ::tcl::for");
285            bundle->interpreter_->eval("rename ::orxonox::for for");
286        }
287        catch (const Tcl::tcl_error& e)
288        {   bundle->interpreter_ = 0; COUT(1) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << std::endl;   }
289        catch (...)
290        {   bundle->interpreter_ = 0; COUT(1) << "Error while creating Tcl-interpreter (" << id_string << "): " << Exception::handleMessage() << std::endl;   }
291    }
292
293    /**
294        @brief Stops and destroys a given Tcl-interpreter
295    */
296    void TclThreadManager::destroy(unsigned int id)
297    {
298        // TODO
299        // Not yet implemented
300        TclInterpreterBundle* bundle = TclThreadManager::getInstance().getInterpreterBundle(id);
301        if (bundle)
302        {
303            bundle->bRunning_ = false;
304        }
305    }
306
307    /**
308        @brief Sends a command to the queue of a given Tcl-interpreter
309        @param id The id of the target interpreter
310        @param command The command to be sent
311    */
312    void TclThreadManager::execute(unsigned int target_id, const std::string& command)
313    {
314        TclThreadManager::getInstance()._execute(target_id, command);
315    }
316
317    /**
318        @brief This function can be called from Tcl to execute a console command.
319
320        Commands which shall be executed are put into a queue and processed as soon as the
321        main thread feels ready to do so. The queue may also be full which results in a temporary
322        suspension of the calling thread until the queue gets ready again.
323    */
324    void TclThreadManager::tcl_execute(const Tcl::object& args)
325    {
326        TclThreadManager::getInstance()._execute(0, stripEnclosingBraces(args.get()));
327    }
328
329    /**
330        @brief This function can be called from Tcl to send a command to the queue of any interpreter.
331        @param target_id The id of the target thread
332    */
333    void TclThreadManager::tcl_crossexecute(int target_id, const Tcl::object& args)
334    {
335        TclThreadManager::getInstance()._execute(static_cast<unsigned int>(target_id), stripEnclosingBraces(args.get()));
336    }
337
338    /**
339        @brief Sends a command to the queue of a given Tcl-interpreter
340        @param id The id of the target interpreter
341        @param command The command to be sent
342    */
343    void TclThreadManager::_execute(unsigned int target_id, const std::string& command)
344    {
345        TclInterpreterBundle* bundle = this->getInterpreterBundle(target_id);
346        if (bundle)
347            bundle->queue_.push_back(command);
348    }
349
350
351    /**
352        @brief Sends a query to a given Tcl-interpreter and waits for the result
353        @param id The id of the target interpreter
354        @param command The command to be sent
355        @return The result of the command
356    */
357    std::string TclThreadManager::query(unsigned int target_id, const std::string& command)
358    {
359        return TclThreadManager::getInstance()._query(0, target_id, command);
360    }
361
362    /**
363        @brief This function can be called from Tcl to send a query to the main thread.
364        @param source_id The id of the calling thread
365
366        A query waits for the result of the command. This means, the calling thread will be blocked until
367        the main thread answers the query. In return, the main thread sends the result of the console
368        command back to Tcl.
369    */
370    std::string TclThreadManager::tcl_query(int source_id, const Tcl::object& args)
371    {
372        return TclThreadManager::getInstance()._query(static_cast<unsigned int>(source_id), 0, stripEnclosingBraces(args.get()), true);
373    }
374
375    /**
376        @brief This function can be called from Tcl to send a query to another thread.
377        @param source_id The id of the calling thread
378        @param target_id The id of the target thread
379    */
380    std::string TclThreadManager::tcl_crossquery(int source_id, int target_id, const Tcl::object& args)
381    {
382        return TclThreadManager::getInstance()._query(static_cast<unsigned int>(source_id), static_cast<unsigned int>(target_id), stripEnclosingBraces(args.get()));
383    }
384
385    /**
386        @brief This function performs a query to any Tcl interpreter
387        @param source_id The id of the calling thread
388        @param target_id The id of the target thread
389        @param command The command to send as a query
390        @param bUseCommandExecutor Only used if the target_id is 0 (which references the main interpreter). In this case it means if the command should be passed to the CommandExecutor (true) or to the main Tcl interpreter (false). This is true when called by tcl_query and false when called by tcl_crossquery.
391    */
392    std::string TclThreadManager::_query(unsigned int source_id, unsigned int target_id, const std::string& command, bool bUseCommandExecutor)
393    {
394        TclInterpreterBundle* source_bundle = this->getInterpreterBundle(source_id);
395        TclInterpreterBundle* target_bundle = this->getInterpreterBundle(target_id);
396        std::string output;
397
398        if (source_bundle && target_bundle)
399        {
400            // At this point we assume the mutex of source_bundle to be locked (because it's executing this query right now an waits for the return value)
401            // We can safely use it's querier list (because there's no other place in the code using the list except this query - and the interpreter can't start more than one query)
402
403            if ((source_bundle->id_ == target_bundle->id_) || source_bundle->queriers_.is_in(target_bundle->id_))
404            {
405                // This query would lead to a deadlock - return with an error
406                TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + getConvertedValue<unsigned int, std::string>(source_bundle->id_) \
407                            + " -> " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
408                            + "), couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
409                            + " from other interpreter with ID " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) + '.');
410            }
411            else
412            {
413                boost::unique_lock<boost::mutex> lock(target_bundle->mutex_, boost::try_to_lock);
414                boost::unique_lock<boost::mutex> mainlock(*this->mainInterpreterMutex_, boost::defer_lock);
415
416                if (!lock.owns_lock() && source_bundle->id_ != 0)
417                {
418                    // We couldn't obtain the try_lock immediately and we're not the main interpreter - wait until the lock becomes possible (note: the main interpreter won't wait and instead returns an error - see below)
419                    if (target_bundle->id_ == 0)
420                    {
421                        // We're querying the main interpreter - use the main interpreter mutex to synchronize
422                        mainlock.lock();
423                        lock.lock();
424                    }
425                    else
426                    {
427                        // We're querying a threaded interpreter - no synchronization needed
428                        lock.lock();
429                    }
430                }
431
432                if (lock.owns_lock())
433                {
434                    // Now the mutex of target_bundle is also locked an we can update the querier list
435                    target_bundle->queriers_.insert(target_bundle->queriers_.getList().begin(), source_bundle->queriers_.getList().begin(), source_bundle->queriers_.getList().end());
436                    target_bundle->queriers_.push_back(source_bundle->id_);
437
438                    // Perform the query (note: this happens in the main thread because we need the returnvalue)
439                    if (target_bundle->id_ == 0 && bUseCommandExecutor)
440                    {
441                        // It's a query to the CommandExecutor
442                        TclThreadManager::debug("TclThread_query -> CE: " + command);
443                        if (!CommandExecutor::execute(command, false))
444                            TclThreadManager::error("Error: Can't execute command \"" + command + "\"!");
445
446                        if (CommandExecutor::getLastEvaluation().hasReturnvalue())
447                            output = CommandExecutor::getLastEvaluation().getReturnvalue().getString();
448                    }
449                    else
450                    {
451                        // It's a query to a Tcl interpreter
452                        TclThreadManager::debug("TclThread_query: " + command);
453
454                        output = TclThreadManager::eval(target_bundle, command, "query");
455                    }
456
457                    // Clear the queriers list of the target
458                    target_bundle->queriers_.clear();
459
460                    // Unlock the mutex of the target_bundle
461                    lock.unlock();
462
463                    // Finally unlock the main interpreter lock if necessary
464                    if (mainlock.owns_lock())
465                        mainlock.unlock();
466                }
467                else
468                {
469                    // This happens if the main thread tries to query a busy interpreter
470                    // To avoid a lock of the main thread, we simply don't proceed with the query in this case
471                    TclThreadManager::error("Error: Couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) + ", interpreter is busy right now.");
472                }
473            }
474
475        }
476
477        return output;
478    }
479
480    /**
481        @brief Creates a non-interactive Tcl-interpreter which executes a file.
482    */
483    void TclThreadManager::source(const std::string& file)
484    {
485        boost::thread(boost::bind(&sourceThread, file));
486    }
487
488    /**
489        @brief This function can be called from Tcl to ask if the thread is still suposed to be running.
490        @param id The id of the thread in question
491    */
492    bool TclThreadManager::tcl_running(int id)
493    {
494        TclInterpreterBundle* bundle = TclThreadManager::getInstance().getInterpreterBundle(static_cast<unsigned int>(id));
495        if (bundle)
496            return bundle->bRunning_;
497        else
498            return false;
499    }
500
501    /**
502        @brief Returns the interpreter bundle with the given id.
503        @param id The id of the interpreter
504        @return The interpreter or 0 if the id doesn't exist
505    */
506    TclInterpreterBundle* TclThreadManager::getInterpreterBundle(unsigned int id)
507    {
508        boost::shared_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
509
510        std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.find(id);
511        if (it != this->interpreterBundles_.end())
512        {
513            return it->second;
514        }
515        else
516        {
517            TclThreadManager::error("Error: No Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(id) + " existing.");
518            return 0;
519        }
520    }
521
522    /**
523        @brief Returns a string containing all elements of a unsigned-integer-list separated by spaces.
524    */
525    std::string TclThreadManager::dumpList(const std::list<unsigned int>& list)
526    {
527        std::string output;
528        for (std::list<unsigned int>::const_iterator it = list.begin(); it != list.end(); ++it)
529        {
530            if (it != list.begin())
531                output += ' ';
532
533            output += getConvertedValue<unsigned int, std::string>(*it);
534        }
535        return output;
536    }
537
538    /**
539        @brief Returns a list with the numbers of all existing Tcl-interpreters.
540
541        This function is used by the auto completion function.
542    */
543    std::list<unsigned int> TclThreadManager::getThreadList() const
544    {
545        boost::shared_lock<boost::shared_mutex> lock(*this->interpreterBundlesMutex_);
546
547        std::list<unsigned int> threads;
548        for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
549            if (it->first > 0 && it->first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
550                threads.push_back(it->first);
551        return threads;
552    }
553
554    /**
555        @brief A helper function to print errors in a thread safe manner.
556    */
557    void TclThreadManager::error(const std::string& error)
558    {
559        TclThreadManager::getInstance().messageQueue_->push_back("error " + error);
560    }
561
562    /**
563        @brief A helper function to print debug information in a thread safe manner.
564    */
565    void TclThreadManager::debug(const std::string& error)
566    {
567        TclThreadManager::getInstance().messageQueue_->push_back("debug " + error);
568    }
569
570    /**
571        @brief Evaluates a Tcl command without throwing exceptions (which may rise problems on certain machines).
572        @return The Tcl return value
573
574        Errors are reported through the @ref error function.
575    */
576    std::string TclThreadManager::eval(TclInterpreterBundle* bundle, const std::string& command, const std::string& action)
577    {
578        Tcl_Interp* interpreter = bundle->interpreter_->get();
579        int cc = Tcl_Eval(interpreter, command.c_str());
580
581        Tcl::details::result result(interpreter);
582
583        if (cc != TCL_OK)
584        {
585            TclThreadManager::error("Tcl error (" + action + ", ID " + getConvertedValue<unsigned int, std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
586            return "";
587        }
588        else
589        {
590            return result;
591        }
592    }
593
594    ////////////////
595    // The Thread //
596    ////////////////
597
598    /**
599        @brief The main function of the thread. Executes a Tcl command.
600        @param bundle The interpreter bundle containing all necessary variables
601        @param command the Command to execute
602    */
603    void tclThread(TclInterpreterBundle* bundle, const std::string& command)
604    {
605        TclThreadManager::debug("TclThread_execute: " + command);
606
607        TclThreadManager::eval(bundle, command, "execute");
608
609        bundle->lock_->unlock();
610    }
611
612    /**
613        @brief The main function of a non-interactive source thread. Executes the file.
614        @param file The name of the file that should be executed by the non-interactive interpreter.
615    */
616    void sourceThread(const std::string& file)
617    {
618        TclThreadManager::debug("TclThread_source: " + file);
619
620        // Prepare the command-line arguments
621        const int argc = 2;
622        char* argv[argc];
623        argv[0] = "tclthread";
624        argv[1] = const_cast<char*>(file.c_str());
625
626        // Start the Tcl-command Tcl_Main with the Tcl_OrxonoxAppInit hook
627        Tcl_Main(argc, argv, Tcl_OrxonoxAppInit);
628
629//        Tcl::object object(file);
630//        int cc = Tcl_FSEvalFile(bundle->interpreter_->get(), object.get_object());
631//        Tcl::details::result result(bundle->interpreter_->get());
632//        if (cc != TCL_OK)
633//            TclThreadManager::error("Tcl error (source, ID " + getConvertedValue<unsigned int, std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
634//
635//        // Unlock the mutex
636//        bundle->lock_->unlock();
637    }
638
639    /**
640        @brief A tcl-init hook to inject the non-interactive Tcl-interpreter into the TclThreadManager.
641    */
642    int Tcl_OrxonoxAppInit(Tcl_Interp* interp)
643    {
644        // Create a new interpreter bundle
645        unsigned int id = TclThreadManager::create();
646        TclInterpreterBundle* bundle = TclThreadManager::getInstance().getInterpreterBundle(id);
647
648        // Replace the default interpreter in the bundle with the non-interactive one (passed as an argument to this function)
649        if (bundle->interpreter_)
650            delete bundle->interpreter_;
651        bundle->interpreter_ = new Tcl::interpreter(interp, true);
652
653        // Initialize the non-interactive interpreter (like in @ref TclBind::createTclInterpreter but exception safe)
654        const std::string& libpath = TclBind::getTclLibraryPath();
655        if (!libpath.empty())
656            TclThreadManager::eval(bundle, "set tcl_library \"" + libpath + '"', "source");
657        int cc = Tcl_Init(interp);
658        TclThreadManager::eval(bundle, "source \"" + TclBind::getInstance().getTclDataPath() + "/init.tcl\"", "source");
659
660        // Initialize the non-interactive interpreter also with the thread-specific stuff
661        TclThreadManager::initialize(bundle);
662
663        // Lock the mutex (this will be locked until the thread finishes - no chance to interact with the interpreter)
664        bundle->lock_->lock();
665
666        // Return to Tcl_Main
667        if (!bundle->interpreter_)
668            return TCL_ERROR;
669        else
670            return cc;
671    }
672}
Note: See TracBrowser for help on using the repository browser.