cpp/jacob/ComThread.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "ComThread.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoInitialize
+  (JNIEnv *env, jclass cls, jint mode)
+{
+  int threadModel = mode;
+  CoInitializeEx(NULL, threadModel);
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoUninitialize
+  (JNIEnv *env, jclass cls)
+{
+  CoUninitialize();
+}
+
+}

cpp/jacob/ComThread.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_ComThread */
+
+#ifndef _Included_com_jacob_com_ComThread
+#define _Included_com_jacob_com_ComThread
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_ComThread
+ * Method:    doCoInitialize
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoInitialize
+  (JNIEnv *, jclass, jint);
+
+/*
+ * Class:     com_jacob_com_ComThread
+ * Method:    doCoUninitialize
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_ComThread_doCoUninitialize
+  (JNIEnv *, jclass);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/Dispatch.cpp

@@ -0,0 +1,582 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "Dispatch.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+#define DISP_FLD "m_pDispatch"
+
+// extract a IDispatch from a jobject
+IDispatch *extractDispatch(JNIEnv *env, jobject arg)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, DISP_FLD, "I");
+  jint anum = env->GetIntField(arg, ajf);
+  IDispatch *v = (IDispatch *)anum;
+  return v;
+}
+
+/**
+ * This method finds an interface rooted on the passed in dispatch object.
+ * This creates a new Dispatch object so it is NOT reliable 
+ * in the event callback thread of a JWS client where the root class loader
+ * does not have com.jacob.com.Dispatch in its classpath
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_QueryInterface
+  (JNIEnv *env, jobject _this, jstring _iid)
+{
+  // get the current IDispatch
+  IDispatch *pIDispatch = extractDispatch(env, _this);
+  if (!pIDispatch) return NULL;
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *siid = env->GetStringUTFChars(_iid, NULL);
+  USES_CONVERSION;
+  LPOLESTR bsIID = A2W(siid);
+  env->ReleaseStringUTFChars(_iid, siid);
+  IID iid;
+  HRESULT hr = IIDFromString(bsIID, &iid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get IID from String", hr);
+    return NULL;
+  }
+
+  // try to call QI on the passed IID
+  IDispatch *disp;
+  hr = pIDispatch->QueryInterface(iid, (void **)&disp);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "QI on IID from String Failed", hr);
+    return NULL;
+  }
+
+  jclass autoClass = env->FindClass("com/jacob/com/Dispatch");
+  jmethodID autoCons = env->GetMethodID(autoClass, "<init>", "(I)V");
+  // construct a Dispatch object to return
+  // I am copying the pointer to java
+  // jacob-msg 1817 - SF 1053871 :  QueryInterface already called AddRef!!
+  //if (disp) disp->AddRef();
+  jobject newAuto = env->NewObject(autoClass, autoCons, disp);
+  return newAuto;
+}
+
+/**
+ * starts up a new instance of the requested program (progId)
+ * and connects to it.  does special code if the progid 
+ * is of the alternate format (with ":")
+ **/
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_createInstanceNative
+  (JNIEnv *env, jobject _this, jstring _progid)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "I");
+
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *progid = env->GetStringUTFChars(_progid, NULL);
+  CLSID clsid;
+  HRESULT hr;
+  IUnknown *punk = NULL;
+  IDispatch *pIDispatch;
+  USES_CONVERSION;
+  LPOLESTR bsProgId = A2W(progid);
+  if (strchr(progid,':')) 
+  {
+     env->ReleaseStringUTFChars(_progid, progid);
+     // it's a moniker
+     hr = CoGetObject(bsProgId, NULL, IID_IUnknown, (LPVOID *)&punk);
+     if (FAILED(hr)) {
+       ThrowComFail(env, "Can't find moniker", hr);
+       return;
+     }
+     IClassFactory *pIClass;
+     // if it was a clsid moniker, I may have a class factory
+     hr = punk->QueryInterface(IID_IClassFactory, (void **)&pIClass);
+     if (!SUCCEEDED(hr)) goto doDisp;
+     punk->Release();
+     // try to create an instance
+     hr = pIClass->CreateInstance(NULL, IID_IUnknown, (void **)&punk);
+     if (FAILED(hr)) {
+       ThrowComFail(env, "Can't create moniker class instance", hr);
+       return;
+     }
+     pIClass->Release();
+     goto doDisp;
+  }
+  env->ReleaseStringUTFChars(_progid, progid);
+  // Now, try to find an IDispatch interface for progid
+  hr = CLSIDFromProgID(bsProgId, &clsid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get object clsid from progid", hr);
+    return;
+  }
+  // standard creation
+  hr = CoCreateInstance(clsid,NULL,CLSCTX_LOCAL_SERVER|CLSCTX_INPROC_SERVER,IID_IUnknown, (void **)&punk);
+  if (!SUCCEEDED(hr)) {
+     ThrowComFail(env, "Can't co-create object", hr);
+     return;
+  }
+doDisp:
+
+  // now get an IDispatch pointer from the IUnknown
+  hr = punk->QueryInterface(IID_IDispatch, (void **)&pIDispatch);
+  if (!SUCCEEDED(hr)) {
+    ThrowComFail(env, "Can't QI object for IDispatch", hr);
+    return;
+  }
+  // CoCreateInstance called AddRef
+  punk->Release();
+  env->SetIntField(_this, jf, (unsigned int)pIDispatch);
+}
+
+/**
+ * attempts to connect to an running instance of the requested program
+ * This exists solely for the factory method connectToActiveInstance.
+ **/
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_getActiveInstanceNative
+  (JNIEnv *env, jobject _this, jstring _progid)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "I");
+
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *progid = env->GetStringUTFChars(_progid, NULL);
+  CLSID clsid;
+  HRESULT hr;
+  IUnknown *punk = NULL;
+  IDispatch *pIDispatch;
+  USES_CONVERSION;
+  LPOLESTR bsProgId = A2W(progid);
+  env->ReleaseStringUTFChars(_progid, progid);
+  // Now, try to find an IDispatch interface for progid
+  hr = CLSIDFromProgID(bsProgId, &clsid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get object clsid from progid", hr);
+    return;
+  }
+  // standard connection
+  //printf("trying to connect to running %ls\n",bsProgId);
+  hr = GetActiveObject(clsid,NULL, &punk);
+  if (!SUCCEEDED(hr)) {
+     ThrowComFail(env, "Can't get active object", hr);
+     return;
+  }
+  // now get an IDispatch pointer from the IUnknown
+  hr = punk->QueryInterface(IID_IDispatch, (void **)&pIDispatch);
+  if (!SUCCEEDED(hr)) {
+    ThrowComFail(env, "Can't QI object for IDispatch", hr);
+    return;
+  }
+  // GetActiveObject called AddRef
+  punk->Release();
+  env->SetIntField(_this, jf, (unsigned int)pIDispatch);
+}
+
+/**
+ * starts up a new instance of the requested program (progId).  
+ * This exists solely for the factory method connectToActiveInstance.
+ **/
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_coCreateInstanceNative
+  (JNIEnv *env, jobject _this, jstring _progid)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "I");
+
+  // if we used env->GetStringChars() would that let us drop the conversion?
+  const char *progid = env->GetStringUTFChars(_progid, NULL);
+  CLSID clsid;
+  HRESULT hr;
+  IUnknown *punk = NULL;
+  IDispatch *pIDispatch;
+  USES_CONVERSION;
+  LPOLESTR bsProgId = A2W(progid);
+  env->ReleaseStringUTFChars(_progid, progid);
+  // Now, try to find an IDispatch interface for progid
+  hr = CLSIDFromProgID(bsProgId, &clsid);
+  if (FAILED(hr)) {
+    ThrowComFail(env, "Can't get object clsid from progid", hr);
+    return;
+  }
+  // standard creation
+  hr = CoCreateInstance(clsid,NULL,CLSCTX_LOCAL_SERVER|CLSCTX_INPROC_SERVER,IID_IUnknown, (void **)&punk);
+  if (!SUCCEEDED(hr)) {
+     ThrowComFail(env, "Can't co-create object", hr);
+     return;
+  }
+  // now get an IDispatch pointer from the IUnknown
+  hr = punk->QueryInterface(IID_IDispatch, (void **)&pIDispatch);
+  if (!SUCCEEDED(hr)) {
+    ThrowComFail(env, "Can't QI object for IDispatch", hr);
+    return;
+  }
+  // CoCreateInstance called AddRef
+  punk->Release();
+  env->SetIntField(_this, jf, (unsigned int)pIDispatch);
+}
+
+/**
+ * release method
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_release
+  (JNIEnv *env, jobject _this)
+{
+  jclass clazz = env->GetObjectClass(_this);
+  jfieldID jf = env->GetFieldID( clazz, DISP_FLD, "I");
+  jint num = env->GetIntField(_this, jf);
+
+  IDispatch *disp = (IDispatch *)num;
+  if (disp) {
+    disp->Release();
+    env->SetIntField(_this, jf, (unsigned int)0);
+  }
+}
+
+static HRESULT
+name2ID(IDispatch *pIDispatch, const char *prop, DISPID *dispid, long lcid)
+{
+  HRESULT     hresult;
+  USES_CONVERSION;
+  LPOLESTR propOle = A2W(prop);
+  hresult = pIDispatch->GetIDsOfNames(IID_NULL,(LPOLESTR*)&propOle,1,lcid,dispid);
+  return hresult;
+}
+
+JNIEXPORT jintArray JNICALL Java_com_jacob_com_Dispatch_getIDsOfNames
+  (JNIEnv *env, jclass clazz, jobject disp, jint lcid, jobjectArray names)
+{
+  IDispatch *pIDispatch = extractDispatch(env, disp);
+  if (!pIDispatch) return NULL;
+
+  int l = env->GetArrayLength(names);
+  int i;
+  LPOLESTR *lps = (LPOLESTR *)CoTaskMemAlloc(l * sizeof(LPOLESTR));
+  DISPID *dispid = (DISPID *)CoTaskMemAlloc(l * sizeof(DISPID));
+  for(i=0;i<l;i++) 
+  {
+    USES_CONVERSION;
+    jstring s = (jstring)env->GetObjectArrayElement(names, i);
+	// if we used env->GetStringChars() would that let us drop the conversion?
+    const char *nm = env->GetStringUTFChars(s, NULL);
+    LPOLESTR nmos = A2W(nm);
+    env->ReleaseStringUTFChars(s, nm);
+    lps[i] = nmos;
+    env->DeleteLocalRef(s);
+  }
+  HRESULT hr = pIDispatch->GetIDsOfNames(IID_NULL,lps,l,lcid,dispid);
+  if (FAILED(hr)) {
+    CoTaskMemFree(lps);
+    CoTaskMemFree(dispid);
+    char buf[1024];
+    strcpy_s(buf, "Can't map names to dispid:");
+    for(i=0;i<l;i++) 
+    {
+      USES_CONVERSION;
+      jstring s = (jstring)env->GetObjectArrayElement(names, i);
+      const char *nm = env->GetStringUTFChars(s, NULL);
+      strcat_s(buf, nm);
+      env->ReleaseStringUTFChars(s, nm);
+      env->DeleteLocalRef(s);
+    }
+    ThrowComFail(env, buf, hr);
+    return NULL;
+  }
+  jintArray iarr = env->NewIntArray(l);
+  // SF 1511033 -- the 2nd parameter should be 0 and not i!
+  env->SetIntArrayRegion(iarr, 0, l, dispid);
+  CoTaskMemFree(lps);
+  CoTaskMemFree(dispid);
+  return iarr;
+}
+
+static char* BasicToCharString(const BSTR inBasicString)
+{
+    char* charString = NULL;
+    const size_t charStrSize = ::SysStringLen(inBasicString) + 1;
+    if (charStrSize > 1)
+    {
+        charString = new char[charStrSize];
+		size_t convertedSize;
+		::wcstombs_s(&convertedSize, charString, charStrSize, inBasicString, charStrSize);
+    }
+    else 
+    {
+        charString = ::_strdup("");
+    }
+    return charString;
+}
+
+static wchar_t* CreateErrorMsgFromResult(HRESULT inResult)
+{
+  wchar_t* msg = NULL;
+  ::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+      FORMAT_MESSAGE_FROM_SYSTEM, NULL, inResult,MAKELANGID(LANG_NEUTRAL,
+      SUBLANG_DEFAULT), (LPWSTR) &msg, 0, NULL);
+  if (msg == NULL)
+  {
+    const wchar_t* message_text = L"An unknown COM error has occured.";
+    size_t bufferLength = (wcslen(message_text) + 1) * sizeof(wchar_t);
+    msg = (wchar_t*) ::LocalAlloc(LPTR, bufferLength);
+    wcscpy_s(msg, bufferLength, message_text);
+  }
+
+  return msg;
+}
+
+static wchar_t* CreateErrorMsgFromInfo(HRESULT inResult, EXCEPINFO* ioInfo,
+ const char* methName)
+{
+  wchar_t* msg = NULL;
+  size_t methNameWSize = 0;
+
+  mbstowcs_s(&methNameWSize, NULL, 0, methName, _TRUNCATE);
+
+  wchar_t* methNameW = new wchar_t[methNameWSize];
+
+  mbstowcs_s(NULL, methNameW, methNameWSize, methName, _TRUNCATE);
+
+  // If this is a dispatch exception (triggered by an Invoke message),
+  // then we have to take some additional steps to process the error
+  // message.
+  if  (inResult == DISP_E_EXCEPTION)
+  {
+    // Check to see if the server deferred filling in the exception
+    // information.  If so, make the call to populate the structure.
+    if (ioInfo->pfnDeferredFillIn != NULL)
+        (*(ioInfo->pfnDeferredFillIn))(ioInfo);
+
+    // Build the error message from exception information content.
+    int sourceLen = SysStringLen(ioInfo->bstrSource);
+    int descLen = SysStringLen(ioInfo->bstrDescription);
+    const size_t MSG_LEN = ::wcslen(methNameW) + sourceLen + descLen + 128;
+    msg = new wchar_t[MSG_LEN];
+    ::wcsncpy_s(msg, MSG_LEN, L"Invoke of: ", wcslen(L"Invoke of: "));
+    ::wcsncat_s(msg, MSG_LEN, methNameW, wcslen(methNameW));
+    ::wcsncat_s(msg, MSG_LEN, L"\nSource: ", wcslen(L"\nSource: "));
+    ::wcsncat_s(msg, MSG_LEN, ioInfo->bstrSource, sourceLen);
+    ::wcsncat_s(msg, MSG_LEN, L"\nDescription: ", wcslen(L"\nDescription: "));
+    ::wcsncat_s(msg, MSG_LEN, ioInfo->bstrDescription, descLen);
+    ::wcsncat_s(msg, MSG_LEN, L"\n", wcslen(L"\n"));
+  }
+  else
+  {
+    wchar_t* msg2 = CreateErrorMsgFromResult(inResult);
+    const size_t MSG_LEN = ::wcslen(methNameW) + ::wcslen(msg2) + 256;
+    msg = new wchar_t[MSG_LEN];
+    ::wcsncpy_s(msg, MSG_LEN, 
+		L"A COM exception has been encountered:\nAt Invoke of: ", 
+		wcslen(L"A COM exception has been encountered:\nAt Invoke of: "));
+    ::wcsncat_s(msg, MSG_LEN, methNameW, wcslen(methNameW));
+    ::wcsncat_s(msg, MSG_LEN, L"\nDescription: ", wcslen(L"\nDescription: "));
+    ::wcsncat_s(msg, MSG_LEN, msg2, wcslen(msg2));
+    // jacob-msg 1075 - SF 1053872 : Documentation says "use LocalFree"!! 
+    //delete msg2;
+	LocalFree(msg2); 
+  }
+  delete methNameW;
+  return msg;
+}
+
+
+#define SETDISPPARAMS(dp, numArgs, pvArgs, numNamed, pNamed) \
+        {\
+           (dp).cArgs  = numArgs; \
+           (dp).rgvarg = pvArgs; \
+           (dp).cNamedArgs = numNamed; \
+           (dp).rgdispidNamedArgs = pNamed; \
+        }
+
+#define SETNOPARAMS(dp) SETDISPPARAMS(dp, 0, NULL, 0, NULL)
+
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_invokev
+  (JNIEnv *env, jclass clazz,
+  jobject disp, jstring name, jint dispid,
+  jint lcid, jint wFlags, jobjectArray vArg, jintArray uArgErr)
+{
+  DISPPARAMS  dispparams;
+  EXCEPINFO   excepInfo;
+  // Sourceforge Bug Tracker 2935662 uninitialized data can be not NULL with bad results
+  excepInfo.pfnDeferredFillIn = NULL;
+
+  IDispatch *pIDispatch = extractDispatch(env, disp);
+  if (!pIDispatch) return NULL;
+
+  int dispID = dispid;
+  if (name != NULL) 
+  {
+    const char *nm = env->GetStringUTFChars(name, NULL);
+    HRESULT hr;
+    if (FAILED(hr = name2ID(pIDispatch, nm, (long *)&dispID, lcid))) {
+      char buf[1024];
+      sprintf_s(buf, 1024, "Can't map name to dispid: %s", nm);
+      ThrowComFail(env, buf, -1);
+      return NULL;
+    }
+    env->ReleaseStringUTFChars(name, nm);
+  }
+
+  int num_args = env->GetArrayLength(vArg);
+  int i, j;
+  VARIANT *varr = NULL;
+  if (num_args) 
+  {
+    varr = (VARIANT *)CoTaskMemAlloc(num_args*sizeof(VARIANT));
+    /* reverse args for dispatch */
+    for(i=num_args-1,j=0;0<=i;i--,j++) 
+    {
+      VariantInit(&varr[j]);
+      jobject arg = env->GetObjectArrayElement(vArg, i);
+      VARIANT *v = extractVariant(env, arg);
+      // no escape from copy?
+      VariantCopy(&varr[j], v);
+      env->DeleteLocalRef(arg);
+    }
+  }
+  // prepare a new return value
+  jclass variantClass = env->FindClass("com/jacob/com/Variant");
+  jmethodID variantCons = 
+      env->GetMethodID(variantClass, "<init>", "()V");
+  // construct a variant to return
+  jobject newVariant = env->NewObject(variantClass, variantCons);
+  // get the VARIANT from the newVariant
+  VARIANT *v = extractVariant(env, newVariant);
+  DISPID  dispidPropertyPut = DISPID_PROPERTYPUT;
+
+  // determine how to dispatch
+  switch (wFlags) 
+  {
+    case DISPATCH_PROPERTYGET: // GET
+    case DISPATCH_METHOD: // METHOD
+    case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
+      {
+        SETDISPPARAMS(dispparams, num_args, varr, 0, NULL);
+        break;
+      }
+    case DISPATCH_PROPERTYPUT:
+    case DISPATCH_PROPERTYPUTREF: // jacob-msg 1075 - SF 1053872
+      {
+        SETDISPPARAMS(dispparams, num_args, varr, 1, &dispidPropertyPut);
+        break;
+      }
+  }
+
+  HRESULT hr = 0;
+  jint count = env->GetArrayLength(uArgErr);
+  if ( count != 0 )
+  {
+	  jint *uAE = env->GetIntArrayElements(uArgErr, NULL);
+	  hr = pIDispatch->Invoke(dispID,IID_NULL,
+		lcid,(WORD)wFlags,&dispparams,v,&excepInfo,(unsigned int *)uAE); // SF 1689061
+	  env->ReleaseIntArrayElements(uArgErr, uAE, 0);
+  }
+  else
+  {
+	  hr = pIDispatch->Invoke(dispID,IID_NULL,
+		lcid,(WORD)wFlags,&dispparams,v,&excepInfo, NULL); // SF 1689061
+  }
+  if (num_args) 
+  {
+    // to account for inouts, I need to copy the inputs back to
+    // the java array after the method returns
+    // this occurs, for example, in the ADO wrappers
+    for(i=num_args-1,j=0;0<=i;i--,j++) 
+    {
+      jobject arg = env->GetObjectArrayElement(vArg, i);
+      VARIANT *v = extractVariant(env, arg);
+      // reverse copy
+      VariantCopy(v, &varr[j]);
+      // clear out the temporary variant
+      VariantClear(&varr[j]);
+      env->DeleteLocalRef(arg);
+    }
+  }
+
+  if (varr) CoTaskMemFree(varr);
+
+  // check for error and display a somewhat verbose error message
+  if (!SUCCEEDED(hr)) {
+    // two buffers that may have to be freed later
+    wchar_t *buf = NULL;
+    char *dispIdAsName = NULL;
+    // this method can get called with a name or a dispatch id
+    // we need to handle both SF 1114159 
+    if (name != NULL){
+	    const char *nm = env->GetStringUTFChars(name, NULL);
+	    buf = CreateErrorMsgFromInfo(hr, &excepInfo, nm);
+	    env->ReleaseStringUTFChars(name, nm);
+    } else {
+		dispIdAsName = new char[256];
+		// get the id string
+		_itoa_s (dispID, dispIdAsName, 256,10);
+		//continue on mostly as before
+		buf = CreateErrorMsgFromInfo(hr,&excepInfo,dispIdAsName); 
+    }
+    
+    // jacob-msg 3696 - SF 1053866
+	if(hr == DISP_E_EXCEPTION)
+	{
+		if(excepInfo.scode != 0)
+		{
+			hr = excepInfo.scode;
+		}
+		else
+		{
+			hr = _com_error::WCodeToHRESULT(excepInfo.wCode);
+		}
+	}
+	
+    ThrowComFailUnicode(env, buf, hr);
+    if (buf) delete buf;
+    if (dispIdAsName) delete dispIdAsName;
+    return NULL;
+  }
+
+  return newVariant;
+}
+
+/*
+ * Wait method added so folks could wait until a com server terminated
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Dispatch_hasExited
+		(JNIEnv *env,jclass clazz, jobject disp, jint dispid, jint lcid) {
+	IDispatch *pIDispatch = extractDispatch(env, disp);
+	if (!pIDispatch) {
+		// should we return 0?
+		return NULL;
+	}
+	ITypeInfo *v;
+	HRESULT hr = pIDispatch->GetTypeInfo(dispid, lcid, &v);
+	if (hr == RPC_E_SERVERCALL_RETRYLATER || hr == RPC_E_CALL_REJECTED || hr
+			== 0) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+}
+
+

cpp/jacob/Dispatch.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class Dispatch */
+
+#ifndef _Included_Dispatch
+#define _Included_Dispatch
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_Dispatch
+ * Method:    QueryInterface
+ * Signature: (Ljava/lang/String;)Lcom/jacob/com/Dispatch;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_QueryInterface
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    createInstance
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_createInstanceNative
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    getActiveInstance
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_getActiveInstanceNative
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    coCreateInstance
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_coCreateInstanceNative
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     Dispatch
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Dispatch_release
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     Dispatch
+ * Method:    getIDsOfNames
+ * Signature: (Ljava/lang/Object;I[Ljava/lang/String;)[I
+ */
+JNIEXPORT jintArray JNICALL Java_com_jacob_com_Dispatch_getIDsOfNames
+  (JNIEnv *, jclass, jobject, jint, jobjectArray);
+
+/*
+ * Class:     Dispatch
+ * Method:    invokev
+ * Signature: (Ljava/lang/Object;Ljava/lang/String;III[LVariant;[I)LVariant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Dispatch_invokev
+  (JNIEnv *, jclass, jobject, jstring, jint, jint, jint, jobjectArray, jintArray);
+
+/*
+ * Class:     Dispatch
+ * Method:    wait
+ * Signature: (Ljava/lang/Object;I;)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Dispatch_hasExited
+	(JNIEnv *, jclass, jobject, jint, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/DispatchEvents.cpp

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "DispatchEvents.h"
+#include "EventProxy.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <objbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+
+#include "util.h"
+
+extern "C"
+{
+
+#define PROXY_FLD "m_pConnPtProxy"
+
+// defined below
+BOOL GetEventIID(IUnknown*, IID*, CComBSTR **, DISPID **, int *,LPOLESTR);
+BOOL GetEventIIDForTypeLib(BSTR, IID*, CComBSTR **, DISPID **, int *,LPOLESTR);
+BOOL getClassInfoFromProgId(LPOLESTR bsProgId,LPTYPEINFO *pClassInfo);
+BOOL MapEventIIDs(IID*, CComBSTR **, DISPID **, int *, LPOLESTR , LPTYPEINFO );
+
+// extract a EventProxy* from a jobject
+EventProxy *extractProxy(JNIEnv *env, jobject arg)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, PROXY_FLD, "I");
+  jint anum = env->GetIntField(arg, ajf);
+  EventProxy *v = (EventProxy *)anum;
+  return v;
+}
+
+/*
+ * pushes the EventProxy (*ep) into tje jobject in the PROXY_FLD location
+ */
+void putProxy(JNIEnv *env, jobject arg, EventProxy *ep)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, PROXY_FLD, "I");
+  jint anum = env->GetIntField(arg, ajf);
+  env->SetIntField(arg, ajf, (jint)ep);
+}
+
+
+/*
+ * Class:     com_jacob_com_DispatchEvents
+ * Method:    init3
+ * Signature: (Lcom/jacob/com/Dispatch;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_init3
+   (JNIEnv *env,
+    jobject _this, jobject src,
+    jobject sink, 
+    jstring _progid, 
+    jstring _typelib)
+{
+	USES_CONVERSION;
+
+  if (_typelib != NULL && _progid == NULL){
+  	// both are required if typelib exists
+  	ThrowComFail(env,"TypeLib was specified but no program id was",-1);
+  	return;
+  }
+  
+  BSTR typeLib = NULL;
+  if (_typelib != NULL){
+  	  // why is this UTF instead of unicode? Then we could probably drop the A2W
+	  const char *typelib = env->GetStringUTFChars(_typelib, NULL);
+	  typeLib = A2W(typelib);
+	  // should we call env->ReleaseStringUTFChars(,) to free the memory like we do everywhere lese?
+	  
+	  //printf("we have a type lib %ls\n",typeLib);
+  }
+
+  // find progid if any
+  LPOLESTR bsProgId = NULL;
+  if (_progid!=NULL) {
+    	// why is this UTF instead of unicode?  Then we could probably drop the A2W
+    	const char *progid = env->GetStringUTFChars(_progid, NULL);
+		bsProgId = A2W(progid);
+	  // should we call env->ReleaseStringUTFChars(,) to free the memory like we do everywhere lese?
+		//printf("we have an applicaton %ls\n",bsProgId);
+  }
+  
+  // get the IDispatch for the source object
+  IDispatch *pDisp = extractDispatch(env, src);
+  CComQIPtr<IUnknown, &IID_IUnknown> pUnk(pDisp);
+  // see if it implements connection points
+  CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pCPC(pUnk);
+  if (!pCPC)
+  {
+    // no events, throw something
+    ThrowComFail(env, "Can't find IConnectionPointContainer", -1);
+    return;
+  }
+   
+  IID eventIID;
+  CComBSTR *mNames;
+  DISPID *mIDs;
+  int n_EventMethods;
+  if (_typelib == NULL){
+	  if (!GetEventIID(pUnk, &eventIID, &mNames, &mIDs, &n_EventMethods,bsProgId)) {
+    	ThrowComFail(env, "Can't find event iid", -1);
+	    return;
+	  }
+  } else {
+	  if (!GetEventIIDForTypeLib(typeLib, &eventIID, &mNames, &mIDs, &n_EventMethods,bsProgId)) {
+    	ThrowComFail(env, "Can't find event iid for type lib", -1);
+	    return;
+	  }
+  }
+
+  // hook up to the default source iid
+  CComPtr<IConnectionPoint> pCP;
+  HRESULT hr = pCPC->FindConnectionPoint(eventIID, &pCP);
+  if (SUCCEEDED(hr))
+  {
+    EventProxy *ep = new EventProxy(env, sink, pCP, eventIID, mNames, mIDs, n_EventMethods);
+    // need to store ep on _this, in case it gets collected
+    putProxy(env, _this, ep);
+  } else {
+    ThrowComFail(env, "Can't FindConnectionPoint", hr);
+  }
+}
+
+/*
+ * Class:     DispatchEvents
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_release
+  (JNIEnv *env, jobject _this)
+{
+  EventProxy *ep = extractProxy(env, _this);
+  if (ep) {
+  	// this is the line that blows up in IETest
+    ep->Release();
+    putProxy(env, _this, NULL);
+  }
+}
+
+/*
+ * I need a reverse map from the event interface's dispids to
+ * function names so that we can reflect them to java
+ */
+void
+LoadNameCache(LPTYPEINFO pTypeInfo, LPTYPEATTR pta,
+   CComBSTR **mNames, DISPID **mIDs, int *nmeth)
+{
+  CComBSTR *names = NULL;
+  DISPID   *ids = NULL;
+  int m_nCount;
+
+  m_nCount = pta->cFuncs;
+  *nmeth = m_nCount;
+  names = m_nCount == 0 ? NULL : new CComBSTR[m_nCount];
+  ids = m_nCount == 0 ? NULL : new DISPID[m_nCount];
+  for (int i=0; i<m_nCount; i++)
+  {
+    FUNCDESC* pfd;
+    if (SUCCEEDED(pTypeInfo->GetFuncDesc(i, &pfd)))
+    {
+      CComBSTR bstrName;
+      if (SUCCEEDED(pTypeInfo->GetDocumentation(pfd->memid, &bstrName, NULL, NULL, NULL)))
+      {
+        names[i].Attach(bstrName.Detach());
+        ids[i] = pfd->memid;
+        /*
+        USES_CONVERSION;
+        printf("map:%d -> %s\n", ids[i], W2A((OLECHAR *)names[i]));
+        */
+      }
+      pTypeInfo->ReleaseFuncDesc(pfd);
+    }
+  }
+  *mNames = names;
+  *mIDs = ids;
+}
+
+#define IMPLTYPE_MASK \
+  (IMPLTYPEFLAG_FDEFAULT | IMPLTYPEFLAG_FSOURCE | IMPLTYPEFLAG_FRESTRICTED)
+
+#define IMPLTYPE_DEFAULTSOURCE \
+  (IMPLTYPEFLAG_FDEFAULT | IMPLTYPEFLAG_FSOURCE)
+
+BOOL GetEventIID(IUnknown *m_pObject, IID* piid,
+     CComBSTR **mNames, DISPID **mIDs, int *nmeth,LPOLESTR bsProgId)
+{
+  *piid = GUID_NULL;
+  ATLASSERT(m_pObject != NULL);
+  // I Always use IProvideClassInfo rather than IProvideClassInfo2
+  // since I also need to create a mapping from dispid to name
+  LPPROVIDECLASSINFO pPCI = NULL;
+  LPTYPEINFO pClassInfo = NULL;
+  if (SUCCEEDED(m_pObject->QueryInterface(IID_IProvideClassInfo, (LPVOID*)&pPCI)))
+  {
+    //printf("got IProvideClassInfo\n");
+    ATLASSERT(pPCI != NULL);
+		HRESULT hr = pPCI->GetClassInfo(&pClassInfo);
+    pPCI->Release();
+    if (!SUCCEEDED(hr)) return false;
+  }
+  else if (getClassInfoFromProgId(bsProgId,&pClassInfo)) {
+	}
+	else  {
+    printf("GetEventIID: couldn't get IProvideClassInfo\n");
+		return false;
+  }
+
+  return MapEventIIDs(piid, mNames, mIDs, nmeth, bsProgId, pClassInfo);
+}
+
+BOOL MapEventIIDs(IID* piid,
+     CComBSTR **mNames, DISPID **mIDs, int *nmeth, LPOLESTR bsProgId, LPTYPEINFO pClassInfo)
+{
+      ATLASSERT(pClassInfo != NULL);
+      //printf("MapEventIIDs: got past ClassInfo assert\n");
+      LPTYPEATTR pClassAttr;
+      if (SUCCEEDED(pClassInfo->GetTypeAttr(&pClassAttr)))
+      {
+        //printf("MapEventIIDs: got TypeAttr\n");
+        ATLASSERT(pClassAttr != NULL);
+        ATLASSERT(pClassAttr->typekind == TKIND_COCLASS);
+
+        // Search for typeinfo of the default events interface.
+        int nFlags;
+        HREFTYPE hRefType;
+
+		//printf("MapEventIIDs: looking at %d class attribute impl types \n");
+        for (unsigned int i = 0; i < pClassAttr->cImplTypes; i++)
+        {
+          if (SUCCEEDED(pClassInfo->GetImplTypeFlags(i, &nFlags)) &&
+            ((nFlags & IMPLTYPE_MASK) == IMPLTYPE_DEFAULTSOURCE))
+          {
+            // Found it.  Now look at its attributes to get IID.
+            LPTYPEINFO pEventInfo = NULL;
+            if (SUCCEEDED(pClassInfo->GetRefTypeOfImplType(i,
+                &hRefType)) &&
+              SUCCEEDED(pClassInfo->GetRefTypeInfo(hRefType,
+                &pEventInfo)))
+            {
+              ATLASSERT(pEventInfo != NULL);
+              LPTYPEATTR pEventAttr;
+              if (SUCCEEDED(pEventInfo->GetTypeAttr(&pEventAttr)))
+              {
+                ATLASSERT(pEventAttr != NULL);
+
+                // create a mapping from dispid to string
+                LoadNameCache(pEventInfo, pEventAttr,
+                              mNames, mIDs, nmeth);
+
+                *piid = pEventAttr->guid;
+                pEventInfo->ReleaseTypeAttr(pEventAttr);
+              }
+              pEventInfo->Release();
+            }
+            break;
+          }
+        }
+        pClassInfo->ReleaseTypeAttr(pClassAttr);
+      }
+      pClassInfo->Release();
+
+  return (!IsEqualIID(*piid, GUID_NULL));
+}
+
+BOOL getClassInfoFromProgId(LPOLESTR bsProgId,LPTYPEINFO *pClassInfo)
+{
+  USES_CONVERSION;
+  CLSID clsid;
+  GUID libid;
+  if (FAILED(CLSIDFromProgID(bsProgId, &clsid))) return false;
+  if (FAILED(StringFromCLSID(clsid,&bsProgId))) return false;
+  HKEY keySoftware, keyClasses, keyCLSID, keyXXXX, keyTypeLib;
+  DWORD dwType, dwCountData=50;
+  BYTE abData[50];
+  LONG lVal;
+  lVal = RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("SOFTWARE"),0,KEY_READ,&keySoftware);
+  if (lVal==ERROR_SUCCESS) {
+		lVal = RegOpenKeyEx(keySoftware,_T("Classes"),0,KEY_READ,&keyClasses);
+		if (lVal==ERROR_SUCCESS) {
+			lVal = RegOpenKeyEx(keyClasses,_T("CLSID"),0,KEY_READ,&keyCLSID);
+			if (lVal==ERROR_SUCCESS) {
+				_TCHAR *tsProgId = W2T(bsProgId);
+				lVal = RegOpenKeyEx(keyCLSID,tsProgId,0,KEY_READ,&keyXXXX);
+				if (lVal==ERROR_SUCCESS) {
+					lVal = RegOpenKeyEx(keyXXXX,_T("TypeLib"),0,KEY_READ,&keyTypeLib);
+					if (lVal==ERROR_SUCCESS) {
+						lVal = RegQueryValueExA(keyTypeLib,NULL,NULL,&dwType,abData,&dwCountData);
+						RegCloseKey(keyTypeLib);
+				  }
+					RegCloseKey(keyXXXX);
+			  }
+				RegCloseKey(keyCLSID);
+			}
+			RegCloseKey(keyClasses);
+		}
+		RegCloseKey(keySoftware);
+  }
+  if (lVal!=ERROR_SUCCESS) return false;
+  BSTR bsLibId = A2BSTR((char*)abData);
+  if (FAILED(CLSIDFromString(bsLibId,&libid))) return false;
+  //Try loading from registry information.
+  ITypeLib* pITypeLib;
+  if (FAILED(LoadRegTypeLib(libid,1,0, LANG_NEUTRAL, &pITypeLib))) return false;
+  //Find ITypeInfo for coclass.
+  pITypeLib->GetTypeInfoOfGuid(clsid, pClassInfo);
+  pITypeLib->Release();
+  return true;
+}
+
+/*
+ * Get the class info from the progId using the given typeLib.
+ */
+BOOL getClassInfoFromProgIdTypeLib(BSTR typeLib, LPOLESTR bsProgId, LPTYPEINFO *pClassInfo)
+{
+  USES_CONVERSION;
+  CLSID clsid;
+
+  if (FAILED(CLSIDFromProgID(bsProgId, &clsid))) return false;
+  if (FAILED(StringFromCLSID(clsid,&bsProgId))) return false;
+
+  ITypeLib* pITypeLib;
+  if (FAILED(LoadTypeLib(typeLib, &pITypeLib)))	return false;
+
+  //Find ITypeInfo for coclass.
+  pITypeLib->GetTypeInfoOfGuid(clsid, pClassInfo);
+  pITypeLib->Release();
+  return true;
+}
+
+BOOL GetEventIIDForTypeLib(BSTR typeLib, IID* piid,
+     CComBSTR **mNames, DISPID **mIDs, int *nmeth,LPOLESTR bsProgId)
+{
+  LPTYPEINFO pClassInfo = NULL;
+  if(getClassInfoFromProgIdTypeLib(typeLib, bsProgId,&pClassInfo))
+  {
+  	if (pClassInfo == NULL){
+  		printf("we had a successful return but pClassInfo is null\n");
+  	}
+    return MapEventIIDs(piid, mNames, mIDs, nmeth, bsProgId, pClassInfo);
+  }
+  else
+  {
+    printf("GetEventIIDForTypeLib: couldn't get IProvideClassInfo\n");
+    return false;
+  }
+}
+
+}

cpp/jacob/DispatchEvents.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class DispatchEvents */
+
+#ifndef _Included_DispatchEvents
+#define _Included_DispatchEvents
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     com_jacob_com_DispatchEvents
+ * Method:    init3
+ * Signature: (Lcom/jacob/com/Dispatch;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_init3
+  (JNIEnv *, jobject, jobject, jobject, jstring, jstring);
+
+/*
+ * Class:     DispatchEvents
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchEvents_release
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+

cpp/jacob/DispatchProxy.cpp

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "ComThread.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+// extract a IStream from a jobject
+IStream *extractStream(JNIEnv *env, jobject arg)
+{
+  jclass argClass = env->GetObjectClass(arg);
+  jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "I");
+  jint anum = env->GetIntField(arg, ajf);
+  IStream *v = (IStream *)anum;
+  return v;
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_MarshalIntoStream
+  (JNIEnv *env, jobject _this, jobject disp)
+{
+  IDispatch *pIDispatch = extractDispatch(env, disp);
+  if (!pIDispatch) return;
+  IStream *ps; // this is the stream we will marshall into
+  HRESULT hr = CoMarshalInterThreadInterfaceInStream(
+                 IID_IDispatch, pIDispatch, &ps);
+  if (!SUCCEEDED(hr))
+  {
+    ThrowComFail(env, "Could not Marshal Dispatch into IStream", hr);
+    return;
+  }
+  // store the stream pointer on the object
+  jclass argClass = env->GetObjectClass(_this);
+  jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "I");
+  env->SetIntField(_this, ajf, (jint)ps);
+}
+
+JNIEXPORT jobject JNICALL Java_com_jacob_com_DispatchProxy_MarshalFromStream
+  (JNIEnv *env, jobject _this)
+{
+  IStream *ps = extractStream(env, _this);
+  if (!ps) 
+  {
+    ThrowComFail(env, "Could not get IStream from DispatchProxy", -1);
+    return NULL;
+  }
+  IDispatch *pD;
+  HRESULT hr = CoGetInterfaceAndReleaseStream(ps, IID_IDispatch, (void **)&pD);
+  // zero out the stream pointer on the object
+  // since the stream can only be read once
+  jclass argClass = env->GetObjectClass(_this);
+  jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "I");
+  env->SetIntField(_this, ajf, (unsigned int)0);
+
+  if (!SUCCEEDED(hr))
+  {
+    ThrowComFail(env, "Could not Marshal Dispatch from IStream", hr);
+    return NULL;
+  }
+  jclass autoClass = env->FindClass("com/jacob/com/Dispatch");
+  jmethodID autoCons = env->GetMethodID(autoClass, "<init>", "(I)V");
+  // construct a Dispatch object to return
+  // I am copying the pointer to java
+  if (pD) pD->AddRef();
+  jobject newAuto = env->NewObject(autoClass, autoCons, pD);
+  return newAuto;
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_release
+  (JNIEnv *env, jobject _this)
+{
+  IStream *ps =  extractStream(env, _this);
+  if (ps) {
+    ps->Release();
+		jclass argClass = env->GetObjectClass(_this);
+    jfieldID ajf = env->GetFieldID( argClass, "m_pStream", "I");
+    env->SetIntField(_this, ajf, (unsigned int)0);
+  }
+}
+
+}

cpp/jacob/DispatchProxy.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_DispatchProxy */
+
+#ifndef _Included_com_jacob_com_DispatchProxy
+#define _Included_com_jacob_com_DispatchProxy
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_DispatchProxy
+ * Method:    MarshalIntoStream
+ * Signature: (Lcom/jacob/com/Dispatch;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_MarshalIntoStream
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_DispatchProxy
+ * Method:    MarshalFromStream
+ * Signature: ()Lcom/jacob/com/Dispatch;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_DispatchProxy_MarshalFromStream
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_DispatchProxy
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_DispatchProxy_release
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/EnumVariant.cpp

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "Dispatch.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+/**
+ * An implementation of IEnumVariant based on code submitted by
+ * Thomas Hallgren (mailto:Thomas.Hallgren@eoncompany.com)
+ */
+extern "C"
+{
+
+// extract a IDispatch from a jobject
+IEnumVARIANT* extractEnumVariant(JNIEnv* env, jobject arg)
+{
+  jfieldID FID_pIEnumVARIANT = 0;
+  jclass clazz = env->GetObjectClass(arg);
+  FID_pIEnumVARIANT = env->GetFieldID(clazz, "m_pIEnumVARIANT", "I");
+  return (IEnumVARIANT*)env->GetIntField(arg, FID_pIEnumVARIANT);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_jacob_com_EnumVariant_Next(JNIEnv* env, jobject _this, jobjectArray vars)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+	//printf("self=%x\n", self);
+  if(self == NULL)
+    return 0;
+
+  ULONG count = (ULONG)env->GetArrayLength(vars);
+  if(count == 0)
+    return 0;
+
+  VARIANT* sink = (VARIANT*)CoTaskMemAlloc(count * sizeof(VARIANT));
+  ULONG fetchCount = 0;
+
+  HRESULT hr = self->Next(count, sink, &fetchCount);
+  if(FAILED(hr))
+  {
+    CoTaskMemFree(sink);
+    ThrowComFail(env, "IEnumVARIANT::Next", hr);
+    return 0;
+  }
+
+  // prepare a new return value array
+  //
+  jclass    clazz = env->FindClass("com/jacob/com/Variant");
+  jmethodID ctor  = env->GetMethodID(clazz, "<init>", "()V");
+
+  for(ULONG idx = 0; idx < fetchCount; ++idx)
+  {
+    // construct a variant to return
+    //
+    jobject newVariant = env->NewObject(clazz, ctor);
+    VARIANT* v = extractVariant(env, newVariant);
+    VariantCopy(v, sink + idx);
+    env->SetObjectArrayElement(vars, idx, newVariant);
+    env->DeleteLocalRef(newVariant);
+    //Sourceforge-1674179 fix memory leak
+    // Variants received while iterating IEnumVARIANT must be cleared when no longer needed
+    // The variant has been copied so no longer needed
+    VariantClear(sink);
+  }
+  CoTaskMemFree(sink);
+  return (jint)fetchCount;
+}
+
+JNIEXPORT void JNICALL
+Java_com_jacob_com_EnumVariant_release(JNIEnv* env, jobject _this)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+  if(self != NULL)
+  {
+    self->Release();
+    jfieldID FID_pIEnumVARIANT = 0;
+    jclass clazz = env->GetObjectClass(_this);
+    FID_pIEnumVARIANT = env->GetFieldID(clazz, "m_pIEnumVARIANT", "I");
+    env->SetIntField(_this, FID_pIEnumVARIANT, (unsigned int)0);
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_com_jacob_com_EnumVariant_Reset(JNIEnv* env, jobject _this)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+  if(self == NULL)
+    return;
+
+  HRESULT hr = self->Reset();
+  if(FAILED(hr))
+    ThrowComFail(env, "IEnumVARIANT::Reset", hr);
+}
+
+JNIEXPORT void JNICALL
+Java_com_jacob_com_EnumVariant_Skip(JNIEnv* env, jobject _this, jint count)
+{
+  IEnumVARIANT* self = extractEnumVariant(env, _this);
+  if(self == NULL)
+    return;
+
+  HRESULT hr = self->Skip((ULONG)count);
+  if(FAILED(hr))
+    ThrowComFail(env, "IEnumVARIANT::Skip", hr);
+}
+
+}

cpp/jacob/EnumVariant.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef _Included_EnumVariant
+#define _Included_EnumVariant
+
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Next
+ * Signature: ([Lcom/jacob/com/Variant;)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_EnumVariant_Next
+  (JNIEnv *, jobject, jobjectArray);
+
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_EnumVariant_release
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Reset
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_EnumVariant_Reset
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_EnumVariant
+ * Method:    Skip
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_EnumVariant_Skip
+  (JNIEnv *, jobject, jint);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/EventProxy.cpp

@@ -0,0 +1,870 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "EventProxy.h"
+#include "Variant.h"
+
+// hook myself up as a listener for delegate
+EventProxy::EventProxy(JNIEnv *env, 
+		jobject aSinkObj, 
+        CComPtr<IConnectionPoint> pConn,
+        IID eid, 
+        CComBSTR mName[], 
+        DISPID mID[], 
+        int mNum) :
+   // initialize some variables
+   m_cRef(0), pCP(pConn), 
+   eventIID(eid), MethNum(mNum), MethName(mName), 
+   MethID(mID)
+{
+	// keep a pointer to the sink
+	javaSinkObj = env->NewGlobalRef(aSinkObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+	// we need this to attach to the event invocation thread
+	env->GetJavaVM(&jvm);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	AddRef();
+    Connect(env);
+}
+
+void EventProxy::Connect(JNIEnv *env) {
+  HRESULT hr = pCP->Advise(this, &dwEventCookie);
+  if (SUCCEEDED(hr)) {
+        connected = 1;
+  } else {
+        connected = 0;
+    ThrowComFail(env, "Advise failed", hr);
+  }
+}
+
+// unhook myself up as a listener and get rid of delegate
+EventProxy::~EventProxy()
+{
+	JNIEnv *env;
+    Disconnect();
+    jint vmConnectionStatus = JNI_EVERSION ;
+    jint attachReturnStatus = -1; // AttachCurrentThread return status.. negative numbers are failure return codes.
+    
+	// attach to the current running thread -- JDK 1.4 jni.h has two param cover for 3 param call
+    vmConnectionStatus = jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
+		if ((env != NULL)&& env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+   	if (vmConnectionStatus == JNI_EDETACHED){
+		//printf("Unhook: Attaching to current thread using JNI Version 1.2 (%d)\n",vmConnectionStatus);
+		JavaVMAttachArgs attachmentArgs; 
+        attachmentArgs.version = JNI_VERSION_1_2;  
+        attachmentArgs.name = NULL; 
+        attachmentArgs.group = NULL; 
+        attachReturnStatus = jvm->AttachCurrentThread((void **)&env, &attachmentArgs); 
+		if ((env != NULL) && env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+   	} else {
+   		// should really look for JNI_OK versus an error because it could have been JNI_EVERSION
+   		// started method with thread hooked to VM so no need to attach again
+   		//printf("Unhook:  No need to attach because already attached %d\n",vmConnectionStatus);
+   	}
+
+   	// we should always have an env by this point but lets be paranoid and check
+	if (env != NULL){
+		env->DeleteGlobalRef(javaSinkObj);
+			if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	}
+	if (MethNum) {
+	    delete [] MethName;
+	    delete [] MethID;
+	}
+	// detach from thread only if we attached to it in this function
+	if (attachReturnStatus == 0){
+		jvm->DetachCurrentThread();
+		//printf("Unhook: Detached\n");
+	} else {
+		//printf("Unhook: No need to detatch because attached prior to method\n");
+	}
+  	//fflush(stdout);
+}
+
+void EventProxy::Disconnect() {
+    if (connected) {
+        pCP->Unadvise(dwEventCookie);
+    }
+}
+
+// I only support the eventIID interface which was passed in
+// by the DispatchEvent wrapper who looked it up as the
+// source object's default source interface
+STDMETHODIMP EventProxy::QueryInterface(REFIID rid, void **ppv)
+{
+  if (rid == IID_IUnknown || rid == eventIID || rid == IID_IDispatch) 
+  {
+    *ppv = this;
+    AddRef();
+    return S_OK;
+  }
+  return E_NOINTERFACE;
+}
+
+// This should never get called - the event source fires events
+// by dispid's, not by name
+STDMETHODIMP EventProxy::GetIDsOfNames(REFIID riid,
+    OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID *rgDispID)
+{
+  return E_UNEXPECTED;
+}
+
+// The actual callback from the connection point arrives here
+STDMETHODIMP EventProxy::Invoke(DISPID dispID, REFIID riid,
+    LCID lcid, unsigned short wFlags, DISPPARAMS *pDispParams,
+    VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
+{
+  	const char 	*eventMethodName = NULL; //Sourceforge report 1394001 
+  	JNIEnv      *env = NULL;
+
+  // map dispID to jmethodID
+  for(int i=0;i<MethNum;i++) 
+  {
+    if (MethID[i] == dispID) { 
+		USES_CONVERSION;
+		eventMethodName = W2A((OLECHAR *)MethName[i]);
+    	}
+  }
+  // added 1.12
+  if (!eventMethodName) {
+  	// just bail if can't find signature.  no need to attach
+	// printf("Invoke: didn't find method name for dispatch id %d\n",dispID);
+   	return S_OK;
+  }
+  if (DISPATCH_METHOD & wFlags) 
+  {
+        
+    // attach to the current running thread
+	//printf("Invoke: Attaching to current thread using JNI Version 1.2\n");
+		JavaVMAttachArgs attachmentArgs; 
+        attachmentArgs.version = JNI_VERSION_1_2;  
+        attachmentArgs.name = NULL; 
+        attachmentArgs.group = NULL; 
+        jvm->AttachCurrentThread((void **)&env, &attachmentArgs); 
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+	if (!eventMethodName) 
+  	{
+	    // could not find this signature in list
+  		// printf("Invoke: didn't find method name for dispatch id %d\n",dispID);
+  		// this probably leaves a native thread attached to the vm when we don't want it
+  		ThrowComFail(env, "Event method received was not defined as part of callback interface", -1);
+  		
+  		// should we detatch before returning?? We probably never get here if we ThrowComFail()
+	    // jvm->DetachCurrentThread();
+    	return S_OK;
+	  }
+
+	// find the class of the InvocationHandler
+   	jclass javaSinkClass = env->GetObjectClass(javaSinkObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Got sink class\n");
+    jmethodID invokeMethod;
+    invokeMethod = env->GetMethodID(javaSinkClass, "invoke", "(Ljava/lang/String;[Lcom/jacob/com/Variant;)Lcom/jacob/com/Variant;");
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+    jstring eventMethodNameAsString = env->NewStringUTF(eventMethodName);
+	//printf("Invoke: Got method name\n");
+	// now do what we need for the variant
+    jmethodID getVariantMethod = env->GetMethodID(javaSinkClass, "getVariant", "()Lcom/jacob/com/Variant;");
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Found way too getVariant\n");
+    jobject aVariantObj = env->CallObjectMethod(javaSinkObj, getVariantMethod); 
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Made Variant\n");
+   	jclass variantClass = env->GetObjectClass(aVariantObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+	// create the variant parameter array
+    // how many params
+    int numVariantParams = pDispParams->cArgs;
+    // make an array of them
+    jobjectArray varr = env->NewObjectArray(numVariantParams, variantClass, 0);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	//printf("Invoke: Created Array\n");
+    int i,j;
+    for(i=numVariantParams-1,j=0;i>=0;i--,j++) 
+    {
+      // construct a java variant holder
+	  jobject arg = env->CallObjectMethod(javaSinkObj, getVariantMethod); 
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+      // get the empty variant from it
+      VARIANT *va = extractVariant(env, arg);
+      // copy the value
+      VariantCopy(va, &pDispParams->rgvarg[i]);
+      // put it in the array
+      env->SetObjectArrayElement(varr, j, arg);
+	  env->DeleteLocalRef(arg);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+    }
+	//printf("Invoke: Filled Array\n");
+    // Set up the return value
+    jobject ret;
+
+    ret = env->CallObjectMethod(javaSinkObj, invokeMethod, 
+		eventMethodNameAsString, varr); 
+	//printf("Invoke: Invoked callback\n");
+    if (!env->ExceptionOccurred() && ret != NULL) {
+        VariantCopy(pVarResult, extractVariant(env,ret));
+    }
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+	// don't need the first variant we created to get the class
+	// SF 1689061 change not accepted but put in as comment for later reminder
+    //Java_com_jacob_com_Variant_release(env, aVariantObj);
+	env->DeleteLocalRef(aVariantObj);
+		if (env->ExceptionOccurred()) { env->ExceptionDescribe(); env->ExceptionClear();}
+
+    // Begin code from Jiffie team that copies parameters back from java to COM
+    for(i=numVariantParams-1,j=0;i>=0;i--,j++) 
+    {
+		jobject arg = env->GetObjectArrayElement(varr, j);
+		VARIANT *java = extractVariant(env, arg);
+		VARIANT *com = &pDispParams->rgvarg[i];
+		convertJavaVariant(java, com);
+		// SF 1689061 change not accepted but put in as comment for later reminder
+		//Java_com_jacob_com_Variant_release(env, arg);
+		zeroVariant(env, arg);
+		env->DeleteLocalRef(arg);
+    }
+    // End code from Jiffie team that copies parameters back from java to COM
+    // detach from thread
+	//printf("Invoke: Detatching\n");
+	jvm->DetachCurrentThread();
+  	//fflush(stdout);
+    return S_OK;
+  }
+  return E_NOINTERFACE;
+}
+
+void EventProxy::convertJavaVariant(VARIANT *java, VARIANT *com) {
+
+	  switch (com->vt)
+	  {	  
+		case VT_DISPATCH:
+		{
+			switch (java->vt)
+			{
+				case VT_DISPATCH:
+				{
+					V_DISPATCH(com) = V_DISPATCH(java);
+					break;
+				}
+
+				case VT_DISPATCH | VT_BYREF:
+				{
+					V_DISPATCH(com) = *V_DISPATCHREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_DISPATCH | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_DISPATCH:
+				{
+					*V_DISPATCHREF(com) = V_DISPATCH(java);
+					break;
+				}
+
+				case VT_DISPATCH | VT_BYREF:
+				{
+					*V_DISPATCHREF(com) = *V_DISPATCHREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_BOOL:
+		{
+			switch (java->vt)
+			{
+				case VT_BOOL:
+				{
+					V_BOOL(com) = V_BOOL(java);
+					break;
+				}
+
+				case VT_BOOL | VT_BYREF:
+				{
+					V_BOOL(com) = *V_BOOLREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_BOOL | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_BOOL:
+				{
+					*V_BOOLREF(com) = V_BOOL(java);
+					break;
+				}
+
+				case VT_BOOL | VT_BYREF:
+				{
+					*V_BOOLREF(com) = *V_BOOLREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI1:
+		{
+			switch (java->vt)
+			{
+				case VT_UI1:
+				{
+					V_UI1(com) = V_UI1(java);
+					break;
+				}
+
+				case VT_UI1 | VT_BYREF:
+				{
+					V_UI1(com) = *V_UI1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI1 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UI1:
+				{
+					*V_UI1REF(com) = V_UI1(java);
+					break;
+				}
+
+				case VT_UI1 | VT_BYREF:
+				{
+					*V_UI1REF(com) = *V_UI1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+
+		case VT_I2:
+		{
+			switch (java->vt)
+			{
+				case VT_I2:
+				{
+					V_I2(com) = V_I2(java);
+					break;
+				}
+
+				case VT_I2 | VT_BYREF:
+				{
+					V_I2(com) = *V_I2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I2 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_I2:
+				{
+					*V_I2REF(com) = V_I2(java);
+					break;
+				}
+
+				case VT_I2 | VT_BYREF:
+				{
+					*V_I2REF(com) = *V_I2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I4:
+		{
+			switch (java->vt)
+			{
+				case VT_I4:
+				{
+					V_I4(com) = V_I4(java);
+					break;
+				}
+
+				case VT_I4 | VT_BYREF:
+				{
+					V_I4(com) = *V_I4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I4 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_I4:
+				{
+					*V_I4REF(com) = V_I4(java);
+					break;
+				}
+
+				case VT_I4 | VT_BYREF:
+				{
+					*V_I4REF(com) = *V_I4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R4:
+		{
+			switch (java->vt)
+			{
+				case VT_R4:
+				{
+					V_R4(com) = V_R4(java);
+					break;
+				}
+
+				case VT_R4 | VT_BYREF:
+				{
+					V_R4(com) = *V_R4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R4 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_R4:
+				{
+					*V_R4REF(com) = V_R4(java);
+					break;
+				}
+
+				case VT_R4 | VT_BYREF:
+				{
+					*V_R4REF(com) = *V_R4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R8:
+		{
+			switch (java->vt)
+			{
+				case VT_R8:
+				{
+					V_R8(com) = V_R8(java);
+					break;
+				}
+
+				case VT_R8 | VT_BYREF:
+				{
+					V_R8(com) = *V_R8REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_R8 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_R8:
+				{
+					*V_R8REF(com) = V_R8(java);
+					break;
+				}
+
+				case VT_R8 | VT_BYREF:
+				{
+					*V_R8REF(com) = *V_R8REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_I1:
+		{
+			switch (java->vt)
+			{
+				case VT_I1:
+				{
+					V_I1(com) = V_I1(java);
+					break;
+				}
+
+				case VT_I1 | VT_BYREF:
+				{
+					V_I1(com) = *V_I1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_I1 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_I1:
+				{
+					*V_I1REF(com) = V_I1(java);
+					break;
+				}
+
+				case VT_I1 | VT_BYREF:
+				{
+					*V_I1REF(com) = *V_I1REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_UI2:
+		{
+			switch (java->vt)
+			{
+				case VT_UI2:
+				{
+					V_UI2(com) = V_UI2(java);
+					break;
+				}
+
+				case VT_UI2 | VT_BYREF:
+				{
+					V_UI2(com) = *V_UI2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI2 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UI2:
+				{
+					*V_UI2REF(com) = V_UI2(java);
+					break;
+				}
+
+				case VT_UI2 | VT_BYREF:
+				{
+					*V_UI2REF(com) = *V_UI2REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_UI4:
+		{
+			switch (java->vt)
+			{
+				case VT_UI4:
+				{
+					V_UI4(com) = V_UI4(java);
+					break;
+				}
+
+				case VT_UI4 | VT_BYREF:
+				{
+					V_UI4(com) = *V_UI4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UI4 | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UI4:
+				{
+					*V_UI4REF(com) = V_UI4(java);
+					break;
+				}
+
+				case VT_UI4 | VT_BYREF:
+				{
+					*V_UI4REF(com) = *V_UI4REF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_INT:
+		{
+			switch (java->vt)
+			{
+				case VT_INT:
+				{
+					V_INT(com) = V_INT(java);
+					break;
+				}
+
+				case VT_INT | VT_BYREF:
+				{
+					V_INT(com) = *V_INTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_INT | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_INT:
+				{
+					*V_INTREF(com) = V_INT(java);
+					break;
+				}
+
+				case VT_INT | VT_BYREF:
+				{
+					*V_INTREF(com) = *V_INTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_UINT:
+		{
+			switch (java->vt)
+			{
+				case VT_UINT:
+				{
+					V_UINT(com) = V_UINT(java);
+					break;
+				}
+
+				case VT_UINT | VT_BYREF:
+				{
+					V_UINT(com) = *V_UINTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_UINT | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_UINT:
+				{
+					*V_UINTREF(com) = V_UINT(java);
+					break;
+				}
+
+				case VT_UINT | VT_BYREF:
+				{
+					*V_UINTREF(com) = *V_UINTREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_CY:
+		{
+			switch (java->vt)
+			{
+				case VT_CY:
+				{
+					V_CY(com) = V_CY(java);
+					break;
+				}
+
+				case VT_CY | VT_BYREF:
+				{
+					V_CY(com) = *V_CYREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_CY | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_CY:
+				{
+					*V_CYREF(com) = V_CY(java);
+					break;
+				}
+
+				case VT_CY | VT_BYREF:
+				{
+					*V_CYREF(com) = *V_CYREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_DATE:
+		{
+			switch (java->vt)
+			{
+				case VT_DATE:
+				{
+					V_DATE(com) = V_DATE(java);
+					break;
+				}
+
+				case VT_DATE | VT_BYREF:
+				{
+					V_DATE(com) = *V_DATEREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_DATE | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_DATE:
+				{
+					*V_DATEREF(com) = V_DATE(java);
+					break;
+				}
+
+				case VT_DATE | VT_BYREF:
+				{
+					*V_DATEREF(com) = *V_DATEREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_BSTR:
+		{
+			switch (java->vt)
+			{
+				case VT_BSTR:
+				{
+					V_BSTR(com) = V_BSTR(java);
+					break;
+				}
+
+				case VT_BSTR | VT_BYREF:
+				{
+					V_BSTR(com) = *V_BSTRREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_BSTR | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_BSTR:
+				{
+					*V_BSTRREF(com) = V_BSTR(java);
+					break;
+				}
+
+				case VT_BSTR | VT_BYREF:
+				{
+					*V_BSTRREF(com) = *V_BSTRREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+				case VT_DECIMAL:
+		{
+			switch (java->vt)
+			{
+				case VT_DECIMAL:
+				{
+					V_DECIMAL(com) = V_DECIMAL(java);
+					break;
+				}
+
+				case VT_DECIMAL | VT_BYREF:
+				{
+					V_DECIMAL(com) = *V_DECIMALREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+		case VT_DECIMAL | VT_BYREF:
+		{
+			switch (java->vt)
+			{
+				case VT_DECIMAL:
+				{
+					*V_DECIMALREF(com) = V_DECIMAL(java);
+					break;
+				}
+
+				case VT_DECIMAL | VT_BYREF:
+				{
+					*V_DECIMALREF(com) = *V_DECIMALREF(java);
+					break;
+				}
+			}
+			break;
+		}
+
+
+    }
+}

cpp/jacob/EventProxy.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+#include <windows.h>
+#include <objbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "stdafx.h"
+#include "util.h"
+
+/*
+ * An instance of this class stands between a connection point
+ * and a java object. When it gets invoked from the cp, it reflects
+ * the call into the java object dynamically. The eventIID is passed
+ * in as are the valid dispids and the corresponding names. A map
+ * is created between the dispids and the java object's method in
+ * the constructor. For now, all the java event methods have to have
+ * the same signature: <name>(Variant[])
+ */
+class EventProxy : public IDispatch
+{
+private:
+  int     connected;
+  LONG    m_cRef;		// a reference counter
+  CComPtr<IConnectionPoint> pCP; // the connection point
+  DWORD   dwEventCookie; // connection point cookie
+  jobject javaSinkObj;   // the java object to delegate calls
+
+  IID     eventIID;      // the interface iid passed in
+  int     MethNum;		// number of methods in the callback interface
+  CComBSTR *MethName;   // Array of method names
+  DISPID   *MethID;     // Array of method ids, used to match invokations to method names
+  JavaVM   *jvm;        // The java vm we are running
+  void convertJavaVariant(VARIANT *java, VARIANT *com);
+  void Connect(JNIEnv *env);
+  void Disconnect();
+public:
+  // constuct with a global JNI ref to a sink object
+  // to which we will delegate event callbacks
+  EventProxy(JNIEnv *jenv, 
+  		jobject aSinkObj, 
+        CComPtr<IConnectionPoint> pConn, 
+        IID eventIID, 
+        CComBSTR *mName, 
+        DISPID *mID, 
+        int mNum);
+  ~EventProxy();
+
+  // IUnknown methods
+  STDMETHODIMP_(ULONG) AddRef(void) 
+  {
+    LONG res = InterlockedIncrement(&m_cRef);
+    return res;
+  }
+
+  STDMETHODIMP_(ULONG) Release(void)
+  {
+    LONG res = InterlockedDecrement(&m_cRef);
+    if (res == 0) {
+    	delete this;
+    }
+    return res;
+    
+  }
+
+  STDMETHODIMP QueryInterface(REFIID rid, void **ppv);
+   
+  // IDispatch methods
+  STDMETHODIMP GetTypeInfoCount(UINT *num) 
+  {
+    *num = 0;
+    return S_OK;
+  }
+
+  STDMETHODIMP GetTypeInfo(UINT, LCID, ITypeInfo **pptInfo)
+  {
+    *pptInfo=NULL;
+    return E_NOTIMPL;
+  }
+
+  // These are the actual supported methods
+  STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR **, UINT, LCID , DISPID *);
+  STDMETHODIMP Invoke(DISPID, REFIID, LCID, WORD , DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *);
+};

cpp/jacob/STA.cpp

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "stdafx.h"
+#include <objbase.h>
+#include "ComThread.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_doMessagePump
+  (JNIEnv *env, jobject obj)
+{
+  // store the current thread id so we can kill it
+  jclass argClass = env->GetObjectClass(obj);
+  jfieldID ajf = env->GetFieldID( argClass, "threadID", "I");
+  jint threadID = (jint)GetCurrentThreadId();
+  env->SetIntField(obj, ajf, threadID);
+
+  MSG msg;
+
+  ZeroMemory(&msg, sizeof(msg));
+  msg.wParam = S_OK;
+
+  while (GetMessage(&msg, NULL, 0, 0))
+  {
+    DispatchMessage(&msg);
+  }
+}
+
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_quitMessagePump
+  (JNIEnv *env, jobject obj)
+{
+  jclass argClass = env->GetObjectClass(obj);
+  jfieldID ajf = env->GetFieldID( argClass, "threadID", "I");
+  jint threadID = env->GetIntField(obj, ajf);
+  PostThreadMessage((DWORD)threadID, WM_QUIT, 0, 0);
+}
+
+}

cpp/jacob/STA.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class STA */
+
+#ifndef _Included_com_jacob_com_STA
+#define _Included_com_jacob_com_STA
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     com_jacob_com_STA
+ * Method:    doMessagePump
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_doMessagePump
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_STA
+ * Method:    quitMessagePump
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_STA_quitMessagePump
+  (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/SafeArray.h

@@ -0,0 +1,940 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_SafeArray */
+
+#ifndef _Included_com_jacob_com_SafeArray
+#define _Included_com_jacob_com_SafeArray
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Inaccessible static: buildVersion */
+/* Inaccessible static: buildDate */
+/* Inaccessible static: DEBUG */
+/* Inaccessible static: class_00024com_00024jacob_00024com_00024JacobObject */
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    init
+ * Signature: (I[I[I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_init
+  (JNIEnv *, jobject, jint, jintArray, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    clone
+ * Signature: ()Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_clone
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    destroy
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_destroy
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getvt
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getvt
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    reinit
+ * Signature: (Lcom/jacob/com/SafeArray;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_reinit
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    reinterpretType
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_reinterpretType
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getLBound
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getLBound__
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getLBound
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getLBound__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getUBound
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getUBound__
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getUBound
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getUBound__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getNumDim
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getNumDim
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFeatures
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getFeatures
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getElemSize
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getElemSize
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromCharArray
+ * Signature: ([C)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromCharArray
+  (JNIEnv *, jobject, jcharArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromIntArray
+ * Signature: ([I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromIntArray
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromLongArray
+ * Signature: ([L)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromLongArray
+  (JNIEnv *, jobject, jlongArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromShortArray
+ * Signature: ([S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromShortArray
+  (JNIEnv *, jobject, jshortArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromDoubleArray
+ * Signature: ([D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromDoubleArray
+  (JNIEnv *, jobject, jdoubleArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromStringArray
+ * Signature: ([Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromStringArray
+  (JNIEnv *, jobject, jobjectArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromByteArray
+ * Signature: ([B)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromByteArray
+  (JNIEnv *, jobject, jbyteArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromFloatArray
+ * Signature: ([F)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromFloatArray
+  (JNIEnv *, jobject, jfloatArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromBooleanArray
+ * Signature: ([Z)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromBooleanArray
+  (JNIEnv *, jobject, jbooleanArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    fromVariantArray
+ * Signature: ([Lcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_fromVariantArray
+  (JNIEnv *, jobject, jobjectArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toCharArray
+ * Signature: ()[C
+ */
+JNIEXPORT jcharArray JNICALL Java_com_jacob_com_SafeArray_toCharArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toIntArray
+ * Signature: ()[I
+ */
+JNIEXPORT jintArray JNICALL Java_com_jacob_com_SafeArray_toIntArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toLongArray
+ * Signature: ()[L
+ */
+JNIEXPORT jlongArray JNICALL Java_com_jacob_com_SafeArray_toLongArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toShortArray
+ * Signature: ()[S
+ */
+JNIEXPORT jshortArray JNICALL Java_com_jacob_com_SafeArray_toShortArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toDoubleArray
+ * Signature: ()[D
+ */
+JNIEXPORT jdoubleArray JNICALL Java_com_jacob_com_SafeArray_toDoubleArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toStringArray
+ * Signature: ()[Ljava/lang/String;
+ */
+JNIEXPORT jobjectArray JNICALL Java_com_jacob_com_SafeArray_toStringArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toByteArray
+ * Signature: ()[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_com_jacob_com_SafeArray_toByteArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toFloatArray
+ * Signature: ()[F
+ */
+JNIEXPORT jfloatArray JNICALL Java_com_jacob_com_SafeArray_toFloatArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toBooleanArray
+ * Signature: ()[Z
+ */
+JNIEXPORT jbooleanArray JNICALL Java_com_jacob_com_SafeArray_toBooleanArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    toVariantArray
+ * Signature: ()[Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobjectArray JNICALL Java_com_jacob_com_SafeArray_toVariantArray
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChar
+ * Signature: (I)C
+ */
+JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChar
+ * Signature: (II)C
+ */
+JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChar
+ * Signature: (IC)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar__IC
+  (JNIEnv *, jobject, jint, jchar);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChar
+ * Signature: (IIC)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar__IIC
+  (JNIEnv *, jobject, jint, jint, jchar);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChars
+ * Signature: (II[CI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getChars
+  (JNIEnv *, jobject, jint, jint, jcharArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChars
+ * Signature: (II[CI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChars
+  (JNIEnv *, jobject, jint, jint, jcharArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInt
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInt
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInt
+ * Signature: (II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInt
+ * Signature: (III)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt__III
+  (JNIEnv *, jobject, jint, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInts
+ * Signature: (II[II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getInts
+  (JNIEnv *, jobject, jint, jint, jintArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInts
+ * Signature: (II[II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInts
+  (JNIEnv *, jobject, jint, jint, jintArray, jint);
+
+/*
+ * Class:     SafeArray
+ * Method:    getLong
+ * Signature: (I)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_SafeArray_getLong__I
+  (JNIEnv *env, jobject _this, jint idx);
+
+/*
+ * Class:     SafeArray
+ * Method:    getLong
+ * Signature: (II)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_SafeArray_getLong__II
+  (JNIEnv *env, jobject _this, jint i, jint j);
+
+/*
+ * Class:     SafeArray
+ * Method:    setLong
+ * Signature: (IJ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLong__IJ
+  (JNIEnv *env, jobject _this, jint idx, jlong c);
+
+/*
+ * Class:     SafeArray
+ * Method:    setLong
+ * Signature: (IIJ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLong__IIJ
+  (JNIEnv *env, jobject _this, jint i, jint j, jlong c);
+
+/*
+ * Class:     SafeArray
+ * Method:    getLongs
+ * Signature: (II[JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getLongs
+  (JNIEnv *env, jobject _this, jint idx, jint nelem, jlongArray ja, jint ja_start);
+
+/*
+ * Class:     SafeArray
+ * Method:    setLongs
+ * Signature: (II[JI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLongs
+  (JNIEnv *env, jobject _this, jint idx, jint nelem, jlongArray ja, jint ja_start);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShort
+ * Signature: (I)S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShort
+ * Signature: (II)S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShort
+ * Signature: (IS)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort__IS
+  (JNIEnv *, jobject, jint, jshort);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShort
+ * Signature: (IIS)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort__IIS
+  (JNIEnv *, jobject, jint, jint, jshort);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShorts
+ * Signature: (II[SI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getShorts
+  (JNIEnv *, jobject, jint, jint, jshortArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShorts
+ * Signature: (II[SI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShorts
+  (JNIEnv *, jobject, jint, jint, jshortArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDouble
+ * Signature: (I)D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDouble
+ * Signature: (II)D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDouble
+ * Signature: (ID)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble__ID
+  (JNIEnv *, jobject, jint, jdouble);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDouble
+ * Signature: (IID)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble__IID
+  (JNIEnv *, jobject, jint, jint, jdouble);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDoubles
+ * Signature: (II[DI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getDoubles
+  (JNIEnv *, jobject, jint, jint, jdoubleArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDoubles
+ * Signature: (II[DI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDoubles
+  (JNIEnv *, jobject, jint, jint, jdoubleArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getString
+ * Signature: (I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getString
+ * Signature: (II)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setString
+ * Signature: (ILjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString__ILjava_lang_String_2
+  (JNIEnv *, jobject, jint, jstring);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setString
+ * Signature: (IILjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString__IILjava_lang_String_2
+  (JNIEnv *, jobject, jint, jint, jstring);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getStrings
+ * Signature: (II[Ljava/lang/String;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getStrings
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setStrings
+ * Signature: (II[Ljava/lang/String;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setStrings
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getByte
+ * Signature: (I)B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getByte
+ * Signature: (II)B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setByte
+ * Signature: (IB)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte__IB
+  (JNIEnv *, jobject, jint, jbyte);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setByte
+ * Signature: (IIB)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte__IIB
+  (JNIEnv *, jobject, jint, jint, jbyte);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBytes
+ * Signature: (II[BI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getBytes
+  (JNIEnv *, jobject, jint, jint, jbyteArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBytes
+ * Signature: (II[BI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBytes
+  (JNIEnv *, jobject, jint, jint, jbyteArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloat
+ * Signature: (I)F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloat
+ * Signature: (II)F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloat
+ * Signature: (IF)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat__IF
+  (JNIEnv *, jobject, jint, jfloat);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloat
+ * Signature: (IIF)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat__IIF
+  (JNIEnv *, jobject, jint, jint, jfloat);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloats
+ * Signature: (II[FI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getFloats
+  (JNIEnv *, jobject, jint, jint, jfloatArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloats
+ * Signature: (II[FI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloats
+  (JNIEnv *, jobject, jint, jint, jfloatArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBoolean
+ * Signature: (I)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBoolean
+ * Signature: (II)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBoolean
+ * Signature: (IZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean__IZ
+  (JNIEnv *, jobject, jint, jboolean);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBoolean
+ * Signature: (IIZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean__IIZ
+  (JNIEnv *, jobject, jint, jint, jboolean);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBooleans
+ * Signature: (II[ZI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getBooleans
+  (JNIEnv *, jobject, jint, jint, jbooleanArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBooleans
+ * Signature: (II[ZI)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBooleans
+  (JNIEnv *, jobject, jint, jint, jbooleanArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariant
+ * Signature: (I)Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant__I
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariant
+ * Signature: (II)Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant__II
+  (JNIEnv *, jobject, jint, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariant
+ * Signature: (ILcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant__ILcom_jacob_com_Variant_2
+  (JNIEnv *, jobject, jint, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariant
+ * Signature: (IILcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant__IILcom_jacob_com_Variant_2
+  (JNIEnv *, jobject, jint, jint, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariants
+ * Signature: (II[Lcom/jacob/com/Variant;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_getVariants
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariants
+ * Signature: (II[Lcom/jacob/com/Variant;I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariants
+  (JNIEnv *, jobject, jint, jint, jobjectArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getVariant
+ * Signature: ([I)Lcom/jacob/com/Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_SafeArray_getVariant___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setVariant
+ * Signature: ([ILcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setVariant___3ILcom_jacob_com_Variant_2
+  (JNIEnv *, jobject, jintArray, jobject);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getChar
+ * Signature: ([I)C
+ */
+JNIEXPORT jchar JNICALL Java_com_jacob_com_SafeArray_getChar___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setChar
+ * Signature: ([IC)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setChar___3IC
+  (JNIEnv *, jobject, jintArray, jchar);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getInt
+ * Signature: ([I)I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_SafeArray_getInt___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setInt
+ * Signature: ([II)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setInt___3II
+  (JNIEnv *, jobject, jintArray, jint);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getLong
+ * Signature: ([I)J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_SafeArray_getLong___3I
+  (JNIEnv *env, jobject _this, jintArray indices);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setLong
+ * Signature: ([IJ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setLong___3IJ
+  (JNIEnv *env, jobject _this, jintArray indices, jlong c);
+
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getShort
+ * Signature: ([I)S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_SafeArray_getShort___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setShort
+ * Signature: ([IS)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setShort___3IS
+  (JNIEnv *, jobject, jintArray, jshort);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getDouble
+ * Signature: ([I)D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_SafeArray_getDouble___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setDouble
+ * Signature: ([ID)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setDouble___3ID
+  (JNIEnv *, jobject, jintArray, jdouble);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getString
+ * Signature: ([I)Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_SafeArray_getString___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setString
+ * Signature: ([ILjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setString___3ILjava_lang_String_2
+  (JNIEnv *, jobject, jintArray, jstring);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getByte
+ * Signature: ([I)B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_SafeArray_getByte___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setByte
+ * Signature: ([IB)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setByte___3IB
+  (JNIEnv *, jobject, jintArray, jbyte);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getFloat
+ * Signature: ([I)F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_SafeArray_getFloat___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setFloat
+ * Signature: ([IF)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setFloat___3IF
+  (JNIEnv *, jobject, jintArray, jfloat);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    getBoolean
+ * Signature: ([I)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_SafeArray_getBoolean___3I
+  (JNIEnv *, jobject, jintArray);
+
+/*
+ * Class:     com_jacob_com_SafeArray
+ * Method:    setBoolean
+ * Signature: ([IZ)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_SafeArray_setBoolean___3IZ
+  (JNIEnv *, jobject, jintArray, jboolean);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/StdAfx.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+// stdafx.h : include file for standard system include files,
+//      or project specific include files that are used frequently,
+//      but are changed infrequently
+
+#if !defined(AFX_STDAFX_H__9988E984_6789_11D3_A646_000000000000__INCLUDED_)
+#define AFX_STDAFX_H__9988E984_6789_11D3_A646_000000000000__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#ifndef STRICT
+#define STRICT
+#endif
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400
+#endif
+//#define _ATL_APARTMENT_THREADED
+#include <windows.h>
+#include <comdef.h>
+#include <comutil.h>
+#include <atlbase.h>
+//You may derive a class from CComModule and use it if you want to override
+//something, but do not change the name of _Module
+extern CComModule _Module;
+//#include <atlcom.h>
+
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_STDAFX_H__9988E984_6789_11D3_A646_000000000000__INCLUDED)

cpp/jacob/Variant.h

@@ -0,0 +1,605 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <jni.h>
+/* Header for class com_jacob_com_Variant */
+
+#ifndef _Included_com_jacob_com_Variant
+#define _Included_com_jacob_com_Variant
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    toEnumVariant
+ * Signature: ()Lcom/jacob/com/EnumVariant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_toEnumVariant
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantNull
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantNull
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    cloneIndirect
+ * Signature: ()Lcom_jacob_com_Variant;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_cloneIndirect
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantShortRef
+ * Signature: (S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantShortRef
+  (JNIEnv *, jobject, jshort);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantIntRef
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantIntRef
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDoubleRef
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDoubleRef
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDateRef
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDateRef
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantStringRef
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantStringRef
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantShortRef
+ * Signature: ()S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_Variant_getVariantShortRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantIntRef
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantIntRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantShort
+ * Signature: (S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantShort
+  (JNIEnv *, jobject, jshort);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantShort
+ * Signature: ()S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_Variant_getVariantShort
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDoubleRef
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDoubleRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDateRef
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDateRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getStringRef
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_Variant_getVariantStringRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    com_jacob_com_VariantClear
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_VariantClear
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    toDispatch
+ * Signature: ()LDispatch;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_toVariantDispatch
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    clone
+ * Signature: ()Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_clone
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantInt
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantInt
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDate
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDate
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantInt
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantInt
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDate
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDate
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantBoolean
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_Variant_getVariantBoolean
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantByte
+ * Signature: ()B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_Variant_getVariantByte
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantBoolean
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantBoolean
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantByte
+ * Signature: (B)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantByte
+  (JNIEnv *, jobject, jbyte);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantEmpty
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantEmpty
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantNothing
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantNothing
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantError
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantError
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantError
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantError
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDouble
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_com_jacob_com_Variant_getVariantDouble
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantCurrency
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantCurrency
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantLong
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantLong
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDispatch
+ * Signature: (Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDispatch
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDouble
+ * Signature: (D)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDouble
+  (JNIEnv *, jobject, jdouble);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantCurrency
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantCurrency
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantLong
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantLong
+  (JNIEnv *, jobject);
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantFloatRef
+ * Signature: (F)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantFloatRef
+  (JNIEnv *, jobject, jfloat);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantCurrencyRef
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantCurrencyRef
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantLongRef
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantLongRef
+  (JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantErrorRef
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantErrorRef
+  (JNIEnv *, jobject, jint);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantBooleanRef
+ * Signature: (Z)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantBooleanRef
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putObjectRef
+ * Signature: (Ljava/lang/Object;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putObjectRef
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantByteRef
+ * Signature: (B)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantByteRef
+  (JNIEnv *, jobject, jbyte);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getString
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_jacob_com_Variant_getVariantString
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantString
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantString
+  (JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantFloatRef
+ * Signature: ()F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_Variant_getVariantFloatRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantCurrencyRef
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantCurrencyRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantLongRef
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_com_jacob_com_Variant_getVariantLongRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantErrorRef
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantErrorRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantBooleanRef
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_Variant_getVariantBooleanRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantByteRef
+ * Signature: ()B
+ */
+JNIEXPORT jbyte JNICALL Java_com_jacob_com_Variant_getVariantByteRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    toVariantSafeArray
+ * Signature: (Z)Lcom/jacob/com/SafeArray;
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_toVariantSafeArray
+  (JNIEnv *, jobject, jboolean);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantSafeArrayRef
+ * Signature: (LSafeArray;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantSafeArrayRef
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantSafeArray
+ * Signature: (LSafeArray;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantSafeArray
+  (JNIEnv *, jobject, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantNoParam
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantNoParam
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantFloat
+ * Signature: ()F
+ */
+JNIEXPORT jfloat JNICALL Java_com_jacob_com_Variant_getVariantFloat
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantFloat
+ * Signature: (F)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantFloat
+  (JNIEnv *, jobject, jfloat);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    changeVariantType
+ * Signature: (S)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_changeVariantType
+  (JNIEnv *, jobject, jshort);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantType
+ * Signature: ()S
+ */
+JNIEXPORT jshort JNICALL Java_com_jacob_com_Variant_getVariantType
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    release
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_release
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    init
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_init
+  (JNIEnv *, jobject);
+
+JNIEXPORT jbyteArray JNICALL Java_com_jacob_com_Variant_SerializationWriteToBytes
+  (JNIEnv *, jobject);
+
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_SerializationReadFromBytes
+  (JNIEnv *, jobject, jbyteArray);
+  
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantVariant
+ * Signature: (Lcom/jacob/com/Variant;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantVariant
+  (JNIEnv *, jobject, jobject);
+
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantVariant
+ * Signature: ()I
+ */
+JNIEXPORT jint JNICALL Java_com_jacob_com_Variant_getVariantVariant
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDecRef
+ * Signature: (Ljava.math.BigDecimal;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDecRef
+  (JNIEnv *env, jobject _this, jint signum, jbyte scale, jint lo, jint mid, jint hi);
+
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    putVariantDec
+ * Signature: (Ljava.math.BigDecimal;)V
+ */
+JNIEXPORT void JNICALL Java_com_jacob_com_Variant_putVariantDec
+  (JNIEnv *env, jobject _this, jint signum, jbyte scale, jint lo, jint mid, jint hi);
+
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDecRef
+ * Signature: ()Ljava.math.BigDecimal
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_getVariantDecRef
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    getVariantDec
+ * Signature: ()Ljava.math.BigDecimal
+ */
+JNIEXPORT jobject JNICALL Java_com_jacob_com_Variant_getVariantDec
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    isVariantConsideredNull
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_jacob_com_Variant_isVariantConsideredNull
+  (JNIEnv *, jobject);
+
+/*
+ * Class:     com_jacob_com_Variant
+ * Method:    zeroVariant
+ * Signature: ()V
+ *
+ * This should only be used on variant objects created by the
+ * com layer as part of a call through EventProxy.
+ * This zeros out the variant pointer in the Variant object
+ * so that the calling COM program can free the memory.
+ * instead of both the COM program and the Java GC doing it.
+ */
+void zeroVariant (JNIEnv *, jobject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

cpp/jacob/include/atlalloc.h

@@ -0,0 +1,764 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#pragma once
+#ifndef __ATLALLOC_H__
+#define __ATLALLOC_H__
+#endif
+
+#include <windows.h>
+#include <ole2.h>
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+/* 
+This is	more than a	little unsatisfying. /Wp64 warns when we convert a size_t to an	int
+because	it knows such a	conversion won't port. 
+But, when we have overloaded templates,	there may well exist both conversions and we need 
+to fool	the	warning	into not firing	on 32 bit builds
+*/
+#if !defined(_ATL_W64)
+#if !defined(__midl) &&	(defined(_X86_)	|| defined(_M_IX86))
+#define	_ATL_W64 __w64
+#else
+#define	_ATL_W64
+#endif
+#endif
+
+/* Can't use ::std::numeric_limits<T> here because we don't want to introduce a new	
+   deprendency of this code on SCL
+*/
+
+template<typename T>
+class AtlLimits;
+
+template<>
+class AtlLimits<int _ATL_W64>
+{
+public:
+	static const int _Min=INT_MIN;
+	static const int _Max=INT_MAX;
+};
+
+template<>
+class AtlLimits<unsigned int _ATL_W64>
+{
+public:
+	static const unsigned int _Min=0;
+	static const unsigned int _Max=UINT_MAX;
+};
+
+template<>
+class AtlLimits<long _ATL_W64>
+{
+public:
+	static const long _Min=LONG_MIN;
+	static const long _Max=LONG_MAX;
+};
+
+template<>
+class AtlLimits<unsigned long _ATL_W64>
+{
+public:
+	static const unsigned long _Min=0;
+	static const unsigned long _Max=ULONG_MAX;
+};
+
+template<>
+class AtlLimits<long long>
+{
+public:
+	static const long long _Min=LLONG_MIN;
+	static const long long _Max=LLONG_MAX;
+};
+
+template<>
+class AtlLimits<unsigned long long>
+{
+public:
+	static const unsigned long long _Min=0;
+	static const unsigned long long _Max=ULLONG_MAX;
+};
+
+/* generic version */
+template<typename T>
+inline HRESULT AtlAdd(T* ptResult, T tLeft, T tRight)
+{
+	if(::ATL::AtlLimits<T>::_Max-tLeft < tRight)
+	{
+		return E_INVALIDARG;
+	}
+	*ptResult= tLeft + tRight;
+	return S_OK;
+}
+
+/* generic but compariatively slow version */
+template<typename T>
+inline HRESULT AtlMultiply(T* ptResult,	T tLeft, T tRight)
+{
+	/* avoid divide 0 */
+	if(tLeft==0)
+	{
+		*ptResult=0;
+		return S_OK;
+	}
+	if(::ATL::AtlLimits<T>::_Max/tLeft < tRight)
+	{
+		return E_INVALIDARG;
+	}
+	*ptResult= tLeft * tRight;
+	return S_OK;
+}
+
+/* fast	version	for	32 bit integers	*/
+template<>
+inline HRESULT AtlMultiply(int _ATL_W64	*piResult, int _ATL_W64	iLeft, int _ATL_W64 iRight)
+{
+	__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
+	if(i64Result>INT_MAX || i64Result < INT_MIN)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<int _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(unsigned int	_ATL_W64 *piResult, unsigned int _ATL_W64 iLeft, unsigned int _ATL_W64 iRight)
+{
+	unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
+	if(i64Result>UINT_MAX)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<unsigned int _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(long	_ATL_W64 *piResult, long _ATL_W64 iLeft, long _ATL_W64 iRight)
+{
+	__int64 i64Result=static_cast<__int64>(iLeft) * static_cast<__int64>(iRight);
+	if(i64Result>LONG_MAX || i64Result < LONG_MIN)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<long _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template<>
+inline HRESULT AtlMultiply(unsigned long _ATL_W64 *piResult, unsigned long _ATL_W64 iLeft, unsigned long _ATL_W64 iRight)
+{
+	unsigned __int64 i64Result=static_cast<unsigned __int64>(iLeft) * static_cast<unsigned __int64>(iRight);
+	if(i64Result>ULONG_MAX)
+	{
+		return E_INVALIDARG;
+	}
+	*piResult=static_cast<unsigned long _ATL_W64>(i64Result);
+	return S_OK;
+}
+
+template <typename T>
+inline T AtlMultiplyThrow(T tLeft, T tRight)
+{
+	T tResult;
+	HRESULT hr=AtlMultiply(&tResult, tLeft, tRight);
+	if(FAILED(hr))
+	{
+		AtlThrow(hr);
+	}
+	return tResult;
+}
+
+template <typename T>
+inline T AtlAddThrow(T tLeft, T	tRight)
+{
+	T tResult;
+	HRESULT hr=AtlAdd(&tResult, tLeft, tRight);
+	if(FAILED(hr))
+	{
+		AtlThrow(hr);
+	}
+	return tResult;
+}
+
+inline LPVOID AtlCoTaskMemCAlloc(ULONG nCount, ULONG nSize)
+{
+	HRESULT hr;
+	ULONG nBytes=0;
+	if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
+	{
+		return NULL;
+	}
+	return ::CoTaskMemAlloc(nBytes);
+}
+
+inline LPVOID AtlCoTaskMemRecalloc(void	*pvMemory, ULONG nCount, ULONG nSize)
+{
+	HRESULT hr;
+	ULONG nBytes=0;
+	if( FAILED(hr=::ATL::AtlMultiply(&nBytes, nCount, nSize)))
+	{
+		return NULL;
+	}
+	return ::CoTaskMemRealloc(pvMemory, nBytes);
+}
+
+}	// namespace ATL
+#pragma pack(pop)
+
+#pragma pack(push,8)
+namespace ATL
+{
+// forward declaration of Checked::memcpy_s
+
+namespace Checked
+{
+    void __cdecl memcpy_s(__out_bcount_part(s1max,n) void *s1, __in size_t s1max, __in_bcount(n) const void *s2, __in size_t n);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Allocation helpers
+
+class CCRTAllocator 
+{
+public:
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		return realloc(p, nBytes);
+	}
+
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return malloc(nBytes);
+	}
+
+	static void Free(void* p) throw()
+	{
+		free(p);
+	}
+};
+
+class CLocalAllocator
+{
+public:
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return ::LocalAlloc(LMEM_FIXED, nBytes);
+	}
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		if (p==NULL){
+			return ( Allocate(nBytes) );
+		
+		}
+		if (nBytes==0){
+			Free(p);
+			return NULL;
+		}
+			return ::LocalReAlloc(p, nBytes, 0);
+		 
+	}
+	static void Free(void* p) throw()
+	{
+		::LocalFree(p);
+	}
+};
+
+class CGlobalAllocator
+{
+public:
+	static void* Allocate(size_t nBytes) throw()
+	{
+		return ::GlobalAlloc(GMEM_FIXED, nBytes);
+	}
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+		if (p==NULL){
+			return ( Allocate(nBytes) );
+		
+		}
+		if (nBytes==0){
+			Free(p);
+			return NULL;
+		}
+		return ( ::GlobalReAlloc(p, nBytes, 0) );
+	}
+	static void Free(void* p) throw()
+	{
+		::GlobalFree(p);
+	}
+};
+
+template <class T, class Allocator = CCRTAllocator>
+class CHeapPtrBase
+{
+protected:
+	CHeapPtrBase() throw() :
+		m_pData(NULL)
+	{
+	}
+	CHeapPtrBase(CHeapPtrBase<T, Allocator>& p) throw()
+	{
+		m_pData = p.Detach();  // Transfer ownership
+	}
+	explicit CHeapPtrBase(T* pData) throw() :
+		m_pData(pData)
+	{
+	}
+
+public:
+	~CHeapPtrBase() throw()
+	{
+		Free();
+	}
+
+protected:
+	CHeapPtrBase<T, Allocator>& operator=(CHeapPtrBase<T, Allocator>& p) throw()
+	{
+		if(m_pData != p.m_pData)
+			Attach(p.Detach());  // Transfer ownership
+		return *this;
+	}
+
+public:
+	operator T*() const throw()
+	{
+		return m_pData;
+	}
+
+	T* operator->() const throw()
+	{
+		ATLASSERT(m_pData != NULL);
+		return m_pData;
+	}
+
+	T** operator&() throw()
+	{
+#if defined(ATLASSUME)
+		ATLASSUME(m_pData == NULL);
+#endif
+		return &m_pData;
+	}
+
+	// Allocate a buffer with the given number of bytes
+	bool AllocateBytes(size_t nBytes) throw()
+	{
+		ATLASSERT(m_pData == NULL);
+		m_pData = static_cast<T*>(Allocator::Allocate(nBytes));
+		if (m_pData == NULL)
+			return false;
+
+		return true;
+	}
+
+	// Attach to an existing pointer (takes ownership)
+	void Attach(T* pData) throw()
+	{
+		Allocator::Free(m_pData);
+		m_pData = pData;
+	}
+
+	// Detach the pointer (releases ownership)
+	T* Detach() throw() 
+	{
+		T* pTemp = m_pData;
+		m_pData = NULL;
+		return pTemp;
+	}
+
+	// Free the memory pointed to, and set the pointer to NULL
+	void Free() throw()
+	{
+		Allocator::Free(m_pData);
+		m_pData = NULL;
+	}
+
+	// Reallocate the buffer to hold a given number of bytes
+	bool ReallocateBytes(size_t nBytes) throw()
+	{
+		T* pNew;
+
+		pNew = static_cast<T*>(Allocator::Reallocate(m_pData, nBytes));
+		if (pNew == NULL)
+			return false;
+		m_pData = pNew;
+
+		return true;
+	}
+
+public:
+	T* m_pData;
+};
+
+template <typename T, class Allocator = CCRTAllocator>
+class CHeapPtr :
+	public CHeapPtrBase<T, Allocator>
+{
+public:
+	CHeapPtr() throw()
+	{
+	}
+	CHeapPtr(CHeapPtr<T, Allocator>& p) throw() :
+		CHeapPtrBase<T, Allocator>(p)
+	{
+	}
+	explicit CHeapPtr(T* p) throw() :
+		CHeapPtrBase<T, Allocator>(p)
+	{
+	}
+
+	CHeapPtr<T, Allocator>& operator=(CHeapPtr<T, Allocator>& p) throw()
+	{
+		CHeapPtrBase<T, Allocator>::operator=(p);
+
+		return *this;
+	}
+
+	// Allocate a buffer with the given number of elements
+	bool Allocate(size_t nElements = 1) throw()
+	{
+		size_t nBytes=0;
+		if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
+		{
+			return false;
+		}
+		return AllocateBytes(nBytes);
+	}
+
+	// Reallocate the buffer to hold a given number of elements
+	bool Reallocate(size_t nElements) throw()
+	{
+		size_t nBytes=0;
+		if(FAILED(::ATL::AtlMultiply(&nBytes, nElements, sizeof(T))))
+		{
+			return false;
+		}
+		return ReallocateBytes(nBytes);
+	}
+};
+
+template< typename T, int t_nFixedBytes = 128, class Allocator = CCRTAllocator >
+class CTempBuffer
+{
+public:
+	CTempBuffer() throw() :
+		m_p( NULL )
+	{
+	}
+	CTempBuffer( size_t nElements ) throw( ... ) :
+		m_p( NULL )
+	{
+		Allocate( nElements );
+	}
+
+	~CTempBuffer() throw()
+	{
+		if( m_p != reinterpret_cast< T* >( m_abFixedBuffer ) )
+		{
+			FreeHeap();
+		}
+	}
+
+	operator T*() const throw()
+	{
+		return( m_p );
+	}
+	T* operator->() const throw()
+	{
+		ATLASSERT( m_p != NULL );
+		return( m_p );
+	}
+
+	T* Allocate( size_t nElements ) throw( ... )
+	{
+		return( AllocateBytes( ::ATL::AtlMultiplyThrow(nElements,sizeof( T )) ) );
+	}
+
+	T* Reallocate( size_t nElements ) throw( ... )
+	{
+		ATLENSURE(nElements < size_t(-1)/sizeof(T) );		
+		size_t nNewSize = nElements*sizeof( T ) ;
+				
+		if (m_p == NULL)
+			return AllocateBytes(nNewSize);
+
+		if (nNewSize > t_nFixedBytes)
+		{
+			if( m_p == reinterpret_cast< T* >( m_abFixedBuffer ) )
+			{
+				// We have to allocate from the heap and copy the contents into the new buffer
+				AllocateHeap(nNewSize);
+				Checked::memcpy_s(m_p, nNewSize, m_abFixedBuffer, t_nFixedBytes);
+			}
+			else
+			{
+				ReAllocateHeap( nNewSize );
+			}
+		}
+		else
+		{
+			m_p = reinterpret_cast< T* >( m_abFixedBuffer );
+		}
+
+		return m_p;
+	}
+
+	T* AllocateBytes( size_t nBytes )
+	{
+		ATLASSERT( m_p == NULL );
+		if( nBytes > t_nFixedBytes )
+		{
+			AllocateHeap( nBytes );
+		}
+		else
+		{
+			m_p = reinterpret_cast< T* >( m_abFixedBuffer );
+		}
+
+		return( m_p );
+	}
+
+private:
+	ATL_NOINLINE void AllocateHeap( size_t nBytes )
+	{
+		T* p = static_cast< T* >( Allocator::Allocate( nBytes ) );
+		if( p == NULL )
+		{
+			AtlThrow( E_OUTOFMEMORY );
+		}
+		m_p = p;
+	}
+ 
+	ATL_NOINLINE void ReAllocateHeap( size_t nNewSize)
+	{
+		T* p = static_cast< T* >( Allocator::Reallocate(m_p, nNewSize) );
+		if ( p == NULL )
+		{
+			AtlThrow( E_OUTOFMEMORY );
+		}
+		m_p = p;
+	}
+
+	ATL_NOINLINE void FreeHeap() throw()
+	{
+		Allocator::Free( m_p );
+	}
+
+private:
+	T* m_p;
+	BYTE m_abFixedBuffer[t_nFixedBytes];
+};
+
+
+// Allocating memory on the stack without causing stack overflow.
+// Only use these through the _ATL_SAFE_ALLOCA_* macros
+namespace _ATL_SAFE_ALLOCA_IMPL
+{
+
+#ifndef _ATL_STACK_MARGIN
+#if defined(_M_IX86)
+#define _ATL_STACK_MARGIN	0x2000	// Minimum stack available after call to _ATL_SAFE_ALLOCA
+#else //_M_AMD64 _M_IA64
+#define _ATL_STACK_MARGIN	0x4000
+#endif
+#endif //_ATL_STACK_MARGIN
+
+//Verifies if sufficient space is available on the stack.
+//Note: This function should never be inlined, because the stack allocation
+//may not be freed until the end of the calling function (instead of the end of _AtlVerifyStackAvailable).
+//The use of __try/__except preverts inlining in this case.
+#if (_ATL_VER > 0x0301)
+inline bool _AtlVerifyStackAvailable(SIZE_T Size)
+{
+    bool bStackAvailable = true;
+
+    __try
+    {
+		SIZE_T size=0;
+		HRESULT hrAdd=::ATL::AtlAdd(&size, Size, static_cast<SIZE_T>(_ATL_STACK_MARGIN));
+		if(FAILED(hrAdd))
+		{
+			ATLASSERT(FALSE);
+			bStackAvailable = false;
+		}
+		else
+		{
+			PVOID p = _alloca(size);
+			if (p)
+			{
+				(p);
+			}
+		}
+    }
+    __except ((EXCEPTION_STACK_OVERFLOW == GetExceptionCode()) ?
+                   EXCEPTION_EXECUTE_HANDLER :
+                   EXCEPTION_CONTINUE_SEARCH)
+    {
+        bStackAvailable = false;
+        _resetstkoflw();
+    }
+    return bStackAvailable;
+}
+
+
+// Helper Classes to manage heap buffers for _ATL_SAFE_ALLOCA
+template < class Allocator>
+class CAtlSafeAllocBufferManager
+{
+private :
+	struct CAtlSafeAllocBufferNode
+	{
+		CAtlSafeAllocBufferNode* m_pNext;
+#if defined(_M_IX86)
+		BYTE _pad[4];
+#elif defined(_M_IA64)
+		BYTE _pad[8];
+#elif defined(_M_AMD64)
+		BYTE _pad[8];
+#else
+	#error Only supported for X86, AMD64 and IA64
+#endif
+		void* GetData()
+		{
+			return (this + 1);
+		}
+	};
+
+	CAtlSafeAllocBufferNode* m_pHead;
+public :
+	
+	CAtlSafeAllocBufferManager() : m_pHead(NULL) {};
+	void* Allocate(SIZE_T nRequestedSize)
+	{
+		CAtlSafeAllocBufferNode *p = (CAtlSafeAllocBufferNode*)Allocator::Allocate(::ATL::AtlAddThrow(nRequestedSize, static_cast<SIZE_T>(sizeof(CAtlSafeAllocBufferNode))));
+		if (p == NULL)
+			return NULL;
+		
+		// Add buffer to the list
+		p->m_pNext = m_pHead;
+		m_pHead = p;
+		
+		return p->GetData();
+	}
+	~CAtlSafeAllocBufferManager()
+	{
+		// Walk the list and free the buffers
+		while (m_pHead != NULL)
+		{
+			CAtlSafeAllocBufferNode* p = m_pHead;
+			m_pHead = m_pHead->m_pNext;
+			Allocator::Free(p);
+		}
+	}
+};
+#endif
+
+}	// namespace _ATL_SAFE_ALLOCA_IMPL
+
+}	// namespace ATL
+ #pragma pack(pop)
+
+// Use one of the following macros before using _ATL_SAFE_ALLOCA
+// EX version allows specifying a different heap allocator
+#define USES_ATL_SAFE_ALLOCA_EX(x)    ATL::_ATL_SAFE_ALLOCA_IMPL::CAtlSafeAllocBufferManager<x> _AtlSafeAllocaManager
+
+#ifndef USES_ATL_SAFE_ALLOCA
+#define USES_ATL_SAFE_ALLOCA		USES_ATL_SAFE_ALLOCA_EX(ATL::CCRTAllocator)
+#endif
+
+// nRequestedSize - requested size in bytes 
+// nThreshold - size in bytes beyond which memory is allocated from the heap.
+
+#if (_ATL_VER > 0x0301)
+
+// Defining _ATL_SAFE_ALLOCA_ALWAYS_ALLOCATE_THRESHOLD_SIZE always allocates the size specified
+// for threshold if the stack space is available irrespective of requested size.
+// This available for testing purposes. It will help determine the max stack usage due to _alloca's
+// Disable _alloca not within try-except prefast warning since we verify stack space is available before.
+#ifdef _ATL_SAFE_ALLOCA_ALWAYS_ALLOCATE_THRESHOLD_SIZE
+#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold)	\
+	__pragma(warning(push))\
+	__pragma(warning(disable:4616))\
+	__pragma(warning(disable:6255))\
+	((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nThreshold) ) ?	\
+		_alloca(nThreshold) :	\
+		((ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nThreshold)) ? _alloca(nThreshold) : 0),	\
+			_AtlSafeAllocaManager.Allocate(nRequestedSize))\
+	__pragma(warning(pop))
+#else
+#define _ATL_SAFE_ALLOCA(nRequestedSize, nThreshold)	\
+	__pragma(warning(push))\
+	__pragma(warning(disable:4616))\
+	__pragma(warning(disable:6255))\
+	((nRequestedSize <= nThreshold && ATL::_ATL_SAFE_ALLOCA_IMPL::_AtlVerifyStackAvailable(nRequestedSize) ) ?	\
+		_alloca(nRequestedSize) :	\
+		_AtlSafeAllocaManager.Allocate(nRequestedSize))\
+	__pragma(warning(pop))
+#endif
+
+#endif
+
+// Use 1024 bytes as the default threshold in ATL
+#ifndef _ATL_SAFE_ALLOCA_DEF_THRESHOLD
+#define _ATL_SAFE_ALLOCA_DEF_THRESHOLD	1024
+#endif
+
+#if (_ATL_VER <= 0x0301) // from atlbase.h
+
+class CComAllocator 
+{
+public:
+	static void* Reallocate(void* p, size_t nBytes) throw()
+	{
+#ifdef _WIN64
+		if( nBytes > INT_MAX )
+		{
+			return( NULL );
+		}
+#endif
+		return ::CoTaskMemRealloc(p, ULONG(nBytes));
+	}
+	static void* Allocate(size_t nBytes) throw()
+	{
+#ifdef _WIN64
+		if( nBytes > INT_MAX )
+		{
+			return( NULL );
+		}
+#endif
+		return ::CoTaskMemAlloc(ULONG(nBytes));
+	}
+	static void Free(void* p) throw()
+	{
+		::CoTaskMemFree(p);
+	}
+};
+
+template <typename T>
+class CComHeapPtr :
+	public CHeapPtr<T, CComAllocator>
+{
+public:
+	CComHeapPtr() throw()
+	{
+	}
+
+	explicit CComHeapPtr(T* pData) throw() :
+		CHeapPtr<T, CComAllocator>(pData)
+	{
+	}
+};
+
+#endif
+

cpp/jacob/include/atlbase.inl

@@ -0,0 +1,428 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the	
+// Active Template Library product.
+
+#ifndef __ATLBASE_INL__
+#define __ATLBASE_INL__
+
+#pragma once
+
+#ifndef __ATLBASE_H__
+	#error atlbase.inl requires atlbase.h to be included first
+#endif
+#pragma warning(push)
+#pragma warning(disable:4571) //catch(...) blocks compiled with /EHs do NOT catch or re-throw Structured Exceptions
+namespace ATL
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// Connection Point Helpers
+
+ATLINLINE ATLAPI AtlAdvise(IUnknown* pUnkCP, IUnknown* pUnk, const IID& iid, LPDWORD pdw)
+{
+	if(pUnkCP == NULL)
+		return E_INVALIDARG;
+		
+	CComPtr<IConnectionPointContainer> pCPC;
+	CComPtr<IConnectionPoint> pCP;
+	HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
+	if (SUCCEEDED(hRes))
+		hRes = pCPC->FindConnectionPoint(iid, &pCP);
+	if (SUCCEEDED(hRes))
+		hRes = pCP->Advise(pUnk, pdw);
+	return hRes;
+}
+
+ATLINLINE ATLAPI AtlUnadvise(IUnknown* pUnkCP, const IID& iid, DWORD dw)
+{
+	if(pUnkCP == NULL)
+		return E_INVALIDARG;
+		
+	CComPtr<IConnectionPointContainer> pCPC;
+	CComPtr<IConnectionPoint> pCP;
+	HRESULT hRes = pUnkCP->QueryInterface(__uuidof(IConnectionPointContainer), (void**)&pCPC);
+	if (SUCCEEDED(hRes))
+		hRes = pCPC->FindConnectionPoint(iid, &pCP);
+	if (SUCCEEDED(hRes))
+		hRes = pCP->Unadvise(dw);
+	return hRes;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Inproc Marshaling helpers
+
+//This API should be called from the same thread that called
+//AtlMarshalPtrInProc
+ATLINLINE ATLAPI AtlFreeMarshalStream(IStream* pStream)
+{
+	HRESULT hRes=S_OK;
+	if (pStream != NULL)
+	{
+		LARGE_INTEGER l;
+		l.QuadPart = 0;
+		pStream->Seek(l, STREAM_SEEK_SET, NULL);
+		hRes=CoReleaseMarshalData(pStream);
+		pStream->Release();
+	}
+	return hRes;
+}
+
+ATLINLINE ATLAPI AtlMarshalPtrInProc(IUnknown* pUnk, const IID& iid, IStream** ppStream)
+{
+	ATLASSERT(ppStream != NULL);
+	if (ppStream == NULL)
+		return E_POINTER;
+		
+	HRESULT hRes = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
+	if (SUCCEEDED(hRes))
+	{
+		hRes = CoMarshalInterface(*ppStream, iid,
+			pUnk, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLESTRONG);
+		if (FAILED(hRes))
+		{
+			(*ppStream)->Release();
+			*ppStream = NULL;
+		}
+	}
+	return hRes;
+}
+
+ATLINLINE ATLAPI AtlUnmarshalPtr(IStream* pStream, const IID& iid, IUnknown** ppUnk)
+{
+	ATLASSERT(ppUnk != NULL);
+	if (ppUnk == NULL)
+		return E_POINTER;
+
+	*ppUnk = NULL;
+	HRESULT hRes = E_INVALIDARG;
+	if (pStream != NULL)
+	{
+		LARGE_INTEGER l;
+		l.QuadPart = 0;
+		pStream->Seek(l, STREAM_SEEK_SET, NULL);
+		hRes = CoUnmarshalInterface(pStream, iid, (void**)ppUnk);
+	}
+	return hRes;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Module
+
+ATLINLINE ATLAPI AtlComModuleGetClassObject(_ATL_COM_MODULE* pComModule, REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+	if (pComModule->cbSize == 0)  // Module hasn't been initialized
+		return E_UNEXPECTED;
+
+	if (ppv == NULL)
+		return E_POINTER;
+	*ppv = NULL;
+
+	HRESULT hr = S_OK;
+
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast; ppEntry++)
+	{
+		if (*ppEntry != NULL)
+		{
+			_ATL_OBJMAP_ENTRY* pEntry = *ppEntry;
+			if ((pEntry->pfnGetClassObject != NULL) && InlineIsEqualGUID(rclsid, *pEntry->pclsid))
+			{
+				if (pEntry->pCF == NULL)
+				{
+					CComCritSecLock<CComCriticalSection> lock(pComModule->m_csObjMap, false);
+					hr = lock.Lock();
+					if (FAILED(hr))
+					{
+						ATLTRACE(atlTraceCOM, 0, _T("ERROR : Unable to lock critical section in AtlComModuleGetClassObject\n"));
+						ATLASSERT(0);
+						break;
+					}
+					if (pEntry->pCF == NULL)
+						hr = pEntry->pfnGetClassObject(pEntry->pfnCreateInstance, __uuidof(IUnknown), (LPVOID*)&pEntry->pCF);
+				}
+				if (pEntry->pCF != NULL)
+					hr = pEntry->pCF->QueryInterface(riid, ppv);
+				break;
+			}
+		}
+	}
+
+	if (*ppv == NULL && hr == S_OK)
+		hr = CLASS_E_CLASSNOTAVAILABLE;
+	return hr;
+}
+
+ATLINLINE ATLAPI AtlComModuleRegisterClassObjects(_ATL_COM_MODULE* pComModule, DWORD dwClsContext, DWORD dwFlags)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+
+	HRESULT hr = S_FALSE;
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast && SUCCEEDED(hr); ppEntry++)
+	{
+		if (*ppEntry != NULL)
+			hr = (*ppEntry)->RegisterClassObject(dwClsContext, dwFlags);
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI AtlComModuleRevokeClassObjects(_ATL_COM_MODULE* pComModule)
+{
+	ATLASSERT(pComModule != NULL);
+	if (pComModule == NULL)
+		return E_INVALIDARG;
+
+	HRESULT hr = S_OK;
+	for (_ATL_OBJMAP_ENTRY** ppEntry = pComModule->m_ppAutoObjMapFirst; ppEntry < pComModule->m_ppAutoObjMapLast && hr == S_OK; ppEntry++)
+	{
+		if (*ppEntry != NULL)
+			hr = (*ppEntry)->RevokeClassObject();
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI_(BOOL) AtlWaitWithMessageLoop(HANDLE hEvent)
+{
+	DWORD dwRet;
+	MSG msg;
+
+	while(1)
+	{
+		dwRet = MsgWaitForMultipleObjects(1, &hEvent, FALSE, INFINITE, QS_ALLINPUT);
+
+		if (dwRet == WAIT_OBJECT_0)
+			return TRUE;    // The event was signaled
+
+		if (dwRet != WAIT_OBJECT_0 + 1)
+			break;          // Something else happened
+
+		// There is one or more window message available. Dispatch them
+		while(PeekMessage(&msg,0,0,0,PM_NOREMOVE))
+		{
+			// check for unicode window so we call the appropriate functions
+			BOOL bUnicode = ::IsWindowUnicode(msg.hwnd);
+			BOOL bRet;
+
+			if (bUnicode)
+				bRet = ::GetMessageW(&msg, NULL, 0, 0);
+			else
+				bRet = ::GetMessageA(&msg, NULL, 0, 0);
+
+			if (bRet > 0)
+			{
+				::TranslateMessage(&msg);
+
+				if (bUnicode)
+					::DispatchMessageW(&msg);
+				else
+					::DispatchMessageA(&msg);
+			}
+
+			if (WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0)
+				return TRUE; // Event is now signaled.
+		}
+	}
+	return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// QI support
+
+ATLINLINE ATLAPI AtlInternalQueryInterface(void* pThis,
+	const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject)
+{
+	ATLASSERT(pThis != NULL);
+	ATLASSERT(pEntries!= NULL);
+	
+	if(pThis == NULL || pEntries == NULL)
+		return E_INVALIDARG ;
+		
+	// First entry in the com map should be a simple map entry
+	ATLASSERT(pEntries->pFunc == _ATL_SIMPLEMAPENTRY);
+	if (ppvObject == NULL)
+		return E_POINTER;
+	*ppvObject = NULL;
+	if (InlineIsEqualUnknown(iid)) // use first interface
+	{
+			IUnknown* pUnk = (IUnknown*)((INT_PTR)pThis+pEntries->dw);
+			pUnk->AddRef();
+			*ppvObject = pUnk;
+			return S_OK;
+	}
+	while (pEntries->pFunc != NULL)
+	{
+		BOOL bBlind = (pEntries->piid == NULL);
+		if (bBlind || InlineIsEqualGUID(*(pEntries->piid), iid))
+		{
+			if (pEntries->pFunc == _ATL_SIMPLEMAPENTRY) //offset
+			{
+				ATLASSERT(!bBlind);
+				IUnknown* pUnk = (IUnknown*)((INT_PTR)pThis+pEntries->dw);
+				pUnk->AddRef();
+				*ppvObject = pUnk;
+				return S_OK;
+			}
+			else //actual function call
+			{
+				HRESULT hRes = pEntries->pFunc(pThis,
+					iid, ppvObject, pEntries->dw);
+				if (hRes == S_OK || (!bBlind && FAILED(hRes)))
+					return hRes;
+			}
+		}
+		pEntries++;
+	}
+	return E_NOINTERFACE;
+}
+
+ATLINLINE ATLAPI_(DWORD) AtlGetVersion(void* /* pReserved */)
+{
+	return _ATL_VER;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Windowing
+
+ATLINLINE ATLAPI_(void) AtlWinModuleAddCreateWndData(_ATL_WIN_MODULE* pWinModule, _AtlCreateWndData* pData, void* pObject)
+{
+	if (pWinModule == NULL)
+		_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
+
+	ATLASSERT(pData != NULL && pObject != NULL);
+	if(pData == NULL || pObject == NULL)
+		_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
+		
+	pData->m_pThis = pObject;
+	pData->m_dwThreadID = ::GetCurrentThreadId();
+	CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
+	if (FAILED(lock.Lock()))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to lock critical section in AtlWinModuleAddCreateWndData\n"));
+		ATLASSERT(0);
+		return;
+	}
+	pData->m_pNext = pWinModule->m_pCreateWndList;
+	pWinModule->m_pCreateWndList = pData;
+}
+
+ATLINLINE ATLAPI_(void*) AtlWinModuleExtractCreateWndData(_ATL_WIN_MODULE* pWinModule)
+{
+	if (pWinModule == NULL)
+		return NULL;
+
+	void* pv = NULL;
+	CComCritSecLock<CComCriticalSection> lock(pWinModule->m_csWindowCreate, false);
+	if (FAILED(lock.Lock()))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to lock critical section in AtlWinModuleExtractCreateWndData\n"));
+		ATLASSERT(0);
+		return pv;
+	}
+	_AtlCreateWndData* pEntry = pWinModule->m_pCreateWndList;
+	if(pEntry != NULL)
+	{
+		DWORD dwThreadID = ::GetCurrentThreadId();
+		_AtlCreateWndData* pPrev = NULL;
+		while(pEntry != NULL)
+		{
+			if(pEntry->m_dwThreadID == dwThreadID)
+			{
+				if(pPrev == NULL)
+					pWinModule->m_pCreateWndList = pEntry->m_pNext;
+				else
+					pPrev->m_pNext = pEntry->m_pNext;
+				pv = pEntry->m_pThis;
+				break;
+			}
+			pPrev = pEntry;
+			pEntry = pEntry->m_pNext;
+		}
+	}
+	return pv;
+}
+
+
+ATLINLINE ATLAPI AtlWinModuleInit(_ATL_WIN_MODULE* pWinModule)
+{
+	if (pWinModule == NULL)
+		return E_INVALIDARG;
+		
+	// check only in the DLL
+	if (pWinModule->cbSize != sizeof(_ATL_WIN_MODULE))
+		return E_INVALIDARG;
+
+	pWinModule->m_pCreateWndList = NULL;
+
+	HRESULT hr = pWinModule->m_csWindowCreate.Init();
+	if (FAILED(hr))
+	{
+		ATLTRACE(atlTraceWindowing, 0, _T("ERROR : Unable to initialize critical section in AtlWinModuleInit\n"));
+		ATLASSERT(0);
+	}
+	return hr;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Module
+
+ATLINLINE ATLAPI AtlModuleAddTermFunc(_ATL_MODULE* pModule, _ATL_TERMFUNC* pFunc, DWORD_PTR dw)
+{
+	if (pModule == NULL)
+		return E_INVALIDARG;
+		
+	HRESULT hr = S_OK;
+	_ATL_TERMFUNC_ELEM* pNew = NULL;
+	ATLTRY(pNew = new _ATL_TERMFUNC_ELEM);
+	if (pNew == NULL)
+		hr = E_OUTOFMEMORY;
+	else
+	{
+		pNew->pFunc = pFunc;
+		pNew->dw = dw;
+		CComCritSecLock<CComCriticalSection> lock(pModule->m_csStaticDataInitAndTypeInfo, false);
+		hr = lock.Lock();
+		if (SUCCEEDED(hr))
+		{
+			pNew->pNext = pModule->m_pTermFuncs;
+			pModule->m_pTermFuncs = pNew;
+		}
+		else
+		{
+			delete pNew;
+			ATLTRACE(atlTraceGeneral, 0, _T("ERROR : Unable to lock critical section in AtlModuleAddTermFunc\n"));
+			ATLASSERT(0);
+		}
+	}
+	return hr;
+}
+
+ATLINLINE ATLAPI_(void) AtlCallTermFunc(_ATL_MODULE* pModule)
+{
+	if (pModule == NULL)
+		_AtlRaiseException((DWORD)EXCEPTION_ACCESS_VIOLATION);
+		
+	_ATL_TERMFUNC_ELEM* pElem = pModule->m_pTermFuncs;
+	_ATL_TERMFUNC_ELEM* pNext = NULL;
+	while (pElem != NULL)
+	{
+		pElem->pFunc(pElem->dw);
+		pNext = pElem->pNext;
+		delete pElem;
+		pElem = pNext;
+	}
+	pModule->m_pTermFuncs = NULL;
+}
+
+} // namespace ATL
+#pragma warning(pop)
+#endif // __ATLBASE_INL__
+

cpp/jacob/include/atlchecked.h

@@ -0,0 +1,605 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLCHECKED_H__
+#define __ATLCHECKED_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atlexcept.h>
+#include <malloc.h>
+#include <string.h>
+#include <mbstring.h>
+#include <wchar.h>
+#include <tchar.h>
+#include <stdlib.h>
+#pragma warning(push)
+#pragma warning(disable:4127)
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+inline errno_t AtlCrtErrorCheck(errno_t nError)
+{
+	switch(nError)
+	{
+	case ENOMEM:
+		AtlThrow(E_OUTOFMEMORY);
+		break;
+	case EINVAL:
+	case ERANGE:
+		AtlThrow(E_INVALIDARG);
+		break;
+	case 0:
+	case STRUNCATE:
+		break;
+	default:
+		AtlThrow(E_FAIL);
+		break;
+	}
+	return nError;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Secure (Checked) CRT functions
+
+namespace Checked
+{
+
+#if _SECURE_ATL
+
+#ifdef _AFX
+#define ATLMFC_CRT_ERRORCHECK(expr) AFX_CRT_ERRORCHECK(expr)
+#else
+#define ATLMFC_CRT_ERRORCHECK(expr) ATL_CRT_ERRORCHECK(expr)
+#endif
+
+inline void __cdecl memcpy_s(__out_bcount_part(_S1max,_N)  void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::memcpy_s(_S1, _S1max, _S2, _N));
+}
+
+inline void __cdecl wmemcpy_s(__out_ecount_part(_N1,_N) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::wmemcpy_s(_S1, _N1, _S2, _N));
+}
+
+inline void __cdecl memmove_s(__out_bcount_part(_S1max,_N) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
+{
+	ATLMFC_CRT_ERRORCHECK(::memmove_s(_S1, _S1max, _S2, _N));
+}
+
+inline void __cdecl strcpy_s(__out_ecount(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
+{
+	ATLMFC_CRT_ERRORCHECK(::strcpy_s(_S1, _S1max, _S2));
+}
+
+inline void __cdecl wcscpy_s(__out_ecount(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
+{
+	ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_S1, _S1max, _S2));
+}
+
+inline void __cdecl tcscpy_s(__out_ecount(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcscpy_s(_Dst, _SizeInChars, _Src));
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::wcscpy_s(_Dst, _SizeInChars, _Src));
+#else
+	ATLMFC_CRT_ERRORCHECK(::strcpy_s(_Dst, _SizeInChars, _Src));
+#endif
+#endif
+}
+
+inline errno_t __cdecl strncpy_s(__out_ecount(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source, __in size_t _Count)
+{
+	return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+}
+
+inline errno_t __cdecl wcsncpy_s(__out_ecount(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
+{
+	return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+}
+
+inline errno_t __cdecl tcsncpy_s(__out_ecount(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source, __in size_t _Count)
+{
+#ifndef _ATL_MIN_CRT
+	return ATLMFC_CRT_ERRORCHECK(::_tcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#else
+#ifdef UNICODE
+	return ATLMFC_CRT_ERRORCHECK(::wcsncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#else
+	return ATLMFC_CRT_ERRORCHECK(::strncpy_s(_Dest, _SizeInChars, _Source,_Count));	
+#endif
+#endif
+}
+
+inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
+{
+	ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
+}
+
+inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
+{
+	ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
+}
+
+inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcscat_s(_Dst, _SizeInChars, _Src));
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::wcscat_s(_Dst, _SizeInChars, _Src));
+#else
+	ATLMFC_CRT_ERRORCHECK(::strcat_s(_Dst, _SizeInChars, _Src));
+#endif
+#endif
+}
+
+inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));	
+}
+
+#if !defined(_MANAGED)
+inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_mbslwr_s(_Str, _SizeInChars));	
+}
+#endif
+
+inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
+{
+#ifndef _ATL_MIN_CRT
+	ATLMFC_CRT_ERRORCHECK(::_tcslwr_s(_Str, _SizeInChars));	
+#else
+#ifdef UNICODE
+	ATLMFC_CRT_ERRORCHECK(::_wcslwr_s(_Str, _SizeInChars));	
+#else
+	ATLMFC_CRT_ERRORCHECK(::_strlwr_s(_Str, _SizeInChars));	
+#endif
+#endif
+}
+
+inline void __cdecl strupr_s(__inout_ecount_z(_SizeInChars) char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_strupr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl wcsupr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_wcsupr_s(_Str, _SizeInChars));	
+}
+
+#if !defined(_MANAGED)
+inline void __cdecl mbsupr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_mbsupr_s(_Str, _SizeInChars));	
+}
+#endif
+
+inline void __cdecl tcsupr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, __in size_t _SizeInChars)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tcsupr_s(_Str, _SizeInChars));	
+}
+
+inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_itoa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_itot_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ltoa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ltot_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ultoa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ultow_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ultot_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_i64toa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_i64tow_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ui64toa_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	ATLMFC_CRT_ERRORCHECK(::_ui64tow_s(_Val, _Buf, _SizeInChars, _Radix));
+}
+
+inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
+{
+	ATLMFC_CRT_ERRORCHECK(::_gcvt_s(_Buffer, _SizeInChars, _Value, _Ndec));
+}
+
+inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
+	__out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
+	__out_ecount_z_opt(_Fname_len) TCHAR *_Fname, __in size_t _Fname_len, 
+	__out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tsplitpath_s(_Path, _Drive, _Drive_len, _Dir, _Dir_len, _Fname, _Fname_len, _Ext, _Ext_len));
+}
+
+inline void __cdecl tmakepath_s(__out_ecount_z(_SizeInChars) TCHAR *_Path, __in size_t _SizeInChars, __in_z const TCHAR *_Drive, 
+	__in_z const TCHAR *_Dir, __in_z const TCHAR *_Fname, __in_z const TCHAR *_Ext)
+{
+	ATLMFC_CRT_ERRORCHECK(::_tmakepath_s(_Path, _SizeInChars, _Drive, _Dir, _Fname, _Ext));
+}
+
+inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
+{
+	return ::strnlen(_Str, _Maxsize);
+}
+
+inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
+{
+	return ::wcsnlen(_Wcs, _Maxsize);
+}
+
+inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
+{
+	return ::_tcsnlen(_Str, _Maxsize);
+}
+
+inline int get_errno()
+{
+	int nErrNo;
+	ATLMFC_CRT_ERRORCHECK(::_get_errno(&nErrNo));
+	return nErrNo;
+}
+
+inline void set_errno(__in int _Value)
+{
+	ATLMFC_CRT_ERRORCHECK(::_set_errno(_Value));
+}
+
+#else // !_SECURE_ATL
+
+#define ATLMFC_CRT_ERRORCHECK(expr) do { expr; } while (0)
+
+inline void __cdecl memcpy_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, size_t _N)
+{
+	(_S1max);
+	memcpy(_S1, _S2, _N);
+}
+
+inline void __cdecl wmemcpy_s(__out_ecount(_N1) wchar_t *_S1, __in size_t _N1, __in_ecount(_N) const wchar_t *_S2, __in size_t _N)
+{
+	(_N1);
+	::wmemcpy(_S1, _S2, _N);
+}
+
+inline void __cdecl memmove_s(__out_bcount(_S1max) void *_S1, __in size_t _S1max, __in_bcount(_N) const void *_S2, __in size_t _N)
+{
+	(_S1max);
+	memmove(_S1, _S2, _N);
+}
+
+inline void __cdecl strcpy_s(__out_ecount_z(_S1max) char *_S1, __in size_t _S1max, __in_z const char *_S2)
+{
+	(_S1max);
+	::strcpy(_S1, _S2);
+}
+
+inline void __cdecl wcscpy_s(__out_ecount_z(_S1max) wchar_t *_S1, __in size_t _S1max, __in_z const wchar_t *_S2)
+{
+	(_S1max);
+	::wcscpy(_S1, _S2);
+}
+
+inline void __cdecl tcscpy_s(__out_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcscpy(_Dst, _Src);
+#else
+#ifdef UNICODE
+	::wcscpy(_Dst, _Src);
+#else
+	::strcpy(_Dst, _Src);
+#endif
+#endif
+}
+
+/* ensure that strncpy_s null-terminate the dest string */
+inline errno_t __cdecl strncpy_s(__out_ecount_z(_SizeInChars) char *_Dest, __in size_t _SizeInChars, __in_z const char *_Source,__in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		_Count = _SizeInChars - 1;
+	}
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline errno_t __cdecl wcsncpy_s(__out_ecount_z(_SizeInChars) wchar_t *_Dest, __in size_t _SizeInChars, __in_z const wchar_t *_Source, __in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		_Count = _SizeInChars - 1;
+	}
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline errno_t __cdecl tcsncpy_s(__out_ecount_z(_SizeInChars) TCHAR *_Dest, __in size_t _SizeInChars, __in_z const TCHAR *_Source,__in size_t _Count)
+{
+	if (_Count == _TRUNCATE)
+	{
+		if(_SizeInChars>0)
+		{
+			_Count = _SizeInChars - 1;
+		}
+		else
+		{
+			_Count =0;
+		}
+	}
+
+#ifndef _ATL_MIN_CRT
+#pragma warning(push)
+#pragma warning(disable: 6535)
+	::_tcsncpy(_Dest,_Source,_Count);
+#pragma warning(pop)
+	if(_SizeInChars>0)
+	{
+		size_t nulCount = __min(_SizeInChars-1, _Count);
+		_Dest[nulCount] = 0;
+	}
+#else
+	while (_Count > 0 && *_Source != 0)
+	{
+		*_Dest++ = *_Source++;
+		--_Count;
+	}
+	*_Dest = 0;
+#endif
+
+	return (*_Source!=0) ? STRUNCATE : 0;
+}
+
+inline void __cdecl strcat_s(__inout_ecount_z(_SizeInChars) char * _Dst, __in size_t _SizeInChars, __in_z const char * _Src)
+{
+	(_SizeInChars);
+	::strcat(_Dst, _Src);
+}
+
+inline void __cdecl wcscat_s(__inout_ecount_z(_SizeInChars) wchar_t * _Dst, __in size_t _SizeInChars, __in_z const wchar_t * _Src)
+{
+	(_SizeInChars);
+	::wcscat(_Dst, _Src);
+}
+
+inline void __cdecl tcscat_s(__inout_ecount_z(_SizeInChars) TCHAR * _Dst, __in size_t _SizeInChars, __in_z const TCHAR * _Src)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcscat(_Dst, _Src);
+#else
+#ifdef UNICODE
+	::wcscat(_Dst, _Src);
+#else
+	::strcat(_Dst, _Src);
+#endif
+#endif
+}
+
+inline void __cdecl strlwr_s(__inout_ecount_z(_SizeInChars) char * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_strlwr(_Str);	
+}
+
+inline void __cdecl wcslwr_s(__inout_ecount_z(_SizeInChars) wchar_t * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_wcslwr(_Str);	
+}
+
+inline void __cdecl mbslwr_s(__inout_bcount_z(_SizeInChars) unsigned char * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+	::_mbslwr(_Str);
+}
+
+inline void __cdecl tcslwr_s(__inout_ecount_z(_SizeInChars) TCHAR * _Str, size_t _SizeInChars)
+{
+	(_SizeInChars);
+#ifndef _ATL_MIN_CRT
+	::_tcslwr(_Str);
+#else
+#ifdef UNICODE
+	::_wcslwr(_Str);
+#else
+	::_strlwr(_Str);
+#endif
+#endif
+}
+
+inline void __cdecl itoa_s(__in int _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_itoa_s(_Val, _Buf, _SizeInChars, _Radix);
+}
+
+inline void __cdecl itot_s(__in int _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_itot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ltoa_s(__in long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ltoa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ltot_s(__in long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ltot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultoa_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultoa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultow_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ultot_s(__in unsigned long _Val, __out_ecount_z(_SizeInChars) TCHAR *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ultot(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl i64toa_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_i64toa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl i64tow_s(__in __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_i64tow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ui64toa_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) char *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ui64toa(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl ui64tow_s(__in unsigned __int64 _Val, __out_ecount_z(_SizeInChars) wchar_t *_Buf, __in size_t _SizeInChars, __in int _Radix)
+{
+	(_SizeInChars);
+	::_ui64tow(_Val, _Buf, _Radix);
+}
+
+inline void __cdecl gcvt_s(__out_ecount_z(_SizeInChars) char *_Buffer, __in size_t _SizeInChars, __in double _Value, __in int _Ndec)
+{
+	(_SizeInChars);
+	::_gcvt(_Value, _Ndec, _Buffer);
+}
+
+inline void __cdecl tsplitpath_s(__in_z const TCHAR *_Path, __out_ecount_z_opt(_Drive_len) TCHAR *_Drive, __in size_t _Drive_len, 
+	__out_ecount_z_opt(_Dir_len) TCHAR *_Dir, __in size_t _Dir_len, 
+	__out_ecount_z_opt(_Fname_ext) TCHAR *_Fname, __in size_t _Fname_len, 
+	__out_ecount_z_opt(_Ext_len) TCHAR *_Ext, __in size_t _Ext_len)
+{
+	(_Drive_len, _Dir_len, _Fname_len, _Ext_len);
+	::_tsplitpath(_Path, _Drive, _Dir, _Fname, _Ext);
+}
+
+inline void __cdecl tmakepath_s(__out_ecount_z(_SizeInChars) TCHAR *_Path, __in size_t _SizeInChars, __in_z const TCHAR *_Drive, 
+	__in_z const TCHAR *_Dir, __in_z const TCHAR *_Fname, __in_z const TCHAR *_Ext)
+{
+	(_SizeInChars);
+	::_tmakepath(_Path, _Drive, _Dir, _Fname, _Ext);
+}
+
+inline size_t __cdecl strnlen(__in_ecount(_Maxsize) const char *_Str, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::strlen(_Str);
+}
+
+inline size_t __cdecl wcsnlen(__in_ecount(_Maxsize) const wchar_t *_Wcs, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::wcslen(_Wcs);
+}
+
+inline size_t __cdecl tcsnlen(__in_ecount(_Maxsize) const TCHAR *_Str, __in size_t _Maxsize)
+{
+	(_Maxsize);
+	return ::_tcslen(_Str);
+}
+
+inline int get_errno()
+{
+	return errno;
+}
+
+inline void set_errno(__in int _Value)
+{
+	errno = _Value;
+}
+
+#endif // _SECURE_ATL
+
+} // namespace Checked
+
+} // namespace ATL
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // __ATLCHECKED_H__
+
+/////////////////////////////////////////////////////////////////////////////
+

cpp/jacob/include/atlcore.h

@@ -0,0 +1,554 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the	
+// Active Template Library product.
+
+#ifndef __ATLCORE_H__
+#define __ATLCORE_H__
+
+#pragma once
+
+#ifdef _ATL_ALL_WARNINGS
+#pragma warning( push )
+#endif
+
+#pragma warning(disable: 4786) // identifier was truncated in the debug information
+#pragma warning(disable: 4127) // constant expression
+
+#include <atldef.h>
+#include <windows.h>
+#include <ole2.h>
+
+#include <limits.h>
+#include <tchar.h>
+#include <mbstring.h>
+
+#include <atlchecked.h>
+#include <atlsimpcoll.h>
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+/////////////////////////////////////////////////////////////////////////////
+// Verify that a null-terminated string points to valid memory
+inline BOOL AtlIsValidString(LPCWSTR psz, size_t nMaxLength = INT_MAX)
+{
+	(nMaxLength);
+	return (psz != NULL);
+}
+
+// Verify that a null-terminated string points to valid memory
+inline BOOL AtlIsValidString(LPCSTR psz, size_t nMaxLength = UINT_MAX)
+{
+	(nMaxLength);
+	return (psz != NULL);
+}
+
+// Verify that a pointer points to valid memory
+inline BOOL AtlIsValidAddress(const void* p, size_t nBytes,
+	BOOL bReadWrite = TRUE)
+{
+	(bReadWrite);
+	(nBytes);
+	return (p != NULL);
+}
+
+template<typename T>
+inline void AtlAssertValidObject(const T *pOb)
+{
+	ATLASSERT(pOb);
+	ATLASSERT(AtlIsValidAddress(pOb, sizeof(T)));
+	if(pOb)
+		pOb->AssertValid();
+}
+#ifdef _DEBUG
+#define ATLASSERT_VALID(x) ATL::AtlAssertValidObject(x)
+#else
+#define ATLASSERT_VALID(x) __noop;
+#endif
+
+// COM Sync Classes
+class CComCriticalSection
+{
+public:
+	CComCriticalSection() throw()
+	{
+		memset(&m_sec, 0, sizeof(CRITICAL_SECTION));
+	}
+	~CComCriticalSection()
+	{
+	}
+	HRESULT Lock() throw()
+	{
+		EnterCriticalSection(&m_sec);
+		return S_OK;
+	}
+	HRESULT Unlock() throw()
+	{
+		LeaveCriticalSection(&m_sec);
+		return S_OK;
+	}
+	HRESULT Init() throw()
+	{
+		HRESULT hRes = E_FAIL;
+		__try
+		{
+			InitializeCriticalSection(&m_sec);
+			hRes = S_OK;
+		}
+		// structured exception may be raised in low memory situations
+		__except(STATUS_NO_MEMORY == GetExceptionCode())
+		{			
+			hRes = E_OUTOFMEMORY;		
+		}
+		return hRes;
+	}
+
+	HRESULT Term() throw()
+	{
+		DeleteCriticalSection(&m_sec);
+		return S_OK;
+	}	
+	CRITICAL_SECTION m_sec;
+};
+
+class CComAutoCriticalSection : public CComCriticalSection
+{
+public:
+	CComAutoCriticalSection()
+	{
+		HRESULT hr = CComCriticalSection::Init();
+		if (FAILED(hr))
+			AtlThrow(hr);
+	}
+	~CComAutoCriticalSection() throw()
+	{
+		CComCriticalSection::Term();
+	}
+private :
+	HRESULT Init(); // Not implemented. CComAutoCriticalSection::Init should never be called
+	HRESULT Term(); // Not implemented. CComAutoCriticalSection::Term should never be called
+};
+
+class CComSafeDeleteCriticalSection : public CComCriticalSection
+{
+public:
+	CComSafeDeleteCriticalSection(): m_bInitialized(false) 
+	{
+	}
+
+	~CComSafeDeleteCriticalSection() throw()
+	{
+		if (!m_bInitialized)
+		{
+			return;
+		}
+		m_bInitialized = false;
+		CComCriticalSection::Term();
+	}
+
+	HRESULT Init() throw()
+	{
+		ATLASSERT( !m_bInitialized );
+		HRESULT hr = CComCriticalSection::Init();
+		if (SUCCEEDED(hr))
+		{
+			m_bInitialized = true;
+		}
+		return hr;
+	}
+
+	HRESULT Term() throw()
+	{
+		if (!m_bInitialized)
+		{
+			return S_OK;
+		}
+		m_bInitialized = false;
+		return CComCriticalSection::Term();
+	}
+
+	HRESULT Lock()
+	{
+		// CComSafeDeleteCriticalSection::Init or CComAutoDeleteCriticalSection::Init
+		// not called or failed.
+		// m_critsec member of CComObjectRootEx is now of type 
+		// CComAutoDeleteCriticalSection. It has to be initialized
+		// by calling CComObjectRootEx::_AtlInitialConstruct
+		ATLASSUME(m_bInitialized);
+		return CComCriticalSection::Lock();
+	}
+
+private:
+	bool m_bInitialized;
+};
+
+class CComAutoDeleteCriticalSection : public CComSafeDeleteCriticalSection
+{
+private:
+	// CComAutoDeleteCriticalSection::Term should never be called
+	HRESULT Term() throw();
+};
+
+class CComFakeCriticalSection
+{
+public:
+	HRESULT Lock() throw() { return S_OK; }
+	HRESULT Unlock() throw() { return S_OK; }
+	HRESULT Init() throw() { return S_OK; }
+	HRESULT Term() throw() { return S_OK; }
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Module 
+
+// Used by any project that uses ATL
+struct _ATL_BASE_MODULE70
+{
+	UINT cbSize;
+	HINSTANCE m_hInst;
+	HINSTANCE m_hInstResource;
+	bool m_bNT5orWin98;
+	DWORD dwAtlBuildVer;
+	const GUID* pguidVer;
+	CComCriticalSection m_csResource;
+	CSimpleArray<HINSTANCE> m_rgResourceInstance;
+};
+typedef _ATL_BASE_MODULE70 _ATL_BASE_MODULE;
+
+class CAtlBaseModule : public _ATL_BASE_MODULE
+{
+public :
+	static bool m_bInitFailed;
+	CAtlBaseModule() throw();
+	~CAtlBaseModule() throw ();
+
+	HINSTANCE GetModuleInstance() throw()
+	{
+		return m_hInst;
+	}
+	HINSTANCE GetResourceInstance() throw()
+	{
+		return m_hInstResource;
+	}
+	HINSTANCE SetResourceInstance(HINSTANCE hInst) throw()
+	{
+		return static_cast< HINSTANCE >(InterlockedExchangePointer((void**)&m_hInstResource, hInst));
+	}
+
+	bool AddResourceInstance(HINSTANCE hInst) throw();
+	bool RemoveResourceInstance(HINSTANCE hInst) throw();
+	HINSTANCE GetHInstanceAt(int i) throw();
+};
+
+__declspec(selectany) bool CAtlBaseModule::m_bInitFailed = false;
+extern CAtlBaseModule _AtlBaseModule;
+
+/////////////////////////////////////////////////////////////////////////////
+// String resource helpers
+
+#pragma warning(push)
+#pragma warning(disable: 4200)
+	struct ATLSTRINGRESOURCEIMAGE
+	{
+		WORD nLength;
+		__field_ecount(nLength) WCHAR achString[];
+	};
+#pragma warning(pop)	// C4200
+
+inline const ATLSTRINGRESOURCEIMAGE* _AtlGetStringResourceImage( HINSTANCE hInstance, HRSRC hResource, UINT id ) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* pImage;
+	const ATLSTRINGRESOURCEIMAGE* pImageEnd;
+	ULONG nResourceSize;
+	HGLOBAL hGlobal;
+	UINT iIndex;
+
+	hGlobal = ::LoadResource( hInstance, hResource );
+	if( hGlobal == NULL )
+	{
+		return( NULL );
+	}
+
+	pImage = (const ATLSTRINGRESOURCEIMAGE*)::LockResource( hGlobal );
+	if( pImage == NULL )
+	{
+		return( NULL );
+	}
+
+	nResourceSize = ::SizeofResource( hInstance, hResource );
+	pImageEnd = (const ATLSTRINGRESOURCEIMAGE*)(LPBYTE( pImage )+nResourceSize);
+	iIndex = id&0x000f;
+
+	while( (iIndex > 0) && (pImage < pImageEnd) )
+	{
+		pImage = (const ATLSTRINGRESOURCEIMAGE*)(LPBYTE( pImage )+(sizeof( ATLSTRINGRESOURCEIMAGE )+(pImage->nLength*sizeof( WCHAR ))));
+		iIndex--;
+	}
+	if( pImage >= pImageEnd )
+	{
+		return( NULL );
+	}
+	if( pImage->nLength == 0 )
+	{
+		return( NULL );
+	}
+
+	return( pImage );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( HINSTANCE hInstance, UINT id ) throw()
+{
+	HRSRC hResource;
+
+	hResource = ::FindResource( hInstance, MAKEINTRESOURCE( ((id>>4)+1) ), RT_STRING );
+	if( hResource == NULL )
+	{
+		return( NULL );
+	}
+
+	return _AtlGetStringResourceImage( hInstance, hResource, id );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( HINSTANCE hInstance, UINT id, WORD wLanguage ) throw()
+{
+	HRSRC hResource;
+
+	hResource = ::FindResourceEx( hInstance, RT_STRING, MAKEINTRESOURCE( ((id>>4)+1) ), wLanguage );
+	if( hResource == NULL )
+	{
+		return( NULL );
+	}
+
+	return _AtlGetStringResourceImage( hInstance, hResource, id );
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( UINT id ) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* p = NULL;
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+
+	for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		p = AtlGetStringResourceImage(hInst, id);
+	}
+	return p;
+}
+
+inline const ATLSTRINGRESOURCEIMAGE* AtlGetStringResourceImage( UINT id, WORD wLanguage ) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* p = NULL;
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+
+	for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		p = AtlGetStringResourceImage(hInst, id, wLanguage);
+	}
+	return p;
+}
+
+inline int AtlLoadString(__in UINT nID, __out_ecount_part_z(nBufferMax, return + 1) LPTSTR lpBuffer, __in int nBufferMax) throw()
+{
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+	int nRet = 0;
+
+	for (int i = 1; hInst != NULL && nRet == 0; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		nRet = LoadString(hInst, nID, lpBuffer, nBufferMax);
+	}
+	return nRet;
+}
+
+inline HINSTANCE AtlFindResourceInstance(LPCTSTR lpName, LPCTSTR lpType, WORD wLanguage = 0) throw()
+{
+	ATLASSERT(lpType != RT_STRING);	// Call AtlFindStringResourceInstance to find the string
+	if (lpType == RT_STRING)
+		return NULL;
+
+	if (ATL_IS_INTRESOURCE(lpType))
+	{
+		/* Prefast false warnings caused by bad-shaped definition of MAKEINTRESOURCE macro from PSDK */
+		if (lpType == ATL_RT_ICON)
+		{
+			lpType = ATL_RT_GROUP_ICON;
+		}
+		else if (lpType == ATL_RT_CURSOR)
+		{
+			lpType = ATL_RT_GROUP_CURSOR;
+		}
+	}
+
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+	HRSRC hResource = NULL;
+
+	for (int i = 1; hInst != NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		hResource = ::FindResourceEx(hInst, lpType, lpName, wLanguage);
+		if (hResource != NULL)
+		{
+			return hInst;
+		}
+	}
+
+	return NULL;
+}
+
+inline HINSTANCE AtlFindResourceInstance(UINT nID, LPCTSTR lpType, WORD wLanguage = 0) throw()
+{
+	return AtlFindResourceInstance(MAKEINTRESOURCE(nID), lpType, wLanguage);
+}
+
+inline HINSTANCE AtlFindStringResourceInstance(UINT nID, WORD wLanguage = 0) throw()
+{
+	const ATLSTRINGRESOURCEIMAGE* p = NULL;
+	HINSTANCE hInst = _AtlBaseModule.GetHInstanceAt(0);
+
+	for (int i = 1; hInst != NULL && p == NULL; hInst = _AtlBaseModule.GetHInstanceAt(i++))
+	{
+		p = AtlGetStringResourceImage(hInst, nID, wLanguage);
+		if (p != NULL)
+			return hInst;
+	}
+
+	return NULL;
+}
+
+/* 
+Needed by both atlcomcli and atlsafe, so needs to be in here 
+*/
+inline HRESULT AtlSafeArrayGetActualVartype
+(
+    SAFEARRAY *psaArray,
+    VARTYPE *pvtType
+)
+{
+    HRESULT hrSystem=::SafeArrayGetVartype(psaArray, pvtType);
+
+    if(FAILED(hrSystem))
+    {
+        return hrSystem;
+    }
+
+    /* 
+    When Windows has a SAFEARRAY of type VT_DISPATCH with FADF_HAVEIID,
+    it returns VT_UNKNOWN instead of VT_DISPATCH. We patch the value to be correct
+    */
+    if(pvtType && *pvtType==VT_UNKNOWN)
+    {
+        if(psaArray && ((psaArray->fFeatures & FADF_HAVEIID)!=0))
+        {
+            if(psaArray->fFeatures & FADF_DISPATCH)
+            {
+                *pvtType=VT_DISPATCH;
+            }
+        }
+    }
+
+    return hrSystem;
+}
+template <typename _CharType>
+inline _CharType* AtlCharNext(const _CharType* p) throw()
+{
+	ATLASSUME(p != NULL);	// Too expensive to check separately here 
+	if (*p == '\0')  // ::CharNextA won't increment if we're at a \0 already
+		return const_cast<_CharType*>(p+1);
+	else
+		return ::CharNextA(p);
+}
+
+template <>
+inline wchar_t* AtlCharNext<wchar_t>(const wchar_t* p) throw()
+{
+	return const_cast< wchar_t* >( p+1 );
+}
+template<typename CharType>
+inline const CharType* AtlstrchrT(const CharType* p, CharType ch) throw()
+{
+	ATLASSERT(p != NULL);	
+	if(p==NULL)
+	{
+		return NULL;
+	}
+	while( *p != 0 )
+	{
+		if (*p == ch)
+		{
+			return p;
+		}
+		p = AtlCharNext(p);
+	}
+	//strchr for '\0' should succeed - the while loop terminates 
+	//*p == 0, but ch also == 0, so NULL terminator address is returned
+	return (*p == ch) ? p : NULL;
+}
+//Ansi and Unicode versions of printf, used with templated CharType trait classes.
+#pragma warning(push)
+#pragma warning(disable : 4793)
+template<typename CharType>
+inline int AtlprintfT(const CharType* pszFormat,... ) throw()
+{
+	int retval=0;
+	va_list argList;
+	va_start( argList, pszFormat );
+	retval=vprintf(pszFormat,argList);
+	va_end( argList );
+	return retval;
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+template<>
+inline int AtlprintfT(const wchar_t* pszFormat,... ) throw()
+{
+	int retval=0;
+	va_list argList;
+	va_start( argList, pszFormat );
+	retval=vwprintf(pszFormat,	argList);
+	va_end( argList );
+	return retval;
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4068 28110)
+
+inline BOOL AtlConvertSystemTimeToVariantTime(const SYSTEMTIME& systimeSrc,double* pVarDtTm)
+{
+	ATLENSURE(pVarDtTm!=NULL);
+	//Convert using ::SystemTimeToVariantTime and store the result in pVarDtTm then
+	//convert variant time back to system time and compare to original system time.	
+
+	BOOL ok = ::SystemTimeToVariantTime(const_cast<SYSTEMTIME*>(&systimeSrc), pVarDtTm);
+
+	SYSTEMTIME sysTime;
+	::ZeroMemory(&sysTime, sizeof(SYSTEMTIME));
+
+	ok = ok && ::VariantTimeToSystemTime(*pVarDtTm, &sysTime);
+	ok = ok && (systimeSrc.wYear == sysTime.wYear &&
+			systimeSrc.wMonth == sysTime.wMonth &&
+			systimeSrc.wDay == sysTime.wDay &&
+			systimeSrc.wHour == sysTime.wHour &&
+			systimeSrc.wMinute == sysTime.wMinute && 
+			systimeSrc.wSecond == sysTime.wSecond);
+
+	return ok;
+}
+#pragma warning(pop)
+
+/////////////////////////////////////////////////////////////////////////////
+
+}	// namespace ATL
+#pragma pack(pop)
+
+#ifdef _ATL_ALL_WARNINGS
+#pragma warning( pop )
+#endif
+
+#endif	// __ATLCORE_H__
+

cpp/jacob/include/atldef.h

@@ -0,0 +1,668 @@
+
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLDEF_H__
+#define __ATLDEF_H__
+
+#pragma once
+
+#pragma warning(disable : 4619)	// there is no warning number
+
+#include <atlrc.h>
+#include <errno.h>
+#include <sal.h>
+
+#ifndef RC_INVOKED
+
+#ifndef __cplusplus
+	#error ATL requires C++ compilation (use a .cpp suffix)
+#endif
+
+#ifdef UNDER_CE
+	#error This version of ATL is not currently supported for CE. Look for the CE specific version.
+#endif
+
+// If you are mixing compilation units that are built as
+// native code with those that are built /clr, you must define
+// the symbol '_ATL_MIXED'. _ATL_MIXED must be defined for all 
+// compilation units in an executable or it must be defined for none of them.
+#if !defined(_ATL_MIXED)
+namespace Inconsistent_definition_of_symbol__ATL_MIXED
+{
+	struct _Please_define_it_the_same_throughout_your_project { };
+}
+#else
+namespace Inconsistent_definition_of_symbol__ATL_MIXED
+{
+#ifdef _M_IX86
+#pragma comment(linker, "/include:??3@YAXPAX@Z")
+#else
+#pragma comment(linker, "/include:??3@YAXPEAX@Z")
+#endif
+	struct _Please_define_it_the_same_throughout_your_project { virtual void one(){} };
+}
+#endif
+namespace Inconsistent_definition_of_symbol__ATL_MIXED
+{
+	__declspec(selectany) _Please_define_it_the_same_throughout_your_project clash = _Please_define_it_the_same_throughout_your_project ();
+}
+
+#if !defined(_ATL_MIXED)
+namespace Define_the_symbol__ATL_MIXED
+{
+#if defined(_M_CEE)
+	struct Thank_you { };
+#else
+#ifdef _M_IX86
+#pragma comment(linker, "/include:??3@YAXPAX@Z")
+#else
+#pragma comment(linker, "/include:??3@YAXPEAX@Z")
+#endif
+	struct Thank_you { virtual void one(){} };
+#endif
+	__declspec(selectany) Thank_you clash = Thank_you();
+}
+#endif
+
+#if defined(_ATL_MIXED)
+#define _ATL_NATIVE_INITIALIZATION
+#endif
+
+#if !defined(_M_CEE)
+#define _ATL_NATIVE_INITIALIZATION
+#endif
+
+#ifdef _UNICODE
+#ifndef UNICODE
+#define UNICODE         // UNICODE is used by Windows headers
+#endif
+#endif
+
+#ifdef UNICODE
+#ifndef _UNICODE
+#define _UNICODE        // _UNICODE is used by C-runtime/MFC headers
+#endif
+#endif
+
+#ifdef _DEBUG
+#ifndef DEBUG
+#define DEBUG
+#endif
+#endif
+
+#ifdef _WIN64
+#define _ATL_SUPPORT_VT_I8  // Always support VT_I8 on Win64.
+#endif
+
+#if !defined(UNALIGNED)
+#if defined(_M_IA64) || defined(_M_AMD64)
+#define UNALIGNED __unaligned
+#else
+#define UNALIGNED
+#endif
+#endif
+
+#if !defined(_countof)
+#if !defined(__cplusplus)
+#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+#else
+extern "C++"
+{
+template <typename _CountofType, size_t _SizeOfArray>
+char (*__countof_helper(UNALIGNED _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+#define _countof(_Array) sizeof(*__countof_helper(_Array))
+}
+#endif
+#endif
+
+#ifndef AtlThrow
+#ifndef _ATL_CUSTOM_THROW
+#define AtlThrow ATL::AtlThrowImpl
+#endif
+#endif // AtlThrow
+
+#ifndef ATLASSERT
+#define ATLASSERT(expr) _ASSERTE(expr)
+#endif // ATLASSERT
+
+/* 
+Why does ATLASSUME exist?
+
+ATL 8 has two existing validation models
+
+ATLASSERT/ATLVERIFY - These are used to make sure a debug build reports a problem with the expression/invariant
+ATLENSURE - Debug is the same as ATLVERIFY, retail throws a C++ exception
+
+We added ATLENSURE because there were too many unreported error paths in ATL and we wanted to bail out of more
+error conditions rather than just trying to continue in retail.
+
+There might be a case for changing 'lots' of ATLASSERT to ATLENSURE, but we chose an incremental approach and only
+changed over where we saw a problem with code reported from a customer or test case. This reduces code churn in our
+code for this version.
+
+In general, our approach is to try to make sure that when something goes wrong
+- the client does not continue to run, because we report an error condition
+- debug builds see an assertion about the problem
+
+Sometimes we have code like
+
+HRESULT ComMethod(void)
+{
+	ATLASSUME(m_pFoo);
+	return m_pFoo->Method();
+}
+
+We could add
+	if(!m_pFoo) return E_POINTER;
+
+But this is very unlikely to help, since it removes the ability of the developer to debug this problem if it's seen in a retail
+build of the application. 
+
+We could try something more severe
+
+	if(!m_pFoo) terminate(); // or your favourite shutdown function
+
+This would ensure good reporting (because VC8 terminate generates a Windows Error Report and crash dump), but hardly seems a big win 
+over the previous crash.
+
+ATLENSURE might seem slightly better. It is debuggable and consistent with ATL in general. In fact, many parts of ATL do just this. 
+But in this specific context, it doesn't look like a great choice. COM methods should not in general be emitting native C++ exceptions 
+as an error reporting strategy. 
+
+So we find ourselves in a quandry. For these kinds of methods, the traditional code (ATLASSERT followed by a crash), seems be the most 
+debuggable thing to do in this situation. At least for VS8, we have decided to stick with this shape.
+
+---
+
+Now consider the impact of cl /analyze. We want cl /analyze to not warn about our potential dereferences when they refer to member variables
+whose state was previously validated by another method. But we do want to see the impact of function contracts on the parameters of the
+function. 
+
+So we've done a broad replace of all the member-related ATLASSERT to ATLASSUME. 
+
+*/
+
+#ifndef ATLASSUME
+#define ATLASSUME(expr) do { ATLASSERT(expr); __analysis_assume(!!(expr)); } while(0)
+#endif // ATLASSERT
+
+#ifndef ATLVERIFY
+#ifdef _DEBUG
+#define ATLVERIFY(expr) ATLASSERT(expr)
+#else
+#define ATLVERIFY(expr) (expr)
+#endif // DEBUG
+#endif // ATLVERIFY
+
+#ifndef ATLENSURE_THROW
+#define ATLENSURE_THROW(expr, hr)          \
+do {                                       \
+	int __atl_condVal=!!(expr);            \
+	ATLASSERT(__atl_condVal);              \
+	if(!(__atl_condVal)) AtlThrow(hr);     \
+} while (0)
+#endif // ATLENSURE
+
+#ifndef ATLENSURE
+#define ATLENSURE(expr) ATLENSURE_THROW(expr, E_FAIL)
+#endif // ATLENSURE
+
+#ifndef ATLENSURE_SUCCEEDED
+#define ATLENSURE_SUCCEEDED(hr) ATLENSURE_THROW(SUCCEEDED(hr), hr)
+#endif // ATLENSURE
+
+/* Used inside COM methods that do not want to throw */
+#ifndef ATLENSURE_RETURN_HR
+#define ATLENSURE_RETURN_HR(expr, hr)          \
+do {                                           \
+	int __atl_condVal=!!(expr);                \
+	ATLASSERT(__atl_condVal);                  \
+	if(!(__atl_condVal)) return hr;            \
+} while (0) 
+#endif 
+
+/* Used inside COM methods that do not want to throw */
+#ifndef ATLENSURE_RETURN
+#define ATLENSURE_RETURN(expr) ATLENSURE_RETURN_HR(expr, E_FAIL)
+#endif
+
+/* generic version that returns 2nd expr if 1st is false; no implication of HRESULT */
+#ifndef ATLENSURE_RETURN_VAL
+#define ATLENSURE_RETURN_VAL ATLENSURE_RETURN_HR
+#endif
+
+#if defined(_SECURE_ATL)
+#error Do not define _SECURE_ATL.
+#undef _SECURE_ATL
+#endif
+#define _SECURE_ATL 1
+
+#if _SECURE_ATL
+
+#ifndef ATL_CRT_ERRORCHECK
+#define ATL_CRT_ERRORCHECK(expr) AtlCrtErrorCheck(expr)
+#endif // ATL_CRT_ERRORCHECK
+
+#ifndef ATL_CRT_ERRORCHECK_SPRINTF
+#define ATL_CRT_ERRORCHECK_SPRINTF(expr) \
+do { \
+	errno_t _saveErrno = errno; \
+	errno = 0; \
+	(expr); \
+	if(0 != errno) \
+	{ \
+		AtlCrtErrorCheck(errno); \
+	} \
+	else \
+	{ \
+		errno = _saveErrno; \
+	} \
+} while (0)
+#endif // ATL_CRT_ERRORCHECK_SPRINTF
+
+#else // !_SECURE_ATL
+
+#define ATL_CRT_ERRORCHECK(expr) do { expr; } while (0)
+#define ATL_CRT_ERRORCHECK_SPRINTF(expr) do { expr; } while (0)
+
+#endif // _SECURE_ATL
+
+///////////////////////////////////////////////////////////////////////////////
+// __declspec(novtable) is used on a class declaration to prevent the vtable
+// pointer from being initialized in the constructor and destructor for the
+// class.  This has many benefits because the linker can now eliminate the
+// vtable and all the functions pointed to by the vtable.  Also, the actual
+// constructor and destructor code are now smaller.
+///////////////////////////////////////////////////////////////////////////////
+// This should only be used on a class that is not directly createable but is
+// rather only used as a base class.  Additionally, the constructor and
+// destructor (if provided by the user) should not call anything that may cause
+// a virtual function call to occur back on the object.
+///////////////////////////////////////////////////////////////////////////////
+// By default, the wizards will generate new ATL object classes with this
+// attribute (through the ATL_NO_VTABLE macro).  This is normally safe as long
+// the restriction mentioned above is followed.  It is always safe to remove
+// this macro from your class, so if in doubt, remove it.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef _ATL_DISABLE_NO_VTABLE
+#define ATL_NO_VTABLE
+#else
+#define ATL_NO_VTABLE __declspec(novtable)
+#endif
+
+#ifdef _ATL_DISABLE_NOTHROW
+#define ATL_NOTHROW
+#else
+#define ATL_NOTHROW __declspec(nothrow)
+#endif
+
+#ifdef _ATL_DISABLE_FORCEINLINE
+#define ATL_FORCEINLINE
+#else
+#define ATL_FORCEINLINE __forceinline
+#endif
+
+#ifdef _ATL_DISABLE_NOINLINE
+#define ATL_NOINLINE
+#else
+#define ATL_NOINLINE __declspec( noinline )
+#endif
+
+#if defined(_ATL_DISABLE_DEPRECATED) || (defined(_PREFAST_) && (_MSC_VER < 1400))
+#define ATL_DEPRECATED(_Message)
+#else
+#define ATL_DEPRECATED(_Message) __declspec( deprecated(_Message) )
+#endif
+
+// If ATL80.DLL is being used then _ATL_STATIC_REGISTRY doesn't really make sense
+#ifdef _ATL_DLL
+#undef _ATL_STATIC_REGISTRY
+#else
+// If not linking to ATL80.DLL, use the static registrar and not building atl.dll
+#ifndef _ATL_DLL_IMPL
+#ifndef _ATL_STATIC_REGISTRY
+#define _ATL_STATIC_REGISTRY
+#endif
+#endif
+#endif
+
+#ifdef _ATL_DEBUG_REFCOUNT
+#ifndef _ATL_DEBUG_INTERFACES
+#define _ATL_DEBUG_INTERFACES
+#endif
+#endif
+
+#ifdef _DEBUG
+#ifndef _ATL_DEBUG
+#define _ATL_DEBUG
+#endif // _ATL_DEBUG
+#endif // _DEBUG
+
+#ifdef _ATL_DEBUG_INTERFACES
+#ifndef _ATL_DEBUG
+#define _ATL_DEBUG
+#endif // _ATL_DEBUG
+#endif // _ATL_DEBUG_INTERFACES
+
+#ifndef _ATL_HEAPFLAGS
+#ifdef _MALLOC_ZEROINIT
+#define _ATL_HEAPFLAGS HEAP_ZERO_MEMORY
+#else
+#define _ATL_HEAPFLAGS 0
+#endif
+#endif
+
+#ifndef _ATL_PACKING
+#define _ATL_PACKING 8
+#endif
+
+#if defined(_ATL_DLL)
+	#define ATLAPI extern "C" HRESULT __declspec(dllimport) __stdcall
+	#define ATLAPI_(x) extern "C" __declspec(dllimport) x __stdcall
+	#define ATLINLINE
+	#define ATLAPIINL extern "C" inline HRESULT __stdcall
+	#define ATLAPIINL_(x) extern "C" inline x __stdcall
+#elif defined(_ATL_DLL_IMPL)
+	#define ATLAPI extern "C" inline HRESULT __stdcall
+	#define ATLAPI_(x) extern "C" inline x __stdcall
+	#define ATLAPIINL ATLAPI
+	#define ATLAPIINL_(x) ATLAPI_(x)
+	#define ATLINLINE
+#else
+	#define ATLAPI __declspec(nothrow) HRESULT __stdcall
+	#define ATLAPI_(x) __declspec(nothrow) x __stdcall
+	#define ATLAPIINL ATLAPI
+	#define ATLAPIINL_(x) ATLAPI_(x)
+	#define ATLINLINE inline
+#endif
+
+#ifdef _ATL_NO_EXCEPTIONS
+	#ifdef _AFX
+	#error MFC projects cannot define _ATL_NO_EXCEPTIONS
+	#endif
+#else
+	#ifndef _CPPUNWIND
+	#define _ATL_NO_EXCEPTIONS
+	#endif
+#endif
+
+#ifdef _CPPUNWIND
+
+#ifndef ATLTRYALLOC
+
+#ifdef _AFX
+#define ATLTRYALLOC(x) try{x;} catch(CException* e){e->Delete();}
+#else
+/* prefast noise VSW 489981 */
+#define ATLTRYALLOC(x) __pragma(warning(push)) __pragma(warning(disable: 4571)) try{x;} catch(...) {} __pragma(warning(pop))
+#endif	//__AFX
+
+#endif	//ATLTRYALLOC
+
+// If you define _ATLTRY before including this file, then
+// you should define _ATLCATCH and _ATLRETHROW as well.
+#ifndef _ATLTRY
+#define _ATLTRY try
+#ifdef _AFX
+#define _ATLCATCH( e ) catch( CException* e )
+#else
+#define _ATLCATCH( e ) catch( CAtlException e )
+#endif
+
+#define _ATLCATCHALL() __pragma(warning(push)) __pragma(warning(disable: 4571)) catch( ... ) __pragma(warning(pop))
+
+#ifdef _AFX
+#define _ATLDELETEEXCEPTION(e) e->Delete();
+#else
+#define _ATLDELETEEXCEPTION(e) e;
+#endif
+
+#define _ATLRETHROW throw
+#endif	// _ATLTRY
+
+/* 
+COM functions should not throw. Which means we should protect their callers from C++ exceptions leaking out. These macros
+can help with that, though they have not yet been applied to the whole of ATL, which uses a variety of patterns to achieve
+this end
+*/
+ 
+#ifndef _ATL_COM_BEGIN 
+#define _ATL_COM_BEGIN \
+	HRESULT __hrAtlComMethod=S_OK; \
+	try \
+	{
+#endif
+
+#ifdef _AFX
+/* Nice to do something more complex here in future to translate an MFC exception to a better HR */
+#define _AFX_COM_END_PART \
+	catch(CException *e) \
+	{ \
+		if(e) \
+		{ \
+			e->Delete(); \
+		} \
+		__hrAtlComMethod=E_FAIL; \
+	}
+#else
+#define _AFX_COM_END_PART \
+	catch(CAtlException e) \
+	{ \
+		__hrAtlComMethod=e.m_hr; \
+	}
+#endif
+
+#ifndef _ATL_COM_END 
+#define _ATL_COM_END \
+	_AFX_COM_END_PART \
+	catch(...) \
+	{ \
+		__hrAtlComMethod=E_FAIL; \
+	} \
+	return hr; 
+#endif
+
+
+
+#else //_CPPUNWIND
+
+#ifndef ATLTRYALLOC
+#define ATLTRYALLOC(x) x;
+#endif	//ATLTRYALLOC
+
+// if _ATLTRY is defined before including this file then 
+// _ATLCATCH and _ATLRETHROW should be defined as well.
+#ifndef _ATLTRY
+#define _ATLTRY
+#define _ATLCATCH( e ) __pragma(warning(push)) __pragma(warning(disable: 4127)) if( false ) __pragma(warning(pop))
+#define _ATLCATCHALL() __pragma(warning(push)) __pragma(warning(disable: 4127)) if( false ) __pragma(warning(pop))
+#define _ATLDELETEEXCEPTION(e)
+#define _ATLRETHROW
+#endif	// _ATLTRY
+
+#endif	//_CPPUNWIND
+
+#ifndef ATLTRY
+#define ATLTRY(x) ATLTRYALLOC(x)
+#endif	//ATLTRY
+
+#define offsetofclass(base, derived) ((DWORD_PTR)(static_cast<base*>((derived*)_ATL_PACKING))-_ATL_PACKING)
+
+/////////////////////////////////////////////////////////////////////////////
+// Master version numbers
+
+#define _ATL     1      // Active Template Library
+#define _ATL_VER 0x0800 // Active Template Library version 8.00
+
+/////////////////////////////////////////////////////////////////////////////
+// Threading
+
+#ifndef _ATL_SINGLE_THREADED
+#ifndef _ATL_APARTMENT_THREADED
+#ifndef _ATL_FREE_THREADED
+#define _ATL_FREE_THREADED
+#endif
+#endif
+#endif
+
+// UUIDOF
+#ifndef _ATL_NO_UUIDOF
+#define _ATL_IIDOF(x) __uuidof(x)
+#else
+#define _ATL_IIDOF(x) IID_##x
+#endif
+
+// Lean and mean
+#ifndef ATL_NO_LEAN_AND_MEAN
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMCX
+#define NOMCX
+#endif
+#endif	// ATL_NO_LEAN_AND_MEAN
+
+#ifdef NOSERVICE
+#ifndef _ATL_NO_SERVICE
+#define _ATL_NO_SERVICE
+#endif	// _ATL_NO_SERVICE
+#else
+#ifdef _ATL_NO_SERVICE
+#ifndef NOSERVICE
+#define NOSERVICE
+#endif	// NOSERVICE
+#endif	// _ATL_NO_SERVICE
+#endif	// NOSERVICE
+
+#include <malloc.h>
+#ifdef _DEBUG
+#include <stdlib.h>
+#endif
+#ifndef _ATL_NO_DEBUG_CRT
+// Warning: if you define the above symbol, you will have
+// to provide your own definition of the ATLASSERT(x) macro
+// in order to compile ATL
+	#include <crtdbg.h>
+#endif
+
+#endif // RC_INVOKED
+
+#define ATLAXWIN_CLASS	"AtlAxWin80"
+#define ATLAXWINLIC_CLASS "AtlAxWinLic80"
+
+// _ATL_INSECURE_DEPRECATE define
+#ifndef _ATL_INSECURE_DEPRECATE
+#if defined(_ATL_SECURE_NO_DEPRECATE) || (defined(_PREFAST_) && (_MSC_VER < 1400))
+#define _ATL_INSECURE_DEPRECATE(_Message)
+#else
+#define _ATL_INSECURE_DEPRECATE(_Message) __declspec(deprecated(_Message))
+#endif // _ATL_SECURE_NO_DEPRECATE
+#endif // _ATL_INSECURE_DEPRECATE
+
+/*
+This is called when something really bad happens -- so bad
+that we consider it dangerous to even throw an exception
+*/
+#ifndef _ATL_FATAL_SHUTDOWN
+#define _ATL_FATAL_SHUTDOWN do { ::TerminateProcess(::GetCurrentProcess(), 0); } while(0);
+#endif
+
+//ATL/MFC code should use standard pointer to member standard syntax &MyClass::MyMethod, instead
+//of the legacy non-standard syntax - MyMethod.
+#ifdef _ATL_ENABLE_PTM_WARNING
+#define PTM_WARNING_DISABLE
+#define PTM_WARNING_RESTORE
+#else
+#define PTM_WARNING_DISABLE \
+	__pragma(warning( push )) \
+	__pragma(warning( disable : 4867 ))
+#define PTM_WARNING_RESTORE \
+	__pragma(warning( pop ))
+#endif //_ATL_ENABLE_PTM_WARNING
+
+/* we have to define our own versions of MAKEINTRESOURCE and IS_INTRESOURCE to 
+ * fix warning 6268. At least until those macros are not cleanend in PSDK.
+   Same comes true for those definitions of constants which use the above macros
+*/
+#define ATL_MAKEINTRESOURCEA(i) ((LPSTR)((ULONG_PTR)((WORD)(i))))
+#define ATL_MAKEINTRESOURCEW(i) ((LPWSTR)((ULONG_PTR)((WORD)(i))))
+#ifdef UNICODE
+#define ATL_MAKEINTRESOURCE  ATL_MAKEINTRESOURCEW
+#else
+#define ATL_MAKEINTRESOURCE  ATL_MAKEINTRESOURCEA
+#endif // !UNICODE
+#define ATL_IS_INTRESOURCE(_r) ((((ULONG_PTR)(_r)) >> 16) == 0)
+
+/*
+ * Predefined Resource Types
+ */
+#define ATL_RT_CURSOR           ATL_MAKEINTRESOURCE(1)
+#define ATL_RT_BITMAP           ATL_MAKEINTRESOURCE(2)
+#define ATL_RT_ICON             ATL_MAKEINTRESOURCE(3)
+#define ATL_RT_MENU             ATL_MAKEINTRESOURCE(4)
+#define ATL_RT_DIALOG           ATL_MAKEINTRESOURCE(5)
+#define ATL_RT_STRING           ATL_MAKEINTRESOURCE(6)
+#define ATL_RT_FONTDIR          ATL_MAKEINTRESOURCE(7)
+#define ATL_RT_FONT             ATL_MAKEINTRESOURCE(8)
+#define ATL_RT_ACCELERATOR      ATL_MAKEINTRESOURCE(9)
+#define ATL_RT_RCDATA           ATL_MAKEINTRESOURCE(10)
+#define ATL_RT_MESSAGETABLE     ATL_MAKEINTRESOURCE(11)
+
+#define ATL_DIFFERENCE     11
+#define ATL_RT_GROUP_CURSOR ATL_MAKEINTRESOURCE((ULONG_PTR)ATL_RT_CURSOR + ATL_DIFFERENCE)
+#define ATL_RT_GROUP_ICON   ATL_MAKEINTRESOURCE((ULONG_PTR)ATL_RT_ICON + ATL_DIFFERENCE)
+#define ATL_RT_VERSION      ATL_MAKEINTRESOURCE(16)
+#define ATL_RT_DLGINCLUDE   ATL_MAKEINTRESOURCE(17)
+#if(WINVER >= 0x0400)
+#define ATL_RT_PLUGPLAY     ATL_MAKEINTRESOURCE(19)
+#define ATL_RT_VXD          ATL_MAKEINTRESOURCE(20)
+#define ATL_RT_ANICURSOR    ATL_MAKEINTRESOURCE(21)
+#define ATL_RT_ANIICON      ATL_MAKEINTRESOURCE(22)
+#endif /* WINVER >= 0x0400 */
+#define ATL_RT_HTML         ATL_MAKEINTRESOURCE(23)
+#ifdef RC_INVOKED
+#define ATL_RT_MANIFEST                        24
+#define ATL_CREATEPROCESS_MANIFEST_RESOURCE_ID  1
+#define ATL_ISOLATIONAWARE_MANIFEST_RESOURCE_ID 2
+#define ATL_ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID 3
+#define ATL_MINIMUM_RESERVED_MANIFEST_RESOURCE_ID 1   /* inclusive */
+#define ATL_MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID 16  /* inclusive */
+#else  /* RC_INVOKED */
+#define ATL_RT_MANIFEST                        ATL_MAKEINTRESOURCE(24)
+#define ATL_CREATEPROCESS_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE( 1)
+#define ATL_ISOLATIONAWARE_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(2)
+#define ATL_ISOLATIONAWARE_NOSTATICIMPORT_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(3)
+#define ATL_MINIMUM_RESERVED_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE( 1 /*inclusive*/)
+#define ATL_MAXIMUM_RESERVED_MANIFEST_RESOURCE_ID ATL_MAKEINTRESOURCE(16 /*inclusive*/)
+#endif /* RC_INVOKED */
+
+/* sal.h stuff that is not in the current LKG */
+#ifndef __out_ecount_part_z
+#define __out_ecount_part_z(size,length)                        __out_ecount_part(size,length) __post __nullterminated
+#endif
+
+#ifndef __out_ecount_part_z_opt
+#define __out_ecount_part_z_opt(size,length)                    __out_ecount_part_opt(size,length) __post __nullterminated
+#endif
+
+#ifndef __deref_opt_out_z
+#define __deref_opt_out_z                                       __deref_opt_out __post __deref __nullterminated
+#endif
+
+#ifndef __out_bcount_part_z
+#define __out_bcount_part_z(size,length)                        __out_bcount_part(size,length) __post __nullterminated
+#endif
+
+#endif // __ATLDEF_H__
+
+/////////////////////////////////////////////////////////////////////////////
+

cpp/jacob/include/atlexcept.h

@@ -0,0 +1,123 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLEXCEPT_H__
+#define __ATLEXCEPT_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atltrace.h>
+
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+/////////////////////////////////////////////////////////////////////////////
+// Exception raise (for functions that cannot return an error code)
+
+inline void __declspec(noreturn) _AtlRaiseException( DWORD dwExceptionCode, DWORD dwExceptionFlags = EXCEPTION_NONCONTINUABLE )
+{
+	RaiseException( dwExceptionCode, dwExceptionFlags, 0, NULL );
+}
+
+class CAtlException
+{
+public:
+	CAtlException() throw() :
+		m_hr( E_FAIL )
+	{
+	}
+
+	CAtlException( HRESULT hr ) throw() :
+		m_hr( hr )
+	{
+	}
+
+	operator HRESULT() const throw()
+	{
+		return( m_hr );
+	}
+
+public:
+	HRESULT m_hr;
+};
+
+#ifndef _ATL_NO_EXCEPTIONS
+
+// Throw a CAtlException with the given HRESULT
+#if defined( _ATL_CUSTOM_THROW )  // You can define your own AtlThrow to throw a custom exception.
+#ifdef _AFX
+#error MFC projects must use default implementation of AtlThrow()
+#endif
+#else
+ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowImpl( HRESULT hr )
+{
+	ATLTRACE(atlTraceException, 0, _T("AtlThrow: hr = 0x%x\n"), hr );
+#ifdef _AFX
+	if( hr == E_OUTOFMEMORY )
+	{
+		AfxThrowMemoryException();
+	}
+	else
+	{
+		AfxThrowOleException( hr );
+	}
+#else
+	throw CAtlException( hr );
+#endif
+};
+#endif
+
+// Throw a CAtlException corresponding to the result of ::GetLastError
+ATL_NOINLINE __declspec(noreturn) inline void WINAPI AtlThrowLastWin32()
+{
+	DWORD dwError = ::GetLastError();
+	AtlThrow( HRESULT_FROM_WIN32( dwError ) );
+}
+
+#else  // no exception handling
+
+// Throw a CAtlException with the given HRESULT
+#if !defined( _ATL_CUSTOM_THROW )  // You can define your own AtlThrow
+
+ATL_NOINLINE inline void WINAPI AtlThrowImpl( HRESULT hr )
+{
+	ATLTRACE(atlTraceException, 0, _T("AtlThrow: hr = 0x%x\n"), hr );
+	ATLASSERT( false );
+	DWORD dwExceptionCode;
+	switch(hr)
+	{
+	case E_OUTOFMEMORY:
+		dwExceptionCode = DWORD(STATUS_NO_MEMORY);
+		break;
+	default:
+		dwExceptionCode = DWORD(EXCEPTION_ILLEGAL_INSTRUCTION);
+		break;
+	}
+	_AtlRaiseException(dwExceptionCode);
+}
+#endif
+
+// Throw a CAtlException corresponding to the result of ::GetLastError
+ATL_NOINLINE inline void WINAPI AtlThrowLastWin32()
+{
+	DWORD dwError = ::GetLastError();
+	AtlThrow( HRESULT_FROM_WIN32( dwError ) );
+}
+
+#endif  // no exception handling
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#endif  // __ATLEXCEPT_H__
+

cpp/jacob/include/atlrc.h

@@ -0,0 +1,28 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#pragma once
+
+#ifndef __ATLRC_H__
+
+#define ATL_RESID_BASE						0xD800
+#define ATL_STRING_BASE						ATL_RESID_BASE
+
+#define ATL_IDS_DATETIME_INVALID			(ATL_STRING_BASE + 0)
+#define ATL_IDS_DATETIMESPAN_INVALID		(ATL_STRING_BASE + 1)
+
+#define ATL_SERVICE_MANAGER_OPEN_ERROR		(ATL_STRING_BASE + 10)
+#define ATL_SERVICE_START_ERROR				(ATL_STRING_BASE + 11)
+#define ATL_SERVICE_OPEN_ERROR				(ATL_STRING_BASE + 12)
+#define ATL_SERVICE_DELETE_ERROR			(ATL_STRING_BASE + 13)
+#define ATL_SERVICE_STOP_ERROR				(ATL_STRING_BASE + 14)
+
+#endif	// __ATLRC_H__
+

cpp/jacob/include/atlsimpcoll.h

@@ -0,0 +1,489 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Active Template Library product.
+
+#ifndef __ATLSIMPCOLL_H__
+#define __ATLSIMPCOLL_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atlchecked.h>
+#include <wchar.h>
+
+#pragma push_macro("malloc")
+#undef malloc
+#pragma push_macro("calloc")
+#undef calloc
+#pragma push_macro("realloc")
+#undef realloc
+#pragma push_macro("_recalloc")
+#undef _recalloc
+#pragma push_macro("free")
+#undef free
+
+#pragma warning(push)
+#pragma warning(disable: 4800) // forcing 'int' value to bool
+
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+#pragma push_macro("new")
+#undef new
+
+/////////////////////////////////////////////////////////////////////////////
+// Collection helpers - CSimpleArray & CSimpleMap
+
+// template class helpers with functions for comparing elements
+// override if using complex types without operator==
+template <class T>
+class CSimpleArrayEqualHelper
+{
+public:
+	static bool IsEqual(const T& t1, const T& t2)
+	{
+		return (t1 == t2);
+	}
+};
+
+template <class T>
+class CSimpleArrayEqualHelperFalse
+{
+public:
+	static bool IsEqual(const T&, const T&)
+	{
+		ATLASSERT(false);
+		return false;
+	}
+};
+
+template <class TKey, class TVal>
+class CSimpleMapEqualHelper
+{
+public:
+	static bool IsEqualKey(const TKey& k1, const TKey& k2)
+	{
+		return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
+	}
+
+	static bool IsEqualValue(const TVal& v1, const TVal& v2)
+	{
+		return CSimpleArrayEqualHelper<TVal>::IsEqual(v1, v2);
+	}
+};
+
+template <class TKey, class TVal>
+class CSimpleMapEqualHelperFalse
+{
+public:
+	static bool IsEqualKey(const TKey& k1, const TKey& k2)
+	{
+		return CSimpleArrayEqualHelper<TKey>::IsEqual(k1, k2);
+	}
+
+	static bool IsEqualValue(const TVal&, const TVal&)
+	{
+		ATLASSERT(FALSE);
+		return false;
+	}
+};
+
+template <class T, class TEqual = CSimpleArrayEqualHelper< T > >
+class CSimpleArray
+{
+public:
+// Construction/destruction
+	CSimpleArray() : m_aT(NULL), m_nSize(0), m_nAllocSize(0)
+	{ }
+
+	~CSimpleArray();
+
+	CSimpleArray(const CSimpleArray< T, TEqual >& src) : m_aT(NULL), m_nSize(0), m_nAllocSize(0)
+	{
+        if (src.GetSize())
+        {
+			m_aT = (T*)calloc(src.GetSize(), sizeof(T));
+			if (m_aT != NULL)
+			{
+				m_nAllocSize = src.GetSize();
+				for (int i=0; i<src.GetSize(); i++)
+					Add(src[i]);
+			}
+		}
+	}
+	CSimpleArray< T, TEqual >& operator=(const CSimpleArray< T, TEqual >& src)
+	{
+		if (GetSize() != src.GetSize())
+		{
+			RemoveAll();
+			m_aT = (T*)calloc(src.GetSize(), sizeof(T));
+			if (m_aT != NULL)
+				m_nAllocSize = src.GetSize();
+		}
+		else
+		{
+			for (int i = GetSize(); i > 0; i--)
+				RemoveAt(i - 1);
+		}
+		for (int i=0; i<src.GetSize(); i++)
+			Add(src[i]);
+		return *this;
+	}
+
+// Operations
+	int GetSize() const
+	{
+		return m_nSize;
+		}
+		BOOL Add(const T& t)
+		{
+			if(m_nSize == m_nAllocSize)
+			{
+				T* aT;
+				int nNewAllocSize = (m_nAllocSize == 0) ? 1 : (m_nSize * 2);
+
+	  
+   				if (nNewAllocSize<0||nNewAllocSize>INT_MAX/sizeof(T))
+				{
+			 
+
+						return FALSE;
+			
+				}
+
+			 
+		
+				aT = (T*)_recalloc(m_aT, nNewAllocSize, sizeof(T));
+				if(aT == NULL)
+					return FALSE;
+				m_nAllocSize = nNewAllocSize;
+				m_aT = aT;
+						
+			}
+			InternalSetAtIndex(m_nSize, t);
+			m_nSize++;
+			return TRUE;
+		}
+	BOOL Remove(const T& t)
+	{
+		int nIndex = Find(t);
+		if(nIndex == -1)
+			return FALSE;
+		return RemoveAt(nIndex);
+	}
+	BOOL RemoveAt(int nIndex)
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		m_aT[nIndex].~T();
+		if(nIndex != (m_nSize - 1))
+			Checked::memmove_s((void*)(m_aT + nIndex), (m_nSize - nIndex) * sizeof(T), (void*)(m_aT + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(T));
+		m_nSize--;
+		return TRUE;
+	}
+	void RemoveAll()
+	{
+		if(m_aT != NULL)
+		{
+			for(int i = 0; i < m_nSize; i++)
+				m_aT[i].~T();
+			free(m_aT);
+			m_aT = NULL;
+		}
+		m_nSize = 0;
+		m_nAllocSize = 0;
+    }   
+	const T& operator[] (int nIndex) const
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+		{
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);					
+		}
+		return m_aT[nIndex];
+	}
+	T& operator[] (int nIndex)
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+		{
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);					
+		}
+		return m_aT[nIndex];
+	}
+	T* GetData() const
+	{
+		return m_aT;
+	}
+
+	int Find(const T& t) const
+	{
+		for(int i = 0; i < m_nSize; i++)
+		{
+			if(TEqual::IsEqual(m_aT[i], t))
+				return i;
+		}
+		return -1;  // not found
+	}
+
+	BOOL SetAtIndex(int nIndex, const T& t)
+	{
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		InternalSetAtIndex(nIndex, t);
+		return TRUE;
+	}
+
+// Implementation
+	class Wrapper
+	{
+	public:
+		Wrapper(const T& _t) : t(_t)
+		{
+		}
+		template <class _Ty>
+		void * __cdecl operator new(size_t, _Ty* p)
+		{
+			return p;
+		}
+		template <class _Ty>
+		void __cdecl operator delete(void* /* pv */, _Ty* /* p */)
+		{
+		}
+		T t;
+	};
+
+// Implementation
+	void InternalSetAtIndex(int nIndex, const T& t)
+	{
+		new(m_aT + nIndex) Wrapper(t);
+	}
+
+	typedef T _ArrayElementType;
+	T* m_aT;
+	int m_nSize;
+	int m_nAllocSize;
+
+};
+
+#define CSimpleValArray CSimpleArray 
+
+	template <class T, class TEqual> inline  CSimpleArray<T, TEqual>::~CSimpleArray()
+	{
+		RemoveAll();
+	}
+
+// intended for small number of simple types or pointers
+template <class TKey, class TVal, class TEqual = CSimpleMapEqualHelper< TKey, TVal > >
+class CSimpleMap
+{
+public:
+	TKey* m_aKey;
+	TVal* m_aVal;
+	int m_nSize;
+
+	typedef TKey _ArrayKeyType;
+	typedef TVal _ArrayElementType;
+
+// Construction/destruction
+	CSimpleMap() : m_aKey(NULL), m_aVal(NULL), m_nSize(0)
+	{ }
+
+	~CSimpleMap()
+	{
+		RemoveAll();	
+	}
+
+// Operations
+	int GetSize() const
+	{
+		return m_nSize;
+	}
+	BOOL Add(const TKey& key, const TVal& val)
+	{
+		TKey* pKey;
+		pKey = (TKey*)_recalloc(m_aKey, (m_nSize + 1), sizeof(TKey));
+		if(pKey == NULL)
+			return FALSE;
+		m_aKey = pKey;
+		TVal* pVal;
+		pVal = (TVal*)_recalloc(m_aVal, (m_nSize + 1), sizeof(TVal));
+		if(pVal == NULL)
+			return FALSE;
+		m_aVal = pVal;
+		InternalSetAtIndex(m_nSize, key, val);
+		m_nSize++;
+		return TRUE;
+	}
+	BOOL Remove(const TKey& key)
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return FALSE;
+		return RemoveAt(nIndex);
+	}
+	BOOL RemoveAt(int nIndex)
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		m_aKey[nIndex].~TKey();
+		m_aVal[nIndex].~TVal();
+		if(nIndex != (m_nSize - 1))
+		{
+			Checked::memmove_s((void*)(m_aKey + nIndex), (m_nSize - nIndex) * sizeof(TKey), (void*)(m_aKey + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(TKey));
+			Checked::memmove_s((void*)(m_aVal + nIndex), (m_nSize - nIndex) * sizeof(TVal), (void*)(m_aVal + nIndex + 1), (m_nSize - (nIndex + 1)) * sizeof(TVal));
+		}
+		TKey* pKey;
+		pKey = (TKey*)_recalloc(m_aKey, (m_nSize - 1), sizeof(TKey));
+		if(pKey != NULL || m_nSize == 1)
+			m_aKey = pKey;
+		TVal* pVal;
+		pVal = (TVal*)_recalloc(m_aVal, (m_nSize - 1), sizeof(TVal));
+		if(pVal != NULL || m_nSize == 1)
+			m_aVal = pVal;
+		m_nSize--;
+		return TRUE;
+	}
+	void RemoveAll()
+	{
+		if(m_aKey != NULL)
+		{
+			for(int i = 0; i < m_nSize; i++)
+			{
+				m_aKey[i].~TKey();
+				m_aVal[i].~TVal();
+			}
+			free(m_aKey);
+			m_aKey = NULL;
+		}
+		if(m_aVal != NULL)
+		{
+			free(m_aVal);
+			m_aVal = NULL;
+		}
+
+		m_nSize = 0;
+	}
+	BOOL SetAt(const TKey& key, const TVal& val)
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return FALSE;
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		m_aKey[nIndex].~TKey();
+		m_aVal[nIndex].~TVal();
+		InternalSetAtIndex(nIndex, key, val);
+		return TRUE;
+	}
+	TVal Lookup(const TKey& key) const
+	{
+		int nIndex = FindKey(key);
+		if(nIndex == -1)
+			return NULL;    // must be able to convert
+		return GetValueAt(nIndex);
+	}
+	TKey ReverseLookup(const TVal& val) const
+	{
+		int nIndex = FindVal(val);
+		if(nIndex == -1)
+			return NULL;    // must be able to convert
+		return GetKeyAt(nIndex);
+	}
+	TKey& GetKeyAt(int nIndex) const
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);
+			
+		return m_aKey[nIndex];
+	}
+	TVal& GetValueAt(int nIndex) const
+	{
+		ATLASSERT(nIndex >= 0 && nIndex < m_nSize);
+		if(nIndex < 0 || nIndex >= m_nSize)
+			_AtlRaiseException((DWORD)EXCEPTION_ARRAY_BOUNDS_EXCEEDED);	
+			
+		return m_aVal[nIndex];
+	}
+
+	int FindKey(const TKey& key) const
+	{
+		for(int i = 0; i < m_nSize; i++)
+		{
+			if(TEqual::IsEqualKey(m_aKey[i], key))
+				return i;
+		}
+		return -1;  // not found
+	}
+	int FindVal(const TVal& val) const
+	{
+		for(int i = 0; i < m_nSize; i++)
+		{
+			if(TEqual::IsEqualValue(m_aVal[i], val))
+				return i;
+		}
+		return -1;  // not found
+	}
+
+	BOOL SetAtIndex(int nIndex, const TKey& key, const TVal& val)
+	{
+		if (nIndex < 0 || nIndex >= m_nSize)
+			return FALSE;
+		InternalSetAtIndex(nIndex, key, val);
+		return TRUE;
+	}
+
+
+// Implementation
+
+	template <typename T>
+	class Wrapper
+	{
+	public:
+		Wrapper(const T& _t) : t(_t)
+		{
+		}
+		template <class _Ty>
+		void *operator new(size_t, _Ty* p)
+		{
+			return p;
+		}
+		template <class _Ty>
+		void operator delete(void* /* pv */, _Ty* /* p */)
+		{
+		}
+		T t;
+	};
+	void InternalSetAtIndex(int nIndex, const TKey& key, const TVal& val)
+	{
+		new(m_aKey + nIndex) Wrapper<TKey>(key);
+		new(m_aVal + nIndex) Wrapper<TVal>(val);
+	}
+};
+
+#pragma pop_macro("new")
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#pragma warning(pop)
+
+#pragma pop_macro("free")
+#pragma pop_macro("realloc")
+#pragma pop_macro("_recalloc")
+#pragma pop_macro("malloc")
+#pragma pop_macro("calloc")
+
+
+#endif  // __ATLSIMPCOLL_H__
+

cpp/jacob/include/atltrace.h

@@ -0,0 +1,450 @@
+// This is a part of the Active Template Library.
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Active Template Library Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the	
+// Active Template Library product.
+
+#ifndef __ATLTRACE_H__
+#define __ATLTRACE_H__
+
+#pragma once
+
+#include <atldef.h>
+#include <atlconv.h>
+
+#ifdef _DEBUG
+#include <stdio.h>
+#include <stdarg.h>
+#endif
+
+#ifdef _DEBUG
+#include <atldebugapi.h>
+
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+#endif  // _DEBUG
+ 
+
+#pragma pack(push,_ATL_PACKING)
+namespace ATL
+{
+
+// Declare a global instance of this class to automatically register a custom trace category at startup
+class CTraceCategory
+{
+public:
+	explicit CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel = 0 ) throw();
+
+#ifdef _DEBUG
+	UINT GetLevel() const throw();
+	void SetLevel( UINT nLevel ) throw();
+	ATLTRACESTATUS GetStatus() const throw();
+	void SetStatus( ATLTRACESTATUS eStatus) throw();
+#endif
+
+	operator DWORD_PTR() const throw();
+
+public:
+#ifdef _DEBUG
+	DWORD_PTR m_dwCategory;
+#endif
+};
+
+#ifdef _DEBUG
+
+class CTrace
+{
+public:
+	typedef int (__cdecl *fnCrtDbgReport_t)(int,const char *,int,const char *,const char *,...);
+
+private:
+	CTrace(
+#ifdef _ATL_NO_DEBUG_CRT
+		fnCrtDbgReport_t pfnCrtDbgReport = NULL)
+#else
+		fnCrtDbgReport_t pfnCrtDbgReport = _CrtDbgReport)
+#endif
+		: m_hInst(reinterpret_cast<HINSTANCE>(&__ImageBase)),
+			m_dwModule( 0 )
+	{
+		m_dwModule = AtlTraceRegister(m_hInst, pfnCrtDbgReport);
+	}
+
+	~CTrace()
+	{
+		AtlTraceUnregister(m_dwModule);
+	}
+
+public:
+	bool ChangeCategory(DWORD_PTR dwCategory, UINT nLevel, ATLTRACESTATUS eStatus)
+	{
+		return 0 !=
+			AtlTraceModifyCategory(0, dwCategory, nLevel, eStatus);
+	}
+
+	bool GetCategory(DWORD_PTR dwCategory, UINT *pnLevel, ATLTRACESTATUS *peStatus)
+	{
+		ATLASSERT(pnLevel && peStatus);
+		return 0 != AtlTraceGetCategory(0, dwCategory, pnLevel, peStatus);
+	}
+	UINT GetLevel()
+	{
+		ATLTRACESTATUS eStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eStatus);
+
+		return nLevel;
+	}
+	void SetLevel(UINT nLevel)
+	{
+		AtlTraceModifyModule(0, m_dwModule, nLevel, ATLTRACESTATUS_ENABLED);
+	}
+	ATLTRACESTATUS GetStatus()
+	{
+		ATLTRACESTATUS eStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eStatus);
+
+		return eStatus;
+	}
+	void SetStatus(ATLTRACESTATUS eStatus)
+	{
+		ATLTRACESTATUS eOldStatus;
+		UINT nLevel;
+		AtlTraceGetModule(0, m_dwModule, &nLevel, &eOldStatus);
+		AtlTraceModifyModule(0, m_dwModule, nLevel, eStatus);
+	}
+	void __cdecl TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFmt, va_list args) const;
+	void __cdecl TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFmt, va_list args) const;
+
+	DWORD_PTR RegisterCategory(LPCSTR pszCategory)
+		{return(AtlTraceRegisterCategoryA(m_dwModule, pszCategory));}
+#ifdef _UNICODE
+	DWORD_PTR RegisterCategory(LPCWSTR pszCategory)
+		{return(AtlTraceRegisterCategoryU(m_dwModule, pszCategory));}
+#endif
+
+	bool LoadSettings(LPCTSTR pszFileName = NULL) const
+		{return 0 != AtlTraceLoadSettings(pszFileName);}
+	void SaveSettings(LPCTSTR pszFileName = NULL) const
+		{AtlTraceSaveSettings(pszFileName);}
+
+public:
+	static CTrace s_trace;
+
+protected:
+	HINSTANCE m_hInst;
+	DWORD_PTR m_dwModule;
+};
+
+    inline void __cdecl CTrace::TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFmt, va_list args) const
+	{
+		AtlTraceVA(m_dwModule, pszFileName, nLine, dwCategory, nLevel, pszFmt, args);
+	}
+	inline void __cdecl CTrace::TraceV(const char *pszFileName, int nLine,
+		DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFmt, va_list args) const
+	{
+		AtlTraceVU(m_dwModule, pszFileName, nLine, dwCategory, nLevel, pszFmt, args);
+	}
+
+extern CTraceCategory atlTraceGeneral;
+
+class CTraceFileAndLineInfo
+{
+public:
+	CTraceFileAndLineInfo(const char *pszFileName, int nLineNo)
+		: m_pszFileName(pszFileName), m_nLineNo(nLineNo)
+	{}
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(DWORD_PTR dwCategory, UINT nLevel, const char *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, dwCategory, nLevel, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(DWORD_PTR dwCategory, UINT nLevel, const wchar_t *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, dwCategory, nLevel, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(const char *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, atlTraceGeneral, 0, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+	void __cdecl operator()(const wchar_t *pszFmt, ...) const
+	{
+		va_list ptr; va_start(ptr, pszFmt);
+		ATL::CTrace::s_trace.TraceV(m_pszFileName, m_nLineNo, atlTraceGeneral, 0, pszFmt, ptr);
+		va_end(ptr);
+	}
+#pragma warning(pop)
+
+private:
+	/* unimplemented */
+	CTraceFileAndLineInfo &__cdecl operator=(const CTraceFileAndLineInfo &right);
+
+	const char *const m_pszFileName;
+	const int m_nLineNo;
+};
+
+#endif  // _DEBUG
+
+#ifdef _DEBUG
+
+inline CTraceCategory::CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel ) throw() :
+	m_dwCategory( 0 )
+{
+	m_dwCategory = ATL::CTrace::s_trace.RegisterCategory( pszCategoryName );
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nStartingLevel, ATLTRACESTATUS_INHERIT);
+}
+
+inline CTraceCategory::operator DWORD_PTR() const throw()
+{
+	return( m_dwCategory );
+}
+
+inline UINT CTraceCategory::GetLevel() const throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eStatus );
+
+	return( nLevel );
+}
+
+inline void CTraceCategory::SetLevel( UINT nLevel ) throw()
+{
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nLevel, ATLTRACESTATUS_ENABLED );
+}
+
+inline ATLTRACESTATUS CTraceCategory::GetStatus() const throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eStatus );
+
+	return( eStatus );
+}
+
+inline void CTraceCategory::SetStatus( ATLTRACESTATUS eStatus ) throw()
+{
+	UINT nLevel;
+	ATLTRACESTATUS eOldStatus;
+	ATL::CTrace::s_trace.GetCategory( m_dwCategory, &nLevel, &eOldStatus );
+	ATL::CTrace::s_trace.ChangeCategory( m_dwCategory, nLevel, eStatus );
+}
+
+#else  // !_DEBUG
+
+inline CTraceCategory::CTraceCategory( LPCTSTR pszCategoryName, UINT nStartingLevel ) throw()
+{
+	(void)pszCategoryName;
+	(void)nStartingLevel;
+}
+
+inline CTraceCategory::operator DWORD_PTR() const throw()
+{
+	return( 0 );
+}
+
+#endif  // _DEBUG
+
+}  // namespace ATL
+ 
+namespace ATL
+{
+
+#ifdef _DEBUG
+#define DECLARE_TRACE_CATEGORY( name ) extern ATL::CTraceCategory name;
+#else
+#define DECLARE_TRACE_CATEGORY( name ) const DWORD_PTR name = 0;
+#endif
+
+DECLARE_TRACE_CATEGORY( atlTraceGeneral )
+DECLARE_TRACE_CATEGORY( atlTraceCOM )  
+DECLARE_TRACE_CATEGORY( atlTraceQI )	
+DECLARE_TRACE_CATEGORY( atlTraceRegistrar )
+DECLARE_TRACE_CATEGORY( atlTraceRefcount )
+DECLARE_TRACE_CATEGORY( atlTraceWindowing )
+DECLARE_TRACE_CATEGORY( atlTraceControls )
+DECLARE_TRACE_CATEGORY( atlTraceHosting ) 
+DECLARE_TRACE_CATEGORY( atlTraceDBClient )  
+DECLARE_TRACE_CATEGORY( atlTraceDBProvider )
+DECLARE_TRACE_CATEGORY( atlTraceSnapin )
+DECLARE_TRACE_CATEGORY( atlTraceNotImpl )   
+DECLARE_TRACE_CATEGORY( atlTraceAllocation )
+DECLARE_TRACE_CATEGORY( atlTraceException )
+DECLARE_TRACE_CATEGORY( atlTraceTime )
+DECLARE_TRACE_CATEGORY( atlTraceCache )		
+DECLARE_TRACE_CATEGORY( atlTraceStencil )
+DECLARE_TRACE_CATEGORY( atlTraceString )
+DECLARE_TRACE_CATEGORY( atlTraceMap )	
+DECLARE_TRACE_CATEGORY( atlTraceUtil )		
+DECLARE_TRACE_CATEGORY( atlTraceSecurity )
+DECLARE_TRACE_CATEGORY( atlTraceSync )
+DECLARE_TRACE_CATEGORY( atlTraceISAPI )		
+
+// atlTraceUser categories are no longer needed.  Just declare your own trace category using CTraceCategory.
+DECLARE_TRACE_CATEGORY( atlTraceUser )
+DECLARE_TRACE_CATEGORY( atlTraceUser2 )
+DECLARE_TRACE_CATEGORY( atlTraceUser3 )
+DECLARE_TRACE_CATEGORY( atlTraceUser4 )
+
+#pragma deprecated( atlTraceUser )
+#pragma deprecated( atlTraceUser2 )
+#pragma deprecated( atlTraceUser3 )
+#pragma deprecated( atlTraceUser4 )
+
+#ifdef _DEBUG
+
+#ifndef _ATL_NO_DEBUG_CRT
+class CNoUIAssertHook
+{
+public:
+	CNoUIAssertHook()
+	{
+		ATLASSERT( s_pfnPrevHook == NULL );
+		s_pfnPrevHook = _CrtSetReportHook(CrtHookProc);
+	}
+	~CNoUIAssertHook()
+	{
+		_CrtSetReportHook(s_pfnPrevHook);
+		s_pfnPrevHook = NULL;
+	}
+
+private:
+	static int __cdecl CrtHookProc(__in int eReportType, __in_z char* pszMessage, __out int* pnRetVal)
+	{
+		
+		if (eReportType == _CRT_ASSERT)
+		{
+			::OutputDebugStringA( "ASSERTION FAILED\n" );
+			::OutputDebugStringA( pszMessage );
+			//If caller doesn't want retVal, so be it.
+			if (pnRetVal != NULL)
+			{
+				*pnRetVal = 1;
+			}
+			return TRUE;
+		}
+
+		if (s_pfnPrevHook != NULL)
+		{
+			return s_pfnPrevHook(eReportType, pszMessage, pnRetVal);
+		}
+		else
+		{
+			return FALSE;
+		}
+	}
+
+private:
+	static _CRT_REPORT_HOOK s_pfnPrevHook;
+};
+
+__declspec( selectany ) _CRT_REPORT_HOOK CNoUIAssertHook::s_pfnPrevHook = NULL;
+
+#define DECLARE_NOUIASSERT() ATL::CNoUIAssertHook _g_NoUIAssertHook;
+
+#endif  // _ATL_NO_DEBUG_CRT
+
+#ifndef ATLTRACE
+#define ATLTRACE ATL::CTraceFileAndLineInfo(__FILE__, __LINE__)
+#define ATLTRACE2 ATLTRACE
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace(LPCSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, atlTraceGeneral, 0, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace(LPCWSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, atlTraceGeneral, 0, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace2(DWORD_PTR dwCategory, UINT nLevel, LPCSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, dwCategory, nLevel, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTrace2(DWORD_PTR dwCategory, UINT nLevel, LPCWSTR pszFormat, ...)
+{
+	va_list ptr;
+	va_start(ptr, pszFormat);
+	ATL::CTrace::s_trace.TraceV(NULL, -1, dwCategory, nLevel, pszFormat, ptr);
+	va_end(ptr);
+}
+#pragma warning(pop)
+
+#define ATLTRACENOTIMPL(funcname)  do { ATLTRACE(ATL::atlTraceNotImpl, 0, _T("ATL: %s not implemented.\n"), funcname); return E_NOTIMPL; } while(0)
+
+#else // !DEBUG
+
+#pragma warning(push)
+#pragma warning(disable : 4793)
+inline void __cdecl AtlTraceNull(...){}
+inline void __cdecl AtlTrace(LPCSTR , ...){}
+inline void __cdecl AtlTrace2(DWORD_PTR, UINT, LPCSTR , ...){}
+inline void __cdecl AtlTrace(LPCWSTR , ...){}
+inline void __cdecl AtlTrace2(DWORD_PTR, UINT, LPCWSTR , ...){}
+#pragma warning(pop)
+
+#ifndef ATLTRACE
+
+#define ATLTRACE            __noop
+#define ATLTRACE2           __noop
+#endif //ATLTRACE
+#define ATLTRACENOTIMPL(funcname)   return E_NOTIMPL
+#define DECLARE_NOUIASSERT()
+
+#endif //!_DEBUG
+
+};  // namespace ATL
+#pragma pack(pop)
+
+#endif  // __ATLTRACE_H__
+

cpp/jacob/msvc/copy.bat

@@ -0,0 +1 @@
+copy Release\jacob.dll ..\..\..\java\native\

cpp/jacob/msvc/jacob.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual C++ Express 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jacob", "jacob.vcxproj", "{745CA8EA-176E-46A7-B2A5-55260DF5639B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Debug|Win32.Build.0 = Debug|Win32
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Release|Win32.ActiveCfg = Release|Win32
+		{745CA8EA-176E-46A7-B2A5-55260DF5639B}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

cpp/jacob/msvc/jacob.vcxproj

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{745CA8EA-176E-46A7-B2A5-55260DF5639B}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>jacob</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\include;C:\Program Files %28x86%29\Java\jdk1.6.0_23\include;C:\Program Files %28x86%29\Java\jdk1.6.0_23\include\win32;$(IncludePath)</IncludePath>
+    <LibraryPath>..\lib;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;JACOB_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;JACOB_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\ComThread.h" />
+    <ClInclude Include="..\Dispatch.h" />
+    <ClInclude Include="..\DispatchEvents.h" />
+    <ClInclude Include="..\DispatchProxy.h" />
+    <ClInclude Include="..\EnumVariant.h" />
+    <ClInclude Include="..\EventProxy.h" />
+    <ClInclude Include="..\SafeArray.h" />
+    <ClInclude Include="..\STA.h" />
+    <ClInclude Include="..\StdAfx.h" />
+    <ClInclude Include="..\util.h" />
+    <ClInclude Include="..\Variant.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\ComThread.cpp" />
+    <ClCompile Include="..\Dispatch.cpp" />
+    <ClCompile Include="..\DispatchEvents.cpp" />
+    <ClCompile Include="..\DispatchProxy.cpp" />
+    <ClCompile Include="..\EnumVariant.cpp" />
+    <ClCompile Include="..\EventProxy.cpp" />
+    <ClCompile Include="..\SafeArray.cpp" />
+    <ClCompile Include="..\STA.cpp" />
+    <ClCompile Include="..\util.cpp" />
+    <ClCompile Include="..\Variant.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

cpp/jacob/msvc/jacob.vcxproj.filters

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="targetver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\SafeArray.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\STA.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\StdAfx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Variant.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\ComThread.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Dispatch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\DispatchEvents.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\DispatchProxy.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\EnumVariant.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\EventProxy.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\ComThread.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Dispatch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\DispatchEvents.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\DispatchProxy.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\EnumVariant.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\EventProxy.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\SafeArray.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\STA.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Variant.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

cpp/jacob/msvc/jacob.vcxproj.user

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+</Project>

cpp/jacob/util.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "Dispatch.h"
+// Win32 support for Ole Automation
+#include <wchar.h>
+#include <string.h>
+#include <atlbase.h>
+#include <objbase.h>
+#include <oleauto.h>
+#include <olectl.h>
+#include "util.h"
+
+extern "C" 
+{
+
+void ThrowComFail(JNIEnv *env, const char* desc, jint hr)
+{
+  jclass failClass = env->FindClass("com/jacob/com/ComFailException");
+  // call the constructor that takes hr and message
+  jmethodID failCons = 
+     env->GetMethodID(failClass, "<init>", "(ILjava/lang/String;)V");
+  if (!desc) {
+	  desc = "Java/COM Error";
+  }
+  jstring js = env->NewStringUTF(desc);
+  jthrowable fail = (jthrowable)env->NewObject(failClass, failCons, hr, js);
+  env->Throw(fail);
+}
+
+void ThrowComFailUnicode(JNIEnv *env, const wchar_t* desc, jint hr)
+{
+  if (!desc) {
+	  ThrowComFail(env, "Java/COM Error", hr);
+  }
+  jclass failClass = env->FindClass("com/jacob/com/ComFailException");
+  // call the constructor that takes hr and message
+  jmethodID failCons = 
+     env->GetMethodID(failClass, "<init>", "(ILjava/lang/String;)V");
+  jstring js = env->NewString((const jchar *) desc, wcslen(desc));
+  jthrowable fail = (jthrowable)env->NewObject(failClass, failCons, hr, js);
+  env->Throw(fail);
+}
+
+// if env's are different throw on the 1st env
+int CheckEnv(JNIEnv *env1, JNIEnv *env2)
+{
+  if (env1 != env2) {
+    jclass failClass = env1->FindClass("com/jacob/com/WrongThreadException");
+    // call the constructor that takes hr and message
+    jmethodID failCons = 
+       env1->GetMethodID(failClass, "<init>", "()V");
+    env1->ThrowNew(failClass, "Wrong Thread");
+		return 0;
+  }
+	return 1;
+}
+
+}

cpp/jacob/util.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 1999-2004 Sourceforge JACOB Project.
+ * All rights reserved. Originator: Dan Adler (http://danadler.com).
+ * Get more information about JACOB at http://sourceforge.net/projects/jacob-project
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <objbase.h>
+extern "C" {
+  VARIANT *extractVariant(JNIEnv *env, jobject arg);
+  void ThrowComFail(JNIEnv *env, const char* desc, jint hr);
+  void ThrowComFailUnicode(JNIEnv *env, const wchar_t* desc, jint hr);
+  IDispatch *extractDispatch(JNIEnv *env, jobject arg);
+  SAFEARRAY *extractSA(JNIEnv *env, jobject arg);
+  void setSA(JNIEnv *env, jobject arg, SAFEARRAY *sa, int copy);
+  SAFEARRAY *copySA(SAFEARRAY *psa);
+}