root/simulator/trunk/src/simulator/task.cpp

//    OSRail -- a network enabled railroad operations simulator and utilities
//    Copyright (C) 2007,2008 Samuel E. Henley sehenley@comcast.net
//
//    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.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
/// \file
/// Implementation file for Task manager of the simulator and the ITask factory.

// Pre-Compiled Header for Simulator
#include "presimulator.h"

#include "task.h"


/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup simulatorcomponent "Simulator Components"
    /// @{
        /// \addtogroup task "Task"
        /// @{


extern ITask* createTask( ISystem& sys )
{
    return new Task( sys );
}

Task::Task( ISystem& sys ) : system( sys ), engine(0)
{
}

Task::~Task()
{
}



//vertual
void Task::startup()
{
    MESSAGE( "Simulator", "Task", "Startup" )
    error.resize( 1024 ); //Common error buffer
    configureScriptEngine();
}

//virtual
void Task::operator()()
{
    if( compiles.empty() )
    {
        if( !scripts.empty() )
        {
            int id = scripts.top().context->GetCurrentFunction();
            const_cast<Script&>(scripts.top()).timeout = scripts.top().max + system.getFrameMilliseconds();
            scripts.top().context->SetLineCallback( asFUNCTION(taskLineCallback), this, asCALL_CDECL );
            scripts.top().context->SetExceptionCallback( asFUNCTION(taskExceptionCallback), this, asCALL_CDECL );

            int result = scripts.top().context->Execute();
            if( result < 0 )
            {
                asIScriptFunction* fd = engine->GetFunctionDescriptorById( id );
                sprintf( &error[0], "Could not execute function %s", fd->GetName() );
                ASSERT( false, "Simulator", "Task", &error[0] )
                scripts.top().context->Release();
                scripts.pop();
            }
            else
            {
                switch( result )
                {
                case asEXECUTION_SUSPENDED :
                    break;

                case asEXECUTION_ABORTED :
                case asEXECUTION_EXCEPTION :
                case asEXECUTION_FINISHED :
                    scripts.top().context->Release();
                    scripts.pop();
                    break;

                default:
                    {
                        asIScriptFunction* fd = engine->GetFunctionDescriptorById( id );
                        sprintf( &error[0], "Program logic error, result from AngelScript Execute unrecognized module %s", fd->GetModuleName() );
                        ASSERT( false, "ScriptManager", "Task", &error[0] )
                    }
                    break;
                }
            }
        }
    }
    else
    {
        const Compile& it = compiles.top();
        asIScriptModule* module = engine->GetModule( it.module.c_str(), asGM_ALWAYS_CREATE );
        module->AddScriptSection( "script", it.script.c_str(), it.script.length(), 0 );
        if( module->Build() < 0 )
        {
            sprintf( &error[0], "Did not create script context for script module %s", it.module.c_str());
            ASSERT( false, "Simulator", "Task", &error[0] )
        }
        else
        {
            size_t size = module->GetFunctionCount();
            for( size_t i=0; i<size; i++ )
            {
                asIScriptContext* context = engine->CreateContext();
                if( !context )
                {
                    sprintf( &error[0], "Could not create context for script module %s", it.module.c_str());
                    ASSERT( false, "ScriptManager", "Task", &error[0] )
                }

                int id = module->GetFunctionIdByIndex( i );
                if( context->Prepare( id ) < 0 )
                {
                    sprintf( &error[0], "Could not Prepare context for script module %s", it.module.c_str());
                    ASSERT( false, "ScriptManager", "Task", &error[0] )
                    context->Release();
                }
                else
                {
                    Script ss;
                    ss.context = context;
                    ss.priority = it.priority;
                    ss.context->SetUserData( reinterpret_cast<void*>(this) );
                    ss.max = it.max;
                    ss.timeout = 0;
                    scripts.push( ss );
                }
            }
        }

        compiles.pop();
    }
}

//virtual
void Task::shutdown()
{
    while( !scripts.empty() )
    {
        scripts.top().context->Release();
        scripts.pop();
    }
    if( engine )engine->Release();
    engine = 0;
    MESSAGE( "Simulator", "Task", "Cleanup scripts" )
    MESSAGE( "Simulator", "Task", "Shutdown" )
}

//virtual
bool Task::addScript( const char* module, const char* script, const clock_t max /*= 10*/, const int priority /*= 0*/ )
{
    ASSERT( engine != 0, "ScriptManager", "Task", "addScript called with no script engine" )
    Compile cc;
    cc.module = module;
    cc.script = script;
    cc.max = max;
    compiles.push( cc );

    return true;
}

//static
void Task::taskMessageCallback( const asSMessageInfo* msg, void* param )
{
    /// \todo Move script error to Console, or logger.
    String type;
    switch( msg->type )
    {
    case asMSGTYPE_ERROR :         type = _(" error="); break;
    case asMSGTYPE_WARNING :       type = _(" warning="); break;
    case asMSGTYPE_INFORMATION :   type = _(" information=");break;
    default : type = _("?");
        ASSERT( false, "Simulator", "Task", "Program error AngelScript message type" ) // How did we get here?
    }

    std::vector<char> error;
    error.resize( 1024 );
    sprintf( &error[0], "%s row=%d col=%d %s %s",
             msg->section,
             msg->row,
             msg->col,
             type.c_str(),
             msg->message );

    MESSAGE( "Simulator", "Task", &error[0] )
}

void Task::taskTimeout( asIScriptContext* context )
{
    if( scripts.top().timeout < system.getFrameMilliseconds() )
    {
        context->Suspend();
    }
}

void Task::taskException( asIScriptContext* context )
{
    context->Suspend();
    int id = context->GetCurrentFunction();
    asIScriptFunction* fd = engine->GetFunctionDescriptorById( id );
    sprintf( &error[0], "Exception in function %s", fd->GetName() );
    ASSERT( false, "Simulator", "Task", &error[0] )
    scripts.top().context->Release();
    scripts.pop();
}

//static
void Task::taskLineCallback( asIScriptContext* context, asDWORD* task )
{
    ASSERT( task, "Simulator", "Task", "Programing error callback Task::taskLineCallback has no object pointer" )
    (reinterpret_cast<Task*>(task))->taskTimeout( context );
}

//static
void Task::taskExceptionCallback( asIScriptContext* context, asDWORD* task )
{
    ASSERT( task, "Simulator", "Task", "Script error callback Task::taskExceptionCallback called" )
    (reinterpret_cast<Task*>(task))->taskException( context );
}

/// \note Script interfaces to simulator
IAi*               g_ai = 0;
IConsoleClient*    g_console = 0;
IFactory*          g_factory = 0;
IGraphics*         g_graphics = 0;
IGui*              g_gui = 0;
IInput*            g_input = 0;
INetwork*          g_network = 0;
IPropertyManager*  g_propertymanager = 0;
ISimulation*       g_simulation = 0;
ISound*            g_sound = 0;
ISystem*           g_system = 0;
ITask*             g_task = 0;
ITest*             g_test = 0;


/// Wrapper for ITask::addScript
bool ITask_addScript_Wrapper( CScriptString& name, CScriptString& script, const int max, const int priority, ITask* task )
{
    return task->addScript( name.buffer.c_str(), script.buffer.c_str(), max, priority );
}

//private
void Task::configureScriptEngine()
{
    // initialize system interfaces, must initialize ITask last in ISystem startup.
    g_ai = system.getAiInterface();
    g_console = system.getConsoleClientInterface();
    g_factory = system.getFactoryInterface();
    g_graphics = system.getGraphicsInterface();
    g_gui = system.getGuiInterface();
    g_input = system.getInputInterface();
    g_network = system.getNetworkInterface();
    g_propertymanager = system.getPropertyManagerInterface();
    g_simulation = system.getSimulationInterface();
    g_sound = system.getSoundInterface();
    g_system = system.getSystemInterface();
    g_task = system.getTaskInterface();
    g_test = system.getTestInterface();

    ASSERT( engine == 0, "Simulator", "Task", "Program error AngelScript engine already created" )
    engine = asCreateScriptEngine( ANGELSCRIPT_VERSION );
    ASSERT( engine, "Simulator", "Task", "Could not create AngelScript engine" )
    engine->SetMessageCallback( asFUNCTION(taskMessageCallback), 0, asCALL_CDECL );
    MESSAGE( "Simulator", "Task", "Initialized scripts" )

    RegisterScriptString( engine );

    // ISystem
    VERIFY(( engine->RegisterObjectType("ISystem", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register ISystem interface" )
    VERIFY(( engine->RegisterObjectMethod( "ISystem", "bool running()", asMETHOD( ISystem, running ), asCALL_THISCALL ) >= 0 ),
            "Simulator", "Task", "Could not register ISystem::running interface" )
    VERIFY(( engine->RegisterGlobalProperty( "ISystem system",  &g_system ) >= 0 ),  "Simulator", "Task", "Unable add properity system to AngelScript Engine" )

    VERIFY(( engine->RegisterObjectType("IGraphics", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register IGraphics interface" )
    VERIFY(( engine->RegisterObjectMethod( "IGraphics", "bool isClosed()", asMETHOD( IGraphics, isClosed ), asCALL_THISCALL ) >= 0 ),
            "Simulator", "Task", "Could not register IGraphics::isClosed interface" )
    VERIFY(( engine->RegisterObjectMethod( "IGraphics", "bool isVisible()", asMETHOD( IGraphics, isVisible ), asCALL_THISCALL ) >= 0 ),
            "Simulator", "Task", "Could not register IGraphics::isVisible interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IGraphics graphics",  &g_graphics ) >= 0 ), "Simulator", "Task", "Unable add properity graphics to AngelScript Engine" )

    // ITask
    VERIFY(( engine->RegisterObjectType( "ITask", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register ITask interface" )
    VERIFY(( engine->RegisterObjectMethod( "ITask", "bool addScript( const string &in name, const string &in script, const int &in max, const int &in priority )",
            asFUNCTION( ITask_addScript_Wrapper ), asCALL_CDECL_OBJLAST ) >= 0 ),
            "Simulator", "Task", "Could not register ITask::addScript (ITask_addScript_Wrapper) interface" )
    VERIFY(( engine->RegisterGlobalProperty( "ITask task",  &g_task ) >= 0 ), "Simulator", "Task", "Unable add properity task to AngelScript Engine" )

    // ISound
    VERIFY(( engine->RegisterObjectType("ISound", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register ISound interface" )
    VERIFY(( engine->RegisterGlobalProperty( "ISound sound",  &g_sound ) >= 0 ), "Simulator", "Task", "Unable add properity sound to AngelScript Engine" )

    // IAi
    VERIFY(( engine->RegisterObjectType("IAi", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register IAi interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IAi ai",  &g_ai ) >= 0 ), "Simulator", "Task", "Unable add properity ai to AngelScript Engine" )

    // IInput
    VERIFY(( engine->RegisterObjectType("IInput", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register IInput interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IInput input",  &g_input ) >= 0 ), "Simulator", "Task", "Unable add properity input to AngelScript Engine" )

    // IGui
    VERIFY(( engine->RegisterObjectType("IGui", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register IGui interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IGui gui",  &g_gui ) >= 0 ), "Simulator", "Task", "Unable add properity gui to AngelScript Engine" )

    // INetwork
    VERIFY(( engine->RegisterObjectType("INetwork", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register INetwork interface" )
    VERIFY(( engine->RegisterGlobalProperty( "INetwork network",  &g_network ) >= 0 ), "Simulator", "Task", "Unable add properity network to AngelScript Engine" )

    // IConsoleClient
    VERIFY(( engine->RegisterObjectType("IConsoleClient", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ),
            "Simulator", "Task", "Could not register IConsoleClient interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IConsoleClient consoleclient",  &g_console ) >= 0 ), "Simulator", "Task", "Unable add properity consoleclient to AngelScript Engine" )

    // IFactory
    VERIFY(( engine->RegisterObjectType("IFactory", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register IFactory interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IFactory factory",  &g_factory ) >= 0 ), "Simulator", "Task", "Unable add properity factory to AngelScript Engine" )

    // IProperityManager
    VERIFY(( engine->RegisterObjectType("IPropertyManager", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ),
            "Simulator", "Task", "Could not register IPropertyManager interface" )
    VERIFY(( engine->RegisterGlobalProperty( "IPropertyManager propertymanager",  &g_propertymanager ) >= 0 ), "Simulator", "Task", "Unable add properity propertymanager to AngelScript Engine" )

    // ISimulation
    VERIFY(( engine->RegisterObjectType("ISimulation", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register ISimulation interface" )
    VERIFY(( engine->RegisterGlobalProperty( "ISimulation simulation",  &g_simulation ) >= 0 ), "Simulator", "Task", "Unable add properity simulation to AngelScript Engine" )

    // Test
    VERIFY(( engine->RegisterObjectType("ITest", 0, asOBJ_REF|asOBJ_NOHANDLE ) >= 0 ), "Simulator", "Task", "Could not register ITest interface" )
    VERIFY(( engine->RegisterGlobalProperty( "ITest test",  &g_test ) >= 0 ), "Simulator", "Task", "Unable add properity test to AngelScript Engine" )


}





         /// @}   group task
    /// @}   group simulatorcomponent
/// @} group simulator