• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMSqVM.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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; either version 2
// of the License, or (at your option) any later version.
// 
// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMSqVM.h"

#include "../include/PCMScriptRegistration.h"

//
// Outer includes
//

#include <stdarg.h>

namespace ParCompMark
{

  //
  // Class constants
  //

  const std::string SqVM::NOMAINMETHOD = "null";
  const u32 SqVM::mStringBufferSize = 32768;

  //
  // Class variables
  //

   SqVM::Pointer SqVM::mCurrentVM;
  Mutex SqVM::mCurrentVMLock;
   SqVM::ScriptOutput SqVM::mScriptOutput = SqVM::LOG;
  char SqVM::mStringBuffer[32768] = "";

  //
  // Constructors & destructor
  //

   SqVM::SqVM(const std::string & name):
        // Parent initializer 
   Name(name                    /* Name of the virtual machine */
  ),
        // Smart pointer initializer 
   mThis(this           /* This pointer */
         , false                /* Do not take ownership of itself */
        )
        // You have to initialize the following attributes:
        // - mThis
        // - mSquirrelVMSys
        // - mCurrentVM
        // - mCurrentVMLock
        // - mError
        // - mInitialized
        // - mScripts
        // - mScriptOutput
        // - mStringBuffer[32768]
  {
        // mThis, mCurrentVM is autoinitialized

        mSquirrelVMSys = 0;

        mScripts = new Container < SqVM::Script, Mutex >;

        mError = false;
        mInitialized = false;

        Logger::getInstance()->log(Logger::NOTICE, "Squirrel virtual machine `" + mName + "\' has been created.");
  }

 /*----------------------------------------------------------------------*/

  SqVM::~SqVM()
  {
        if(mInitialized)
         finalize();

        Logger::getInstance()->log(Logger::NOTICE, "Squirrel virtual machine `" + mName + "\' has been destroyed.");
  }

 /*----------------------------------------------------------------------*/

  //
  // Class methods
  //

  void SqVM::printFunction(::HSQUIRRELVM sqVM, const SQChar * s, ...)
  {
        va_list arglist;

        va_start(arglist, s);
#ifdef SQUNICODE
        vwsprintf(mStringBuffer, s, arglist);
#else
        vsprintf(mStringBuffer, s, arglist);
#endif
        va_end(arglist);

        if(mCurrentVM->mError || strcasestr(mStringBuffer, " error "))
        {
         switch (mScriptOutput)
         {
                case SqVM::LOG:
                 Logger::getInstance()->logMultiLine(Logger::ERROR,
                                                        "Squirrel error on VM(" + mCurrentVM->getName() + ") : " +
                                                        mStringBuffer);
                 break;
                case SqVM::STD:
                 std::cerr << mStringBuffer;
                 break;
         }

         // Error string in output causes error state
         mCurrentVM->mError = true;
        } else
         switch (mScriptOutput)
         {
                case SqVM::LOG:
                 Logger::getInstance()->logMultiLine(Logger::NOTICE,
                                                        "Squirrel message on VM(" + mCurrentVM->getName() + ") : " +
                                                        mStringBuffer);
                 break;
                case SqVM::STD:
                 std::cout << mStringBuffer;
                 break;
         }
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  std::string SqVM::runScriptFromFile(const std::string & filename, const std::string & mainMethod,
                                        const std::list < std::string > &parameters, const bool & hasReturn)
  {
        activate();

        // Find or add script
        SqVM::Script::Pointer script = findOrAddScript(filename, false, mainMethod, hasReturn);

        // Copy parameters
        setParameters(script, parameters);

        // Compile the script (if needed) and then execute it
        compileAndExecuteScript(script);

        // Copy return value
        std::string returnValue = script->returnValue;

        // Unlock the script
        script.unlock();

        deactivate();

        return returnValue;
  }

 /*----------------------------------------------------------------------*/

  std::string SqVM::runScriptFromString(const std::string & scriptString, const std::string & scriptName,
                                        const std::string & mainMethod,
                                        const std::list < std::string > &parameters,
                                        const bool & hasReturn)
  {
        SqVM::Script::Pointer script;

        try
        {
         activate();

         // The script has a name
         if(scriptName.size())
                script = findOrAddScript(scriptName, true, mainMethod, hasReturn);

         // The script is unnamed
         else
                script = createScript("", true, mainMethod, hasReturn);

         // Set script string
         script->scriptString = scriptString;

         // Copy parameters
         setParameters(script, parameters);

         // Compile the script (if needed) and then execute it
         compileAndExecuteScript(script);

         // Copy return value
         std::string returnValue = script->returnValue;

         // Unlock the script
         script.unlock();

         deactivate();

         return returnValue;
        }
        catch(const Exception & e)
        {
         // Unlock the script and deactivate the VM
         if(script.getLocked())
                script.unlock();

         deactivate();

         // Throw forward
         throw Exception(e);
        }

        return "";
  }

 /*----------------------------------------------------------------------*/

  std::string SqVM::runScriptByName(const std::string & scriptName,
                                  const std::list < std::string > &parameters)
  {
        activate();

        SqVM::Script::Pointer script = findScript(scriptName);

        // Compile the script (if needed) and then execute it
        compileAndExecuteScript(script);

        // Copy return value
        std::string returnValue = script->returnValue;

        // Unlock the script
        script.unlock();

        deactivate();

        return returnValue;
  }

 /*----------------------------------------------------------------------*/

  void SqVM::finalize()
  {

        Assert(mInitialized, INVALID_OPERATION_ERROR, "SqVM::finalize()");

        activate();

        // Shut down VM
        SquirrelVM::Shutdown();
        delete mSquirrelVMSys;

        mSquirrelVMSys = 0;

        deactivate();

        mInitialized = false;

        Logger::getInstance()->log(Logger::DEBUG, "Squirrel virtual machine `" + mName + "\' has been finalized.");
  }

 /*----------------------------------------------------------------------*/

  void SqVM::activate()
  {
        // Lock static attribute and assign current VM
        mCurrentVMLock.lock();
        mCurrentVM = mThis;
        //mCurrentVM.assignWithLock(mThis);

        // Initialize VM if needed
        // (providing that the current VM is activated)
        if(!mInitialized)
         initialize();

        // Activate VM
        if(mSquirrelVMSys)
         SquirrelVM::SetVMSys(*mSquirrelVMSys);
  }

 /*----------------------------------------------------------------------*/

  void SqVM::deactivate()
  {
        // Unlock static attribute
        //mCurrentVM.unlock();

        // Set Null pointer as current VM
        mCurrentVM = 0;

        mCurrentVMLock.unlock();
  }

 /*----------------------------------------------------------------------*/

  void SqVM::initialize()
  {
        Assert(!mInitialized, INVALID_OPERATION_ERROR, "SqVM::initialize()");
        // Assume that the current VM is activated

        // Create virtual machine
        SquirrelVM::Init();
        mSquirrelVMSys = new SquirrelVMSys();
        SquirrelVM::GetVMSys(*mSquirrelVMSys);

        // The handlers use the print function set through(sq_setprintfunc)
        // to output the error.
        sq_setprintfunc(mSquirrelVMSys->_VM, SqVM::printFunction);

        mInitialized = true;

        // Call autogenerated Squirrel class bindings method
        squirrelClassBindings();

        Logger::getInstance()->log(Logger::DEBUG, "Squirrel virtual machine `" + mName + "\' has been initialized.");
  }

 /*----------------------------------------------------------------------*/

  SqVM::Script::Pointer SqVM::createScript(const std::string & scriptName, const bool & dynamic,
                                          const std::string & mainMethod, const bool & hasReturn)
  {
        SqVM::Script::Pointer script(new SqVM::Script());
        script->compiled = false;
        script->name = scriptName;
        script->dynamic = dynamic;
        script->mainMethod = mainMethod;
        script->scriptString = "";
        script->hasReturn = hasReturn;
        script.lock();

        return script;
  }

 /*----------------------------------------------------------------------*/

  SqVM::Script::Pointer SqVM::findScript(const std::string & scriptName)
  {
        SqVM::Script::Pointer script;

        // Add script if does not exists
        mScripts.lock();

        if(!mScripts->has(scriptName))
        {
         mScripts.unlock();
         deactivate();
         Except(INVALID_NAME_ERROR, "SqVM::findScript()", "The script `" + scriptName + "\' is not found.");
        }

        script = mScripts->get(scriptName);
        script.lock();
        mScripts.unlock();

        return script;
  }

 /*----------------------------------------------------------------------*/

  SqVM::Script::Pointer SqVM::findOrAddScript(const std::string & scriptName, const bool & dynamic,
                                                const std::string & mainMethod, const bool & hasReturn)
  {
        SqVM::Script::Pointer script;

        // Add script if does not exists
        mScripts.lock();
        if(mScripts->has(scriptName))
        {
         // The script is already exists
         // (lock, because we will need it)
         script = mScripts->get(scriptName);
         script.lock();

         // Test main method and dynamic flag
         if(script->mainMethod != mainMethod)
         {
                script.unlock();
                mScripts.unlock();
                deactivate();
                Except(INVALID_NAME_ERROR, "SqVM::findOrAddScript()",
                   "The script `" + scriptName + "\' is already exists but with another entry point.");
         }

         else if(script->dynamic != dynamic)
         {
                script.unlock();
                mScripts.unlock();
                deactivate();
                Except(INVALID_VALUE_ERROR, "SqVM::findOrAddScript()",
                   "The script `" + scriptName + "\' is already exists but with different dynamic flag.");
         }

         else if(script->hasReturn != hasReturn)
         {
                script.unlock();
                mScripts.unlock();
                deactivate();
                Except(INVALID_VALUE_ERROR, "SqVM::findOrAddScript()",
                   "The script `" + scriptName + "\' is already exists but with different return flag.");
         }

        } else
        {
         // New script (lock, because we will need it)
         script = createScript(scriptName, dynamic, mainMethod, hasReturn);

         mScripts->add(scriptName, script);
        }

        mScripts.unlock();

        return script;
  }

 /*----------------------------------------------------------------------*/

  void SqVM::compileAndExecuteScript(SqVM::Script::Pointer & script)
  {
        // Setup script state for error checking
        ScriptState scriptState = UNCOMPILED;

        // Readable script name
        std::string scriptName = script->name.size()? script->name : "(unnamed)";
        scriptName = script->dynamic ? "(dynamic) script `" + scriptName + "\'" : "script `" + scriptName + "\'";

        try
        {

         // Compile the script if needed
         if(!script->compiled)
         {
                // Compile the Squirrel script from source
                if(script->dynamic)
                 script->scriptObject = SquirrelVM::CompileBuffer(_SC(script->scriptString.c_str()));
                else
                 script->scriptObject = SquirrelVM::CompileScript(_SC(script->name.c_str()));

                // Run the script (this creates functions etc.)
                SquirrelVM::RunScript(script->scriptObject);
                script->compiled = true;
                Logger::getInstance()->log(Logger::NOTICE, "Squirrel script `" + script->name + "\' compiled.");
         }

         scriptState = COMPILED;

         // Execute the script (call entry method if given)
         if(script->mainMethod != SqVM::NOMAINMETHOD)
         {
                switch (script->hasReturn)
                {
                 case true:
                        switch (script->parameterCount)
                        {
                         case 0:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))();
                                break;
                         case 1:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))(script->parameters[0]);
                                break;
                         case 2:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))(script->parameters[0],
                                                                                         script->parameters[1]);
                                break;
                         case 3:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))(script->parameters[0],
                                                                                         script->parameters[1],
                                                                                         script->parameters[2]);
                                break;
                         case 4:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))(script->parameters[0],
                                                                                         script->parameters[1],
                                                                                         script->parameters[2],
                                                                                         script->parameters[3]);
                                break;
                         case 5:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))(script->parameters[0],
                                                                                         script->parameters[1],
                                                                                         script->parameters[2],
                                                                                         script->parameters[3],
                                                                                         script->parameters[4]);
                                break;
                         case 6:
                                script->returnValue =::SqPlus::SquirrelFunction <
                                 const SQChar * >(_T(script->mainMethod.c_str()))(script->parameters[0],
                                                                                         script->parameters[1],
                                                                                         script->parameters[2],
                                                                                         script->parameters[3],
                                                                                         script->parameters[4],
                                                                                         script->parameters[5]);
                                break;
                         default:
                                Except(SCRIPT_ERROR, "SqVM::compileAndExecuteScript",
                                   "Too many parameters passed to `" + script->mainMethod + "\' in script `" +
                                   scriptName + "\'");
                        }
                        break;
                 case false:
                        switch (script->parameterCount)
                        {
                         case 0:
                                ::SqPlus::SquirrelFunction < void >(_T(script->mainMethod.c_str())) ();

                                break;
                         case 1:
                                ::SqPlus::SquirrelFunction <
                                 void >(_T(script->mainMethod.c_str())) (script->parameters[0]);
                                break;
                         case 2:
                                ::SqPlus::SquirrelFunction <
                                 void >(_T(script->mainMethod.c_str())) (script->parameters[0],
                                                                         script->parameters[1]);
                                break;
                         case 3:
                                ::SqPlus::SquirrelFunction <
                                 void >(_T(script->mainMethod.c_str())) (script->parameters[0],
                                                                         script->parameters[1],
                                                                         script->parameters[2]);
                                break;
                         case 4:
                                ::SqPlus::SquirrelFunction <
                                 void >(_T(script->mainMethod.c_str())) (script->parameters[0],
                                                                         script->parameters[1],
                                                                         script->parameters[2],
                                                                         script->parameters[3]);
                                break;
                         case 5:
                                ::SqPlus::SquirrelFunction <
                                 void >(_T(script->mainMethod.c_str())) (script->parameters[0],
                                                                         script->parameters[1],
                                                                         script->parameters[2],
                                                                         script->parameters[3],
                                                                         script->parameters[4]);
                                break;
                         case 6:
                                ::SqPlus::SquirrelFunction <
                                 void >(_T(script->mainMethod.c_str())) (script->parameters[0],
                                                                         script->parameters[1],
                                                                         script->parameters[2],
                                                                         script->parameters[3],
                                                                         script->parameters[4],
                                                                         script->parameters[5]);
                                break;
                         default:
                                Except(SCRIPT_ERROR, "SqVM::compileAndExecuteScript",
                                   "Too many parameters passed to `" + script->mainMethod + "\' in script `" +
                                   scriptName + "\'");
                        }
                }
         }

         scriptState = EXECUTED;

        }
        catch(SquirrelError & e)
        {
         // Turn on error flag
         mError = true;

         // Unlock the script
         script.unlock();

         deactivate();

         // Report error to logfile
         switch (scriptState)
         {
                case UNCOMPILED:
                 if(script->dynamic)
                        Logger::getInstance()->log(Logger::ERROR,
                                                 "Squirrel " + scriptName +
                                                 " cannot be compiled, since it has errors.");
                 else
                        Logger::getInstance()->log(Logger::ERROR,
                                                 "Squirrel " + scriptName +
                                                 " cannot be loaded or compiled, since it has errors or the file does not exist.");
                 break;
                case COMPILED:
                 Logger::getInstance()->log(Logger::ERROR,
                                           "An error occured after executing method `" + script->mainMethod +
                                           "\' of " + scriptName);
                 break;
                case EXECUTED:
                 Logger::getInstance()->log(Logger::FATAL,
                                           "Some internal error occured after the execution of " + scriptName +
                                           ". It should not be happened.");
                 break;
         }

         // Log dynamic source
         if(script->dynamic)
         {
                Logger::getInstance()->logMultiLine(Logger::ERROR,
                                                 "Here is the source of the dynamic script for debugging:\n ===[ code starts ] =========== \n"
                                                 + script->scriptString + "\n ===[ code ends ] ============= ");
         }

         Except(SCRIPT_ERROR, "SqVM::compileAndExecuteScript", "Squirrel error: `" + std::string(e.desc) + "\'");
        }
  }

 /*----------------------------------------------------------------------*/

  void SqVM::setParameters(SqVM::Script::Pointer & script, const std::list < std::string > &parameters)
  {
        u32 _i = 0;

        for(std::list < std::string >::const_iterator i = parameters.begin(); i != parameters.end(); i++, _i++)
         script->parameters[_i] = (*i).c_str();

        script->parameterCount = _i;
  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team