Calling VC++ functrion from a Fortran DLL

[pre]
SUBROUTINE MyDllSub(...,StoreOrtho)
!DEC$ATTRIBUTES DLLEXPORT:: MyDllSub
...
INTERFACE
SUBROUTINE StoreOrtho(x,y,hC,slope)
!DEC$ATTRIBUTES C:: StoreOrtho
REAL:: x(*),y(*),hC(*),slope(*)
END SUBROUTINE
END INTERFACE
...
Call StoreOrtho(X,Y,HEIGHT_COEF,SLOPE)
...
//====================================
#include "StoreOrtho.h"
//Fortran & callback function declaration
typedef void (*CALLBACKPROC)(
float* x, float* y, float* hC, float* slope);
extern "C" void _declspec(dllimport) __stdcall
MyDllSub(..., CALLBACKPROC Callback);
...
MyDllSub(...,StoreOrtho)
[/pre]

HTH
Jugoslav

First, CALLBACKPROC is a typedef for (C) function of appropriate prototype. Last argument to MyDllSub is (address of) such a routine. The actual argument will be yours StoreOrtho.

On Fortran side, last argument is a routine. INTERFACE block specifies its prototype. Once passed through argument-list, it can be called as any other subroutine.

I put #include "StoreOrtho.h" to describe "whatever header file is routine StoreOrtho declared in".

However, if StoreOrtho is actually a class method (you didn't say so the first time), the things change a bit:

- In C++, the first argument to a class method is hidden this. To workaround that, you have to either a) (simpler) declare StoreOrtho as static (but note that in this case it is not instantiated per object, but only per entire class) or b) Pass this all the way round through MyDllProc arg's list back to CALL StoreOrtho from Fortran (I'm not even sure about syntax correctness of the following C++ code):

SUBROUTINE MyDllSub(...,this,StoreOrtho)
!DEC$ATTRIBUTES DLLEXPORT:: MyDllSub
...
INTEGER:: this
INTERFACE    
   SUBROUTINE StoreOrtho(this,x,y,hC,slope)   
   !DEC$ATTRIBUTES C:: StoreOrtho   
   INTEGER:: this
   REAL:: x(*),y(*),hC(*),slope(*)   
   END SUBROUTINE
END INTERFACE
...
Call StoreOrtho(this,X,Y,HEIGHT_COEF,SLOPE)
...
//====================================
//callback function declaration
typedef void (*CALLBACKPROC)(RefraDoc* pObj, 
   float* x, float* y, float* hC, float* slope);
//Fortran function declaration
extern "C" void _declspec(dllimport) __stdcall 
   MyDllSub(..., RefraDoc* pObj, CALLBACKPROC Callback);
...
MyDllSub(...,this,StoreOrtho);

IMHO it's better to avoid passing class methods around.

- Have in mind that default calling convention in VC++ is __fastcall, which is not supported in CVF. You have to use __cdecl in StoreOrtho's declaration. (!DEC$ATTRIBUTES C corresponds to __cdecl).

Jugoslav

My comments & additions are marked bold.

!=======================
First in Refra.h the main class of my project I have the declaration of my fortran subroutine, who look like this:

I assume you had dllimport and __stdcall here -- otherwise I don't know how it worked
extern "C" _declspec(dllimport) __stdcall PROPAGATE_DLL (float* periode, double* deltaT,
const char* END_CONDITION, int L_END_CONDITION, int* flag_zoom, int* flag, CRefraDoc* Doc, void* Callback);
I added void* to simplify things -- I'm really not sure how to typedef a class member in C++. The call should look like:

PROPAGATE_DLL (periode, deltaT, END_CONDITION, L_END_CONDITION, flag_zoom, flag, &YourRefraDoc, (void*)YourRefraDoc.StoreOrtho);

After that in RefraDoc.h I have the declaration of my StoreOrtho function:

void __cdecl StoreOrtho(float x[600], float y[600], float heightCoef[600], float slope[600]);

And in RefraDoc.cpp is implementation:

Use either __cdecl or __stdcall, but don't leave it undefined -- I think if you omit it, it defaults to __fastcall.
void __cdecl CRefraDoc::StoreOrtho(float x[600], float y[600], float heightCoef[600], float slope[600])
{
COrthogonale *newOrtho = new COrthogonale;

newOrtho->x = x;
newOrtho->y = y;
newOrtho->heightCoef = heightCoef;
newOrtho->slope = slope;

m_aOrthoArray.Add(newOrtho);

return;
}
Where m_aOrthoArray was of type CObArray.

My dll subroutine (PROPAGATE_DLL) was called in a function of RefraDoc.cpp

This subroutine was looking like this...

SUBROUTINE PROPAGATE_DLL(PERIOD,DELTA_T,END_CONDITION,
ZOOMF,BWF,this,StoreOrtho)
DON'T use ALIAS to cheat calling convention. CVF default is __stdcall and I matched that in C++ declaration. You were actualy faking __cdecl name decoration, which causes screwage of the stack
!DEC$ ATTRIBUTES DLLEXPORT:: PROPAGATE_DLL
...

INTEGER:: This
INTERFACE
SUBROUTINE StoreOrtho(THIS,X,Y,HEIGHT_COEF,SLOPE)
!DEC$ATTRIBUTES C:: StoreOrtho
INTEGER:: This
REAL:: X(*),Y(*),HEIGHT_COEF(*),SLOPE(*)
END SUBROUTINE
END INTERFACE
! The place were I need to call my C++ function
Call StoreOrtho(THIS,X,Y,HEIGHT_COEF,SLOPE)

...
...

END

Yeah, C++ is rather unforgivable about type conversions, especially pointer-to-function casts (and I admit I'm not versatile enough in C++ either to always get it right without few tries). Basically, it complains that the actual argument (StoreOrtho) passed to Fortran routine does not match CALLBACKPROC prototype. Try either:

typedef void (__cdecl *CALLBACKPROC)(float* x, 
float* y,float* hc, float* slope);

or

typedef void (__cdecl *CALLBACKPROC)(CRefraDoc* cDoc, float* x, 
float* y,float* hc, float* slope)

(perhaps * must be replaced with []).

Also, you forgot __stdcall in PROPAGATE_DLL declaration.

Jugoslav

Do you have __cdecl specified for StoreOrtho in RefraDoc.h? Sounds as if you don't.

Don't get me wrong, but you should have a word or two with a C++ expert, which I'm definitely not. Most of my C++ programming consists of trial-and-error method :-).

OK, finally...
You can't pass a non-static class member function to a non-C++ routine. What you can do is to pass a static class member (or non-member) and let that function act as a "bridge" or "driver", i.e. which just calls non-static StoreOrtho itself.

Attached is a simple mixed fortran-C++ workspace which exhibits the technique. I hope you will be able to adapt it to your needs.

Jugoslav

I found this thread in an attempt to solve my own, related problems to calling back to several C++ functions from a FORTRAN dll. My FORTRAN dll needs to callback several C++ functions. I'm wondering if I can pass all the C++ function pointers to FORTRAN at once and save them in global variables, so that I can call the C++ routines later as needed. That would be much easier than trying to pass the function pointers in every time, and then pass them around to other internal FORTRAN subroutines that actually need to do the callback. I don't know jack about FORTRAN, but I've figured out that I can place all the INTERFACE blocks in a module (I think) and use the USE statement inside the differenent subroutines. Now if I just knew how to save the function pointers to global variables.

Michael

See here and maybe here. Beware that it's nonstandard and that it will work only under CVF.

Jugoslav