Current VF90 Restrictions and unimplemented features for Linux/g77
----------------------------------------------------------------

-  Dependence on SEQUENCE in derived types, including:
 
   a) Equivalence of derived type with non-conformable derived types
   or other variables.

   b) Sequence derived types arrays in COMMON cannot be accessed in
   all possible ways.

   Example:
     type abc
       sequence
       integer, dimension(10) :: a,b
     end type
     type(abc) da
     common /.../ da(10)
     ...
     da(j)%a(11) = ...   ! one might think this refers to da(j)%b(1)

   c) TRANSFER intrinsic.

     type uh_oh
        sequence
        real x, y
     end type
     type (uh_oh) bad(100)
     complex c
     c = TRANSFER (bad(50),c)

-  Nonadvancing input.  (Nonadvancing output is translated using the $
   edit descriptor, where available.)

-  For some systems, list-directed I/O to internal file.  
   (This is legal f90 but not f77; some f77 compilers allow, some don't.)

-  For some systems, character array pointers.  (Depends on f77
   compiler.)

-  Character pointer arrays, by default are not translated. The -x9
   switch will translate character pointers but support is limited
   to byte-aligned data sizes and character*1 and character*2.

-  Recursion is limited to a stack limit, with current default of 100. 
   The stack size can be increased or decreased with the -Zrecur=value 
   directive.

-  NAMELIST I/O for derived types.

-  DELIM= on OPEN statements.

-  RECL= on OPEN statements for sequential access files.

-  Use of array elements in specification (i.e. dimensioning) expressions.

-  Recursive ENTRYs.

-  SIZE of expression involving implied DOs with certain kinds of
   variable upper bounds.

	subroutine sub(n)
	isize = SIZE( (/((i,i=1,j),j=1,n)/) )     ! i loop bounds...
                                                  ! ...depend on j loop
-  7-dimensional array in recursive routine.

-  Automatic character objects in recursive routines.

-  DATA statement with vector subscript.

	integer,parameter ::v(3)=(/3,2,1/)
	integer a(3)
	data a(v(:)) /1,2,3/              !! <====
	write(*,*) a

-  Certain user character functions with dynamic length.

-  Use of certain intrinsic functions in dimensioning expressions
   of dummy arrays and character variables.

      subroutine sub(a,n,m)
      dimension a(max(n,m),100)

-  Some arguments to INQUIRE(IOLENGTH=):
       dummy arguments
       implied DOs
       derived types
       expressions involving functions

-  Function argument to recursive procedure, if the function
   can be different at different levels of the recursion.

-  DATAing of derived type variables in BLOCK DATAs; only
   handled if no components are arrays or structures. 

-  Indirect recursion.

-  For some systems, possibly a few of the new edit descriptors, 
   e.g. B, depending on what extensions the f77 compiler allows

=================== end of document =====================
