This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[Patch, Fortran, 4.6] Coarray 5/n: Some coarray declaration fixes
- From: Tobias Burnus <burnus at net-b dot de>
- To: gcc patches <gcc-patches at gcc dot gnu dot org>, gfortran <fortran at gcc dot gnu dot org>
- Date: Fri, 05 Mar 2010 09:00:53 +0100
- Subject: [Patch, Fortran, 4.6] Coarray 5/n: Some coarray declaration fixes
Dear all,
when writing the first patch, I did some misreading of the standard.
a) Even for assumed-shape arrays, the codimensions have to be assumed
size - except if the coarray is allocatable. The check moved from
array.c to resolve.c; I also moved down one test and added an "else if"
to prevent two error message for the same problem.
b) I misread ultimate component; thus one can have a coarray of derived
type, which contains as component (1) an derived type with a coarray
component (2). If the former component (1) is allocatable or a pointer.
c) In one check, I missed a "c->allocatable".
Build on x86-64-linux and currently regtesting.
OK for the 4.6 stage1?
Tobias
C528 A nonallocatable coarray shall have a coarray-spec that is an
explicit-coshape-spec.
C525 An entity whose type has a coarray ultimate component shall be
a nonpointer nonallocatable scalar, shall not be a coarray,
and shall not be a function result.
1.3.29.4 ultimate component:
a component that is of intrinsic type, a pointer, or allocatable;
or an ultimate component of a nonpointer nonallocatable component
of derived type
fortran/array.c | 46 +++++++-----------------------------
fortran/gfortran.h | 2 -
fortran/parse.c | 3 +-
fortran/resolve.c | 18 +++++++++-----
testsuite/gfortran.dg/coarray_4.f90 | 2 -
testsuite/gfortran.dg/coarray_6.f90 | 26 ++++++++++++++++++++
6 files changed, 52 insertions(+), 45 deletions(-)
2010-03-05 Tobias Burnus <burnus@net-b.de>
PR fortran/18918
* gfortran.h (gfc_array_spec): Add cotype.
* array.c (gfc_match_array_spec,gfc_set_array_spec): Use it
and defer error diagnostic.
* resolve.c (resolve_fl_derived): Add missing check.
(resolve_symbol): Add cotype/type check.
* parse.c (parse_derived): Fix setting of coarray_comp.
2010-03-05 Tobias Burnus <burnus@net-b.de>
PR fortran/18918
* gfortran.dg/coarray_4.f90: Fix test.
* gfortran.dg/coarray_6.f90: Add more tests.
diff --git a/gcc/fortran/array.c b/gcc/fortran/array.c
index 4b2ccf6..c291ad8 100644
--- a/gcc/fortran/array.c
+++ b/gcc/fortran/array.c
@@ -342,7 +342,6 @@ match
gfc_match_array_spec (gfc_array_spec **asp, bool match_dim, bool match_codim)
{
array_type current_type;
- array_type coarray_type = AS_UNKNOWN;
gfc_array_spec *as;
int i;
@@ -467,23 +466,10 @@ coarray:
if (current_type == AS_UNKNOWN)
goto cleanup;
- if (as->rank && as->type != AS_DEFERRED && current_type == AS_DEFERRED)
- {
- gfc_error ("Array at %C has non-deferred shape and deferred "
- "coshape");
- goto cleanup;
- }
- if (as->rank && as->type == AS_DEFERRED && current_type != AS_DEFERRED)
- {
- gfc_error ("Array at %C has deferred shape and non-deferred "
- "coshape");
- goto cleanup;
- }
-
if (as->corank == 1)
- coarray_type = current_type;
+ as->cotype = current_type;
else
- switch (coarray_type)
+ switch (as->cotype)
{ /* See how current spec meshes with the existing. */
case AS_UNKNOWN:
goto cleanup;
@@ -491,7 +477,7 @@ coarray:
case AS_EXPLICIT:
if (current_type == AS_ASSUMED_SIZE)
{
- coarray_type = AS_ASSUMED_SIZE;
+ as->cotype = AS_ASSUMED_SIZE;
break;
}
@@ -518,7 +504,7 @@ coarray:
if (current_type == AS_ASSUMED_SHAPE)
{
- as->type = AS_ASSUMED_SHAPE;
+ as->cotype = AS_ASSUMED_SHAPE;
break;
}
@@ -553,10 +539,11 @@ coarray:
goto cleanup;
}
- if (as->rank == 0 && coarray_type == AS_ASSUMED_SIZE)
- as->type = AS_EXPLICIT;
- else if (as->rank == 0)
- as->type = coarray_type;
+ if (as->cotype == AS_ASSUMED_SIZE)
+ as->cotype = AS_EXPLICIT;
+
+ if (as->rank == 0)
+ as->type = as->cotype;
done:
if (as->rank == 0 && as->corank == 0)
@@ -613,26 +600,13 @@ gfc_set_array_spec (gfc_symbol *sym, gfc_array_spec *as, locus *error_loc)
return SUCCESS;
}
- if (sym->as->type == AS_DEFERRED && as->type != AS_DEFERRED)
- {
- gfc_error ("'%s' at %L has deferred shape and non-deferred coshape",
- sym->name, error_loc);
- return FAILURE;
- }
-
- if (sym->as->type != AS_DEFERRED && as->type == AS_DEFERRED)
- {
- gfc_error ("'%s' at %L has non-deferred shape and deferred coshape",
- sym->name, error_loc);
- return FAILURE;
- }
-
if (as->corank)
{
/* The "sym" has no corank (checked via gfc_add_codimension). Thus
the codimension is simply added. */
gcc_assert (as->rank == 0 && sym->as->corank == 0);
+ sym->as->cotype = as->cotype;
sym->as->corank = as->corank;
for (i = 0; i < as->corank; i++)
{
diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h
index ad13b40..fb29bde 100644
--- a/gcc/fortran/gfortran.h
+++ b/gcc/fortran/gfortran.h
@@ -867,7 +867,7 @@ typedef struct
{
int rank; /* A rank of zero means that a variable is a scalar. */
int corank;
- array_type type;
+ array_type type, cotype;
struct gfc_expr *lower[GFC_MAX_DIMENSIONS], *upper[GFC_MAX_DIMENSIONS];
/* These two fields are used with the Cray Pointer extension. */
diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c
index b68afba..190148c 100644
--- a/gcc/fortran/parse.c
+++ b/gcc/fortran/parse.c
@@ -2115,7 +2115,8 @@ endType:
sym->attr.proc_pointer_comp = 1;
/* Looking for coarray components. */
- if (c->attr.codimension || c->attr.coarray_comp)
+ if (c->attr.codimension
+ || (c->attr.coarray_comp && !c->attr.pointer && !c->attr.allocatable))
sym->attr.coarray_comp = 1;
/* Look for private components. */
diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c
index 4217c47..5f8a3e7 100644
--- a/gcc/fortran/resolve.c
+++ b/gcc/fortran/resolve.c
@@ -10466,7 +10466,8 @@ resolve_fl_derived (gfc_symbol *sym)
/* F2008, C444. */
if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.coarray_comp
- && (c->attr.codimension || c->attr.pointer || c->attr.dimension))
+ && (c->attr.codimension || c->attr.pointer || c->attr.dimension
+ || c->attr.allocatable))
{
gfc_error ("Component '%s' at %L with coarray component "
"shall be a nonpointer, nonallocatable scalar",
@@ -11304,11 +11305,6 @@ resolve_symbol (gfc_symbol *sym)
}
}
- if (sym->attr.codimension && sym->attr.allocatable
- && sym->as->type != AS_DEFERRED)
- gfc_error ("Allocatable coarray variable '%s' at %L must have "
- "deferred shape", sym->name, &sym->declared_at);
-
/* F2008, C526. */
if (((sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.coarray_comp)
|| sym->attr.codimension)
@@ -11340,6 +11336,16 @@ resolve_symbol (gfc_symbol *sym)
gfc_error ("Variable '%s' at %L is a coarray or has a coarray "
"component and is not ALLOCATABLE, SAVE nor a "
"dummy argument", sym->name, &sym->declared_at);
+ /* F2008, C528. */
+ else if (sym->attr.codimension && !sym->attr.allocatable
+ && sym->as->cotype == AS_DEFERRED)
+ gfc_error ("Coarray variable '%s' at %L shall not have codimensions with "
+ "deferred shape", sym->name, &sym->declared_at);
+ else if (sym->attr.codimension && sym->attr.allocatable
+ && (sym->as->type != AS_DEFERRED || sym->as->cotype != AS_DEFERRED))
+ gfc_error ("Allocatable coarray variable '%s' at %L must have "
+ "deferred shape", sym->name, &sym->declared_at);
+
/* F2008, C541. */
if (((sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.coarray_comp)
diff --git a/gcc/testsuite/gfortran.dg/coarray_4.f90 b/gcc/testsuite/gfortran.dg/coarray_4.f90
index 71fbf98..cb693ea 100644
--- a/gcc/testsuite/gfortran.dg/coarray_4.f90
+++ b/gcc/testsuite/gfortran.dg/coarray_4.f90
@@ -48,7 +48,7 @@ subroutine invalid(n)
integer, save :: hf4(5)[n,*] ! { dg-error "cannot have the SAVE attribute" }
integer, allocatable :: a2[*] ! { dg-error "must have deferred shape" }
- integer, allocatable :: a3(:)[*] ! { dg-error "deferred shape and non-deferred coshape" }
+ integer, allocatable :: a3(:)[*] ! { dg-error "must have deferred shape" }
integer, allocatable :: a4[*] ! { dg-error "must have deferred shape" }
end subroutine invalid
diff --git a/gcc/testsuite/gfortran.dg/coarray_6.f90 b/gcc/testsuite/gfortran.dg/coarray_6.f90
index f122fd4..b6d8b49 100644
--- a/gcc/testsuite/gfortran.dg/coarray_6.f90
+++ b/gcc/testsuite/gfortran.dg/coarray_6.f90
@@ -51,6 +51,32 @@ function func() result(func2) ! { dg-error "shall not be a coarray or have a coa
type(t) :: func2
end function func
+subroutine invalid()
+ type t
+ integer, allocatable :: a[:]
+ end type t
+ type t2
+ type(t), allocatable :: b ! { dg-error "nonpointer, nonallocatable scalar" }
+ end type t2
+ type t3
+ type(t), pointer :: c ! { dg-error "nonpointer, nonallocatable scalar" }
+ end type t3
+ type t4
+ type(t) :: d(4) ! { dg-error "nonpointer, nonallocatable scalar" }
+ end type t4
+end subroutine invalid
+
+subroutine valid(a)
+ integer :: a(:)[4,-1:6,4:*]
+ type t
+ integer, allocatable :: a[:]
+ end type t
+ type t2
+ type(t) :: b
+ end type t2
+ type(t2), save :: xt2[*]
+end subroutine valid
+
program main
integer :: A[*] ! Valid, implicit SAVE attribute
end program main