https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

Fortran Reserved Words - Fortran Keywords

Return to Fortran Glossary, Reserved Words, Fortran, Fortran Libraries, Fortran Syntax, Fortran Data Structures, Fortran Algorithms, Fortran Development Tools, Fortran DevOps - Fortran SRE - Fortran CI/CD, Cloud Native Fortran - Fortran Microservices - Serverless Fortran, Fortran Security - Fortran DevSecOps, Functional Fortran, Fortran Concurrency, Fortran Data Science - Fortran and Databases, Fortran Machine Learning, Fortran Topics, Awesome Fortran, Awesome IBM Mainframe, IBM Mainframe Glossary, IBM Mainframe Development, IBM Mainframe Bibliography, COBOL, COBOL Glossary

Also called: Fortran Language Keywords, Fortran Reserved Keywords, Fortran Keywords, Fortran Reserved Identifiers, Fortran Reserved words

Provide a list of Reserved Words in Fortran. Answer in MediaWiki syntax with the URL of the official documentation for each language reference.

Provide a list of Reserved Words in Fortran with a brief description of each. Answer in MediaWiki syntax.

3.5

Here's a list of reserved words in Fortran along with brief descriptions, using MediaWiki syntax:

ALLOCATABLE: Used to declare dynamic arrays whose memory is allocated during execution.
ALLOCATE: Allocates memory for dynamic arrays declared with the ALLOCATABLE attribute.
ASSIGN: Assigns a label to a statement.
ASSOCIATE: Associates a variable with another variable or a section of an array.
BACKSPACE: Moves the file position indicator to the beginning of the previous record in a file.
BLOCK: Defines a block of code for structured programming.
BYTE: Specifies a data type with a size of one byte.
CALL: Invokes a subroutine or function.
CASE: Specifies a case within a SELECT CASE construct.
CHARACTER: Declares variables of type character, used to store strings.
CLOSE: Closes a file.
COMMON: Declares common blocks, which are shared blocks of memory between program units.
COMPLEX: Declares variables of type complex, used to store complex numbers.
CONTAINS: Contains a block of internal procedures within a module or subroutine.
CONTINUE: Continues execution at the next statement.
CYCLE: Skips to the next iteration of a DO loop.
DATA: Initializes variables with specified values.
DEALLOCATE: Releases memory allocated to dynamic arrays.
DEFAULT: Specifies the default case within a SELECT CASE construct.
DIMENSION: Declares the dimensions of arrays.
DO: Starts a loop construct.
DOUBLE: Declares variables of type double precision, used to store double-precision floating-point numbers.
ELEMENTAL: Specifies that a subroutine or function operates element-wise on arrays.
ELSE: Specifies the alternative condition in an IF-THEN-ELSE construct.
ELSEIF: Specifies an alternative condition in an IF-THEN-ELSEIF construct.
END: Marks the end of a program unit.
ENDIF: Marks the end of an IF-THEN or IF-THEN-ELSE construct.
ENDFILE: Moves the file position indicator to the end of the file.
ENTRY: Declares an alternate entry point into a subroutine.
ENUM: Declares an enumerated data type.
EQUIVALENCE: Establishes equivalences between variables.
EXIT: Exits a loop prematurely.
EXTERNAL: Declares external procedures.
FORALL: Specifies array operations without explicit loops.
FORMAT: Specifies the format of input/output data.
FUNCTION: Declares a function.
GENERIC: Declares generic procedures that can have multiple specific implementations.
GO: Transfers control to a specified label.
GOTO: Transfers control unconditionally to a specified label.
IF: Specifies a conditional statement.
IMPLICIT: Specifies default data types for undeclared variables.
IMPORT: Imports entities from a module into the current scope.
IN: Specifies an input argument in a subroutine or function declaration.
INCLUDE: Includes source code from another file.
INOUT: Specifies an input/output argument in a subroutine or function declaration.
INTENT: Specifies the intended usage of subroutine or function arguments.
INTERFACE: Declares an interface block for defining procedure interfaces.
INTRINSIC: Declares intrinsic functions.
INT: Declares variables of type integer, used to store integer numbers.
INQUIRE: Inquires about the properties of a file or device.
LOGICAL: Declares variables of type logical, used to store logical values (true or false).
MODULE: Defines a module, which encapsulates data and procedures.
NAMELIST: Declares a namelist group for reading and writing groups of variables.
NONE: Specifies no argument in a procedure declaration.
NULLIFY: Sets a pointer to null.
ONLY: Limits the use of entities from a USE statement.
OPEN: Opens a file.
OPTIONAL: Specifies optional arguments in subroutine or function declarations.
OUT: Specifies an output argument in a subroutine or function declaration.
PARAMETER: Declares parameters with constant values.
POINTER: Declares variables that store memory addresses.
PRECISION: Specifies the precision of floating-point numbers.
PRINT: Prints output to the standard output device.
PRIVATE: Specifies that variables or procedures are private to a module.
PROCEDURE: Declares a procedure within a module.
PROGRAM: Defines a program unit.
PUBLIC: Specifies that variables or procedures are accessible from outside a module.
PURE: Specifies that a function has no side effects.
READ: Reads input from a file.
REAL: Declares variables of type real, used to store real numbers.
RECURSIVE: Specifies that a subroutine or function can call itself.
RESULT: Specifies the result variable in a function declaration.
RETURN: Returns control from a function or subroutine.
REWIND: Moves the file position indicator to the beginning of a file.
SAVE: Preserves the value of variables between subroutine calls.
SELECT: Selects one of several alternative constructs.
SEQUENCE: Specifies that variables in a common block are stored sequentially in memory.
STOP: Stops program execution.
SUBROUTINE: Defines a subroutine.
TARGET: Specifies that a variable is a target of a pointer assignment.
THEN: Specifies the consequence in an IF-THEN or ELSEIF construct.
TO: Specifies the upper bound of a range.
TYPE: Defines a derived data type.
USE: Brings entities from a module into the current scope.
VALUE: Specifies that an argument is passed by value.
VOLATILE: Specifies that a variable's value may change unexpectedly.
WHERE: Specifies array operations with conditional expressions.
WHILE: Specifies a loop that continues while a condition is true.
WRITE: Writes output to a file.

```

These are the reserved words in Fortran along with their descriptions, used for various purposes in programming with the Fortran language.

4.0

To provide you with the most accurate and up-to-date list of reserved words in Fortran and the URL for its official documentation, I will perform a quick search to find the latest reference. Please wait a moment.

Fortran, as a programming language, has evolved through various standards, each introducing new keywords while maintaining compatibility with previous versions. However, it's important to note that Fortran specifications explicitly state that keywords are not reserved words as seen in other programming languages. This means in Fortran, the context determines the meaning of keywords, allowing for a more flexible use of language elements.

Below is a summary of Fortran keywords introduced in different versions, along with links to official documentation where you can delve deeper into each standard:

FORTRAN 77 Keywords

Introduced basic control structures and declarations like `IF`, `GOTO`, `CALL`, `FUNCTION`, and more.

Fortran 90 Keywords

Added modern programming concepts like `MODULE`, `ALLOCATE`, `CASE`, `INTERFACE`, and others.

Fortran 95 Keywords

Included enhancements like `ELEMENTAL` and `PURE`.

Fortran 2003 Keywords

Introduced object-oriented features and interoperability with C, including `CLASS`, `ABSTRACT`, `EXTENDS`, and `BIND(C)`.

Fortran 2008 Keywords

Focused on concurrent computing features, adding `BLOCK`, `CRITICAL`, `DO CONCURRENT`, and submodules.

Fortran 2018 Keywords

Continued improvements on concurrency and interoperability, introducing `SELECT RANK` and clarifying the use of `IMPORT` in new contexts.

For a detailed list of all Fortran 2018 Standard keywords, including intrinsic procedure argument names (specifiers), you can refer to the repository maintained by cdslaborg on GitHub【6†source】.

The Fortran Wiki provides a comprehensive overview of keywords introduced in various Fortran standards, from FORTRAN 77 to Fortran 2018【7†source】.

For information on the GNU Fortran compiler's support for different Fortran standards, including Fortran 95, 2003, 2008, and partial support for 2018, the GNU project documentation is a reliable resource【8†source】.

Please note that the official Fortran standard documents, detailing every aspect of the language including keywords for each version, can be purchased from ISO. Some free documents, typically final drafts, are also available through various online resources.

(FtrnWiki)