Using pointers for abstraction

[Dishaw__Jim]

I have a module that implements an algebraic expression parser. The module consists of two public subroutines, initialize_expression and evaluate_expression. The initialize_expression takes a string and converts into an internal representation.

Right now that internal representation gets returned to the calling program (it is just an array of a data type). What I would like to do is hide the internal representation from the calling program and return just a "generic" pointer, much like dss_create() routine does in the Math Kernel Library.

Part of the rationale is philosophical--the calling program shouldn't care about the internal representation, part of it is to minimize recompling if I change the internal representation.

Is this even a good idea to do in Fortran? What is the "best" way for doing this? The definition of "best" means closest to the standard.

[Jugoslav_Dujic]

Well, the concept of handle is a well known paradigm. What makes this difficult in the context of Fortran is that there's no standard-conforming way to "cast" a pointer to something into void*, (metaphorically speaking), or, pointer to something into a pointer to something else.

So, you can reuse (and cheat on) the fact that Fortran scalar POINTERs are 32 (64)-bit entities in all compilers around and provide a mismatch on the argument-lists (i.e. INTEGER, POINTER vs. TYPE(Internal), POINTER); doing so, however, would require deliberate breaking of explicit interfaces provided by the MODULEs.

A possibly better approach is to use ISO_C_BINDING module (which can have legitimate uses even in purely Fortran contexts), and which lets you cast a C pointer to Fortran pointer (C_F_POINTER) and reverse (C_LOC) using a type(C_PTR) as "mediator". It gives you wider portability, but it's not implemented in all modern compilers yet (it is in at least Ifort 10.x, and g95).

[jimdempseyatthecove]

There is a somewhat standard way to call C/C++ from Fortran. If you wish to have your code follow a standard then you could have a C/C++ dummy routine that takes a Reference of one type and returns the handle (void*). Let C/C++ perform the cast.

Jim Dempsey

[Steven_L_Intel1]

I would suggest the same as Jugoslav, use ISO_C_BINDING and the C_PTR type. Declare a derived type with PRIVATE components to hold the context identifier and have this be the handle.