Adding upstream version 2:8.1.0875.upstream/2%8.1.0875upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 813 insertions, 0 deletions

diff --git a/src/if_ole.cpp b/src/if_ole.cpp
new file mode 100644
index 0000000..0888883
--- /dev/null
+++ b/src/if_ole.cpp
@@ -0,0 +1,813 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved		by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ */
+
+#if defined(FEAT_OLE) && defined(FEAT_GUI_W32)
+/*
+ * OLE server implementation.
+ *
+ * See os_mswin.c for the client side.
+ */
+
+/*
+ * We have some trouble with order of includes here.  For Borland it needs to
+ * be different from MSVC...
+ */
+#ifndef __BORLANDC__
+extern "C" {
+# include "vim.h"
+}
+#endif
+
+#include <windows.h>
+#include <oleauto.h>
+
+extern "C" {
+#ifdef __BORLANDC__
+# include "vim.h"
+#endif
+extern HWND s_hwnd;
+extern HWND vim_parent_hwnd;
+}
+
+#if (defined(_MSC_VER) && (_MSC_VER >= 1700)) || (__cplusplus >= 201103L)
+# define FINAL final
+#else
+# define FINAL
+#endif
+
+#if (defined(_MSC_VER) && _MSC_VER < 1300) || !defined(MAXULONG_PTR)
+/* Work around old versions of basetsd.h which wrongly declares
+ * UINT_PTR as unsigned long */
+# undef UINT_PTR
+# define UINT_PTR UINT
+#endif
+
+#include "if_ole.h"	// Interface definitions
+#include "iid_ole.c"	// UUID definitions (compile here)
+
+/* Supply function prototype to work around bug in Mingw oleauto.h header */
+#ifdef __MINGW32__
+WINOLEAUTAPI UnRegisterTypeLib(REFGUID libID, WORD wVerMajor,
+	    WORD wVerMinor, LCID lcid, SYSKIND syskind);
+#endif
+
+/*****************************************************************************
+ 1. Internal definitions for this file
+*****************************************************************************/
+
+class CVim;
+class CVimCF;
+
+/* Internal data */
+// The identifier of the registered class factory
+static unsigned long cf_id = 0;
+
+// The identifier of the running application object
+static unsigned long app_id = 0;
+
+// The single global instance of the class factory
+static CVimCF *cf = 0;
+
+// The single global instance of the application object
+static CVim *app = 0;
+
+/* GUIDs, versions and type library information */
+#define MYCLSID CLSID_Vim
+#define MYLIBID LIBID_Vim
+#define MYIID IID_IVim
+
+#define MAJORVER 1
+#define MINORVER 0
+#define LOCALE 0x0409
+
+#define MYNAME "Vim"
+#define MYPROGID "Vim.Application.1"
+#define MYVIPROGID "Vim.Application"
+
+#define MAX_CLSID_LEN 100
+
+/*****************************************************************************
+ 2. The application object
+*****************************************************************************/
+
+/* Definition
+ * ----------
+ */
+
+class CVim FINAL : public IVim
+{
+public:
+    virtual ~CVim();
+    static CVim *Create(int *pbDoRestart);
+
+    // IUnknown members
+    STDMETHOD(QueryInterface)(REFIID riid, void ** ppv);
+    STDMETHOD_(unsigned long, AddRef)(void);
+    STDMETHOD_(unsigned long, Release)(void);
+
+    // IDispatch members
+    STDMETHOD(GetTypeInfoCount)(UINT *pCount);
+    STDMETHOD(GetTypeInfo)(UINT iTypeInfo, LCID, ITypeInfo **ppITypeInfo);
+    STDMETHOD(GetIDsOfNames)(const IID &iid, OLECHAR **names, UINT n, LCID, DISPID *dispids);
+    STDMETHOD(Invoke)(DISPID member, const IID &iid, LCID, WORD flags, DISPPARAMS *dispparams, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr);
+
+    // IVim members
+    STDMETHOD(SendKeys)(BSTR keys);
+    STDMETHOD(Eval)(BSTR expr, BSTR *result);
+    STDMETHOD(SetForeground)(void);
+    STDMETHOD(GetHwnd)(UINT_PTR *result);
+
+private:
+    // Constructor is private - create using CVim::Create()
+    CVim() : ref(0), typeinfo(0) {};
+
+    // Reference count
+    unsigned long ref;
+
+    // The object's TypeInfo
+    ITypeInfo *typeinfo;
+};
+
+/* Implementation
+ * --------------
+ */
+
+CVim *CVim::Create(int *pbDoRestart)
+{
+    HRESULT hr;
+    CVim *me = 0;
+    ITypeLib *typelib = 0;
+    ITypeInfo *typeinfo = 0;
+
+    *pbDoRestart = FALSE;
+
+    // Create the object
+    me = new CVim();
+    if (me == NULL)
+    {
+	MessageBox(0, "Cannot create application object", "Vim Initialisation", 0);
+	return NULL;
+    }
+
+    // Load the type library from the registry
+    hr = LoadRegTypeLib(MYLIBID, 1, 0, 0x00, &typelib);
+    if (FAILED(hr))
+    {
+	HKEY hKey;
+
+	// Check we can write to the registry.
+	// RegCreateKeyEx succeeds even if key exists. W.Briscoe W2K 20021011
+	if (RegCreateKeyEx(HKEY_CLASSES_ROOT, MYVIPROGID, 0, NULL,
+		  REG_OPTION_NON_VOLATILE,
+		  KEY_ALL_ACCESS, NULL, &hKey, NULL))
+	{
+	    delete me;
+	    return NULL; // Unable to write to registry. Quietly fail.
+	}
+	RegCloseKey(hKey);
+
+	if (MessageBox(0, "Cannot load registered type library.\nDo you want to register Vim now?",
+		    "Vim Initialisation", MB_YESNO | MB_ICONQUESTION) != IDYES)
+	{
+	    delete me;
+	    return NULL;
+	}
+
+	RegisterMe(FALSE);
+
+	// Load the type library from the registry
+	hr = LoadRegTypeLib(MYLIBID, 1, 0, 0x00, &typelib);
+	if (FAILED(hr))
+	{
+	    MessageBox(0, "You must restart Vim in order for the registration to take effect.",
+						     "Vim Initialisation", 0);
+	    *pbDoRestart = TRUE;
+	    delete me;
+	    return NULL;
+	}
+    }
+
+    // Get the type info of the vtable interface
+    hr = typelib->GetTypeInfoOfGuid(MYIID, &typeinfo);
+    typelib->Release();
+
+    if (FAILED(hr))
+    {
+	MessageBox(0, "Cannot get interface type information",
+						     "Vim Initialisation", 0);
+	delete me;
+	return NULL;
+    }
+
+    // Save the type information
+    me->typeinfo = typeinfo;
+    return me;
+}
+
+CVim::~CVim()
+{
+    if (typeinfo && vim_parent_hwnd == NULL)
+	typeinfo->Release();
+    typeinfo = 0;
+}
+
+STDMETHODIMP
+CVim::QueryInterface(REFIID riid, void **ppv)
+{
+    if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IDispatch) || IsEqualIID(riid, MYIID))
+    {
+	AddRef();
+	*ppv = this;
+	return S_OK;
+    }
+
+    *ppv = 0;
+    return E_NOINTERFACE;
+}
+
+STDMETHODIMP_(ULONG)
+CVim::AddRef()
+{
+    return ++ref;
+}
+
+STDMETHODIMP_(ULONG)
+CVim::Release()
+{
+    // Don't delete the object when the reference count reaches zero, as there
+    // is only a single application object, and its lifetime is controlled by
+    // the running instance, not by its reference count.
+    if (ref > 0)
+	--ref;
+    return ref;
+}
+
+STDMETHODIMP
+CVim::GetTypeInfoCount(UINT *pCount)
+{
+    *pCount = 1;
+    return S_OK;
+}
+
+STDMETHODIMP
+CVim::GetTypeInfo(UINT iTypeInfo, LCID, ITypeInfo **ppITypeInfo)
+{
+    *ppITypeInfo = 0;
+
+    if (iTypeInfo != 0)
+	return DISP_E_BADINDEX;
+
+    typeinfo->AddRef();
+    *ppITypeInfo = typeinfo;
+    return S_OK;
+}
+
+STDMETHODIMP
+CVim::GetIDsOfNames(
+	const IID &iid,
+	OLECHAR **names,
+	UINT n,
+	LCID,
+	DISPID *dispids)
+{
+    if (iid != IID_NULL)
+	return DISP_E_UNKNOWNINTERFACE;
+
+    return typeinfo->GetIDsOfNames(names, n, dispids);
+}
+
+STDMETHODIMP
+CVim::Invoke(
+	DISPID member,
+	const IID &iid,
+	LCID,
+	WORD flags,
+	DISPPARAMS *dispparams,
+	VARIANT *result,
+	EXCEPINFO *excepinfo,
+	UINT *argerr)
+{
+    if (iid != IID_NULL)
+	return DISP_E_UNKNOWNINTERFACE;
+
+    ::SetErrorInfo(0, NULL);
+    return typeinfo->Invoke(static_cast<IDispatch*>(this),
+			    member, flags, dispparams,
+			    result, excepinfo, argerr);
+}
+
+STDMETHODIMP
+CVim::GetHwnd(UINT_PTR *result)
+{
+    *result = (UINT_PTR)s_hwnd;
+    return S_OK;
+}
+
+STDMETHODIMP
+CVim::SetForeground(void)
+{
+    /* Make the Vim window come to the foreground */
+    gui_mch_set_foreground();
+    return S_OK;
+}
+
+STDMETHODIMP
+CVim::SendKeys(BSTR keys)
+{
+    int len;
+    char *buffer;
+    char_u *str;
+    char_u *ptr;
+
+    /* Get a suitable buffer */
+    len = WideCharToMultiByte(CP_ACP, 0, keys, -1, 0, 0, 0, 0);
+    buffer = (char *)alloc(len+1);
+
+    if (buffer == NULL)
+	return E_OUTOFMEMORY;
+
+    len = WideCharToMultiByte(CP_ACP, 0, keys, -1, buffer, len, 0, 0);
+
+    if (len == 0)
+    {
+	vim_free(buffer);
+	return E_INVALIDARG;
+    }
+
+    /* Translate key codes like <Esc> */
+    str = replace_termcodes((char_u *)buffer, &ptr, FALSE, TRUE, FALSE);
+
+    /* If ptr was set, then a new buffer was allocated,
+     * so we can free the old one.
+     */
+    if (ptr)
+	vim_free((char_u *)(buffer));
+
+    /* Reject strings too long to fit in the input buffer. Allow 10 bytes
+     * space to cover for the (remote) possibility that characters may enter
+     * the input buffer between now and when the WM_OLE message is actually
+     * processed. If more that 10 characters enter the input buffer in that
+     * time, the WM_OLE processing will simply fail to insert the characters.
+     */
+    if ((int)(STRLEN(str)) > (vim_free_in_input_buf() - 10))
+    {
+	vim_free(str);
+	return E_INVALIDARG;
+    }
+
+    /* Pass the string to the main input loop. The memory will be freed when
+     * the message is processed.  Except for an empty message, we don't need
+     * to post it then.
+     */
+    if (*str == NUL)
+	vim_free(str);
+    else
+	PostMessage(NULL, WM_OLE, 0, (LPARAM)str);
+
+    return S_OK;
+}
+
+STDMETHODIMP
+CVim::Eval(BSTR expr, BSTR *result)
+{
+#ifdef FEAT_EVAL
+    int len;
+    char *buffer;
+    char *str;
+    wchar_t *w_buffer;
+
+    /* Get a suitable buffer */
+    len = WideCharToMultiByte(CP_ACP, 0, expr, -1, 0, 0, 0, 0);
+    if (len == 0)
+	return E_INVALIDARG;
+
+    buffer = (char *)alloc((unsigned)len);
+
+    if (buffer == NULL)
+	return E_OUTOFMEMORY;
+
+    /* Convert the (wide character) expression to an ASCII string */
+    len = WideCharToMultiByte(CP_ACP, 0, expr, -1, buffer, len, 0, 0);
+    if (len == 0)
+	return E_INVALIDARG;
+
+    /* Evaluate the expression */
+    ++emsg_skip;
+    str = (char *)eval_to_string((char_u *)buffer, NULL, TRUE);
+    --emsg_skip;
+    vim_free(buffer);
+    if (str == NULL)
+	return E_FAIL;
+
+    /* Convert the result to wide characters */
+    MultiByteToWideChar_alloc(CP_ACP, 0, str, -1, &w_buffer, &len);
+    vim_free(str);
+    if (w_buffer == NULL)
+	return E_OUTOFMEMORY;
+
+    if (len == 0)
+    {
+	vim_free(w_buffer);
+	return E_FAIL;
+    }
+
+    /* Store the result */
+    *result = SysAllocString(w_buffer);
+    vim_free(w_buffer);
+
+    return S_OK;
+#else
+    return E_NOTIMPL;
+#endif
+}
+
+/*****************************************************************************
+ 3. The class factory
+*****************************************************************************/
+
+/* Definition
+ * ----------
+ */
+
+class CVimCF FINAL : public IClassFactory
+{
+public:
+    static CVimCF *Create();
+    virtual ~CVimCF() {};
+
+    STDMETHOD(QueryInterface)(REFIID riid, void ** ppv);
+    STDMETHOD_(unsigned long, AddRef)(void);
+    STDMETHOD_(unsigned long, Release)(void);
+    STDMETHOD(CreateInstance)(IUnknown *punkOuter, REFIID riid, void ** ppv);
+    STDMETHOD(LockServer)(BOOL lock);
+
+private:
+    // Constructor is private - create via Create()
+    CVimCF() : ref(0) {};
+
+    // Reference count
+    unsigned long ref;
+};
+
+/* Implementation
+ * --------------
+ */
+
+CVimCF *CVimCF::Create()
+{
+    CVimCF *me = new CVimCF();
+
+    if (me == NULL)
+	MessageBox(0, "Cannot create class factory", "Vim Initialisation", 0);
+
+    return me;
+}
+
+STDMETHODIMP
+CVimCF::QueryInterface(REFIID riid, void **ppv)
+{
+    if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IClassFactory))
+    {
+	AddRef();
+	*ppv = this;
+	return S_OK;
+    }
+
+    *ppv = 0;
+    return E_NOINTERFACE;
+}
+
+STDMETHODIMP_(ULONG)
+CVimCF::AddRef()
+{
+    return ++ref;
+}
+
+STDMETHODIMP_(ULONG)
+CVimCF::Release()
+{
+    // Don't delete the object when the reference count reaches zero, as there
+    // is only a single application object, and its lifetime is controlled by
+    // the running instance, not by its reference count.
+    if (ref > 0)
+	--ref;
+    return ref;
+}
+
+/*ARGSUSED*/
+STDMETHODIMP
+CVimCF::CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
+{
+    return app->QueryInterface(riid, ppv);
+}
+
+/*ARGSUSED*/
+STDMETHODIMP
+CVimCF::LockServer(BOOL lock)
+{
+    return S_OK;
+}
+
+/*****************************************************************************
+ 4. Registry manipulation code
+*****************************************************************************/
+
+// Internal use only
+static void SetKeyAndValue(const char *path, const char *subkey, const char *value);
+static void GUIDtochar(const GUID &guid, char *GUID, int length);
+static void RecursiveDeleteKey(HKEY hKeyParent, const char *child);
+static const int GUID_STRING_SIZE = 39;
+
+// Register the component in the registry
+// When "silent" is TRUE don't give any messages.
+
+extern "C" void RegisterMe(int silent)
+{
+    BOOL ok = TRUE;
+
+    // Get the application startup command
+    char module[MAX_PATH];
+
+    ::GetModuleFileName(NULL, module, MAX_PATH);
+
+    // Unregister first (quietly)
+    UnregisterMe(FALSE);
+
+    // Convert the CLSID into a char
+    char clsid[GUID_STRING_SIZE];
+    GUIDtochar(MYCLSID, clsid, sizeof(clsid));
+
+    // Convert the LIBID into a char
+    char libid[GUID_STRING_SIZE];
+    GUIDtochar(MYLIBID, libid, sizeof(libid));
+
+    // Build the key CLSID\\{...}
+    char Key[MAX_CLSID_LEN];
+    strcpy(Key, "CLSID\\");
+    strcat(Key, clsid);
+
+    // Add the CLSID to the registry
+    SetKeyAndValue(Key, NULL, MYNAME);
+    SetKeyAndValue(Key, "LocalServer32", module);
+    SetKeyAndValue(Key, "ProgID", MYPROGID);
+    SetKeyAndValue(Key, "VersionIndependentProgID", MYVIPROGID);
+    SetKeyAndValue(Key, "TypeLib", libid);
+
+    // Add the version-independent ProgID subkey under HKEY_CLASSES_ROOT
+    SetKeyAndValue(MYVIPROGID, NULL, MYNAME);
+    SetKeyAndValue(MYVIPROGID, "CLSID", clsid);
+    SetKeyAndValue(MYVIPROGID, "CurVer", MYPROGID);
+
+    // Add the versioned ProgID subkey under HKEY_CLASSES_ROOT
+    SetKeyAndValue(MYPROGID, NULL, MYNAME);
+    SetKeyAndValue(MYPROGID, "CLSID", clsid);
+
+    wchar_t w_module[MAX_PATH];
+    MultiByteToWideChar(CP_ACP, 0, module, -1, w_module, MAX_PATH);
+
+    ITypeLib *typelib = NULL;
+    if (LoadTypeLib(w_module, &typelib) != S_OK)
+    {
+	if (!silent)
+	    MessageBox(0, "Cannot load type library to register",
+						       "Vim Registration", 0);
+	ok = FALSE;
+    }
+    else
+    {
+	if (RegisterTypeLib(typelib, w_module, NULL) != S_OK)
+	{
+	    if (!silent)
+		MessageBox(0, "Cannot register type library",
+						       "Vim Registration", 0);
+	    ok = FALSE;
+	}
+	typelib->Release();
+    }
+
+    if (ok && !silent)
+	MessageBox(0, "Registered successfully", "Vim", 0);
+}
+
+// Remove the component from the registry
+//
+// Note: There is little error checking in this code, to allow incomplete
+// or failed registrations to be undone.
+extern "C" void UnregisterMe(int bNotifyUser)
+{
+    // Unregister the type library
+    ITypeLib *typelib;
+    if (SUCCEEDED(LoadRegTypeLib(MYLIBID, MAJORVER, MINORVER, LOCALE, &typelib)))
+    {
+	TLIBATTR *tla;
+	if (SUCCEEDED(typelib->GetLibAttr(&tla)))
+	{
+	    UnRegisterTypeLib(tla->guid, tla->wMajorVerNum, tla->wMinorVerNum,
+			      tla->lcid, tla->syskind);
+	    typelib->ReleaseTLibAttr(tla);
+	}
+	typelib->Release();
+    }
+
+    // Convert the CLSID into a char
+    char clsid[GUID_STRING_SIZE];
+    GUIDtochar(MYCLSID, clsid, sizeof(clsid));
+
+    // Build the key CLSID\\{...}
+    char Key[MAX_CLSID_LEN];
+    strcpy(Key, "CLSID\\");
+    strcat(Key, clsid);
+
+    // Delete the CLSID Key - CLSID\{...}
+    RecursiveDeleteKey(HKEY_CLASSES_ROOT, Key);
+
+    // Delete the version-independent ProgID Key
+    RecursiveDeleteKey(HKEY_CLASSES_ROOT, MYVIPROGID);
+
+    // Delete the ProgID key
+    RecursiveDeleteKey(HKEY_CLASSES_ROOT, MYPROGID);
+
+    if (bNotifyUser)
+	MessageBox(0, "Unregistered successfully", "Vim", 0);
+}
+
+/****************************************************************************/
+
+// Convert a GUID to a char string
+static void GUIDtochar(const GUID &guid, char *GUID, int length)
+{
+    // Get wide string version
+    LPOLESTR wGUID = NULL;
+    StringFromCLSID(guid, &wGUID);
+
+    // Covert from wide characters to non-wide
+    wcstombs(GUID, wGUID, length);
+
+    // Free memory
+    CoTaskMemFree(wGUID);
+}
+
+// Delete a key and all of its descendants
+static void RecursiveDeleteKey(HKEY hKeyParent, const char *child)
+{
+    // Open the child
+    HKEY hKeyChild;
+    LONG result = RegOpenKeyEx(hKeyParent, child, 0,
+			       KEY_ALL_ACCESS, &hKeyChild);
+    if (result != ERROR_SUCCESS)
+	return;
+
+    // Enumerate all of the descendants of this child
+    FILETIME time;
+    char buffer[1024];
+    DWORD size = 1024;
+
+    while (RegEnumKeyEx(hKeyChild, 0, buffer, &size, NULL,
+			NULL, NULL, &time) == S_OK)
+    {
+	// Delete the descendants of this child
+	RecursiveDeleteKey(hKeyChild, buffer);
+	size = 256;
+    }
+
+    // Close the child
+    RegCloseKey(hKeyChild);
+
+    // Delete this child
+    RegDeleteKey(hKeyParent, child);
+}
+
+// Create a key and set its value
+static void SetKeyAndValue(const char *key, const char *subkey, const char *value)
+{
+    HKEY hKey;
+    char buffer[1024];
+
+    strcpy(buffer, key);
+
+    // Add subkey name to buffer.
+    if (subkey)
+    {
+	strcat(buffer, "\\");
+	strcat(buffer, subkey);
+    }
+
+    // Create and open key and subkey.
+    long result = RegCreateKeyEx(HKEY_CLASSES_ROOT,
+				 buffer,
+				 0, NULL, REG_OPTION_NON_VOLATILE,
+				 KEY_ALL_ACCESS, NULL,
+				 &hKey, NULL);
+    if (result != ERROR_SUCCESS)
+	return;
+
+    // Set the value
+    if (value)
+	RegSetValueEx(hKey, NULL, 0, REG_SZ, (BYTE *)value,
+		      (DWORD)STRLEN(value)+1);
+
+    RegCloseKey(hKey);
+}
+
+/*****************************************************************************
+ 5. OLE Initialisation and shutdown processing
+*****************************************************************************/
+extern "C" void InitOLE(int *pbDoRestart)
+{
+    HRESULT hr;
+
+    *pbDoRestart = FALSE;
+
+    // Initialize the OLE libraries
+    hr = OleInitialize(NULL);
+    if (FAILED(hr))
+    {
+	MessageBox(0, "Cannot initialise OLE", "Vim Initialisation", 0);
+	goto error0;
+    }
+
+    // Create the application object
+    app = CVim::Create(pbDoRestart);
+    if (app == NULL)
+	goto error1;
+
+    // Create the class factory
+    cf = CVimCF::Create();
+    if (cf == NULL)
+	goto error1;
+
+    // Register the class factory
+    hr = CoRegisterClassObject(
+	MYCLSID,
+	cf,
+	CLSCTX_LOCAL_SERVER,
+	REGCLS_MULTIPLEUSE,
+	&cf_id);
+
+    if (FAILED(hr))
+    {
+	MessageBox(0, "Cannot register class factory", "Vim Initialisation", 0);
+	goto error1;
+    }
+
+    // Register the application object as active
+    hr = RegisterActiveObject(
+	app,
+	MYCLSID,
+	0,
+	&app_id);
+
+    if (FAILED(hr))
+    {
+	MessageBox(0, "Cannot register application object", "Vim Initialisation", 0);
+	goto error1;
+    }
+
+    return;
+
+    // Errors: tidy up as much as needed and return
+error1:
+    UninitOLE();
+error0:
+    return;
+}
+
+extern "C" void UninitOLE()
+{
+    // Unregister the application object
+    if (app_id)
+    {
+	RevokeActiveObject(app_id, NULL);
+	app_id = 0;
+    }
+
+    // Unregister the class factory
+    if (cf_id)
+    {
+	CoRevokeClassObject(cf_id);
+	cf_id = 0;
+    }
+
+    // Shut down the OLE libraries
+    OleUninitialize();
+
+    // Delete the application object
+    if (app)
+    {
+	delete app;
+	app = NULL;
+    }
+
+    // Delete the class factory
+    if (cf)
+    {
+	delete cf;
+	cf = NULL;
+    }
+}
+#endif /* FEAT_OLE */