C code:

#include <stdlib.h>

int main(int ac, char *av[])

{

    to_fortran(2);

}

Fortran code:

       subroutine to_fortran(i)

       integer, value :: i

       print *, i

       end

4.1.9.3 Stream I/O (Fortran 2000)

A new "stream" I/O scheme has been proposed as part of the Fortran 2000 draft standard. Stream I/O access treats a data file as a continuous sequence of bytes, addressable by a positive integer starting from 1. Declare a stream I/O file with the ACCESS='STREAM' specifier on the OPEN statement. File positioning to a byte address requires a POS=scalar_integer_expression specifier on a READ or WRITE statement. The INQUIRE statement accepts ACCESS='STREAM', a specifier STREAM=scalar_character_variable, and POS=scalar_integer_variable.

4.1.9.4 Formatted I/O Features From Fortran 2000

Three new Fortran 2000 formatted I/O specifiers have been implemented in f95. They may appear on OPEN, READ, WRITE, PRINT, and INQUIRE statements:

• DECIMAL=['POINT'|'COMMA']

Change the default decimal editing mode. The default uses a period to separate the whole number and decimal parts of a floating-point number formatted with D, E, EN, ES, F, and G editing. 'COMMA' changes the default to use comma instead of a period, to print, for example, 123,456. The default is 'POINT', which uses a period, to print, for example, 123.456.

• ROUND=['PROCESSOR_DEFINED' | 'COMPATIBLE']

Set the default rounding mode for formatted I/O D, E, EN, ES, F, and G editing. With 'COMPATIBLE', the value resulting from data conversion is the one closer to the two nearest represetnations, or the value away from zero if the value is halfway between them. With 'PROCESSOR_DEFINED', the rounding mode is dependent on the processor's default mode, and is the compiler default if ROUND is not specified.

As an example, WRITE(*,'(f11.4)') 0.11115 prints 0.1111 in default mode, and 0.1112 in 'COMPATIBLE' mode.

• IOMSG=character-variable

Returns an error message as a string in the specified character variable. This is the same error message that would appear on standard output. Users should allocated a character buffer large enough to hold the longest message. (CHARACTER*256 should be sufficient.)

When used in INQUIRE statements, these specifiers declare a character variable for returning the current values.

New edit descriptors DP, DC, RP, and RC change the defaults within a single FORMAT statement to decimal point, decimal comma, processor-defined rounding, and compatible rounding respectively. For example:

WRITE(*,'(I5,DC,F10.3)') N, W

prints a comma instead of a period in the F10.3 output item.

See also the -iorounding compiler command-line option for changing the floating-point rounding modes on formatted I/O. (-iorounding=mode.)

4.1.9.5 STRUCTURE and UNION (VAX Fortran)

To aid the migration of programs from f77, f95 accepts VAX Fortran STRUCTURE and UNION statements, a precursor to the "derived types" in Fortran 95. For syntax details see the FORTRAN 77 Language Reference manual.

The field declarations within a STRUCTURE can be one of the following:

• A substructure -- either another STRUCTURE declaration, or a record that has been previously defined.
• A UNION declaration.
• A TYPE declaration, which can include initial values.
• A derived type having the SEQUENCE attribute. (This is particular to f95 only.)

As with f77, a POINTER statement cannot be used as a field declaration.

f95 also allows:

• Either `.' or `%' can be used as a structure field dereference symbol:
  struct.field or struct%field.
• Structures can appear in a formatted I/O statement.
• Structures can be initialized in a PARAMETER statement; the format is the same as a derived type initialization.
• Structures can appear as components in a derived type, but the derived type must be declared with the SEQUENCE attribute.

4.1.10 I/O Extensions

Some I/O extensions that appeared in Forte Developer Fortran 77 are now part of the Fortran 95 compiler:

• NAMELIST Input Format:

The group name may be preceded by $ or & on input. The & is the only form accepted by the Fortran 95 standard, and is what is written by NAMELIST output.

Accepts $ as the symbol terminating input except if the last data item in the group is CHARACTER data, in which case the $ is treated as input data.

Allows NAMELIST input to start in the first column of a record.

• OPEN(...,FORM='BINARY') treats the file as binary data without record marks:

Opening a file with FORM='BINARY' has roughly the same effect as FORM='UNFORMATTED', except that no record lengths are embedded in the file. Without this data, there is no way to tell where one record begins, or ends. Thus, it is impossible to BACKSPACE a FORM='BINARY' file, because there is no way of telling where to backspace to. A READ on a 'BINARY' file will read as much data as needed to fill the variables on the input list.

• WRITE statement: Data is written to the file in binary, with as many bytes transferred as specified by the output list.
• READ statement: Data is read into the variables on the input list, transferring as many bytes as required by the list. Because there are no record marks on the file, there will be no "end-of-record" error detection. The only errors detected are "end-of-file" or abnormal system errors.
• INQUIRE statement: INQUIRE on a file opened with FORM="BINARY" returns:

FORM="BINARY"
ACCESS="SEQUENTIAL"
DIRECT="NO"
FORMATTED="NO"
UNFORMATTED="YES"
RECL= AND NEXTREC= are undefined

• BACKSPACE statement: Not allowed--returns an error.
• ENDFILE statement: Truncates file at current position, as usual.
• REWIND statement: Repositions file to beginning of data, as usual.

• Recursive I/O possible on different units (this is because the f95 I/O library is "MT-Warm").
• RECL=2147483646 (2³¹-2) is the default record length on sequential formatted, list directed, and namelist output.
• ENCODE and DECODE are recognized and implemented as described in the FORTRAN 77 Language Reference Manual.
• Non-advancing I/O is enabled with ADVANCE='NO', as in:

write(*,'(a)',ADVANCE='NO') 'n= '
read(*,*) n

---

4.2 Directives

A compiler directive directs the compiler to do some special action. Directives are also called pragmas.

A compiler directive is inserted into the source program as one or more lines of text. Each line looks like a comment, but has additional characters that identify it as more than a comment for this compiler. For most other compilers, it is treated as a comment, so there is some code portability.

Sun-style parallelization directives are the default with f95 -explicitpar. To switch to Cray-style directives, use the -mp=cray compiler command-line flag. Explicit parallelization with OpenMP directives requires compiling with -openmp.

A complete summary of Fortran directives appears in Appendix D.

4.2.1 Form of Special f95 Directive Lines

f95 recognizes its own special directives in addition to those described in Chapter 2. These have the following syntax:

!DIR$ d1, d2, ...

4.2.1.1 Fixed-Form Source

• Put CDIR$ or !DIR$ in columns 1 through 5.
• Directives are listed in columns 7 and beyond.
• Columns beyond 72 are ignored.
• An initial directive line has a blank in column 6.
• A continuation directive line has a nonblank in column 6.

4.2.1.2 Free-Form Source

• Put !DIR$ followed by a space anywhere in the line.

The !DIR$ characters are the first nonblank characters in the line (actually, non-whitespace).

• Directives are listed after the space.
• An initial directive line has a blank, tab, or newline in the position immediately after the !DIR$.
• A continuation directive line has a character other than a blank, tab, or newline in the position immediately after the !DIR$.

Thus, !DIR$ in columns 1 through 5 works for both free-form source and fixed-form source.

4.2.2 FIXED and FREE Directives

These directives specify the source form of lines following the directive line.

4.2.2.1 Scope

They apply to the rest of the file in which they appear, or until the next FREE or FIXED directive is encountered.

4.2.2.2 Uses

• They allow you to switch source forms within a source file.
• They allow you to switch source forms for an INCLUDE file. You insert the directive at the start of the INCLUDE file. After the INCLUDE file has been processed, the source form reverts back to the form being used prior to processing the INCLUDE file.

4.2.2.3 Restrictions

The FREE/FIXED directives:

• Each must appear alone on a compiler directive line (not continued).
• Each can appear anywhere in your source code. Other directives must appear within the program unit they affect.

Example: A FREE directive.

!DIR$ FREE DO i = 1, n a(i) = b(i) * c(i) END DO

4.2.3 Parallelization Directives

A parallelization directive is a special comment that directs the compiler to attempt to parallelize the next DO loop. These are summarized in Appendix D and described in the chapter on parallelization in the Fortran Programming Guide. f95 recognizes both Sun and Cray style parallelization directives, as well as the OpenMP Fortran API directives. OpenMP parallelization is described in the Forte Developer OpenMP API User's Guide.

---

4.3 Module Files

Compiling a file containing a Fortran 95 MODULE generates a module interface file (.mod file) for every MODULE encountered in the source. The file name is derived from the name of the MODULE; file xyz.mod (all lowercase) will be created for MODULE xyz.

Compilation also generates a .o module implementation object file for the source file containing the MODULE statements. Link with the module implementation object file along with the all other object files to create an executable.

The compiler creates module interface files and implementation object files in the directory specified by the -moddir=dir flag or the MODDIR evironment variable. If not specified, the compiler writes .mod files in the current working directory.

The compiler looks in the current working directory for the interface files when compiling USE modulename statements. The -Mpath option allows you to give the compiler an additional path to search. Module implementation object files must be listed explicitly on the command line for the link step.

Typically, programmers define one MODULE per file and assign the same name to the MODULE and the source file containing it. However, this is not a requirement.

In this example, all the files are compiled at once. The module source files appear first before their use in the main program.

demo% cat mod_one.f90 MODULE one ... END MODULE demo% cat mod_two.f90 MODULE two ... END MODULE demo% cat main.f90 USE one USE two ... END demo% f95 -o main mod_one.f90 mod_two.f90 main.f90

Compilation creates the files:

main
main.o
one.mod
mod_one.o
two.mod
mod_two.o

The next example compiles each unit separately and links them together.

demo% f95 -c mod_one.f90 mod_two.f90 demo% f95 -c main.f90 demo% f95 -o main main.o mod_one.o mod_two.o

When compiling main.f90, the compiler searches the current directory for one.mod and two.mod. These must be compiled before compiling any files that reference the modules on USE statements. The link step requires the module implementation object files mod_one.o and mod_two.o appear along with all other object files to create the executable.

4.3.1 Searching for Modules

With the release of the Forte Developer 7 Fortran 95 compiler, .mod files can be stored into an archive (.a) file. An archive must be explicitly specified in a -Mpath flag on the command line for it to be searched for modules. The compiler does not search archive files by default.

Only .mod files with the same names that appear on USE statements will be searched. For example, the Fortran 95 statement USE mymod causes the compiler to search for the module file mymod.mod by default.

While searching, the compiler gives higher priority to the directory where the module files are being written. This can be controlled by the -moddir=dir option flag and the MODDIR environment variable. This implies that if only the -Mpath option is specified, the current directory will be searched for modules first, before the directories and files listed on the -M flag.

4.3.2 The -use=list Option Flag

The -use=list flag forces one or more implicit USE statements into each subprogram or module subprogram compiled with this flag. By using the flag, it is not necessary to modify source programs when a module or module file is required for some feature of a library or application.

Compiling with -use=module_name has the effect of adding a USE module_name to each subprogram or module being compiled. Compiling with -use=module_file_name has the effect of adding a USE module_name for each of the modules contained in the module_file_name file.

4.3.3 The fdumpmod Command

Use the fdumpmod(1) command to display information about the contents of a module information file.

demo% fdumpmod mods.mod GROUP v8 version 0.16 mods.mod X v8 version 0.16 mods.mod

The dumpmod command will display information about modules in a single .mod file, files formed by concatenating .mod files, and in .a archives of .mod files. The display includes the name of the module, the target architecture, and a version number. See the fdumpmod(1) man page for details.

---

4.4 Intrinsics

f95 supports some intrinsic procedures that are extensions beyond the standard.

TABLE 4-4 Nonstandard Intrinsics

Name	Definition	Function Type	Argument Types	Arguments	Notes
COT	Cotangent	real	real	([X=]x)	P, E
DDIM	Positive difference	double precision	double precision	([X=]x,[Y=]y)	P, E
LEADZ	Get the number of leading 0 bits	integer	Boolean, integer, real, or pointer	([I=]i)	NP, I
POPCNT	Get the number of set bits	integer	Boolean, integer, real, or pointer	([I=]i)	NP, I
POPPAR	Calculate bit population parity	integer	Boolean, integer, real, or pointer	([X=]x)	NP, I

Notes on the above table:
P	The name can be passed as an argument.
NP	The name cannot be passed as an argument.
E	External code for the intrinsic is called at run time.
I	f95 generates inline code for the intrinsic procedure.

See the Fortran Library Reference for a more complete discussion of intrinsics, including those from Fortran 77 that are recognized by the Fortran 95 compiler.

---

4.5 Forward Compatibility

Future releases of f95 are intended to be source code compatible with this release.

Module information files generated by this release of f95 are not guaranteed to be compatible with future releases.

---

4.6 Mixing Languages

On Solaris systems, routines written in C can be combined with Fortran programs, since these languages have common calling conventions.See the C-Fortran Interface chapter in the Fortran Programming Guide for details on how to interoperate between C and Fortran routines.

Fortran User's Guide

816-2457-10

Copyright © 2002, Sun Microsystems, Inc. All rights reserved.