Re: Way to autogenerate C/C++ Headers?

Apart from the BIND(C) lines in the Fortran module, I can get it
to work if:
- I remove the #ifdefs (right now completely ignored)
- I put spaces before and after the braces in the struct definition
- Oh, and I fix a small error in the Tcl code:
puts "$error" <-- the quotation mark was missing.

I will take your example as another benchmark. Thanks for this.

Regards,

Arjen

Just to give you an impression, the results are:

! Interfaces for wrapper routines (derived from xx)
!
module xx

interface
subroutine odessa_segment_initialize ( )

end subroutine odessa_segment_initialize
subroutine odessa_segment_extend ( )

end subroutine odessa_segment_extend
subroutine odessa_segment_stop ( s )
integer :: s
end subroutine odessa_segment_stop
integer function odessa_segment_create ( n, size )
integer :: n
integer :: size
end function odessa_segment_create
subroutine odessa_segment_suppress ( s )
integer :: s
end subroutine odessa_segment_suppress
subroutine odessa_segment_adjust ( s, n )
integer :: s
integer :: n
end subroutine odessa_segment_adjust
integer function odessa_segment_length ( s )
integer :: s
end function odessa_segment_length
integer function odessa_segment_n1 ( s )
integer :: s
end function odessa_segment_n1
subroutine odessa_segment_count_plus ( s )
integer :: s
end subroutine odessa_segment_count_plus
subroutine odessa_segment_count_minus ( s )
integer :: s
end subroutine odessa_segment_count_minus
integer function odessa_segment_clone ( s1 )
integer :: s1
end function odessa_segment_clone
subroutine odessa_segment_copy ( s1, s2 )
integer :: s1
integer :: s2
end subroutine odessa_segment_copy
subroutine odessa_segment_print ( s )
integer :: s
end subroutine odessa_segment_print
! Ambiguous interface: scalars or arrays?
subroutine odessa_segment_all ( s, type, size, n, n1 )
integer :: s
integer, dimension(*) :: type
integer, dimension(*) :: size
integer, dimension(*) :: n
integer, dimension(*) :: n1
end subroutine odessa_segment_all
subroutine odessa_segment_set_type ( s, type )
integer :: s
integer :: type
end subroutine odessa_segment_set_type
integer function odessa_segment_type ( s )
integer :: s
end function odessa_segment_type
subroutine odessa_segment_insert ( s, ipos )
integer :: s
integer :: ipos
end subroutine odessa_segment_insert
subroutine odessa_segment_replace ( s, ipos )
integer :: s
integer :: ipos
end subroutine odessa_segment_replace
subroutine odessa_segment_address ( s )
integer :: s
end subroutine odessa_segment_address
integer function odessa_segment_number ( )

end function odessa_segment_number
! Ambiguous interface: scalars or arrays?
subroutine odessa_segment_info ( a, b, c, d )
integer, dimension(*) :: a
integer, dimension(*) :: b
integer, dimension(*) :: c
integer, dimension(*) :: d
end subroutine odessa_segment_info
integer function odessa_segment_check ( s, t )
integer :: s
integer :: t
end function odessa_segment_check
end interface

end module

and:

/* Wrapper derived from xx
*/
#include "xx"

#ifdef WIN32
#define STDCALL stdcall__
#else
#define STDCALL
#endif


#ifdef FTN_ALLCAPS
#define odessa_segment_initialize_ ODESSA_SEGMENT_INITIALIZE
#endif

void STDCALL odessa_segment_initialize_ (
) {

}

#ifdef FTN_ALLCAPS
#define odessa_segment_extend_ ODESSA_SEGMENT_EXTEND
#endif

void STDCALL odessa_segment_extend_ (
) {

}

#ifdef FTN_ALLCAPS
#define odessa_segment_stop_ ODESSA_SEGMENT_STOP
#endif

void STDCALL odessa_segment_stop_ (
int* s ) {
odessa_segment_stop ( *s );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_create_ ODESSA_SEGMENT_CREATE
#endif

int STDCALL odessa_segment_create_ (
int* n,
int* size ) {
result__ = odessa_segment_create ( *n, *size );
return result__;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_suppress_ ODESSA_SEGMENT_SUPPRESS
#endif

void STDCALL odessa_segment_suppress_ (
int* s ) {
odessa_segment_suppress ( *s );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_adjust_ ODESSA_SEGMENT_ADJUST
#endif

void STDCALL odessa_segment_adjust_ (
int* s,
int* n ) {
odessa_segment_adjust ( *s, *n );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_length_ ODESSA_SEGMENT_LENGTH
#endif

int STDCALL odessa_segment_length_ (
int* s ) {
result__ = odessa_segment_length ( *s );
return result__;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_n1_ ODESSA_SEGMENT_N1
#endif

int STDCALL odessa_segment_n1_ (
int* s ) {
result__ = odessa_segment_n1 ( *s );
return result__;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_count_plus_ ODESSA_SEGMENT_COUNT_PLUS
#endif

void STDCALL odessa_segment_count_plus_ (
int* s ) {
odessa_segment_count_plus ( *s );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_count_minus_ ODESSA_SEGMENT_COUNT_MINUS
#endif

void STDCALL odessa_segment_count_minus_ (
int* s ) {
odessa_segment_count_minus ( *s );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_clone_ ODESSA_SEGMENT_CLONE
#endif

int STDCALL odessa_segment_clone_ (
int* s1 ) {
result__ = odessa_segment_clone ( *s1 );
return result__;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_copy_ ODESSA_SEGMENT_COPY
#endif

void STDCALL odessa_segment_copy_ (
int* s1,
int* s2 ) {
odessa_segment_copy ( *s1, *s2 );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_print_ ODESSA_SEGMENT_PRINT
#endif

void STDCALL odessa_segment_print_ (
int* s ) {
odessa_segment_print ( *s );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_all_ ODESSA_SEGMENT_ALL
#endif

void STDCALL odessa_segment_all_ (
int* s,
int* type,
int* size,
int* n,
int* n1 ) {
odessa_segment_all ( *s, type, size, n, n1 );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_set_type_ ODESSA_SEGMENT_SET_TYPE
#endif

void STDCALL odessa_segment_set_type_ (
int* s,
int* type ) {
odessa_segment_set_type ( *s, *type );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_type_ ODESSA_SEGMENT_TYPE
#endif

int STDCALL odessa_segment_type_ (
int* s ) {
result__ = odessa_segment_type ( *s );
return result__;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_insert_ ODESSA_SEGMENT_INSERT
#endif

void STDCALL odessa_segment_insert_ (
int* s,
int* ipos ) {
odessa_segment_insert ( *s, *ipos );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_replace_ ODESSA_SEGMENT_REPLACE
#endif

void STDCALL odessa_segment_replace_ (
int* s,
int* ipos ) {
odessa_segment_replace ( *s, *ipos );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_address_ ODESSA_SEGMENT_ADDRESS
#endif

void STDCALL odessa_segment_address_ (
int* s ) {
odessa_segment_address ( *s );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_number_ ODESSA_SEGMENT_NUMBER
#endif

int STDCALL odessa_segment_number_ (
) {
int result__;

}

#ifdef FTN_ALLCAPS
#define odessa_segment_info_ ODESSA_SEGMENT_INFO
#endif

void STDCALL odessa_segment_info_ (
int* a,
int* b,
int* c,
int* d ) {
odessa_segment_info ( a, b, c, d );
return;
}

#ifdef FTN_ALLCAPS
#define odessa_segment_check_ ODESSA_SEGMENT_CHECK
#endif

int STDCALL odessa_segment_check_ (
int* s,
int* t ) {
result__ = odessa_segment_check ( *s, *t );
return result__;
}
.

Relevant Pages