***introduction
The syntax of each F statement is described in this list.

Notation
--------
[xxx]         means optional xxx
xxx-list      means one or more xxx separated by commas
[xxx-list]    means zero or more xxx separated by commas
{xxx | yyy}   means either xxx or yyy
[things]...   means zero or more "things"
               where "things" can contain other syntax
               such as [xxx-list] and {xxx | yyy}.
{things}-list means one or more "things" separated by commas
               where "things" can contain other syntax
               such as [xxx-list] and {xxx | yyy}.

Terms
-----
NAME - 31 alphanumberic chars or '_', starting with
       'a'..'z' or 'A'..'Z', and not ending in '_'.
EXPR - EXPRessions are described elsewhere.
ATTR - ATTRibutes are described elsewhere.
LEFT - A container that can be stored into.  This is
       commonly known as something that is allowed on the
       left of the = in an assignment stmt.
FORMAT - A character expression for
         input/output formatting.
***allocate
allocate (LEFT-list [, stat=LEFT])
***assignment
LEFT = EXPR
***backspace
backspace (unit=EXPR [, iostat=LEFT])
***call
call NAME([EXPR-list])
***case
case (EXPR [,EXPR])
case (:EXPR)
case (EXPR:)
case (EXPR:EXPR)
case ( { EXPR | :EXPR | EXPR: | EXPR:EXPR }-list )
***case default
case default
***character
character (len=EXPR) [, ATTR-list] :: NAME-list
character (len=EXPR) ,{parameter|save}
                     [, ATTR-list] :: {NAME=EXPR}-list
***close
close (unit=EXPR [, iostat=LEFT] [, status=EXPR] )
***complex
complex [(kind=NAME)] [, ATTR-list] :: NAME-list
complex [(kind=NAME)] ,{parameter|save}
                      [, ATTR-list] :: {NAME=EXPR}-list
***contains
contains
***cycle
cycle
cycle NAME
***deallocate
deallocate (LEFT-list [, stat=LEFT])
***do
      do
      do NAME = EXPR , EXPR [, EXPR]
NAME: do
NAME: do NAME = EXPR , EXPR [, EXPR]
***else
else
***elseif
elseif (EXPR) then
***elsewhere
elsewhere
***enddo
enddo
enddo NAME
***endfile
endfile (unit=EXPR [, iostat=LEFT])
***endfunction
endfunction NAME
***endif
endif
***endinterface
endinterface
***endmodule
endmodule NAME
***endprogram
endprogram NAME
***endselect
endselect
***endsubroutine
endsubroutine NAME
***endtype
endtype NAME
***endwhere
endwhere
***exit
exit
exit NAME
***function
function NAME ( [NAME-list] ) result ( NAME )
recursive function NAME ( [NAME-list] ) result ( NAME )
***if
if (EXPR) then
***inquire
inquire (iolength=LEFT) EXPR-list
inquire ( { unit=EXPR | file=EXPR }
          [, iostat=LEFT]
          [, exist=LEFT]
          [, opened=LEFT]
          [, number=LEFT]
          [, named=LEFT]
          [, name=LEFT]
          [, access=LEFT]
          [, sequential=LEFT]
          [, direct=LEFT]
          [, form=LEFT]
          [, formatted=LEFT]
          [, unformatted=LEFT]
          [, recl=LEFT]
          [, nextrec=LEFT]
          [, position=LEFT]
          [, action=LEFT]
          [, read=LEFT]
          [, write=LEFT]
          [, readwrite=LEFT] )
***integer
integer [(kind=NAME)] [, ATTR-list] :: NAME-list
integer [(kind=NAME)] ,{parameter|save}
                      [, ATTR-list] :: {NAME=EXPR}-list
***interface for dummy procedure
interface
***interface for external procedure
interface
***interface for generic/specific overload
interface NAME
***intrinsic
intrinsic NAME-list
***logical
logical [(kind=NAME)] [, ATTR-list] :: NAME-list
logical [(kind=NAME)] ,{parameter|save}
                      [, ATTR-list] :: {NAME=EXPR}-list
***module
module NAME
***module procedure
module procedure NAME-list
***nullify
nullify (LEFT-list)
***open
open (unit=EXPR, action=EXPR, status=EXPR
      [, position=EXPR]
      [, iostat=LEFT]
      [, file=EXPR]
      [, access=EXPR]
      [, form=EXPR]
      [, recl=EXPR] )
***pointer assignment
LEFT => EXPR
***print
print * [, EXPR-list]
print FORMAT, EXPR-list
***private no list
private
***private with list
private :: NAME-list
***program
program NAME
***public no list
public
***public with list
public :: NAME-list
***read
read * [, NAME-list]
read FORMAT, LEFT-list
read (unit=EXPR [, fmt="FORMAT"] [, iostat=LEFT]
    [, rec=EXPR] [, advance=EXPR] [, size=LEFT]) LEFT-list
***real
real [(kind=NAME)] [, ATTR-list] :: NAME-list
real [(kind=NAME)] ,{parameter|save}
                   [, ATTR-list] :: {NAME=EXPR}-list
***return
return
***rewind
rewind (unit=EXPR [, iostat=LEFT])
***select case
select case (EXPR)
***stop
stop
***subroutine
subroutine NAME ( [NAME-list] )
recursive subroutine NAME ( [NAME-list] )
***type
type, public :: NAME
type, private :: NAME
***type(name)
type (NAME) [, ATTR-list] :: NAME-list
type (NAME)  , ATTR-list  :: NAME=EXPR [, NAME=EXPR]...
type (NAME) [, ATTR-list] :: {NAME=EXPR | NAME}
                          [, {NAME=EXPR | NAME}]...
***use
use NAME [, only : NAME-list]
use NAME [, only : {NAME=>NAME | NAME}
                [, {NAME=>NAME | NAME}]... ]
use NAME [, NAME=>NAME [, NAME=>NAME]... ]
***where
where (EXPR)
***write
write * [, EXPR-list]
write FORMAT, EXPR-list
write (unit=EXPR [, fmt="FORMAT"] [, iostat=LEFT]
    [, rec=EXPR] [, advance=EXPR] [, size=LEFT]) EXPR-list
***END
