MS Excel calling into Haskell

Recently, I was tasked with creating an Excel addin that calls into a Haskell module. While most of the pieces are already well-documented, I haven't seen them put all together. Furthermore, there additional modifications that are needed to get this to work. For this end, I decided to put up a quick how-to on this.

The Haskell environment

I used ghc 6.8.3 for this project. In the docs, they have some pretty good notes about making a DLL. I say pretty good, because even with minor version changes (6.6.1 to 6.8.3), this seems to have changed a bit. After finding the right version of the docs, things went much more smoothly. Once found, I pretty much followed the steps verbatim from :

12.6.2. Making DLLs to be called from other languages

The Haskell DLL

Verbatim from the docs, the actual Haskell source file, adder.hs:

module Adder where

adder :: Int -> Int -> IO Int  -- gratuitous use of IO
adder x y = return (x+y)

foreign export stdcall adder :: Int -> Int -> IO Int

And the corresponding DllMain.c that will be linked together with:

#include <windows.h>
#include <rts.h>

extern void __stginit_Adder(void);

static char* args[] = { "ghcDll", NULL };
                       /* N.B. argv arrays must end with NULL */

BOOL STDCALL
DllMain(
 HANDLE hModule,
 DWORD reason,
 void* reserved)
{
  return TRUE;
}

__stdcall void AdderBegin()
{
 startupHaskell(1, args, __stginit_Adder);
}

__stdcall void AdderEnd()
{
 hs_exit();
}

Note, that this code is similiar but different then the one at the sample page

noted above. Mainly, because of the DllMain issues, we don't call anything in the DllMain.

The export header file:

#ifdef __cplusplus
extern "C"
{
#endif
 __declspec(dllexport) void __stdcall AdderBegin(void);
 __declspec(dllexport) void __stdcall AdderEnd(void);
 __declspec(dllexport) long __stdcall adder(long x, long y);
#ifdef __cplusplus
}
#endif

In some cases (noted below), a DEF file is needed, like so:

LIBRARY Adder
EXPORTS
 adder@8=_adder
 AdderBegin@0=_AdderBegin
 AdderEnd@0=_AdderEnd

To help with debugging, a Test console application:

#ifdef __cplusplus
#include "stdafx.h"
#include "TestConsole.h"
#include "../Adder/adder.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// The one and only application object

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
 int nRetCode = 0;

 // initialize MFC and print and error on failure
 if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
 {
  _tprintf(_T("Fatal Error: MFC initialization failed\n"));
  nRetCode = 1;
 }
 else
 {
  AdderBegin();

  wcout << adder(5, 3);
  wcout << _T("\r\n");

  AdderEnd();
 }

 return nRetCode;
}

Finally, the MS Excel addin:

The excel addin is based off of the article at:
http://blogs.msdn.com/andreww/archive/2007/12/09/building-an-excel-xll-in-c-c-with-vs-2008.aspx
Although this project is created to be a Excel 2007 addin, there is no inherit functionality related to 2007 and with some minor modifications should work off older versions of excel.

I have changed

__declspec(dllexport) long SumTwo(long arg1, long arg2)
{
 return adder(arg1, arg2);
}

// Excel calls xlAutoOpen when it loads the XLL.
__declspec(dllexport) int WINAPI xlAutoOpen(void)
{
 static XLOPER12 xDLL;
 int i;

 AdderBegin();

 // Fetch the name of this XLL. This is used as the first arg
 // to the REGISTER function to specify the name of the XLL.
 Excel12f(xlGetName, &xDLL, 0);

 // Loop through the g_rgUDFs[] table, registering each
 // function in the table using xlfRegister.
 for (i = 0; i < g_UdfCount; i++)
 {
  Excel12f(xlfRegister, 0, 1 + g_UdfDataFieldCount,
    (LPXLOPER12) &xDLL,
    (LPXLOPER12) TempStr12(g_rgUDFs[i][0]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][1]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][2]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][3]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][4]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][5]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][6]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][7]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][8]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][9]),
    (LPXLOPER12) TempStr12(g_rgUDFs[i][10])
    );
 }

 // Free the XLL filename.
 Excel12f(xlFree, 0, 1, (LPXLOPER12) &xDLL);
 return 1;
}

// Excel calls xlAutoClose when it unloads the XLL.
__declspec(dllexport) int WINAPI xlAutoClose(void)
{
 int i;
 //debugPrintf("xlAutoClose\n");

 // Delete all names added by xlAutoOpen or xlAutoRegister.
 for (i = 0; i < g_UdfCount; i++)
 {
  Excel12f(xlfSetName, 0, 1, TempStr12(g_rgUDFs[i][2]));
 }

 AdderEnd();
 return 1;
}

A build script to put it all together:

cd adder
ghc -c adder.hs -fglasgow-exts
ghc -c dllMain.c
ghc -shared -o adder.dll adder.o adder_stub.o dllMain.o
rem ghc -shared --enable-stdcall-fixup -o adder.dll adder.o adder_stub.o dllMain.o
lib /MACHINE:x86 /DEF:adder.def /OUT:adder.lib /NOLOGO /SUBSYSTEM:WINDOWS
copy adder.lib ..\Bin\Lib
copy adder.dll \windows
cd ..
msbuild ExcelToHaskell.sln /t:Rebuild /p:Configuration=Release /p:Platform=Win32

 

Dumpbin to the rescue

Testing the Haskell module with the TestConsole app is quite helpful. Initially, I was having some linking problems. Using the SDK tool dumpbin /exports was quite helpful in debugging.

VS 2005 / 2008 differences

Interesting enough, some minor changes are needed if you are upgrading to VS 2008 or switching between this and VS 2005. The 2008 version seems to need the DEF file while the 2005 one doesn't.

Putting the DLL in the right place

Normally, putting DLLs in the same directory as the module that are calling them is enough for them to be found. In this case, however, the calling process is Excel and hence the DLL needs to be somewhere on the standard calling path. In this case, I just made a quick and dirty solution of putting the module in the WINDOWS directory.