Mixing C and Fortran on the SP

!FILENAME: f_main.f
!
PROGRAM f_calls_c
        IMPLICIT NONE

        REAL :: p1_x, p1_y, p2_x, p2_y
        EXTERNAL calc_dist

        p1_x = 0.0
        p1_y = 0.0
        p2_x = 3.0
        p2_y = 4.0

        CALL calc_dist(p1_x,p1_y,p2_x,p2_y)

END PROGRAM f_calls_c

/* FILENAME: calc_c.c
*/
#include <math.h>
void calc_dist(float *x1, float *y1, float *x2, float *y2)
{
        float dxsq, dysq, distance;

        dxsq = (*x2-*x1)*(*x2-*x1);
        dysq = (*y2-*y1)*(*y2-*y1);

        distance = sqrt( dxsq + dysq );

        printf("The distance between the points is %13.5e\n",
			distance);

}

/* FILENAME: c_main.c
   Shows how to call a FORTRAN routine from C
*/

extern void calc_dist(float*, float*, float*, float*);

void main()
{
        float p1_x,p1_y,p2_x,p2_y;

        p1_x = 0.0;
        p1_y = 0.0;
        p2_x = 3.0;
        p2_y = 4.0;

        calc_dist(&p1_x,&p1_y,&p2_x,&p2_y);
}

! FILENAME: calc_f.f
!
SUBROUTINE calc_dist(x1,y1,x2,y2)
        IMPLICIT NONE
        REAL :: x1,y1,x2,y2
        REAL :: distance

        distance = SQRT( (x2-x1)**2 + (y2-y1)**2 )

        WRITE(6,1) distance
1       FORMAT("The distance between the points is ", 1pe13.5)

END SUBROUTINE calc_dist

/* FILENAME: calc_c++.h 
	This is the C++ routine.
*/
 #include <iostream.h>
 #include <math.h>

template<class T> class calc {

public:

calc() {cout <<"Inside C++ constructor"<<endl;}
~calc() {cout <<"Inside C++ destructor"<<endl;}
 
 void calc_dist(T *x1, T *y1, T *x2, T *y2)
 {
         T dxsq, dysq, distance;

         dxsq = (*x2-*x1)*(*x2-*x1);
         dysq = (*y2-*y1)*(*y2-*y1);

         distance = sqrt( dxsq + dysq );

         cout <<"The distance between the points is "
		<<distance<<" \n"<<endl;

 }
};

/* Filename: calc_cwrapper.C */
#include <stdio.h>
#include "calc_c++.h"

extern "C" void calc_dist(float *x,float *y,float *X,float *Y);

void calc_dist(float *x,float *y,float *X,float *Y) {
        printf("Inside C function, creating C++ object\n");

        calc<float>* c=new calc<float>();
        c->calc_dist(x,y,X,Y);
        
        printf("Back in C function, will delete C++ object\n");
        delete c;
}

! FILENAME: calc_mod_f.f
!
MODULE CALCULATION

      CONTAINS
        SUBROUTINE CALC_DIST(x1,y1,x2,y2)
        IMPLICIT NONE
        REAL :: x1,y1,x2,y2
        REAL :: distance

        distance = SQRT( (x2-x1)**2 + (y2-y1)**2 ) 

        WRITE(6,1) distance
1       FORMAT("The distance between the points is ", 1pe13.5) 

        END SUBROUTINE CALC_DIST 

END MODULE CALCULATION

 
/* FILENAME: c_main_mod.c
   Shows how to call a FORTRAN routine from C
   In this case the FORTRAN routine, named CALC_DIST,  
        is in the FORTRAN module named calculation
*/

extern void __calculation_NMOD_calc_dist(float *, float *, 
				float *, float *);

void main() 
{
        float p1_x,p1_y,p2_x,p2_y;

        p1_x = 0.0;
        p1_y = 0.0;
        p2_x = 3.0;
        p2_y = 4.0;

        __calculation_NMOD_calc_dist(&p1_x,&p1_y,&p2_x,&p2_y);
}

!FILENAME: give_chars.f
!
! Gives some examples of passing Fortran strings to
! a C routine that prints a character string beginning
! at the address of the start of the passed character
! string and ending at the C string termination character, which is
! CHAR(0) in Fortran.
 
PROGRAM give_chars

        IMPLICIT NONE

        CHARACTER(LEN=1)::  a(9),d
        CHARACTER(LEN=8)::  b,c,e
        REAL:: f
        EXTERNAL TAKE_CHARS 
        
! These are put in COMMON block to insure they are all 
! adjacent in memory

        COMMON//b,c,d
        COMMON/c2/e,f

        a(1) = 'a'
        a(2) = 'b'
        a(3) = 'c'
        a(4) = 'd'
        a(5) = 'e'
        a(6) = 'f' 
        a(7) = 'g'
        a(8) = 'h'

! This behavior of this call is undefined, since there is
! no string terminator character being passed to the C
! routine. It will 'work' if there fortuitously happens to be
! a zero in the next memory location after a(8).
 
        PRINT *, ""
        PRINT *, "This may or may not print a(1) to a(8):"
        CALL TAKE_CHARS(a)


! This puts a string terminator character in a(6)

        a(6) = CHAR(0)  ! String terminator for C routine
        PRINT *, ""
        PRINT *, "This will print a(1) to a(5):"
        CALL TAKE_CHARS(a)

!
        b='ABCDEFGH'
        c='ijklmnop'
        d = CHAR(0)     !String terminator for C routine

!       The string terminator in d follows the string c in memory
!       but there is no string terminator character between c and d
!       (All this controlled by COMMON block declaration).

        PRINT *, ""
        PRINT *, "This will print string b and c:"
        CALL TAKE_CHARS(b)

!       Here we append a string terminator character to  the
!       string b when we pass it. 

        PRINT *, ""
        PRINT *, "This will print string b only:"
        CALL TAKE_CHARS(b // CHAR(0)) !Appends string terminator to b

!       The following will print string e plus garbage
!       because the C routine does not see a string terminator
!       before the REAL value f 

        e = 'abcdefgh'
        f = ATAN(1.)
        PRINT *, ""
        PRINT *, "This will print string e plus garbage:"
        CALL TAKE_CHARS(e)
         
                
END PROGRAM give_chars

 
/* FILENAME: take_chars.c
   A routine to take a Fortran character string
   and print it. It assumes that the Fortran routine
   has explicitly appended a string terminator character
   to the string before passing it.
*/


void take_chars(char *fstring, long int fstringLen)
{
        
/*      This printf() function (with %s) will print characters until
        it encounters a \0 character, which it interprets as an 
        end-of-string signal.
*/ 
         
        printf("The passed string is: %s\n",fstring);
        printf("The passed string length is: %d\n",fstringLen);
}