Some standard content:
GB/T3057—1996
This standard is equivalent to the international standards ISO/IEC1539:1991 "Information technology programming language Fortran" and 1SO/IEC1539:1991/Cor.1,1993 Information technology programming language Fortran Technical Modification 1". According to ISO/IEC1539:1991/Cor.1:1993, this standard applies to 1.4.1.2-4.6.3.3.2.4, 4.4.1, 5.1, 5-1.1-5, 5.1.1.7, 5.3, 7.1.6.1, 7.5-3.1, 7.5.3.2, 9.4.1, 9.42, 10.5.4.1.2, 10.8.1, 11.3.2, 12.1.2.2.1.12.3-2.1, 12.3.2.2, 12.4.1.1, 12.5.2.4, 12.5.2.5, 12. 5.2.8.12. 5.4, 13.13.13, 13.13.25, 13.13.66, 13.13.80, 13.13.100, 14.1.3.14.6.2.1 and Appendix A have been corrected. This standard is completely consistent with the international standard in terms of technical content, and only slightly differs from the international standard in the following two points: a) According to the provisions of GB1.1-93, the table numbers have been changed, and b) According to national conditions, the content of Appendix E has been omitted. This standard describes the form of programs expressed in Fortran language and establishes the interpretation of these programs. It consists of the specification of Fortran language.
Appendices A to F of this standard are all informative appendices. This standard replaces GB3057-82 from the month it takes effect. This standard is proposed by the Ministry of Electronics Industry of the People's Republic of China. This standard is under the jurisdiction of the Standardization Research Institute of the Ministry of Electronics Industry. This standard was drafted by: Software Institute of the Chinese Academy of Sciences, Beijing Cable Plant, and the Programming Language Subcommittee of the National Standardization Committee. The main drafters of this standard are: Cheng Hu, Chen Mingyuan, Wu Qingbao, Xu Zuyuan, Gong Maojiang, Chen Tianqing, Bao Youxin, and Feng Hui. This standard was first issued in May 1982.
GB/T3057—1996
ISO/IEC Foreword
ISO (International Organization for Standardization) and IEC (International Electrotechnical Commission) are specialized standardization organizations worldwide. National member bodies (which are members of ISO or IEC) participate in the formulation of international standards for specific technical scopes through technical committees established by international organizations. The technical committees of ISO and IEC cooperate in areas of common interest. Other official and non-official international organizations in contact with ISO and IEC may also participate in the formulation of international standards. For information technology, ISO and IEC have established a joint technical committee, namely 1SO/IEC JTC1. Draft international standards proposed by the joint technical committee are circulated to national member bodies for voting. Publication as an International Standard requires a vote of at least 75 % of the national bodies voting on the subject.
International Standard ISO/IEC 1539 was prepared by Joint Technical Committee ISO/IFC JTC1 \ Information Technology ". This second edition cancels and replaces the first edition (ISO 1539; 1980), which has been technically revised. Appendices A, B, C, D, E and F are for reference only. GB/T 3057—1996
Standard Programming Language Fartran
This standard specifies the form of programs expressed in the Fortran language (informally known as \Fortran90\) and establishes the interpretation of these programs. It consists of a specification of the Fortran language. No subset of this language is specified in this standard. Except for the restrictions noted in 1.4.1, the legal and semantic meanings of the national standard commonly known as \FORTRAN77" are fully included in this standard. However, any FORTRAN77 program that conforms to the standard is also conforming to the standard under this standard. With a few exceptions noted in the text of this standard, new features may be incorporated compatibly into such programs. A Fortran processing system conforming to the standard is also a FORTRAN77 processing system conforming to the standard. Note that the name of the language Fortran differs from FORTRAN77 in that only the first letter is capitalized. FORTRAN77 and FORTRAN66 used only capital letters in the formal names of their languages, but Fortran90 did not continue this tradition. Among the various extensions to FORTRAN77 in this standard, the following seven notable extensions are the main ones: (1) Array operations: (2) Improved numerical computing facilities; (3) Parameterized intrinsic data types; (4) User-defined data types; (5) Various facilities for module data definition and procedure definition: (6) Pointers: (7) Language evolution concepts.
Other extensions are included in this standard, such as improved source program form facilities, more control constructs, recursion, additional input/output facilities, and dynamically allocatable arrays. Array Operations
Computations involving large arrays are an important part of engineering and scientific computing. In Fortran, arrays can be used as entities. Operations for manipulating complete arrays and subarrays (array fragments) are included in this specification for two main reasons: (1) These features provide a more concise and higher-level language that will allow programmers to develop and maintain scientific/engineering applications more quickly and reliably;
(2) These features greatly facilitate the optimization of array operations on a variety of computer architectures. The arithmetic, logical, character, and intrinsic (predefined) functions in FORTRAV77 have been extended to operate on array-valued operands. Such extensions include complete array assignment, partial array assignment and masked array assignment, array-valued constants and array-valued expressions, and facilities for defining user-supplied array-valued functions. New intrinsic procedures are also provided for manipulating and constructing arrays, implementing gather/scatter operations, and supporting extended array-related computational capabilities. For example, an intrinsic is provided to sum the elements of an array. Numerical computing
Scientific computing is one of the fundamental application areas of Fortran, and all technical aspects of this standard are covered in this document.The guiding goal of the work is to strengthen the Fortran language GB/T3057-1996
so that it can be used to implement software in the scientific field. Although non-numerical computing has grown rapidly in scientific application systems, numerical computing still occupies a dominant position. Accordingly, these extensions include: portable control of numerical precision description; query of internal numerical representation characteristics; and improved control of numerical program performance (for example, improved reduction and proportionality of variable range). Parameterized character data types
For national languages such as China and Japan that use large character sets, some optional facilities for multi-byte character data are added by using a kind parameter for derived data types. This facility also allows the use of additional character sets for various special purposes, such as characters used in mathematics, chemistry or music. Derived types
"Derived types" is the term given by this standard to a group of functions that allow programmers to define some arbitrary data structures and define operations on these data structures. Data structures are user-defined and aggregated by intrinsic data types and derived data types. Intrinsic uses of structured objects include assignment, input/output, and use as procedure arguments. Without additional derived type operations defined by the user, the derived data type facility is a simple data structure mechanism. With additional operation definitions, the derived type provides an effective implementation mechanism for data abstraction. Procedure definitions can be used to define operations on intrinsic or derived types, and can also be used to define non-intrinsic assignments to intrinsic and derived types.
Module Definitions
In FORTRAN77, there is no way to define a global data area in just one place and have it used by all program units in an application system. In addition, the ENTRY statement is inconvenient and very restrictive when implementing a group of related procedures (which may involve common data objects). Finally, there is no means in FORTRAN77 to make individual procedure definitions (especially their interface information) locally known to a program unit. These and other deficiencies are addressed by a new type of sequence unit that can contain any combination of data object declarations, derived type definitions, procedure definitions, and procedure interface information. This program unit, called a module, can be thought of as a generalization of and replacement for the block data program unit. A module is accessible from any program unit, making the contents of the module available to that program unit. Thus, modules provide improved facilities for defining global data areas, procedure packages, and encapsulated data abstractions. Pointers
Pointers allow arrays to be dynamically sized and rearranged, and structures to be linked, so that tables, trees, and graphs can be created. An object of any intrinsic or derived type can be declared to have pointer attributes. Once such an object becomes associated with an object, it can appear almost anywhere a non-pointer object of the same type, with similar type parameters, and of the same shape can appear.
Evolution of the language
As new facilities are added, some of the old features become redundant and may eventually be eliminated due to the decline of their usefulness. For example: the numerical facility alluded to above provides double precision capabilities; due to the new array facility, non-uniform variable binding (such as combining an array element with a virtual array) is unnecessary (and, in fact, it is not very useful as an array operation); block data program units are redundant and are submodules, etc. As part of the language transition, a list of (deprecated and past) language features is provided to allow unused features in the language to be deleted from future standards. GB/T30571996
Constitution of this standard
This document consists of 14 chapters, covering 7 conceptual areas. The seven areas and the chapters that cover them are as follows: High/Low Level Concepts
Data Concepts
Execution Control
Input/Output
Program Units
Scope and Association Rules
High/Low Level Concepts
Chapters 1, 2.3
Chapters 4.5, 6
Chapters 7, 13
Chapter 8
Chapters 9, 10
Chapters 11, 12
Chapter 14
Chapter 2 (Fprtran Terms and Concepts) contains many high-level Fortran concepts. They include concepts about an executable program and the relationships between its major parts. This chapter also includes the syntax of program units, the rules for statement order, and the definitions of many basic terms used throughout this document.
Chapter 3 (Characters, Lexical Notation, and Source Program Forms) describes the low-level elements of Fortran, such as the character set and the allowed source program forms. It also includes the rules for constructing literal constants and names for Fortran entities, and lists all Fortran operators. Data Concepts
Array operations (with arrays as data objects) and data structures provide a rich set of data concepts in Fortran. The main concepts are the concepts of data types, the concepts of data objects, and the concepts of the use of data objects, which are described in Chapters 1, 5, and 6, respectively.
Chapter 4 (Intrinsic and Derived Data Types) describes the difference between a data type and a data object, and then focuses on the description of data types. This chapter defines a data type as a collection of individual data values, corresponding forms representing these values (various constants), and various operations on these values. This chapter also introduces the concept of intrinsic data types and describes the properties of the various intrinsic Fortran types (INTEGER, REAL, COMPLEX, LOGICAL, and CHARACTER). Note that only the concept of data object type is described here, and the concept of data object declaration and its properties is not described. Chapter 4 also introduces the concept of derived (user-defined) data types, which are some composite types whose components will eventually be decomposed into intrinsic types, and gives the details of defining derived types (note: since intrinsic types are predefined, they do not need to be and cannot be redefined by programmers, and there is no corresponding part for intrinsic types). As with intrinsic types, this chapter only discusses the type properties of derived types, and does not discuss the declaration of derived type data objects.
Chapter 5 (Declaration and Description of Data Objects) describes in detail how to declare named data objects and how to give them the desired properties (attributes). The first important attribute of a data object (that is, the only attribute that is required for every data object) is the data type of the object, so the type declaration statement is the main function of this chapter. This chapter describes in detail the various attributes and two methods of describing these attributes (type declaration statement and attribute description statement). This chapter also describes implicit determination of type and storage combination (COMMON and EQUIVALENCE),and the initialization of data object values. Chapter 6 (Use of Data Objects) deals with the concept of variables and describes the various forms that variables can take. Scalar variables include strings and substrings, structure (derived type) objects, structure components, and array elements. Arrays and array fragments are considered variables. Among the various array facilities, this chapter describes array fragments (subarrays) and the allocation and deallocation of arrays (user-controlled dynamic arrays). Computation
Chapter 7 (Expressions and Assignment) describes how various computations are expressed in Fortran. This includes the forms that operands (elementary quantities) can take in these expressions and the effects of operators. The precedence of operators is strictly defined in the form of semantic rules and summarized in a table. The description of this chapter includes the relationship between defined operators (operators defined by the user) and intrinsic operators (+, *, AND, R, etc.). This chapter describes in detail the rules for evaluating expressions and the interpretation rules (semantics) for intrinsic and defined operators.
Chapter 7 also describes the assignment of calculation results to data objects, which has three basic forms: traditional assignment statements, pointer assignment statements, and WHERE statements and WHERE constructs. Among them, WHERE statements and WHERE constructs allow masked array assignments.
Chapter 13 (Intrinsic Procedures) describes more than a hundred intrinsic procedures that provide a rich set of computational capabilities. In addition to the intrinsic functions already in FORTRAN77, it also includes many array processing functions, a complete set of numerical environment query functions, and a set of procedures that operate on bit operations in the form of non-negative integer data. Execution Control
Chapter 8 (Execution Control) describes various control constructs (IF, CASE, and DO constructs, etc.), various branch statements (various forms of GOTO), and other control statements (IF, arithmetic IF, CONTINUE, STOP, and PAUSE, etc.). Except for the newly added CASE construct and the TX) loop that is expanded to include an ENDDO termination optional statement, several new control clauses, and new EXIT and CYCEE statements, all other statements are the same as in FORTRAN77. Input/Output
Chapter 9 (Input/Output Statements) contains definitions of the following concepts: records, files; file connections (OPEN, CLOSE and pre-connected files); various data transfer statements (READ, WRITE and PRINT, etc.) for processing partial records and variable-length records: file positioning and file query (INQUIRE).
Chapter 10 (Input/Output Editing) describes the input/output format, including the FORMAT statement and FMT= specifier, edit mode descriptor, table input/output and name table input/output program units
Chapter 11 (Program Units) describes the main program, external auxiliary program, module and block data program units. Modules, along with the USE statement, are described as a mechanism for encapsulating data and procedure definitions for use (access) by other program units. Modules are described as a tool for defining the following items: various global exported type definitions, global data object declarations, procedure libraries, and various combinations of these. Chapter 12 (Procedures) contains a comprehensive discussion of the definition and invocation of procedures (including user-defined functions and subroutines). This chapter explains the concepts of implicit and explicit procedure interfaces, identifies various situations in which an explicit procedure interface is required, and describes the rules governing real and virtual arguments and their combinations. Chapter 12 also describes the use of the OPERATOR option in the interface block to allow the invocation of functions using infix and prefix operators as well as the traditional function form. Similarly, this chapter describes the use of the ASSIGNMENT option in the interface block to allow an alternative syntax for subroutine calls. This chapter also includes a description of recursive procedures, the RFTURN statement, the ENTRY statement, internal procedures and CONTAINS statements, statement functions, generic procedure names, and methods of accessing non-Fortran procedures.
Rules for Scope and Cohesion
Chapter 14 (Scope, Cohesion, and Definitions) explains the use of the term "scope" (which is now particularly important due to the addition of internal procedures, modules, and other new features) and describes the scope properties of various entities (including names and operators); it also describes the general rules governing procedure argument binding, pointer binding, and storage binding. Finally, Chapter 14 describes the events that cause variables to become defined (with predicated declarativeness) and the events that cause variables to become meaningless. 1 Overview
National Standard of the People's Republic of China
Information Technology Programming Language Fortran
Informatlon technalegy
Programming language—FortranGB/T 3057—1996
idt IS0/IEC 1539: 1991
Supersedes GR3057--82
1.1 Scope
This standard specifies the form of programs expressed in the Fortran language and establishes the interpretation of programs expressed in the Fortran language. The purpose of this standard is to promote the portability, reliability, maintainability, and efficient execution of Fortran programs for use on a variety of computing systems.
1.2 Processing System
A combination of a computing system and a mechanism for converting programs so that they can be used on that computing system. 1.3 Inclusions and Exclusions
This standard defines the boundaries of the Fortran language by identifying which clauses are included and which are excluded. 1.3.1 Inclusions
This standard defines:
(1) The various forms that programs written in the Fortran language may take; (2) The rules for interpreting the meaning of a program and its data; (3) The forms of input data processed by such a program; and (4) The forms of output data produced by the use of such a program. 1.3.2 Exclusions
This standard does not specify:
(1) mechanisms for converting programs for use on a computing system; (2) operations required to construct and configure programs for use on a computing system; (3) methods for converting programs or their input or output data to or from storage media; (4) the performance of programs and processing systems when the rules of this standard fail to establish an interpretation, except for the detection and reporting requirements of processing systems in 1.4 (2) to (8); (5) the size or complexity of programs and their data, which may exceed the capabilities of any dedicated computing system or the capabilities of a specific processing system;
(6) the physical properties of the representation of quantities and the methods of rounding, approximation, and calculation of numbers on a specific processing system; (7) the physical properties of input/output records, files, and units; (8) the physical properties of storage and execution procedures. 1.4 Conformance
The requirements, prohibitions, and options specified in this standard relate primarily to the forms and relationships permitted for programs conforming to the standard, not to processing systems.
If an executable program (see 2.2.1) contains only the forms and relationships described herein, and the executable program has an interpretation in accordance with this standard, then the State Administration of Technical Supervision approved on December 18, 1996 and implemented on July 1, 1997
GB/T 3057-1996
The executable program is a program that complies with the standard. If a program unit (see 2.2) can be included in an executable program in such a way that it allows the executable program to comply with the standard, then the program unit complies with this standard. A processing system complies with this standard if:
1) It executes any program that complies with the standard in such a way that it complies with the interpretation here, subject to any restrictions that the processing system may impose on the size and complexity of the program. L. (2) It includes the ability to detect and report the following uses, that is, the use of forms indicated as deleted or obsolete in the submitted program unit, such use can be detected using the numbered syntax rules and their associated constraints. (3) It includes the ability to detect and report the use of additional forms or relationships within submitted program units that are not permitted by numbered rules and their associated constraints. (4) It includes the ability to detect and report the use of parameter values of a type not supported by the processing system within submitted program units (see 4.3).
(5) It includes the ability to detect and report the use of source program forms or text boxes that are not permitted by Clause 3 within a submitted program unit.
(6) It includes the ability to detect and report the use of nominal usage within a submitted program that is inconsistent with the rules for the use of nominal, label, operator, and assignment symbols in Clause 14. (7) It includes the ability to detect and report the use of intrinsic procedures that do not define names in Clause 13 within a submitted program unit.
(8) It includes the ability to detect and report reasons for rejecting a submitted program. However, in farmat-specificatirms that are not part of the formal-stmt (see 10.1.1), processing systems are not required to detect and report the use of deleted or obsolete functions, or the use of additional forms or relations. Processing systems that conform to the standard may allow additional forms and relations as long as the additions do not conflict with the standard forms and relations. However, a conforming processing system may allow the addition of intrinsic procedures even if doing so would cause a conflict with procedure names in a conforming program. If such a conflict involves an external procedure name, the processing system is permitted to use the intrinsic procedure unless the name is given as an interface or as an FXTFRNAI. attribute in the same scope unit (see Chapter 14). A conforming program is not permitted to use nonstandard intrinsic procedures added by the processing system. Note that a conforming program may not include any form or relationship prohibited by the national standard, but a conforming processing system may allow such form or relationship if such form or relationship does not change the proper interpretation of the conforming program. For example, a conforming processing system may incorporate additional intrinsic data types. Because conforming programs may impose requirements on processing systems beyond the scope of this standard or may include non-portable standard provisions, such as the use of non-Fortran defined external procedures, conformance to this standard does not guarantee that conforming programs will execute consistently on all or any conforming processing systems.
In some cases, this standard permits the provision of certain facilities that are not fully specified in the standard. These facilities are marked as being system-dependent. They must be provided to the user with methods or semantics determined by the system. 1.4.1 FORTRAN77 Compatibility
Except as noted in this section, this standard is a compatible extension of the previous Fortran national standard GB3057-82, informally known as FORTRAN77, and a system that conforms to the national standard for this standard is a system that conforms to the national standard for FORTRAN77. Any FORTRAN77 program that conforms to the standard is still a conforming program under this standard; however, see (4) below regarding intrinsic procedures. This standard restricts the behavior of certain FORTRAN77 functions that are system-dependent. So a FORTRAN77 program that conforms to the standard that uses one of these system-dependent functions may have a different interpretation under this standard, but is still a conforming program. The following properties of FORTRAN.V77 are interpreted differently in this standard: (1) When a DOUBI.EPRECISION data object in a DATA statement is initialized with a constant, FORTRAN.V77 permits the processing system to provide a precision greater than that which can be included in the real data derived from the real constant. This standard does not allow the processing system this option.
GB/T 3057—1996
(2) If a named variable that is not in a common block is initialized in a TA statement and the SAVE attribute is not specified, FORTRAN77 leaves its SAVE attribute to the dependent processing system. This standard specifies (see 5.2.9) that the named variable has the SAVE attribute. bzxz.net
(3) FORTRAN77 requires that the number of characters required by the input table must be less than or equal to the number of characters in the record during formatting of the input. In addition to specifying the "PAD=\NO" option in the appropriate OPEV statement, this standard specifies (see 9.4.4.4.2) that input records be logically padded with spaces if there are not enough characters in the record. (4) This standard has more intrinsic functions than FORTRAN 77 and adds fewer intrinsic subroutines. However, if a FORTRAN 77 program conforming to the standard refers to a procedure having the same name as a new standard intrinsic procedure, it is interpreted differently under this standard unless the procedure is specified in an EXTERNAL statement as recommended in the Appendix for non-intrinsic functions to FORTRAN. RAN77 standard.
(5) 0-value pairs used for table entries in format output statements - some G edit descriptors will have different formats. In addition, the Fortran90 standard stipulates that how values are rounded will affect the output field format. FORTRAN77 does not address this issue: therefore, some FORTRAN77 processing systems will produce output formats different from Fortran90 processing systems for certain combinations of values and G edit descriptors. (6) FORTRAN77 allows intrinsic functions to be declared even when there is no function defined for that type. For example, INTRINSIC SIN
IOGICA. SIN
This standard stipulates (5.1) that a type declaration for an intrinsic function can only confirm the type of an existing function. Therefore, a FORTRAN77 program that conforms to the standard declares a type that is not defined for an intrinsic function and will not comply with this standard. 1.5 Notation used in this standard
In this standard, "shall" is interpreted as required and "shall not" is interpreted as prohibited. 1.5.1 Grammar Rules
Grammar rules are used to help summarize the forms that Fortan's lexical tokens, statements, and constructs can take. These grammar rules are expressed in a variation of Backus-Naur Form (BNF), in which: (1) Except where noted, characters from the Fottan character set (see 3.1) are written in a prescribed form. (2 Lowercase italic letters and words (often hyphenated and abbreviated) denote general grammatical classes in which specific grammatical entities must be replaced by real statements. Some common notations used in grammatical terminology are: stmt
for statement
for expression
for specifier
for variable
for attribute
for declaration
for definition
for descriptor
for operator
(3) The grammatical metasymbols used are:
(statement)
(expression)
(sp ecificr)
(intcger)
(argument)
(attribute）
(declaration)
(definition)
(descriptor）
(operator)
Introduce a grammar class definition
Introduce a grammar class substitution
Enclose an optional clause
Enclose an optional repeating clause, this repeating clause can appear zero or more timesContinue:-a grammar rule
GB/T 3057--1996
(4) Each grammar rule is given a unique identification number of the form Rsn, where s is a two-digit chapter number and nn is a two-digit sequence number within the chapter. The grammar rules are appropriately distributed throughout the text and referenced by their identification numbers when necessary. Some rules in Chapters 2 and 3 are described in more detail in later chapters, in which case the chapter number s is the later chapter number to which the rule is referred. The rules are collected in Appendix D. (5) The grammar rules are not a complete and precise description of the syntax of Fortran, and cannot be used to automatically generate Fortran parsers. Where the grammar rules are incomplete, corresponding constraints and text are provided. (6) Deprecated features are indicated by font size differences (see 1.6).This is an example of using font size for a deprecated feature. An example of using the syntax rule is: digit-stringis
digit[digit]
The following form is an example of a digit string allowed by the above rule: dligit
digit digit
digit digit digit digit digit
digit digit digit digit digit digit digit digit When digit is replaced with a specific entity, the actual digit string can be: 4
10243852
1.5.2 Assumed syntax rules
To minimize the number of additional syntax rules and to convey appropriate constraint information, the following rules are defined. The letters "ryz" represent any legal syntax class phrase:
tye-list
tyz-name
xcatar-rye
Constraint: statar-ryz must be a scalar. 1.5.3 Syntax Conventions and Features
(1) Any syntax-like name ending in \-stmt\ follows the rules for source-program formalism: it must be terminated by a line end or a semicolon. If it does not form part of another statement (such as an IF or WHERE statement), it may be numbered. Otherwise, anything that is considered a source-program formal statement ends with \-stmt\ as given in the syntax rules. (2) The rules for statement sequencing are strictly described in the definition of program-unit (see R202-R216) and the expression hierarchy is strictly described in the definition of erp (see R723). (3) The suffix \-spec\ is generally used for descriptors, such as input/output statement descriptors. Also used in type declaration attribute specifications (e.g., "array-spec\ in R512), and in other rare cases. (i) When referring to type parameters (including enclosing parentheses), the term \selector\ is used. See "length-selector\ (see R507) and hind-selector\ (see R505). (5) The term \suhsrripl\ (e.g., R617, R618, and R619) is generally used in array definitions. 1.5.4 Text Conventions
In descriptive text, formal English equivalents of BNF grammar terms are usually used. Capitalized keywords are used in the text to identify specific statements and attributes, for example, "END\ statement. Boldface words are also used in the text where they are first defined with a specific meaning.
Deleted and Obsolete Features
This standard protects users' investments in existing software by including all FORTRAN 77 syntax that is not dependent on the processing system. 3057-1996
language elements. This document identifies two categories of obsolete functionality. There is nothing in the first category, which consists of functionality that was considered redundant in FORTRAV77 and is rarely used. The second category, which consists of functionality that was considered redundant in FORTRAN77 but is still frequently used. 1.6.1 Nature of the Deprecated Features
(1) Better methods already exist in FORTRAN77, and (2) these features are not included in this version of Fortran. 1.6.2 Nature of the Deprecated Features
|tt||(1) Better methods are available in FORTRAV77.(2) Programmers are advised to use these better methods in new programs and to convert existing code to these methods.(3) These features are identified in the text of this document by using a distinctive font (see 1.5.1).(4) If the use of these features in Fortran programs is no longer meaningful, they may be considered for removal in the next version.(5) It is recommended that the next Fortran standards committee consider removing only those language features that appear in the obsolete function table.(6) As long as these features continue to be widely used in Fortran programs, it is recommended that they be removed from the Fortran standard. Processing systems that support the Fortran language continue to support these features.
1.7 Modules
This standard provides facilities to promote the design and use of modules and reusable software. Data and various definitions of procedures can be organized into non-executable program units called modules and made available to any other program unit. In addition to global data and procedure library facilities, modules also provide a mechanism for defining data abstractions and for certain language extensions. Modules are described in 11.3 and may be standardized as a separate subsidiary standard. Standard modules must not use any obsolete features, nor any Non-standard forms do not use any non-standard relations. 1.8 Referenced Standards
The following standards contain clauses that, through reference in this standard, constitute the meaning of this standard. The versions indicated are valid at the time of publication of this standard. All standards are subject to revision. Parties using this standard should investigate the possibility of using the latest versions of the following standards: GB/T 7408-94 Data Elements and Interchange Formats Method for Representing Dates and Times for Information Interchange (eqIS 08601:1988) GB 1988-89 Information Processing Seven-bit Coded Character Set for Information Interchange (eqIS 646:1983) CCIR Recommendation 460-2
| 2 Fortran Terminology and Concepts
2.1 High-level Syntax
This chapter introduces the terminology related to program units and other Forlran concepts above the construct, statement, and expression level, and clarifies the relationship between them. The notation of syntax rules is described in 1.5.1. Note that some syntax rules in this chapter are subject to constraints given in appropriate places in later chapters.
R201erecutable-prugram
rogram-unin
Epragtamn-rit]-
A recutable-program must precisely encompass a main-proram program-unit. R202 program-nit
R1101 main-progran
main-program
ieriernal szbprogram
module
blockdata
Fprogram-stmt7
[speeification parr]
[eretion-perl]
R203 erternaf-subprugram
R1215function-subprogram
R1219 subroutite-subprogrm
R1104 module
R1llBock-data
R204 sperificalion-part
R205 inplirif-fart
R206 impticit-purt-siml
R207 derlaratinn-canstruct
R208 exetwim-part
R209 execution-part-construrtR210 inernat-subprogram-partGB/T 3057-:1996
[internai-sub program-puzrt]end-sub program-slmt
frunction-suhprogram
swbrouine subprogram
funetian-stmt
[speei ficavton-purt]
[execution-part?
[internal subprogram-part]
end-function-stmt
subroutinte-stmt
[specification parr]
[eaecutiam-part]
[internatl-subprogram -pari
end-snbroutine-stmt
mod ule-stmt
[specification- purt]
[module-progrum-purr]
end-mudufe-stnt
bock-datu-stmt
[tperification-part]
ernd -btock-datu-stmt
[use-stmt]...
[im implicit-part.
[deelaration-construcs].
[implicit-part-stmt ]...
imptiet-stmt
imptictt-stm
parameter-tmt
farmat-stmt
entry-stme
derited -type-def
inter face-bork
type-declaration-simt
deelaration-stmt
parameter-stmt
format-stmt| |tt||entrgr-stmt
stnt-funcrion-stnl
erecutable-constrre!
[eaecution-purt-consiruet ]...exetabte-tunstruct
frmut-stnt
daa-stnt
earystmt
comtains-xtmt
internat-subprugrum
[internat-wbprogram]...
Tip: This standard content only shows part of the intercepted content of the complete standard. If you need the complete standard, please go to the top to download the complete standard document for free.