Browse by Tags

Tagged Content List
  • Blog Post: SimpleScript Part Seven: Binder Skeleton

    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 that each module is going to need its own name table...
  • Blog Post: invoke.cpp

    #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 must addref the pointer before the invocation. Why...
  • Blog Post: invoke.h

    #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(VARIANT * pvar); #endif // INVOKE_H ...
  • Blog Post: binder.cpp

    #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 = new Binder(); if (NULL == *ppBinder) return E_OUTOFMEMORY;...
  • Blog Post: binder.h

    #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(UINT cArgs, VARIANTARG * rgvarArgs, VARIANT * pvarResult...
  • Blog Post: SimpleScript Part Six: Threading Technicalities

    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 up: free threaded objects can be called...
  • Blog Post: SimpleScript Part Five: Named Items and Modules

    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 via the aptly named AddNamedItem method on the...
  • Blog Post: nameditemlist.h

    #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; BSTR m_bstrName; DWORD m_flags; BOOL IsPersistent...
  • Blog Post: nameditemlist.cpp

    #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; if (NULL != this->m_pMutex) delete this->m_pMutex;...
  • Blog Post: mutex.cpp

    #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 = E_OUTOFMEMORY; goto LError; } fSuccess = InitializeCriticalSectionAndSpinCount...
  • Blog Post: mutex.h

    #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 // MUTEX_H }
  • Blog Post: hash.h

    #ifndef HASH_H // { #define HASH_H extern ULONG ComputeHash(const WCHAR * psz); #endif // HASH_H }
  • Blog Post: hash.cpp

    #include "headers.h" ULONG ComputeHash(const WCHAR * psz) { AssertReadString(psz); ULONG hash = 0; while (*psz != '\0') { hash = 17 * hash + *psz; ++psz; } return hash; }
  • Blog Post: SimpleScript Part Four: Finite State Machines and Script Engines

    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 way. Basically it goes like this: an FSM has a...
  • Blog Post: SimpleScript Part Three: Engine Skeleton

    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 objects that depend on that DLL which are still...
  • Blog Post: engine.h

    #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, public IActiveScriptParse, public IActiveScriptParseProcedure2...
  • Blog Post: 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...
  • Blog Post: SimpleScript Part Two: Class Factories Are Also Boring

    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 intrepid developer created in order to try and understand...
  • Blog Post: classfac.h

    #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(REFIID riid, void** ppv); STDMETHODIMP_(ULONG) AddRef...
  • Blog Post: dllmain.h

    #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 }
  • Blog Post: classfac.cpp

    #include "headers.h" // ClassFactory ClassFactory::ClassFactory() { m_cref = 1; } ClassFactory::~ClassFactory() { } HRESULT ClassFactory::Create(ClassFactory * * ppFactory) { AssertOutPtr(ppFactory); *ppFactory = new ClassFactory(); if (NULL == *ppFactory) return E_OUTOFMEMORY; return S_OK;...
  • Blog Post: SimpleScript Part One: DllMain is Boring

    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. Before I go on, let me take this opportunity to...
  • Blog Post: dllmain.cpp

    #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 const WCHAR * pszCLSID = L"CLSID"; static const...
  • Blog Post: assert.cpp

    #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, sizeof meminfo); // If pv is a kernel-mode address...
  • Blog Post: assert.h

    #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 IsGoodReadPtr(void * pv, ULONG cb); extern BOOL...
Page 1 of 2 (30 items) 12