*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> mkf2c (1)              


MKF2C(1)							      MKF2C(1)

NAME    [Toc]    [Back]

     mkf2c - generate FORTRAN-C	interface routines

SYNOPSIS    [Toc]    [Back]

     mkf2c [ options ] [ cprog.fc [ cprog.s ] ]

DESCRIPTION    [Toc]    [Back]

     mkf2c is used to generate assembly-language routines to provide greater
     flexibility when calling a	C function from	a FORTRAN routine.

     Mkf2c accepts as input a set of C functions, and produces an assemblylanguage
 interface	routine	in the output file.  If	the input and output
     files are not specified, mkf2c reads from stdin and writes	to stdout.
     The input may be a	copy of	the actual C file being	interfaced, perhaps
     filtered by the program extcentry(1).  The	output of mkf2c	is an
     assembly-language (.s) file that must be assembled	with as(1), and	loaded
     with the FORTRAN and C routines that are to be interfaced.

     The assembly-language output is KPIC code which must be assembled with
     the -KPIC option to as(1) unless an unshared .o is	desired.

     Mkf2c uses	the parameter declarations in the C function headers to
     transform each parameter of the calling language to that of the receiving
     language. The standard basic C types attached to the parameters are used
     to	determine the object each parameter represents - i.e., whether it is a
     value or pointer, its size, whether it is unsigned, etc.

     For C functions in	K&R style, the opening and closing brace of the
     function body must	be present. Information	in the body of the function is
     ignored. For C functions in ANSI C	function prototype style, the function
     may be either a definition	(and whatever is between the opening and
     closing brace is ignored) or a declaration	(ie, with ; rather than	{}).
     Function parameters in ANSI C style function prototypes need not name the
     parameters.  Function parameters in ANSI C	style function prototypes
     cannot use	typedef	names to declare parameter types.

     mkf2c expects its input to	consist	solely of the functions	it is to
     interface,	comments, and lines which begin	with the preprocessor control
     character '#'.  It	can match braces, enabling it to bound function
     bodies.  It cannot, however, understand other C constructs	normally
     occurring at the global level (typedefs, structure	declarations, data
     declarations, function prototypes,	etc.).	Such unrecognized constructs
     must be eliminated	from the input (this is	the purpose of extcentry(1)).

     Mkf2c will	ignore functions of storage class static .

     The simplest way to generate an interface for a C function	is to simply
     hand-code a copy of the function which consists of	the entry and
     parameter declarations with an empty body.	 This stub, which is
     traditionally suffixed with .fc is	then used as input to mkf2c, and the
     resultant .s file is assembled and	linked into the	executable.  The root
     name of the stub file must	differ from the	root name of the file

									Page 1

MKF2C(1)							      MKF2C(1)

     containing	the actual C functions (so that	the name of the	resultant .os
     differ). NOTE: the	-KPIC switch must be given to as(1) unless the object
     is	to be non-shared.

	  mkf2c	foo.fc foo.s
	  as -KPIC foo.s -o foo.o

     It	is also	possible to create wrappers from existing C source code.  This
     is	done by	adding special rules to	your makefile and adding special
     comments around each function for which an	interface is to	be generated.
     See the example at	the end	of this	man page.

     The options to mkf2c(1) are the following:

     -32       Generate	wrappers with (old) 32-bit calling conventions.	 At
	       this time, it is	the default, but may change as different ABIs
	       become the future default.

     -64       Generate	wrappers with 64-bit pointer sizes, and	using the 64
	       bit calling conventions.

     -n32      Generate	wrappers with the n32 calling conventions.

     -f	       Suppress	extending floats to doubles across the call. Normally,
	       formal parameters of type float in the (K&R) C input to mkf2c
	       are dereferenced	and converted to type double across the
	       interface, to conform to	C calling conventions.	This option
	       suppresses the conversion to double.  If	this option is
	       selected, the receiving routine in C should have	a prototype
	       with the	float parameters declared correctly.  For declarations
	       input to	mkf2c in ANSI C	style function prototypes float
	       arguments are not extended, so -f need not be supplied.

     -o	output Name the	output file output. If the output filename is not
	       specified by a -o filename switch, mkf2c	will use the second
	       filename	appearing in its argument list as the output file
	       name.  This method must be used if it is	desired	to generate an
	       interface routine in a file when	the input is from stdin.

     -U	       Normally, upper case characters appearing in FORTRAN external
	       names are mapped	to lower case.	This option suppresses that
	       mapping,	allowing FORTRAN external names	to be of mixed case.
	       This option should be used in conjunction with the -U option to

	       Specify the signed attribute of single-character	parameters.
	       The setting of this option determines whether a scalar
	       parameter of type char (in the C	input to mkf2c), which
	       corresponds to a	FORTRAN	argument of type character*1, should
	       be sign-extended	across the interface.  The default setting is

									Page 2

MKF2C(1)							      MKF2C(1)

     -u	       Keep underscores	in function names.  By default underscores are
	       removed and a warning is	issued.

     -l	       By default, mkf2c truncates FORTRAN external names to six
	       characters to conform to	the ANSI standard and to be
	       backwards-compatible with the IRIS 4D Series.  This switch
	       allows the maximum number of characters in FORTRAN external
	       names to	be the same as that enforced by	the FORTRAN front-end
	       (currently 32).	If this	switch is not specified, the FORTRAN
	       program should have the C function name truncated to six
	       characters at the call.

     -w	       Inhibit the generation of warning messages.  As creating
	       wrappers	can cause confusion, mkf2c gives warning messages for
	       constructs which	will result in an interface which is
	       'unnatural' for C (i.e.,	in which the C side of the interface
	       must take special precautions when accessing the	parameters or
	       naming the routines).  An example of this would be passing a
	       FORTRAN character variable as a C character array.  Mkf2c knows
	       that this situation requires C to use special care when
	       manipulating the	string,	as it is not null-terminated, and,
	       hence, it generates a warning message. It is recommended	that
	       -w only be used by programmers experienced with the generation
	       of wrappers.

	       This is used when the wrapper and the target C function will be
	       placed in the same DSO.	A further optimization is taken	which
	       removes the restoring of	the gp register	after the call return.

EXAMPLE    [Toc]    [Back]

     In	this example, a	FORTRAN	program	wants to call a	C function
     AllParameters with	many parameters.  The FORTRAN program is in the	file
     f.f and the C function is in the file c.c.	 These are the only two	files
     in	the program.  The special comments /*CENTRY*/ and /*ENDCENTRY*/	have
     been added	to the C source	code to	bracket	the function for which an
     interface is to be	generated.  The	C function header is given below:

									Page 3

MKF2C(1)							      MKF2C(1)

	  /* CENTRY */
	  short	s;
	  char c,*cptr;
	  int *ptr1;
	  char *ptr2[];
	  short	ar1[];
	  float	f;
	  double d,*d1;
	  struct test_s	*struct1;
	  char string1[],string2[30];
	  sometype u;
	       The C function body is ignored by mkf2c.
	  /* ENDCENTRY */

     When this function	is run through mkf2c, a	complaint will be given	about
     not understanding the type	of parameter u.	 It will be assumed to be a
     simple pointer.  Additionally, a warning about passing the	parameters
     string1 and string2 as simple pointers will be given.  (These FORTRAN
     character variables each have an associated length	which is passed	as a
     hidden parameter to the C function, at the	end of the parameter list.
     These additional parameters may be	accessed by the	C function by the use
     of	the varargs macros.  See the FORTRAN Language Reference	Manual for
     more information.)

     The parameter i will be assumed to	be of type int,	as it is by the	C
     compiler ccom during compilation.

     Several items are noteworthy about	the parameters in this example.	 The
     parameters	i, s, c, f, and	d will be dereferenced across the call.	The
     parameter f will be extended to a double across the call unless the -f
     switch is given to	mkf2c(1). The parameters ptr1, ptr2, ar1, d1, struct1,
     string1, and string2 will be passed as simple pointers.  The FORTRAN
     character*1 variable which	is passed as c will be dereferenced and
     extended to a long	across the call. If the	-signed	switch is specified, c
     will be sign-extended when	being dereferenced.  A copy of parameter cptr
     will be made and the copy null-terminated.	 A pointer to this copy	will

									Page 4

MKF2C(1)							      MKF2C(1)

     be	passed.	 The C entry point will	be named AllParameters.	 The FORTRAN
     entry point name depends on whether or not	the -U and/or the -l switches
     have been given.  The various combinations	of these switches and their
     effect is detailed	below:

			    |Switches |	FORTRAN	Entry  |
			    |<none>   |	allpar_	       |
			    |-l	      |	allparameters_ |
			    |-U	      |	AllPar_	       |
			    |-l	-U    |	AllParameters_ |

     The program can be	made easily and	the interface generated	automatically
     by	adding the following special rules to your makefile:

	   # .fc must be added to your SUFFIXES	between	.c and .o
	   .SUFFIXES: .o .fc .c	.s .f


	   test:  f.o c.o
		  f77 -o test f.o c.o

	   # note -- each .c file containing routines to be interfaced must have
	   # a dependency such as the following
	   c.o:	c.fc

		   cc $(CFLAGS)	-c $*.c
		   mkf2c $(F2CFLAGS) $<	$*.s
		   as $(ASFLAGS) -o $*.wo $*.s
		   ld -r $*.o $*.wo -o $*.tmp
		   mv $*.tmp $*.o
		   rm -f $*.s $*.wo

		   extcentry $*.c $*.fc

		    rm -f *.o test *.fc

     In	the make, the program extcentry	will be	run on c.c to produce c.fc.
     This program (see extcentry(1)) will copy to c.fc all text	in c.c which
     is	between	the special comments /*	CENTRY */ and /* ENDCENTRY */.	Mkf2c

									Page 5

MKF2C(1)							      MKF2C(1)

     will then be run on c.fc, and the make variable F2CFLAGS will be passed
     to	it.  The C source will be compiled with	cc(1) (using cc	$CFLAGS), and
     the output	of mkf2c will be assembled (with as $ASFLAGS).	These two .os
     will then be loaded together into a single	relocatable named c.o.

     If	it is desired to pass mkf2c(1) some flags (e.g., -l and	-signed), the
     make variable F2CFLAGS should be set in the makefile, as

	       F2CFLAGS	= -signed -l

SEE ALSO    [Toc]    [Back]

     extcentry(1), cc(1), FORTRAN Language Reference Manual

DIAGNOSTICS    [Toc]    [Back]

     Mkf2c is very simple-minded about diagnosing syntax errors.  It can
     detect such things	as a formal parameter having its type declared when it
     is	not in the formal parameter list.  A few such cases give intelligible
     error messages.  The program will complain	about types it does not
     understand.  The default type assigned in such cases is simple pointer.
     Mkf2c will	also delete characters from FORTRAN entry names	which are
     illegal (e.g., underscores).  The user will be warned in such instances.
     Most errors that the programs detect are indicated	only by	the source
     line number.

     If	mkf2c encounters an error which	it cannot remedy, it will abort,
     giving the	line number on which the error occurred.  The resultant	.s
     file will be removed, and an error	exit will be taken.

     Because of	its limited error diagnostic ability, it is advisable to use
     cc	(1) to determine whether the input syntax is correct before passing it
     to	mkf2c.

BUGS    [Toc]    [Back]

     mkf2c does	not understand the ANSI	notation a(void) as meaning a function
     with no arguments.

     In	ANSI C style function prototypes, typedef names	cannot be used.

AUTHOR    [Toc]    [Back]

     Greg Boyd

									PPPPaaaaggggeeee 6666
[ Back ]
 Similar pages
Name OS Title
pxfopen IRIX Provides a Fortran interface to the open(2) system call
tapeio IRIX FORTRAN tape device specific I/O routines
sdfft2dui IRIX 2D FFT Real to Complex workspace initialization routines. FORTRAN SPECIFICATION subroutine SFFT2DUI( n1, n2, w
sdfft3dui IRIX 3D FFT Real to Complex workspace initialization routines. FORTRAN SPECIFICATION subroutine SFFT3DUI( n1, n2, n
sdfft1dui IRIX 1D FFT Real to Complex workspace initialization routines. FORTRAN SPECIFICATION subroutine SFFT1DUI( n, worksp
sdfftm1dui IRIX Multiple 1D, FFT Real to Complex workspace initialization routines. FORTRAN SPECIFICATION subroutine SFFTM1DUI
cry2mips IRIX Converts Fortran data types between Cray Fortran data types and MIPS IEEE Fortran data types
sia_getpasswd Tru64 interface to the getpw* and getgr* routines for SIA (Security Integration Architecture)
stcu Tru64 routines that provide a compilation unit symbol table interface
sia_getgroup Tru64 interface to the getpw* and getgr* routines for SIA (Security Integration Architecture)
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service