diff options
Diffstat (limited to 'gcc/f/symbol.def')
| -rw-r--r-- | gcc/f/symbol.def | 654 |
1 files changed, 654 insertions, 0 deletions
diff --git a/gcc/f/symbol.def b/gcc/f/symbol.def new file mode 100644 index 00000000000..ad100d4ebbe --- /dev/null +++ b/gcc/f/symbol.def @@ -0,0 +1,654 @@ +/* Definitions and documentations for attributes used in GNU F77 compiler + Copyright (C) 1995, 1996 Free Software Foundation, Inc. + Contributed by James Craig Burley (burley@gnu.ai.mit.edu). + +This file is part of GNU Fortran. + +GNU Fortran is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Fortran is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Fortran; see the file COPYING. If not, write to +the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ + +/* "How g77 learns about symbols" + + There are three primary things in a symbol that g77 uses to keep + track of what it has learned about that symbol: + + 1. The state + 2. The attributes + 3. The info + + State, attributes, and info (see f-info* files) all start out with + "NONE" fields when a symbol is first created. + + In a PROGRAM or BLOCK DATA program unit, info where cannot be DUMMY + or RESULT. Any combinations including those possibilities are not + considered possible in such program units. + + As soon as a symbol is created, it _must_ have its state changed to + SEEN, UNCERTAIN, or UNDERSTOOD. + + If SEEN, some info might be set, such as the type info (as in when + the TYPE attribute is present) or kind/where info. + + If UNCERTAIN, the permitted combinations of attributes and info are + listed below. Only the attributes ACTUALARG, ADJUSTABLE, ANYLEN, ARRAY, + DUMMY, EXTERNAL, SFARG, and TYPE are permitted. (All these attributes + are contrasted to each attribute below, even though some combinations + wouldn't be permitted in SEEN state either.) Note that DUMMY and + RESULT are not permitted in a PROGRAM/BLOCKDATA program unit, which + results in some of the combinations below not occurring (not UNCERTAIN, + but UNDERSTOOD). + + ANYLEN|TYPE & ~(ACTUALARG|ADJUSTABLE|ARRAY|DUMMY|EXTERNAL|SFARG): + ENTITY/DUMMY, ENTITY/RESULT, FUNCTION/INTRINSIC. + + ARRAY & ~(ACTUALARG|ANYLEN|DUMMY|EXTERNAL|SFARG|TYPE): + ENTITY/DUMMY, ENTITY/LOCAL. + + ARRAY|TYPE & ~(ACTUALARG|ANYLEN|DUMMY|EXTERNAL|SFARG): + ENTITY/DUMMY, ENTITY/LOCAL. + + DUMMY & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|EXTERNAL|SFARG|TYPE): + ENTITY/DUMMY, FUNCTION/DUMMY, SUBROUTINE/DUMMY. + + DUMMY|TYPE & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|EXTERNAL|SFARG): + ENTITY/DUMMY, FUNCTION/DUMMY. + + EXTERNAL & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|DUMMY|SFARG|TYPE): + FUNCTION/DUMMY, FUNCTION/GLOBAL, SUBROUTINE/DUMMY, + SUBROUTINE/GLOBAL, BLOCKDATA/GLOBAL. + + EXTERNAL|ACTUALARG & ~(ADJUSTABLE|ANYLEN|ARRAY|DUMMY|SFARG|TYPE): + FUNCTION/GLOBAL, SUBROUTINE/GLOBAL. + + EXTERNAL|DUMMY & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|SFARG|TYPE): + FUNCTION/DUMMY, SUBROUTINE/DUMMY. + + EXTERNAL|TYPE & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|DUMMY|SFARG): + FUNCTION/DUMMY, FUNCTION/GLOBAL. + + SFARG & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|DUMMY|EXTERNAL|TYPE): + ENTITY/DUMMY, ENTITY/LOCAL. + + SFARG|TYPE & ~(ACTUALARG|ADJUSTABLE|ANYLEN|ARRAY|DUMMY|EXTERNAL): + ENTITY/DUMMY, ENTITY/LOCAL. + + TYPE & ~(ACTUALARG|ANYLEN|ARRAY|DUMMY|EXTERNAL|SFARG): + ENTITY/DUMMY, ENTITY/LOCAL, ENTITY/RESULT, FUNCTION/DUMMY, + FUNCTION/GLOBAL, FUNCTION/INTRINSIC. + + If UNDERSTOOD, the attributes are no longer considered, and the info + field is considered to be as fully filled in as possible by analyzing + a single program unit. + + Each of the attributes (used only for SEEN/UNCERTAIN states) is + defined and described below. In many cases, a symbol starts out as + SEEN and has attributes set as it is seen in various contexts prior + to the first executable statement being seen (the "exec transition"). + Once that happens, either it becomes immediately UNDERSTOOD and all + its info filled in, or it becomes UNCERTAIN and its info only partially + filled in until it becomes UNDERSTOOD. While UNCERTAIN, only a + subset of attributes are possible/important. + + Not all symbols reach the UNDERSTOOD state, and in some cases symbols + go immediately from NONE to the UNDERSTOOD or even UNCERTAIN state. + For example, given "PROGRAM FOO", everything is known about the name + "FOO", so it becomes immediately UNDERSTOOD. + + Also, there are multiple name spaces, and not all attributes are + possible/permitted in all name spaces. + + The only attributes permitted in the global name space are: + + ANY, CBLOCK, SAVECBLOCK. + + The only attributes permitted in the local name space are: + + ANY, ACTUALARG, ADJUSTABLE, ADJUSTS, ANYLEN, ANYSIZE, ARRAY, COMMON, + DUMMY, EQUIV, EXTERNAL, INIT, INTRINSIC, NAMELIST, RESULT, SAVE, SFARG, + SFUNC, TYPE. + + In the stmt-func name space, no attributes are used, just the states. + +*/ + + +/* Actual argument. Always accompanied by EXTERNAL. + + Context is a name used as an actual argument passed to a procedure + other than a statement function. + + Valid in UNCERTAIN state and local name space only. + + This attribute is used only to flag the fact that an EXTERNAL'ed name + has been seen as an actual argument, and therefore cannot be + discovered later to be a DUMMY argument (via an ENTRY statement). + + If DUMMY + EXTERNAL already, it is permitted to see the name + as an actual argument, but ACTUALARG is not added as an attribute since + that fact does not improve knowledge about the name. Hence it is not + permitted to transition ACTUALARG + EXTERNAL += DUMMY, and the + transition DUMMY + EXTERNAL += ACTUALARG is not actually done. + + Cannot be combined with: ANYLEN, ARRAY, DUMMY, SFARG, TYPE. + + Can be combined with: ACTUALARG, ANY, EXTERNAL. + + Unrelated: ADJUSTABLE, ADJUSTS, ANYSIZE, CBLOCK, COMMON, EQUIV, INIT, + INTRINSIC, NAMELIST, RESULT, SAVE, SAVECBLOCK, SFUNC. + +*/ + +DEFATTR (FFESYMBOL_attrACTUALARG, FFESYMBOL_attrsACTUALARG, "ACTUALARG") +#ifndef FFESYMBOL_attrsACTUALARG +#define FFESYMBOL_attrsACTUALARG ((ffesymbolAttrs) 1 << FFESYMBOL_attrACTUALARG) +#endif + +/* Has adjustable dimension(s). Always accompanied by ARRAY. + + Context is an ARRAY-attributed name with an adjustable dimension (at + least one dimension containing a variable reference). + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ADJUSTS, COMMON, EQUIV, EXTERNAL, + NAMELIST, INIT, INTRINSIC, RESULT, SAVE, SFARG, SFUNC. + + Can be combined with: ANY, ANYLEN, ANYSIZE, ARRAY, TYPE. + + Must be combined with: DUMMY. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrADJUSTABLE, FFESYMBOL_attrsADJUSTABLE, "ADJUSTABLE") +#ifndef FFESYMBOL_attrsADJUSTABLE +#define FFESYMBOL_attrsADJUSTABLE ((ffesymbolAttrs) 1 << FFESYMBOL_attrADJUSTABLE) +#endif + +/* Adjusts an array. + + Context is an expression in an array declarator, such as in a + DIMENSION, COMMON, or type-specification statement. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ANYLEN, ANYSIZE, ARRAY, + EXTERNAL, INTRINSIC, RESULT, SAVE, SFUNC. + + Can be combined with: ADJUSTS, ANY, COMMON, DUMMY, EQUIV, INIT, + NAMELIST, SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrADJUSTS, FFESYMBOL_attrsADJUSTS, "ADJUSTS") +#ifndef FFESYMBOL_attrsADJUSTS +#define FFESYMBOL_attrsADJUSTS ((ffesymbolAttrs) 1 << FFESYMBOL_attrADJUSTS) +#endif + +/* Can be anything now, diagnostic has been issued at least once. + + Valid in UNDERSTOOD state only. Valid in any name space. + + Can be combined with anything. + +*/ + +DEFATTR (FFESYMBOL_attrANY, FFESYMBOL_attrsANY, "ANY") +#ifndef FFESYMBOL_attrsANY +#define FFESYMBOL_attrsANY ((ffesymbolAttrs) 1 << FFESYMBOL_attrANY) +#endif + +/* Assumed (any) length. Always accompanied by TYPE. + + Context is a name listed in a CHARACTER statement and given a length + specification of (*). + + Valid in SEEN and UNCERTAIN states. Valid in local name space only. + + In SEEN state, attributes marked below with "=" are unrelated. + + In UNCERTAIN state, attributes marked below with "+" are unrelated, + attributes marked below with "-" cannot be combined with ANYLEN, + and attributes marked below with "!" transition to state UNDERSTOOD + instead of acquiring the new attribute. Any other subsequent mentioning + of the name transitions to state UNDERSTOOD. UNCERTAIN state is not + valid for this attribute in PROGRAM/BLOCKDATA program unit. + + Cannot be combined with: ACTUALARG=, ADJUSTS+, ANYLEN, COMMON+, EQUIV+, + EXTERNAL, INIT+, INTRINSIC+, NAMELIST+, SAVE+, SFARG, SFUNC+. + + Can be combined with: ADJUSTABLE+, ANY, ANYSIZE+, ARRAY-, DUMMY!, RESULT+, + TYPE. + + Unrelated: CBLOCK, SAVECBLOCK. + + In PROGRAM/BLOCKDATA, cannot be combined with ARRAY. + +*/ + +DEFATTR (FFESYMBOL_attrANYLEN, FFESYMBOL_attrsANYLEN, "ANYLEN") +#ifndef FFESYMBOL_attrsANYLEN +#define FFESYMBOL_attrsANYLEN ((ffesymbolAttrs) 1 << FFESYMBOL_attrANYLEN) +#endif + +/* Has assumed (any) size. Always accompanied by ARRAY. + + Context is an ARRAY-attributed name with its last dimension having + an upper bound of "*". + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTS, ANYSIZE, COMMON, EQUIV, EXTERNAL, + NAMELIST, INIT, INTRINSIC, RESULT, SAVE, SFARG, SFUNC. + + Can be combined with: ADJUSTABLE, ANY, ANYLEN, ARRAY, TYPE. + + Must be combined with: DUMMY. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrANYSIZE, FFESYMBOL_attrsANYSIZE, "ANYSIZE") +#ifndef FFESYMBOL_attrsANYSIZE +#define FFESYMBOL_attrsANYSIZE ((ffesymbolAttrs) 1 << FFESYMBOL_attrANYSIZE) +#endif + +/* Array. + + Context is a name followed by an array declarator, such as in a + type-statement-decl, a DIMENSION statement, or a COMMON statement. + + Valid in SEEN and UNCERTAIN states. Valid in local name space only. + + In SEEN state, attributes marked below with "=" are unrelated. + + In UNCERTAIN state, attributes marked below with "+" are unrelated, + attributes marked below with "-" cannot be combined with ARRAY, + and attributes marked below with "!" transition to state UNDERSTOOD + instead of acquiring the new attribute. Any other subsequent mentioning + of the name transitions to state UNDERSTOOD. UNCERTAIN state is not + valid for this attribute in PROGRAM/BLOCKDATA program unit. + + Cannot be combined with: ACTUALARG=, ADJUSTS+, ARRAY, EXTERNAL, + INTRINSIC+, RESULT+, SFARG, SFUNC+. + + Can be combined with: ADJUSTABLE+, ANY, ANYLEN-, ANYSIZE+, COMMON+, + DUMMY!, EQUIV+, INIT+, NAMELIST+, SAVE+, TYPE. + + Unrelated: CBLOCK, SAVECBLOCK. + + In PROGRAM/BLOCKDATA, cannot be combined with ANYLEN. + Cannot follow INIT. + +*/ + +DEFATTR (FFESYMBOL_attrARRAY, FFESYMBOL_attrsARRAY, "ARRAY") +#ifndef FFESYMBOL_attrsARRAY +#define FFESYMBOL_attrsARRAY ((ffesymbolAttrs) 1 << FFESYMBOL_attrARRAY) +#endif + +/* COMMON block. + + Context is a name enclosed in slashes in a COMMON statement. + + Valid in SEEN state and global name space only. + + Cannot be combined with: + + Can be combined with: CBLOCK, SAVECBLOCK. + + Unrelated: ACTUALARG, ADJUSTABLE, ADJUSTS, ANY, ANYLEN, ANYSIZE, + ARRAY, COMMON, DUMMY, EQUIV, EXTERNAL, INIT, INTRINSIC, NAMELIST, + RESULT, SAVE, SFARG, SFUNC, TYPE. + +*/ + +DEFATTR (FFESYMBOL_attrCBLOCK, FFESYMBOL_attrsCBLOCK, "CBLOCK") +#ifndef FFESYMBOL_attrsCBLOCK +#define FFESYMBOL_attrsCBLOCK ((ffesymbolAttrs) 1 << FFESYMBOL_attrCBLOCK) +#endif + +/* Placed in COMMON. + + Context is a name listed in a COMMON statement but not enclosed in + slashes. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ANYLEN, ANYSIZE, COMMON, DUMMY, + EXTERNAL, INTRINSIC, RESULT, SAVE, SFUNC. + + Can be combined with: ADJUSTS, ANY, ARRAY, EQUIV, INIT, NAMELIST, + SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrCOMMON, FFESYMBOL_attrsCOMMON, "COMMON") +#ifndef FFESYMBOL_attrsCOMMON +#define FFESYMBOL_attrsCOMMON ((ffesymbolAttrs) 1 << FFESYMBOL_attrCOMMON) +#endif + +/* Dummy argument. + + Context is a name listed in the arglist of FUNCTION, SUBROUTINE, ENTRY. + (Statement-function definitions have dummy arguments, but since they're + the only possible entities in the statement-function name space, this + attribution mechanism isn't used for them.) + + Valid in SEEN and UNCERTAIN states. Valid in local name space only. + + In SEEN state, attributes marked below with "=" are unrelated. + + In UNCERTAIN state, attributes marked below with "+" are unrelated, + attributes marked below with "-" cannot be combined with DUMMY, + and attributes marked below with "!" transition to state UNDERSTOOD + instead of acquiring the new attribute. Any other subsequent mentioning + of the name transitions to state UNDERSTOOD. UNCERTAIN state is not + valid for this attribute in PROGRAM/BLOCKDATA program unit. + + Cannot be combined with: ACTUALARG=, COMMON+, EQUIV+, INIT+, INTRINSIC+, + NAMELIST+, RESULT+, SAVE+, SFUNC+. + + Can be combined with: ADJUSTABLE+, ADJUSTS+, ANY, ANYLEN-, ANYSIZE+, + ARRAY-, DUMMY, EXTERNAL, SFARG-, TYPE. + + Unrelated: CBLOCK, SAVECBLOCK. + + VXT Fortran disallows DUMMY + NAMELIST. + F90 allows DUMMY + NAMELIST (with some restrictions), g77 doesn't yet. + +*/ + +DEFATTR (FFESYMBOL_attrDUMMY, FFESYMBOL_attrsDUMMY, "DUMMY") +#ifndef FFESYMBOL_attrsDUMMY +#define FFESYMBOL_attrsDUMMY ((ffesymbolAttrs) 1 << FFESYMBOL_attrDUMMY) +#endif + +/* EQUIVALENCE'd. + + Context is a name given in an EQUIVALENCE statement. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ANYLEN, ANYSIZE, DUMMY, + EXTERNAL, INTRINSIC, RESULT, SFUNC. + + Can be combined with: ADJUSTS, ANY, ARRAY, COMMON, EQUIV, INIT, + NAMELIST, SAVE, SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrEQUIV, FFESYMBOL_attrsEQUIV, "EQUIV") +#ifndef FFESYMBOL_attrsEQUIV +#define FFESYMBOL_attrsEQUIV ((ffesymbolAttrs) 1 << FFESYMBOL_attrEQUIV) +#endif + +/* EXTERNAL. + + Context is a name listed in an EXTERNAL statement. + + Valid in SEEN and UNCERTAIN states. Valid in local name space only. + + In SEEN state, attributes marked below with "=" are unrelated. + + In UNCERTAIN state, attributes marked below with "+" are unrelated, + attributes marked below with "-" cannot be combined with EXTERNAL, + and attributes marked below with "!" transition to state UNDERSTOOD + instead of acquiring the new attribute. Many other subsequent mentionings + of the name transitions to state UNDERSTOOD. UNCERTAIN state is not + valid for this attribute in PROGRAM/BLOCKDATA program unit. + + Cannot be combined with: ADJUSTABLE+, ADJUSTS+, ANYLEN, ANYSIZE+, + ARRAY, COMMON+, EQUIV+, EXTERNAL, INIT+, INTRINSIC+, NAMELIST+, RESULT+, + SAVE+, SFARG, SFUNC+. + + Can be combined with: ACTUALARG=, ANY, DUMMY, TYPE. + + Unrelated: CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrEXTERNAL, FFESYMBOL_attrsEXTERNAL, "EXTERNAL") +#ifndef FFESYMBOL_attrsEXTERNAL +#define FFESYMBOL_attrsEXTERNAL ((ffesymbolAttrs) 1 << FFESYMBOL_attrEXTERNAL) +#endif + +/* Given an initial value. + + Context is a name listed in a type-def-stmt such as INTEGER or REAL + and given an initial value or values. Someday will also include + names in DATA statements, which currently immediately exec-transition + their targets. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ANYLEN, ANYSIZE, DUMMY, EXTERNAL, + INIT, INTRINSIC, RESULT, SFUNC. + + Can be combined with: ADJUSTS, ANY, ARRAY, COMMON, EQUIV, NAMELIST, + SAVE, SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + + Cannot be followed by ARRAY. + +*/ + +DEFATTR (FFESYMBOL_attrINIT, FFESYMBOL_attrsINIT, "INIT") +#ifndef FFESYMBOL_attrsINIT +#define FFESYMBOL_attrsINIT ((ffesymbolAttrs) 1 << FFESYMBOL_attrINIT) +#endif + +/* INTRINSIC. + + Context is a name listed in an INTRINSIC statement. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ADJUSTS, ANYLEN, ANYSIZE, ARRAY, + COMMON, DUMMY, EQUIV, EXTERNAL, INIT, INTRINSIC, NAMELIST, RESULT, + SAVE, SFARG, SFUNC. + + Can be combined with: ANY, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrINTRINSIC, FFESYMBOL_attrsINTRINSIC, "INTRINSIC") +#ifndef FFESYMBOL_attrsINTRINSIC +#define FFESYMBOL_attrsINTRINSIC ((ffesymbolAttrs) 1 << FFESYMBOL_attrINTRINSIC) +#endif + +/* NAMELISTed. + + Context is a name listed in a NAMELIST statement but not enclosed in + slashes. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ANYLEN, ANYSIZE, DUMMY, EXTERNAL, + INTRINSIC, RESULT, SFUNC. + + Can be combined with: ADJUSTS, ANY, ARRAY, COMMON, EQUIV, INIT, + NAMELIST, SAVE, SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrNAMELIST, FFESYMBOL_attrsNAMELIST, "NAMELIST") +#ifndef FFESYMBOL_attrsNAMELIST +#define FFESYMBOL_attrsNAMELIST ((ffesymbolAttrs) 1 << FFESYMBOL_attrNAMELIST) +#endif + +/* RESULT of a function. + + Context is name in RESULT() clause in FUNCTION or ENTRY statement, or + the name in a FUNCTION or ENTRY statement (within a FUNCTION subprogram) + that has no RESULT() clause. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ADJUSTS, ANYSIZE, ARRAY, COMMON, + DUMMY, EQUIV, EXTERNAL, INIT, INTRINSIC, NAMELIST, RESULT, SAVE, SFUNC. + + Can be combined with: ANY, ANYLEN, SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + + Cannot be preceded by SFARG. + +*/ + +DEFATTR (FFESYMBOL_attrRESULT, FFESYMBOL_attrsRESULT, "RESULT") +#ifndef FFESYMBOL_attrsRESULT +#define FFESYMBOL_attrsRESULT ((ffesymbolAttrs) 1 << FFESYMBOL_attrRESULT) +#endif + +/* SAVEd (not enclosed in slashes). + + Context is a name listed in a SAVE statement but not enclosed in slashes. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADUSTABLE, ADJUSTS, ANYLEN, ANYSIZE, COMMON, + DUMMY, EXTERNAL, INTRINSIC, RESULT, SAVE, SFUNC. + + Can be combined with: ANY, ARRAY, EQUIV, INIT, NAMELIST, + SFARG, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrSAVE, FFESYMBOL_attrsSAVE, "SAVE") +#ifndef FFESYMBOL_attrsSAVE +#define FFESYMBOL_attrsSAVE ((ffesymbolAttrs) 1 << FFESYMBOL_attrSAVE) +#endif + +/* SAVEd (enclosed in slashes). + + Context is a name enclosed in slashes in a SAVE statement. + + Valid in SEEN state and global name space only. + + Cannot be combined with: SAVECBLOCK. + + Can be combined with: CBLOCK. + + Unrelated: ACTUALARG, ADJUSTABLE, ADJUSTS, ANY, ANYLEN, ANYSIZE, + ARRAY, COMMON, DUMMY, EQUIV, EXTERNAL, INIT, INTRINSIC, NAMELIST, + RESULT, SAVE, SFARG, SFUNC, TYPE. + +*/ + +DEFATTR (FFESYMBOL_attrSAVECBLOCK, FFESYMBOL_attrsSAVECBLOCK, "SAVECBLOCK") +#ifndef FFESYMBOL_attrsSAVECBLOCK +#define FFESYMBOL_attrsSAVECBLOCK ((ffesymbolAttrs) 1 << FFESYMBOL_attrSAVECBLOCK) +#endif + +/* Name used as a statement function arg or DATA implied-DO iterator. + + Context is a name listed in the arglist of statement-function-definition + or as the iterator in an implied-DO construct in a DATA statement. + + Valid in SEEN and UNCERTAIN states. Valid in local name space only. + + In SEEN state, attributes marked below with "=" are unrelated. + + In UNCERTAIN state, attributes marked below with "+" are unrelated, + attributes marked below with "-" cannot be combined with SFARG, + and attributes marked below with "!" transition to state UNDERSTOOD + instead of acquiring the new attribute. Any other subsequent mentioning + of the name transitions to state UNDERSTOOD. UNCERTAIN state is not + valid for this attribute in PROGRAM/BLOCKDATA program unit. + + Cannot be combined with: ACTUALARG=, ADJUSTABLE+, ANYLEN, ANYSIZE+, + ARRAY, EXTERNAL, INTRINSIC+, SFUNC+. + + Can be combined with: ADJUSTS+, ANY, COMMON+, DUMMY!, EQUIV+, INIT+, + NAMELIST+, RESULT+, SAVE+, SFARG, TYPE. + + Unrelated: CBLOCK, SAVECBLOCK. + + Cannot be followed by RESULT. + +*/ + +DEFATTR (FFESYMBOL_attrSFARG, FFESYMBOL_attrsSFARG, "SFARG") +#ifndef FFESYMBOL_attrsSFARG +#define FFESYMBOL_attrsSFARG ((ffesymbolAttrs) 1 << FFESYMBOL_attrSFARG) +#endif + +/* Statement function name. + + Context is a statement-function-definition statement, the name being + defined. + + Valid in SEEN state and local name space only. + + Cannot be combined with: ADJUSTABLE, ADJUSTS, ANYLEN, ANYSIZE, ARRAY, + COMMON, DUMMY, EQUIV, EXTERNAL, INIT, INTRINSIC, NAMELIST, RESULT, + SAVE, SFARG, SFUNC. + + Can be combined with: ANY, TYPE. + + Unrelated: ACTUALARG, CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrSFUNC, FFESYMBOL_attrsSFUNC, "SFUNC") +#ifndef FFESYMBOL_attrsSFUNC +#define FFESYMBOL_attrsSFUNC ((ffesymbolAttrs) 1 << FFESYMBOL_attrSFUNC) +#endif + +/* Explicitly typed. + + Context is a name listed in a type-def-stmt such as INTEGER or REAL. + + Valid in SEEN and UNCERTAIN states. Valid in local name space only. + + In SEEN state, attributes marked below with "=" are unrelated. + + In UNCERTAIN state, attributes marked below with "+" are unrelated, + attributes marked below with "-" cannot be combined with TYPE, + and attributes marked below with "!" transition to state UNDERSTOOD + instead of acquiring the new attribute. Many other subsequent mentionings + of the name transitions to state UNDERSTOOD. UNCERTAIN state is not + valid for this attribute in PROGRAM/BLOCKDATA program unit. + + Cannot be combined with: ACTUALARG=, TYPE. + + Can be combined with: ADJUSTABLE+, ADJUSTS+, ANY, ANYLEN, ANYSIZE+, + ARRAY, COMMON+, DUMMY, EQUIV+, EXTERNAL, INIT+, INTRINSIC+, NAMELIST+, + RESULT+, SAVE+, SFARG, SFUNC+. + + Unrelated: CBLOCK, SAVECBLOCK. + +*/ + +DEFATTR (FFESYMBOL_attrTYPE, FFESYMBOL_attrsTYPE, "TYPE") +#ifndef FFESYMBOL_attrsTYPE +#define FFESYMBOL_attrsTYPE ((ffesymbolAttrs) 1 << FFESYMBOL_attrTYPE) +#endif |