(g77.info)Direction of Language Development
Direction of Language Development
The purpose of the following description of the GNU Fortran language
is to promote wide portability of GNU Fortran programs.
GNU Fortran is an evolving language, due to the fact that `g77'
itself is in beta test. Some current features of the language might
later be redefined as dialects of Fortran supported by `g77' when
better ways to express these features are added to `g77', for example.
Such features would still be supported by `g77', but would be available
only when one or more command-line options were used.
The GNU Fortran *language* is distinct from the GNU Fortran
*compilation system* (`g77').
For example, `g77' supports various dialects of Fortran--in a sense,
these are languages other than GNU Fortran--though its primary purpose
is to support the GNU Fortran language, which also is described in its
documentation and by its implementation.
On the other hand, non-GNU compilers might offer support for the GNU
Fortran language, and are encouraged to do so.
Currently, the GNU Fortran language is a fairly fuzzy object. It
represents something of a cross between what `g77' accepts when
compiling using the prevailing defaults and what this document
describes as being part of the language.
Future versions of `g77' are expected to clarify the definition of
the language in the documentation. Often, this will mean adding new
features to the language, in the form of both new documentation and new
support in `g77'. However, it might occasionally mean removing a
feature from the language itself to "dialect" status. In such a case,
the documentation would be adjusted to reflect the change, and `g77'
itself would likely be changed to require one or more command-line
options to continue supporting the feature.
The development of the GNU Fortran language is intended to strike a
* Serving as a mostly-upwards-compatible language from the de facto
UNIX Fortran dialect as supported by `f77'.
* Offering new, well-designed language features. Attributes of such
features include not making existing code any harder to read (for
those who might be unaware that the new features are not in use)
and not making state-of-the-art compilers take longer to issue
diagnostics, among others.
* Supporting existing, well-written code without gratuitously
rejecting non-standard constructs, regardless of the origin of the
code (its dialect).
* Offering default behavior and command-line options to reduce and,
where reasonable, eliminate the need for programmers to make any
modifications to code that already works in existing production
* Diagnosing constructs that have different meanings in different
systems, languages, and dialects, while offering clear, less
ambiguous ways to express each of the different meanings so
programmers can change their code appropriately.
One of the biggest practical challenges for the developers of the
GNU Fortran language is meeting the sometimes contradictory demands of
the above items.
For example, a feature might be widely used in one popular
environment, but the exact same code that utilizes that feature might
not work as expected--perhaps it might mean something entirely
different--in another popular environment.
Traditionally, Fortran compilers--even portable ones--have solved
this problem by simply offering the appropriate feature to users of the
respective systems. This approach treats users of various Fortran
systems and dialects as remote "islands", or camps, of programmers, and
assume that these camps rarely come into contact with each other (or,
especially, with each other's code).
Project GNU takes a radically different approach to software and
language design, in that it assumes that users of GNU software do not
necessarily care what kind of underlying system they are using,
regardless of whether they are using software (at the user-interface
level) or writing it (for example, writing Fortran or C code).
As such, GNU users rarely need consider just what kind of underlying
hardware (or, in many cases, operating system) they are using at any
particular time. They can use and write software designed for a
general-purpose, widely portable, heterogenous environment--the GNU
In line with this philosophy, GNU Fortran must evolve into a product
that is widely ported and portable not only in the sense that it can be
successfully built, installed, and run by users, but in the larger
sense that its users can use it in the same way, and expect largely the
same behaviors from it, regardless of the kind of system they are using
at any particular time.
This approach constrains the solutions `g77' can use to resolve
conflicts between various camps of Fortran users. If these two camps
disagree about what a particular construct should mean, `g77' cannot
simply be changed to treat that particular construct as having one
meaning without comment (such as a warning), lest the users expecting
it to have the other meaning are unpleasantly surprised that their code
misbehaves when executed.
The use of the ASCII backslash character in character constants is
an excellent (and still somewhat unresolved) example of this kind of
controversy. Note: Backslash in Constants. Other examples are
likely to arise in the future, as `g77' developers strive to improve
its ability to accept an ever-wider variety of existing Fortran code
without requiring significant modifications to said code.
Development of GNU Fortran is further constrained by the desire to
avoid requiring programmers to change their code. This is important
because it allows programmers, administrators, and others to more
faithfully evaluate and validate `g77' (as an overall product and as
new versions are distributed) without having to support multiple
versions of their programs so that they continue to work the same way
on their existing systems (non-GNU perhaps, but possibly also earlier
versions of `g77').
Next: Standard Support Up: Language
[ Dokumentation lokal installierter Software ]