The basic components of the Fortran language are its

- the letters A ... Z and a ... z (which are equivalent outside a character context);
- the numerals 0 ... 9;
- the underscore _; and
- the special characters
= : + blank - * / ( ) , . $ ' (old) ! " % & ; < > ? (new)

Label: 123 Constant: 123.456789_long Keyword: ALLOCATABLE Operator: .add. Name: solve_equation (up to 31 characters, including _) Separator: / ( ) (/ /) , = => : :: ; %

From the tokens, we can build statements. These can be coded using
the new free

FUNCTION string_concat(s1, s2) ! This is a comment TYPE (string) :: s1, s2, string_concat string_concat%string_data = s1%string_data(1:s1%length) // & s2%string_data(1:s2%length) ! This is a continuation string_concat%length = s1%length + s2%length END FUNCTION string_concatNote the trailing comments and the trailing continuation mark. There may be 39 continuation lines, and 132 characters per line. Blanks are significant. Where a token or character constant is split across two lines:

... start_of& &_name ... 'a very long & &string'a leading & on the continued line is also required.

Automatic conversion of source form for existing programs can be carried out by convert.f90. Its options are:

- significant blank handling;
- indentation;
- CONTINUE replaced by END DO;
- name added to subprogram END statement; and
- INTEGER*2 etc. syntax converted.

1 0 -999 32767 +10for the default

INTEGER, PARAMETER :: two_bytes = SELECTED_INT_KIND(4)that allows us to define constants of the form

-1234_two_bytes +1_two_bytesHere, two_bytes is the kind type parameter; it can also be a default integer literal constant, like

-1234_2but use of an explicit literal constant would be non-portable.

The KIND function supplies the value of a kind type parameter:

KIND(1) KIND(1_two_bytes)and the RANGE function supplies the actual decimal range (so the user must make the actual mapping to bytes):

RANGE(1_two_bytes)

Also, in DATA statements, binary, octal and hexcadecimal constants may be used:

B'01010101' O'01234567' Z'10fa'

INTEGER, PARAMETER :: long = SELECTED_REAL_KIND(9, 99)for at least 9 decimal digits of precision and a range of 10*(-99) to 10**99, allowing

1.7_longAlso, we have the intrinsic functions

KIND(1.7_long) PRECISION(1.7_long) RANGE(1.7_long)that give in turn the kind type value, the actual precision (here at least 9), and the actual range (here at least 99).

(1, 3.7_long)

'A string' "Another" 'A "quote"' ''(the last being a null string). Other kinds are allowed, especially for support of non-European languages:

2_' 'and again the kind value is given by the KIND function:

KIND('ASCII')

.FALSE. .true._one_bitand the KIND function operates as expected:

KIND(.TRUE.)

The numeric types are based on model numbers with associated inquiry functions (whose values are independent of the values of their arguments):

DIGITS(X) Number of significant digits EPSILON(X) Almost negligible compared to one (real) HUGE(X) Largest number MAXEXPONENT(X) Maximum model exponent (real) MINEXPONENT(X) Minimum model exponent (real) PRECISION(X) Decimal precision (real, complex) RADIX(X) Base of the model RANGE(X) Decimal exponent range TINY(X) Smallest postive number (real)These functions are important for portable numerical software.

We can specify scalar variables corresponding to the five intrinsic types:

INTEGER(KIND=2) i REAL(KIND=long) a COMPLEX current LOGICAL Pravda CHARACTER(LEN=20) word CHARACTER(LEN=2, KIND=Kanji) kanji_wordwhere the optional KIND parameter specifies a non-default kind, and the LEN= specifier replaces the *len form. The explicit KIND and LEN specifiers are optional:

CHARACTER(2, Kanji) kanji_wordworks just as well.

For derived-data types we must first define the form of the type:

TYPE person CHARACTER(10) name REAL age END TYPE personand then create structures of that type:

TYPE(person) you, meTo select components of a derived type, we use the % qualifier:

you%ageand the form of a literal constant of a derived type is shown by:

you = person('Smith', 23.5)which is known as a structure constructor. Definitions may refer to a previously defined type:

TYPE point REAL x, y END TYPE point TYPE triangle TYPE(point) a, b, c END TYPE triangleand for a variable of type triangle, as in

TYPE(triangle) twe have components of type point:

t%a t%b t%cwhich, in turn, have ultimate components of type real:

t%a%x t%a%y t%b%x etc.We note that the % qualifier was chosen rather than . because of ambiguity difficulties.

Arrays are considered to be variables in their own right. Given

REAL a(10) INTEGER, DIMENSION(0:100, -50:50) :: map(the latter an example of the syntax that allows grouping of attributes to the left of :: and of variables sharing the attributes to the right), we have two arrays whose elements are in array element order (column major), but not necessarily in contiguous storage. Elements are, for example,

a(1) a(i*j)and are scalars. The subscripts may be any scalar integer expression. Sections are

a(i:j) ! rank one map(i:j, k:l:m) ! rank two a(map(i, k:l)) ! vector subscript a(3:2) ! zero lengthWhole arrays and array sections are array-valued objects. Array-valued constants (constructors) are available:

(/ 1, 2, 3, 4, 5 /) (/ (i, i = 1, 9, 2) /) (/ ( (/ 1, 2, 3 /), i = 1, 10) /) (/ (0, i = 1, 100) /) (/ (0.1*i, i = 1, 10) /)making use of the implied-DO loop notation familiar from I/O lists. A derived data type may, of course, contain array components:

TYPE triplet REAL, DIMENSION(3) :: vertex END TYPE triplet TYPE(triplet), DIMENSION(4) :: tso that

t(2) is a scalar (a structure) t(2)%vertex is an array component of a scalar

There are some other interesting character extensions. Just as a substring as in

CHARACTER(80), DIMENSION(60) :: page ... = page(j)(i:i) ! substringwas already possible, so now are the substrings

'0123456789'(i:i) you%name(1:2)Also, zero-length strings are allowed:

page(j)(i:i-1) ! zero-length stringFinally, there are some new intrinsic character functions:

ACHAR IACHAR (for ASCII set) ADJUSTL ADJUSTR LEN_TRIM INDEX(s1, s2, BACK=.TRUE.) REPEAT SCAN (for one of a set) TRIM VERIFY(for all of a set)