engine.cpp

#include "headers.h"

ScriptEngine::ScriptEngine()
{
    DLLAddRef();

    this->m_cref = 1;
    this->m_thread = threadNone;
    this->m_state = SCRIPTSTATE_UNINITIALIZED;
    this->m_psite = NULL;
    this->m_pNamedItemList = NULL;
}

ScriptEngine::~ScriptEngine()
{
    Assert(this->m_cref == 0);

    if (this->m_state != SCRIPTSTATE_CLOSED && this->m_state != SCRIPTSTATE_UNINITIALIZED)
    {
        Bug("It's a very bad idea to deallocate an initialized engine.");
    }

    this->Close();
    if (NULL != this->m_pNamedItemList)
        delete this->m_pNamedItemList;

    DLLRelease();
}

HRESULT ScriptEngine::Create(ScriptEngine * * ppEngine)
{
    AssertOutPtr(ppEngine);

    HRESULT hr;

    *ppEngine = NULL;
    ScriptEngine * pEngine = NULL;

    pEngine = new ScriptEngine();
    if (NULL == pEngine)
    {
        hr = E_OUTOFMEMORY;
        goto LError;
    }

    hr = NamedItemList::Create(23, &pEngine->m_pNamedItemList);
    if (FAILED(hr))
        goto LError;

    *ppEngine = pEngine;
    pEngine = NULL;

    hr = S_OK;       

LError:

    if (NULL != pEngine)
        pEngine->Release();
       
    return hr;
}

void ScriptEngine::ChangeScriptState(SCRIPTSTATE state)
{
    if (this->m_state != state)
    {
        this->m_state = state;
        if (this->m_psite != NULL)
            this->m_psite->OnStateChange(state);
    }
}

BOOL ScriptEngine::IsInitialized(void)
{
    switch(this->m_state)
    {
    case SCRIPTSTATE_CLOSED:
    case SCRIPTSTATE_UNINITIALIZED:
        Assert(NULL == this->m_psite);
        Assert(threadNone == this->m_thread);
        return FALSE;
    case SCRIPTSTATE_INITIALIZED:
    case SCRIPTSTATE_STARTED:
    case SCRIPTSTATE_CONNECTED:
    case SCRIPTSTATE_DISCONNECTED:
        Assert(threadNone != this->m_thread);
        Assert(NULL != this->m_psite);
        return TRUE;
    default:
        Bug("The script state is a bad value.");
        return FALSE;
    }
}

HRESULT ScriptEngine::VerifyThread(void)
{
    if (this->IsInitialized() && this->m_thread != GetCurrentThreadId())
    {

        Bug("The host is in violation of the script engine threading contract. "
            "Hosts are required to treat the engine as apartment threaded when "
            "the engine is initialized (with some exceptions) and as rental "
            "threaded when it is not initialized.");

        return E_UNEXPECTED;
    }
    return S_OK;
}

HRESULT ScriptEngine::Uninitialize(void)
{
    HRESULT hr;
   
    if (this->m_state == SCRIPTSTATE_CLOSED)
    {
        Bug("It is illegal to move a script engine from CLOSED to UNINITIALIZED");
        // Pointless, too.
        return E_UNEXPECTED;
    }

    if (this->m_state == SCRIPTSTATE_UNINITIALIZED)
        return S_OK;

    hr = this->Initialize();
    if (FAILED(hr))
        goto LError;

    this->m_pNamedItemList->Reset();

    this->m_psite->Release();
    this->m_psite = NULL;
    this->m_thread = threadNone;

    hr = S_OK;

LError:

    return hr;
}

HRESULT ScriptEngine::Initialize(void)
{
    HRESULT hr;
   
    if (!this->IsInitialized())
    {
        Bug("To initialize an uninitialized engine, call SetScriptSite.");
        return E_UNEXPECTED;
    }

    if (this->m_state == SCRIPTSTATE_INITIALIZED)
        return S_OK;

    if (this->m_state == SCRIPTSTATE_CONNECTED || this->m_state == SCRIPTSTATE_DISCONNECTED)
    {
        hr = this->FullyDisconnectEventSinks();
        if (FAILED(hr))
            goto LError;
    }

    hr = this->StopEngine();
    if (FAILED(hr))
        goto LError;

    hr = S_OK;

LError:

    return hr;
}

HRESULT ScriptEngine::Start(void)
{
    HRESULT hr;

    if (!this->IsInitialized())
    {
        Bug("You cannot start an uninitialized engine.");
        return E_UNEXPECTED;
    }

    if (this->m_state == SCRIPTSTATE_STARTED)
        return S_OK;

    if (this->m_state == SCRIPTSTATE_CONNECTED || this->m_state == SCRIPTSTATE_DISCONNECTED)
    {
        hr = this->FullyDisconnectEventSinks();
        if (FAILED(hr))
            goto LError;
    }

    hr = this->Execute();

    if (SCRIPT_E_REPORTED == hr)
        hr = S_OK;
    if (FAILED(hr))
        goto LError;

    hr = S_OK;

LError:

    return hr;
}

HRESULT ScriptEngine::Execute(void)
{
    // UNDONE
    return S_OK;
}

HRESULT ScriptEngine::StopEngine(void)
{
    // UNDONE
    return S_OK;
}

HRESULT ScriptEngine::Connect(void)
{
    HRESULT hr;

    if (!this->IsInitialized())
    {
        Bug("You cannot connect an uninitialized engine.");
        return E_UNEXPECTED;
    }

    if (this->m_state == SCRIPTSTATE_CONNECTED)
        return S_OK;

    if (this->m_state == SCRIPTSTATE_DISCONNECTED)
    {
        hr = this->ReconnectEventSinks();
        if (FAILED(hr))
            goto LError;
    }
    else
    {
        hr = this->Start();
        if (FAILED(hr))
            goto LError;

        hr = this->ConnectEventSinks();
        if (FAILED(hr))
            goto LError;       
    }

    hr = S_OK;

LError:

    return hr;
}

HRESULT ScriptEngine::TemporarilyDisconnectEventSinks(void)
{
    if (this->m_state == SCRIPTSTATE_DISCONNECTED)
        return S_OK;

    if (this->m_state != SCRIPTSTATE_CONNECTED)
    {
        Bug("You cannot disconnect an engine that is not connected!");
        return E_UNEXPECTED;
    }
   
    // UNDONE
    return S_OK;
}

HRESULT ScriptEngine::FullyDisconnectEventSinks(void)
{
    Assert(this->m_state == SCRIPTSTATE_CONNECTED || this->m_state == SCRIPTSTATE_DISCONNECTED);

    // UNDONE
    return S_OK;
}

HRESULT ScriptEngine::ConnectEventSinks(void)
{
    // UNDONE
    return S_OK;
}

HRESULT ScriptEngine::ReconnectEventSinks(void)
{
    // UNDONE
    return S_OK;
}

// IUnknown

STDMETHODIMP ScriptEngine::QueryInterface(REFIID riid, void * * ppv)
{
    // This method can be called on any thread at any time.
   
    if (NULL == ppv)
    {
        Bug("Null out pointer");
        return E_POINTER;
    }
       
    AssertOutPtr(ppv);

    *ppv = NULL;

    if (IsEqualIID(riid, IID_IUnknown))
        *ppv = (IUnknown *)(IActiveScript *) this;
    else if (IsEqualIID(riid, IID_IActiveScript))
        *ppv = (IActiveScript *) this;
    else if (IsEqualIID(riid, IID_IActiveScriptParse))
        *ppv = (IActiveScriptParse *) this;
    else if (IsEqualIID(riid, IID_IActiveScriptParseProcedure2))
        *ppv = (IActiveScriptParseProcedure2 *) this;
    else if (IsEqualIID(riid, IID_IObjectSafety))
        *ppv = (IObjectSafety *) this;
    else
        return E_NOINTERFACE;

    this->AddRef();
    return S_OK;
}

STDMETHODIMP_(ULONG) ScriptEngine::AddRef(void)
{
    // This method can be called on any thread at any time.
   
    return InterlockedIncrement(&this->m_cref);
}

STDMETHODIMP_(ULONG) ScriptEngine::Release(void)
{
    // This method can be called on any thread at any time,
    // but if this is the final release, the engine should be
    // uninitialized.
   
    long cref = InterlockedDecrement(&this->m_cref);
    if (0 == cref)
        delete this;
    return cref;
}

// IActiveScript

STDMETHODIMP ScriptEngine::SetScriptSite(IActiveScriptSite * psite)
{
    if (NULL == psite)
    {
        Bug("Null site pointer");
        return E_POINTER;
    }

    AssertReadPtr(psite);
   
    if (this->IsInitialized())
    {
        Bug("It is a violation of the script engine contract to set "
            "the site of an engine which is already initialized");
        return E_UNEXPECTED;
    }
       
    psite->AddRef();
    this->m_psite = psite;
    this->m_thread = GetCurrentThreadId();

    this->ChangeScriptState(SCRIPTSTATE_INITIALIZED);

    return S_OK;
}
   
STDMETHODIMP ScriptEngine::GetScriptSite(REFIID riid, void * * ppv)
{
    HRESULT hr;

    if (NULL == ppv)
    {
        Bug("Null out pointer");
        return E_POINTER;
    }

    AssertOutPtr(ppv);

    *ppv = NULL;
   
    hr = this->VerifyThread();
    if (FAILED(hr))
        return hr;

    if (this->m_psite == NULL)
        return S_FALSE;

    return this->m_psite->QueryInterface(riid, ppv);
}

STDMETHODIMP ScriptEngine::SetScriptState(SCRIPTSTATE state)
{
    HRESULT hr;
   
    hr = this->VerifyThread();
    if (FAILED(hr))
        goto LError;
   
    switch(state)
    {
    default:
        Bug("The script state is a bad value.");
        hr = E_INVALIDARG;
        break;
    case SCRIPTSTATE_CLOSED:
        hr = this->Close();
        break;
    case SCRIPTSTATE_UNINITIALIZED:
        hr = this->Uninitialize();
        break;
    case SCRIPTSTATE_INITIALIZED:
        hr = this->Initialize();
        break;
    case SCRIPTSTATE_STARTED:
        hr = this->Start();
        break;
    case SCRIPTSTATE_CONNECTED:
        hr = this->Connect();
        break;
    case SCRIPTSTATE_DISCONNECTED:
        hr = this->TemporarilyDisconnectEventSinks();
        break;
    }

    if (FAILED(hr))
        goto LError;

    this->ChangeScriptState(state);

    hr = S_OK;

LError:

    return hr;
}

STDMETHODIMP ScriptEngine::Close(void)
{
    HRESULT hr;

    if (this->m_state == SCRIPTSTATE_CLOSED)
        return S_OK;

    hr = this->VerifyThread();
    if (FAILED(hr))
        goto LError;

    hr = this->Uninitialize();
    if (FAILED(hr))
        goto LError;

    this->m_pNamedItemList->Clear();

    this->ChangeScriptState(SCRIPTSTATE_CLOSED);

    hr = S_OK;

LError:   

    return hr;
}

STDMETHODIMP ScriptEngine::AddNamedItem(const WCHAR * pszName, DWORD flags)
{

// There are six possible flags.  Suppose the named item is "foo":
//
// SCRIPTITEM_ISVISIBLE     : foo is added to the namespace, so you can call
//                            "foo.bar(123)" from the script
// SCRIPTITEM_ISSOURCE      : foo is an object which sources events
// SCRIPTITEM_GLOBALMEMBERS : calling "bar(123)" calls "foo.bar(123)".  Think
//                            "window.alert()". These guys go into the global module.
// SCRIPTITEM_ISPERSISTENT  : foo survives when we go back to Uninitialized state.
// SCRIPTITEM_CODEONLY      : foo is just the name of a module, not an object
// SCRIPTITEM_NOCODE        : foo is just the name of a named item, not a code module

    HRESULT hr;

    if (NULL == pszName)
        return E_POINTER;

    AssertReadString(pszName);
   
    if (!this->IsInitialized())
    {
        Bug("It is a violation of the script engine contract to add "
            "a named item to an uninitialized engine.");
        return E_UNEXPECTED;
    }

    if ((flags & ~SCRIPTITEM_ALL_FLAGS) != 0)
    {
        Bug("Bad flag passed to AddNamedItem");
        return E_INVALIDARG;
    }

    hr = this->VerifyThread();
    if (FAILED(hr))
        return hr;

    hr = this->m_pNamedItemList->Add(pszName, flags);
    if (FAILED(hr))
        return hr;

    return S_OK;
}

STDMETHODIMP ScriptEngine::AddTypeLib(REFGUID rguid, DWORD major, DWORD minor,
    DWORD flags)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::GetScriptDispatch(const WCHAR * pszName,
    IDispatch * * ppdisp)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::GetScriptState(SCRIPTSTATE * pstate)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::GetCurrentScriptThreadID(SCRIPTTHREADID * pthread)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::GetScriptThreadID(DWORD thread, SCRIPTTHREADID * pthread)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::GetScriptThreadState(SCRIPTTHREADID thread,
    SCRIPTTHREADSTATE * pstate)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::InterruptScriptThread(SCRIPTTHREADID thread,
    const EXCEPINFO * pexcepinfo, DWORD flags)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::Clone(IActiveScript * * ppScriptEngine)
{
    return E_NOTIMPL;
}

// IActiveScriptParse

STDMETHODIMP ScriptEngine::InitNew(void)
{
    return S_OK;
}

STDMETHODIMP ScriptEngine::AddScriptlet(const WCHAR * pszDefaultName,
    const WCHAR * pszCode, const WCHAR * pszItemName, const WCHAR * pszSubItemName,
    const WCHAR * pszEventName, const WCHAR * pszDelimiter, DWORD sourceContext,
    ULONG startingLineNumber, DWORD flags, BSTR * pbstrName, EXCEPINFO * pexcepinfo)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::ParseScriptText(const WCHAR * pszCode,
    const WCHAR * pszItemName, IUnknown *punkContext, const WCHAR * pszDelimiter,
    DWORD sourceContext, ULONG startingLineNumber, DWORD flags,
    VARIANT *pvarResult, EXCEPINFO *pexcepinfo)
{
    return E_NOTIMPL;
}

// IActiveScriptParseProcedure2

STDMETHODIMP ScriptEngine::ParseProcedureText(const WCHAR * pstrCode,
    const WCHAR * pstrFormalParams, const WCHAR * pstrProcedureName,
    const WCHAR * pstrItemName, IUnknown * punkContext, const WCHAR * pstrDelimiter,
    DWORD sourceContext, ULONG startingLineNumber, DWORD flags, IDispatch * * ppdisp)
{
    return E_NOTIMPL;
}

// IObjectSafety

STDMETHODIMP ScriptEngine::GetInterfaceSafetyOptions(REFIID riid,
    DWORD * pSupported, DWORD * pEnabled)
{
    return E_NOTIMPL;
}

STDMETHODIMP ScriptEngine::SetInterfaceSafetyOptions(REFIID riid,
    DWORD mask, DWORD options)
{
    return E_NOTIMPL;
}