In Part Five I was discussing modules: there is a "global module" and any number of additional modules. Each module is associated with a named item, and the only module which is associated with more than one named item is the global module. This means...

#include "headers.h" HRESULT InvokeDispatch(IDispatch * pdisp, DISPID dispid, REFIID riid, LCID lcid, WORD flags, DISPPARAMS * pDispParams, VARIANT * pvarResult, EXCEPINFO * pExcepInfo, UINT * pError) { AssertReadPtr(pdisp); HRESULT hr; // We...

#ifndef INVOKE_H // { #define INVOKE_H extern HRESULT InvokeDispatch(IDispatch * pdisp, DISPID dispid, REFIID riid, LCID lcid, WORD flags, DISPPARAMS * pDispParams, VARIANT * pvarResult, EXCEPINFO * pExcepInfo, UINT * pError); extern BOOL IsValidDispatch...

#include "headers.h" Binder::Binder() { DLLAddRef(); this->m_cref = 1; this->m_thread = GetCurrentThreadId(); } Binder::~Binder(void) { DLLRelease(); } HRESULT Binder::Create(Binder * * ppBinder) { AssertOutPtr(ppBinder); *ppBinder ...

#ifndef BINDER_H // { #define BINDER_H class Binder : public IDispatch { protected: class Name { public: Name(); ~Name(); HRESULT SetValue(VARIANTARG * pvar); HRESULT GetValue(VARIANT * pvar); BOOL IsFunction(void); HRESULT ExecuteFunction...

Refresher Course Before you read this, you might want to take a quick refresher on my original posting on the script engine threading model. That was a somewhat simplified (!) description of the actual script engine contract. Let me just sum...

Named Items "Named items" are what we call the "top level" objects of the host provided object model. WScript in WSH, window in Internet Explorer, Response in ASP, are all named items. A host tells an initialized script engine about named items...

#ifndef NAMEDITEMLIST_H // { #define NAMEDITEMLIST_H class NamedItemList { private: class NamedItem { private: NamedItem(); public: ~NamedItem(); static HRESULT Create(const WCHAR * pszName, NamedItem * * ppNamedItem); NamedItem * m_pNext;...

#include "headers.h" NamedItemList::NamedItemList() { this->m_cBuckets = 0; this->m_Buckets = NULL; this->m_pMutex = NULL; } NamedItemList::~NamedItemList() { this->Clear(); if (NULL != this->m_Buckets) delete[] this->m_Buckets;...

#include "headers.h" Mutex::Mutex() { m_fInitialized = FALSE; } HRESULT Mutex::Create(Mutex * * ppMutex) { AssertOutPtr(ppMutex); HRESULT hr; BOOL fSuccess; DWORD error; Mutex * pMutex = NULL; pMutex = new Mutex(); if (NULL == pMutex) { hr...

#ifndef MUTEX_H // { #define MUTEX_H class Mutex { private: CRITICAL_SECTION m_criticalsection; BOOL m_fInitialized; Mutex(); public: static HRESULT Create(Mutex * * ppMutex); ~Mutex(); void Enter(void); void Leave(void); }; #endif ...

#ifndef HASH_H // { #define HASH_H extern ULONG ComputeHash(const WCHAR * psz); #endif // HASH_H }

#include "headers.h" ULONG ComputeHash(const WCHAR * psz) { AssertReadString(psz); ULONG hash = 0; while (*psz != '\0') { hash = 17 * hash + *psz; ++psz; } return hash; }

Last time I said that I'd discuss finite state machines (also sometimes called finite state automata, same thing.) The FSM is a fundamental idea in theoretical computer science because it models computing machinery in a very simple, abstract and general...

Before I get into today's topic I want to quickly address a minor defect that Raymond Chen (who apparently spends his holiday in Sweden doing remote code-reviews, oddly enough) was good enough to point out to me. It is legal to unload a DLL if the only...

#ifndef ENGINE_H // { #define ENGINE_H const DWORD threadNone = 0xFFFFFFFF; // The error has been reported to the host via IActiveScriptSite::OnScriptError const HRESULT SCRIPT_E_REPORTED = 0x80020101L; class ScriptEngine : public IActiveScript...

#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...

Before I get into it, a Lambda poster pointed me at the NullScript project, which is a very interesting illustration of how reverse engineering works. It's an implementation of a "null" script engine -- an engine with no language -- in ATL, which the...

#ifndef CLASSFAC_H #define CLASSFAC_H class ClassFactory : public IClassFactory { private: long m_cref; ClassFactory(); ~ClassFactory(); public: static HRESULT Create(ClassFactory * * ppFactory); // IUnknown STDMETHODIMP QueryInterface...

#ifndef DLLMAIN_H // { #define DLLMAIN_H extern void DLLAddRef(void); extern void DLLRelease(void); extern void DLLAddLock(void); extern void DLLReleaseLock(void); #endif // DLLMAIN_H }

#include "headers.h" // ClassFactory ClassFactory::ClassFactory() { m_cref = 1; } ClassFactory::~ClassFactory() { } HRESULT ClassFactory::Create(ClassFactory * * ppFactory) { AssertOutPtr(ppFactory); *ppFactory = new ClassFactory(); if (NULL...

In talking with our support engineer it's just become more muddled. I'm pretty sure now actually that the customer does not want to build a script engine, but whether they want to build a script editor, a script host or a script debugger is unclear. ...

#include "headers.h" // // Helper methods // static long g_cReferences = 0; static long g_cLocks = 0; static HMODULE g_hmodule = NULL; static const WCHAR * pszEngineName = L"SimpleScript"; static const WCHAR * pszOLEScript = L"OLEScript"; static...

#include "headers.h" static BOOL IsGoodPtr(void * pv, ULONG cb, DWORD dwFlags) { DWORD dwSize; MEMORY_BASIC_INFORMATION meminfo; if (NULL == pv) return FALSE; memset(&meminfo, 0x00, sizeof meminfo); dwSize = VirtualQuery(pv, &meminfo...

#ifndef ASSERT_H // { #define ASSERT_H extern BOOL Debugger(); extern BOOL AssertProc(const char *pszFile, long lwLine, const char *pszMsg); extern BOOL IsValidReadString(const WCHAR * psz); extern BOOL IsValidReadStringN(const WCHAR * psz); extern BOOL...