OSDN Git Service

* config/ia64/ia64.c: Fix a comment typo.
[pf3gnuchains/gcc-fork.git] / gcc / fortran / gfortran.texi
1 \input texinfo  @c -*-texinfo-*-
2 @c %**start of header
3 @setfilename gfortran.info
4 @set copyrights-gfortran 1999-2005
5
6 @include gcc-common.texi
7
8 @settitle The GNU Fortran 95 Compiler
9
10 @c Create a separate index for command line options
11 @defcodeindex op
12 @c Merge the standard indexes into a single one.
13 @syncodeindex fn cp
14 @syncodeindex vr cp
15 @syncodeindex ky cp
16 @syncodeindex pg cp
17 @syncodeindex tp cp
18
19 @c %**end of header
20
21 @c Use with @@smallbook.
22
23 @c %** start of document
24
25 @c Cause even numbered pages to be printed on the left hand side of
26 @c the page and odd numbered pages to be printed on the right hand
27 @c side of the page.  Using this, you can print on both sides of a
28 @c sheet of paper and have the text on the same part of the sheet.
29
30 @c The text on right hand pages is pushed towards the right hand
31 @c margin and the text on left hand pages is pushed toward the left
32 @c hand margin.
33 @c (To provide the reverse effect, set bindingoffset to -0.75in.)
34
35 @c @tex
36 @c \global\bindingoffset=0.75in
37 @c \global\normaloffset =0.75in
38 @c @end tex
39
40 @copying
41 Copyright @copyright{} @value{copyrights-gfortran} Free Software Foundation, Inc.
42
43 Permission is granted to copy, distribute and/or modify this document
44 under the terms of the GNU Free Documentation License, Version 1.1 or
45 any later version published by the Free Software Foundation; with the
46 Invariant Sections being ``GNU General Public License'' and ``Funding
47 Free Software'', the Front-Cover
48 texts being (a) (see below), and with the Back-Cover Texts being (b)
49 (see below).  A copy of the license is included in the section entitled
50 ``GNU Free Documentation License''.
51
52 (a) The FSF's Front-Cover Text is:
53
54      A GNU Manual
55
56 (b) The FSF's Back-Cover Text is:
57
58      You have freedom to copy and modify this GNU Manual, like GNU
59      software.  Copies published by the Free Software Foundation raise
60      funds for GNU development.
61 @end copying
62
63 @ifinfo
64 @dircategory Programming
65 @direntry
66 * gfortran: (gfortran).                  The GNU Fortran 95 Compiler.
67 @end direntry
68 This file documents the use and the internals of
69 the GNU Fortran 95 compiler, (@command{gfortran}).
70
71 Published by the Free Software Foundation
72 59 Temple Place - Suite 330
73 Boston, MA 02111-1307 USA
74
75 @insertcopying
76 @end ifinfo
77
78 Contributed by Steven Bosscher (@email{s.bosscher@@gcc.gnu.org}).
79
80 @setchapternewpage odd
81 @titlepage
82 @title Using GNU Fortran 95
83 @sp 2
84 @center Steven Bosscher
85 @page
86 @vskip 0pt plus 1filll
87 For the @value{version-GCC} Version*
88 @sp 1
89 Published by the Free Software Foundation @*
90 59 Temple Place - Suite 330@*
91 Boston, MA 02111-1307, USA@*
92 @c Last printed ??ber, 19??.@*
93 @c Printed copies are available for $? each.@*
94 @c ISBN ???
95 @sp 1
96 @insertcopying
97 @end titlepage
98 @summarycontents
99 @contents
100 @page
101
102 @node Top, Copying,, (DIR)
103 @top Introduction
104 @cindex Introduction
105
106 This manual documents the use of @command{gfortran}, 
107 the GNU Fortran 95 compiler. You can find in this manual how to invoke
108 @command{gfortran}, as well as its features and incompatibilities.
109
110 @ifset DEVELOPMENT
111 @emph{Warning:} This document, and the compiler it describes, are still
112 under development.  While efforts are made to keep it up-to-date, it might
113 not accurately reflect the status of the most recent @command{gfortran}.
114 @end ifset
115
116 @comment
117 @comment  When you add a new menu item, please keep the right hand
118 @comment  aligned to the same column.  Do not use tabs.  This provides
119 @comment  better formatting.
120 @comment
121 @menu
122 * Copying::              GNU General Public License says
123                          how you can copy and share GNU Fortran.
124 * GNU Free Documentation License::
125                          How you can copy and share this manual.
126 * Funding::              How to help assure continued work for free software.
127 * Getting Started::      What you should know about @command{gfortran}.
128 * GFORTRAN and GCC::     You can compile Fortran, C, or other programs.
129 * GFORTRAN and G77::     Why we chose to start from scratch.
130 * Invoking GFORTRAN::    Command options supported by @command{gfortran}.
131 * Project Status::       Status of @command{gfortran}, roadmap, proposed extensions.
132 * Contributing::         How you can help.
133 * Standards::            Standards supported by @command{gfortran}
134 * Extensions::           Language extensions implemented by @command{gfortran}
135 * Intrinsic Procedures:: Intrinsic procedures supported by @command{gfortran}
136 * Index::                Index of this documentation.
137 @end menu
138
139
140
141 @c ---------------------------------------------------------------------
142 @c GNU General Public License
143 @c ---------------------------------------------------------------------
144
145 @include gpl.texi
146
147
148
149 @c ---------------------------------------------------------------------
150 @c GNU Free Documentation License
151 @c ---------------------------------------------------------------------
152
153 @include fdl.texi
154
155
156
157 @c ---------------------------------------------------------------------
158 @c Funding Free Software
159 @c ---------------------------------------------------------------------
160
161 @include funding.texi
162
163
164
165 @c ---------------------------------------------------------------------
166 @c Getting Started
167 @c ---------------------------------------------------------------------
168
169 @node Getting Started
170 @chapter Getting Started
171
172 Gfortran is the GNU Fortran 95 compiler front end,
173 designed initially as a free replacement for,
174 or alternative to, the unix @command{f95} command;
175 @command{gfortran} is command you'll use to invoke the compiler.
176
177 Gfortran is still in an early state of development.
178 @command{gfortran} can generate code for most constructs and expressions,
179 but much work remains to be done.
180
181 When @command{gfortran} is finished,
182 it will do everything you expect from any decent compiler: 
183
184 @itemize @bullet
185 @item
186 Read a user's program,
187 stored in a file and containing instructions written
188 in Fortran 77, Fortran 90 or Fortran 95.
189 This file contains @dfn{source code}.
190
191 @item
192 Translate the user's program into instructions a computer
193 can carry out more quickly than it takes to translate the
194 instructions in the first
195 place.  The result after compilation of a program is
196 @dfn{machine code},
197 code designed to be efficiently translated and processed
198 by a machine such as your computer.
199 Humans usually aren't as good writing machine code
200 as they are at writing Fortran (or C++, Ada, or Java),
201 because is easy to make tiny mistakes writing machine code.
202
203 @item
204 Provide the user with information about the reasons why
205 the compiler is unable to create a binary from the source code.
206 Usually this will be the case if the source code is flawed.
207 When writing Fortran, it is easy to make big mistakes.
208 The Fortran 90 requires that the compiler can point out
209 mistakes to the user.
210 An incorrect usage of the language causes an @dfn{error message}.
211
212 The compiler will also attempt to diagnose cases where the
213 user's program contains a correct usage of the language,
214 but instructs the computer to do something questionable.
215 This kind of diagnostics message is called a @dfn{warning message}.
216
217 @item
218 Provide optional information about the translation passes
219 from the source code to machine code.
220 This can help a user of the compiler to find the cause of
221 certain bugs which may not be obvious in the source code,
222 but may be more easily found at a lower level compiler output.
223 It also helps developers to find bugs in the compiler itself.
224
225 @item
226 Provide information in the generated machine code that can
227 make it easier to find bugs in the program (using a debugging tool,
228 called a @dfn{debugger}, such as the GNU Debugger @command{gdb}). 
229
230 @item
231 Locate and gather machine code already generated to
232 perform actions requested by statements in the user's program.
233 This machine code is organized into @dfn{modules} and is located
234 and @dfn{linked} to the user program. 
235 @end itemize
236
237 Gfortran consists of several components:
238
239 @itemize @bullet
240 @item
241 A version of the @command{gcc} command
242 (which also might be installed as the system's @command{cc} command)
243 that also understands and accepts Fortran source code.
244 The @command{gcc} command is the @dfn{driver} program for
245 all the languages in the GNU Compiler Collection (GCC);
246 With @command{gcc},
247 you can compiler the source code of any language for
248 which a front end is available in GCC.
249
250 @item
251 The @command{gfortran} command itself,
252 which also might be installed as the
253 system's @command{f95} command.
254 @command{gfortran} is just another driver program,
255 but specifically for the Fortran 95 compiler only.
256 The difference with @command{gcc} is that @command{gfortran}
257 will automatically link the correct libraries to your program.
258
259 @item
260 A collection of run-time libraries.
261 These libraries contains the machine code needed to support
262 capabilities of the Fortran language that are not directly
263 provided by the machine code generated by the
264 @command{gfortran} compilation phase,
265 such as intrinsic functions and subroutines,
266 and routines for interaction with files and the operating system.
267 @c and mechanisms to spawn,
268 @c unleash and pause threads in parallelized code.
269
270 @item
271 The Fortran compiler itself, (@command{f951}).
272 This is the gfortran parser and code generator,
273 linked to and interfaced with the GCC backend library.
274 @command{f951} ``translates'' the source code to
275 assembler code.  You would typically not use this
276 program directly;
277 instead, the @command{gcc} or @command{gfortran} driver
278 programs will call it for you.
279 @end itemize
280
281
282
283 @c ---------------------------------------------------------------------
284 @c GFORTRAN and GCC
285 @c ---------------------------------------------------------------------
286
287 @node GFORTRAN and GCC
288 @chapter GFORTRAN and GCC
289 @cindex GNU Compiler Collection
290
291 GCC used to be the GNU ``C'' Compiler,
292 but is now known as the @dfn{GNU Compiler Collection}.
293 GCC provides the GNU system with a very versatile
294 compiler middle end (shared optimization passes),
295 and with back ends (code generators) for many different
296 computer architectures and operating systems.
297 The code of the middle end and back end are shared by all
298 compiler front ends that are in the GNU Compiler Collection.
299
300 A GCC front end is essentially a source code parser
301 and a pass to generate a representation of the semantics
302 of the program in the source code in the GCC language
303 independent intermediate language,
304 called @dfn{GENERIC}.
305
306 The parser takes a source file written in a
307 particular computer language, reads and parses it,
308 and tries to make sure that the source code conforms to
309 the language rules.
310 Once the correctness of a program has been established,
311 the compiler will build a data structure known as the
312 @dfn{Abstract Syntax tree},
313 or just @dfn{AST} or ``tree'' for short.
314 This data structure represents the whole program
315 or a subroutine or a function.
316 The ``tree'' is passed to the GCC middle end,
317 which will perform optimization passes on it,
318 pass the optimized AST and generate assembly
319 for the program unit.
320
321 Different phases in this translation process can be,
322 and in fact @emph{are} merged in many compiler front ends.
323 GNU Fortran 95 has a strict separation between the
324 parser and code generator.
325
326 The goal of the gfortran project is to build a new front end for GCC:
327 A Fortran 95 front end.
328 In a non-gfortran installation,
329 @command{gcc} will not be able to compile Fortran 95 source code
330 (only the ``C'' front end has to be compiled if you want to build GCC,
331 all other languages are optional).
332 If you build GCC with gfortran, @command{gcc} will recognize
333 @file{.f/.f90/.f95} source files and accepts Fortran 95 specific
334 command line options.
335
336
337
338 @c ---------------------------------------------------------------------
339 @c GFORTRAN and G77
340 @c ---------------------------------------------------------------------
341
342 @node GFORTRAN and G77
343 @chapter GFORTRAN and G77
344 @cindex Fortran 77
345 @cindex G77
346
347 Why do we write a compiler front end from scratch? 
348 There's a fine Fortran 77 compiler in the
349 GNU Compiler Collection that accepts some features
350 of the Fortran 90 standard as extensions.
351 Why not start from there and revamp it?
352
353 One of the reasons is that Craig Burley, the author of G77,
354 has decided to stop working on the G77 front end.
355 On @uref{http://world.std.com/~burley/g77-why.html,
356 Craig explains the reasons for his decision to stop working on G77}
357 in one of the pages in his homepage.
358 Among the reasons is a lack of interest in improvements to
359 @command{g77}.
360 Users appear to be quite satisfied with @command{g77} as it is.
361 While @command{g77} is still being maintained (by Toon Moene),
362 it is unlikely that sufficient people will be willing
363 to completely rewrite the existing code. 
364
365 But there are other reasons to start from scratch.
366 Many people, including Craig Burley,
367 no longer agreed with certain design decisions in the G77 front end.
368 Also, the interface of @command{g77} to the back end is written in
369 a style which is confusing and not up to date on recommended practice.
370 In fact, a full rewrite had already been planned for GCC 3.0.
371
372 When Craig decided to stop,
373 it just seemed to be a better idea to start a new project from scratch,
374 because it was expected to be easier to maintain code we
375 develop ourselves than to do a major overhaul of @command{g77} first,
376 and then build a Fortran 95 compiler out of it.
377
378 @include invoke.texi
379
380 @c ---------------------------------------------------------------------
381 @c Project Status
382 @c ---------------------------------------------------------------------
383
384 @node Project Status
385 @chapter Project Status
386
387 @quotation
388 As soon as gfortran can parse all of the statements correctly,
389 it will be in the ``larva'' state.
390 When we generate code, the ``puppa'' state.
391 When gfortran is done,
392 we'll see if it will be a beautiful butterfly,
393 or just a big bug....
394
395 --Andy Vaught, April 2000
396 @end quotation
397
398 The start of the GNU Fortran 95 project was announced on
399 the GCC homepage in March 18, 2000
400 (even though Andy had already been working on it for a while,
401 or course).
402
403 Gfortran is currently reaching the stage where is is able to compile real
404 world programs.  However it is still under development and has many rough
405 edges.
406
407 @menu
408 * Compiler Status::
409 * Library Status::
410 * Proposed Extensions::
411 @end menu
412
413 @node Compiler Status
414 @section Compiler Status
415
416 @table @emph
417 @item Front end
418 This is the part of gfortran which parses a source file, verifies that it
419 is valid Fortran 95, performs compile time replacement of constants
420 (PARAMETER variables) and reads and generate module files. This is
421 almost complete. Every Fortran 95 source should be accepted, and most
422 none-Fortran 95 source should be rejected. If you find a source file where
423 this is not true, please tell us. You can use the -fsyntax-only switch to
424 make gfortran quit after running the front end, effectively reducing it to
425 a syntax checker.
426
427 @item Middle end interface
428 These are the parts of gfortran that take the parse tree generated by the
429 front end and translate it to the GENERIC form required by the GCC back
430 end. Work is ongoing in these parts of gfortran, but a large part has
431 already been completed.
432 @end table
433
434 @node Library Status
435 @section Library Status
436
437 Some intrinsic functions map directly to library functions, and in most
438 cases the name of the library function used depends on the type of the
439 arguments.  For some intrinsics we generate inline code, and for others,
440 such as sin, cos and sqrt, we rely on the backend to use special
441 instructions in the floating point unit of the CPU if available, or to
442 fall back to a call to libm if these are not available.
443
444 Implementation of some non-elemental intrinsic functions (eg. DOT_PRODUCT,
445 AVERAGE) is not yet optimal. This is hard because we have to make decisions
446 whether to use inline code (good for small arrays as no function call
447 overhead occurs) or generate function calls (good for large arrays as it
448 allows use of hand-optimized assembly routines, SIMD instructions, etc.)
449
450 The IO library is still under development.  The following features should be
451 usable for real programs:
452
453 @itemize @minus
454 @item List directed
455 @item Unformatted sequential
456 @end itemize
457
458 Usable with bugs:
459
460 @itemize @minus
461 @item Formatted sequential ('T' edit descriptor, and others)
462 @end itemize
463
464 Not recommended:
465
466 @itemize @minus
467 @item Unformatted direct access
468 @item Formatted direct access
469 @end itemize
470
471 Many Fortran programs only use a small subset of the available IO
472 capabilities, so your mileage may vary.
473
474 @node Proposed Extensions
475 @section Proposed Extensions
476
477 Here's a list of proposed extensions for @command{gfortran}, in no particular
478 order.  Most of these are necessary to be fully compatible with
479 existing Fortran compilers, but they are not part of the official
480 J3 Fortran 95 standard.
481
482 @subsection Compiler extensions: 
483 @itemize @bullet
484 @item
485 Flag for defining the kind number for default logicals.
486
487 @item
488 User-specified alignment rules for structures.
489 @item
490 Flag to generate a @code{Makefile} info.
491
492 @item
493 Automatically extend single precision constants to double.
494
495 @item
496 Cray pointers (this was high on the @command{g77} wishlist).
497
498 @item
499 Compile code that conserves memory by dynamically allocating common and
500 module storage either on stack or heap.
501
502 @item
503 Flag to cause the compiler to distinguish between upper and lower case
504 names.  The Fortran 95 standard does not distinguish them.
505
506 @item
507 Compile switch for changing the interpretation of a backslash from a
508 character to ``C''-style escape characters.
509
510 @item
511 Compile flag to generate code for array conformance checking (suggest -CC).
512
513 @item
514 User control of symbol names (underscores, etc).
515
516 @item
517 Compile setting for maximum size of stack frame size before spilling
518 parts to static or heap.
519
520 @item
521 Flag to force local variables into static space.
522
523 @item
524 Flag to force local variables onto stack.
525
526 @item
527 Flag to compile lines beginning with ``D''.
528
529 @item
530 Flag to ignore lines beginning with ``D''.
531
532 @item
533 Flag for maximum errors before ending compile.
534
535 @item
536 Generate code to check for null pointer dereferences -- prints locus of
537 dereference instead of segfaulting.  There was some discussion about this
538 option in the g95 development mailing list.
539
540 @item
541 Allow setting default unit number.
542
543 @item
544 Option to initialize of otherwise uninitialized integer and floating
545 point variables.
546
547 @item
548 Support for OpenMP directives.  This also requires support from the runtime
549 library and the rest of the compiler.
550
551 @item
552 Support for Fortran 200x. This includes several new features including
553 floating point exceptions, extended use of allocatable arrays, C
554 interoperability, Parameterizer data types and function pointers.
555 @end itemize
556
557
558 @subsection Environment Options
559 @itemize @bullet
560 @item
561 Pluggable library modules for random numbers, linear algebra.
562 LA should use BLAS calling conventions.
563
564 @item
565 Environment variables controlling actions on arithmetic exceptions like
566 overflow, underflow, precision loss -- Generate NaN, abort, default.
567 action.
568
569 @item
570 Set precision for fp units that support it (i387).
571
572 @item
573 Variables for setting fp rounding mode.
574
575 @item
576 Variable to fill uninitialized variables with a user-defined bit
577 pattern.
578
579 @item
580 Environment variable controlling filename that is opened for that unit
581 number.
582
583 @item
584 Environment variable to clear/trash memory being freed.
585
586 @item
587 Environment variable to control tracing of allocations and frees.
588
589 @item
590 Environment variable to display allocated memory at normal program end.
591
592 @item
593 Environment variable for filename for * IO-unit.
594
595 @item
596 Environment variable for temporary file directory.
597
598 @item
599 Environment variable forcing standard output to be line buffered (unix).
600
601 @item
602 Variable for swapping endianness during unformatted read.
603
604 @item
605 Variable for swapping Endianness during unformatted write.
606 @end itemize
607
608 @c ---------------------------------------------------------------------
609 @c Extensions
610 @c ---------------------------------------------------------------------
611
612 @c Maybe this chapter should be merged with the 'Standards' section,
613 @c whenever that is written :-)
614
615 @node Extensions
616 @chapter Extensions
617 @cindex Extension
618
619 @command{gfortran} implements a number of extensions over standard
620 Fortran. This chapter contains information on their syntax and
621 meaning.
622
623 @menu
624 * Old-style kind specifications::
625 * Old-style variable initialization::
626 * Extensions to namelist::
627 @end menu
628
629 @node Old-style kind specifications
630 @section Old-style kind specifications
631 @cindex Kind specifications
632
633 @command{gfortran} allows old-style kind specifications in
634 declarations. These look like:
635 @smallexample
636       TYPESPEC*k x,y,z
637 @end smallexample
638 where @code{TYPESPEC} is a basic type, and where @code{k} is a valid kind
639 number for that type. The statement then declares @code{x}, @code{y}
640 and @code{z} to be of type @code{TYPESPEC} with kind @code{k}. In
641 other words, it is equivalent to the standard conforming declaration
642 @smallexample
643       TYPESPEC(k) x,y,z
644 @end smallexample
645
646 @node Old-style variable initialization
647 @section Old-style variable initialization
648 @cindex Initialization
649
650 @command{gfortran} allows old-style initialization of variables of the
651 form:
652 @smallexample
653       INTEGER*4 i/1/,j/2/
654       REAL*8 x(2,2) /3*0.,1./
655 @end smallexample
656 These are only allowed in declarations without double colons
657 (@code{::}), as these were introduced in Fortran 90 which also
658 introduced a new syntax for variable initializations. The syntax for
659 the individual initializers is as for the @code{DATA} statement, but
660 unlike in a @code{DATA} statement, an initializer only applies to the
661 variable immediately preceding. In other words, something like
662 @code{INTEGER I,J/2,3/} is not valid.
663
664 Examples of standard conforming code equivalent to the above example, are:
665 @smallexample
666 ! Fortran 90
667       INTEGER(4) :: i = 1, j = 2
668       REAL(8) :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
669 ! Fortran 77
670       INTEGER  i, j
671       DOUBLE PRECISION x(2,2)
672       DATA i,j,x /1,2,3*0.,1./
673 @end smallexample
674
675 @node Extensions to namelist
676 @section Extensions to namelist
677 @cindex Namelist
678
679 @command{gfortran} fully supports the fortran95 standard for namelist io
680 including array qualifiers, substrings and fully qualified derived types.
681 The output from a namelist write is compatible with namelist read.  The
682 output has all names in upper case and indentation to column 1 after the
683 namelist name.  Two extensions are permitted:
684
685 Old-style use of $ instead of &
686 @smallexample
687 $MYNML
688  X(:)%Y(2) = 1.0 2.0 3.0
689  CH(1:4) = "abcd"
690 $END
691 @end smallexample
692
693 It should be noticed that the default terminator is / rather than &END.
694
695 Querying of the namelist when inputting from stdin. After at least
696 one space, entering ? sends to stdout the namelist name and the names of
697 the variables in the namelist:
698 @smallexample
699 ?
700
701 &mynml
702  x
703  x%y
704  ch
705 &end
706 @end smallexample
707
708 Entering =? outputs the namelist to stdout, as if WRITE (*,NML = mynml)
709 had been called:
710 @smallexample
711 =?
712
713 &MYNML
714  X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
715  X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
716  X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
717  CH=abcd,  /
718 @end smallexample
719
720 To aid this dialog, when input is from stdin, errors produce send their
721 messages to stderr and execution continues, even if IOSTAT is set.
722
723 @include intrinsic.texi
724 @c ---------------------------------------------------------------------
725 @c Contributing
726 @c ---------------------------------------------------------------------
727
728 @node Contributing
729 @chapter Contributing
730 @cindex Contributing
731
732 Free software is only possible if people contribute to efforts
733 to create it.
734 We're always in need of more people helping out with ideas
735 and comments, writing documentation and contributing code.
736
737 If you want to contribute to GNU Fortran 95,
738 have a look at the long lists of projects you can take on.
739 Some of these projects are small,
740 some of them are large;
741 some are completely orthogonal to the rest of what is
742 happening on @command{gfortran},
743 but others are ``mainstream'' projects in need of enthusiastic hackers.
744 All of these projects are important!
745 We'll eventually get around to the things here,
746 but they are also things doable by someone who is willing and able.
747
748 @menu
749 * Contributors::
750 * Projects::
751 @end menu
752
753
754 @node Contributors
755 @section Contributors to GNU Fortran 95
756 @cindex Contributors
757 @cindex Credits
758 @cindex Authors
759
760 Most of the parser was hand-crafted by @emph{Andy Vaught}, who is
761 also the initiator of the whole project.  Thanks Andy!
762 Most of the interface with GCC was written by @emph{Paul Brook}.
763
764 The following individuals have contributed code and/or
765 ideas and significant help to the gfortran project
766 (in no particular order): 
767
768 @itemize @minus
769 @item Andy Vaught
770 @item Katherine Holcomb
771 @item Tobias Schlüter
772 @item Steven Bosscher
773 @item Toon Moene
774 @item Tim Prince
775 @item Niels Kristian Bech Jensen
776 @item Steven Johnson
777 @item Paul Brook
778 @item Feng Wang
779 @item Bud Davis
780 @end itemize
781
782 The following people have contributed bug reports,
783 smaller or larger patches,
784 and much needed feedback and encouragement for the
785 @command{gfortran} project: 
786
787 @itemize @minus
788 @item Erik Schnetter
789 @item Bill Clodius
790 @item Kate Hedstrom
791 @end itemize
792
793 Many other individuals have helped debug,
794 test and improve @command{gfortran} over the past two years,
795 and we welcome you to do the same!
796 If you already have done so,
797 and you would like to see your name listed in the
798 list above, please contact us.
799
800
801 @node Projects
802 @section Projects
803
804 @table @emph
805
806 @item Help build the test suite
807 Solicit more code for donation to the test suite.
808 We can keep code private on request.
809
810 @item Bug hunting/squishing
811 Find bugs and write more test cases!
812 Test cases are especially very welcome,
813 because it allows us to concentrate on fixing bugs
814 instead of isolating them.
815
816 @item Smaller projects (``bug'' fixes):
817   @itemize @minus
818   @item Allow init exprs to be numbers raised to integer powers.
819   @item Implement correct rounding.
820   @item Implement F restrictions on Fortran 95 syntax.
821   @item See about making Emacs-parsable error messages.
822   @end itemize
823 @end table
824
825 If you wish to work on the runtime libraries,
826 please contact a project maintainer.
827 @c TODO: email!
828
829
830 @c ---------------------------------------------------------------------
831 @c Standards
832 @c ---------------------------------------------------------------------
833
834 @node Standards
835 @chapter Standards
836 @cindex Standards
837
838 The GNU Fortran 95 Compiler aims to be a conforming implementation of
839 ISO/IEC 1539:1997 (Fortran 95).
840
841 In the future it may also support other variants and extensions to the Fortran
842 language.  This includes ANSI Fortran 77, Fortran 90, Fortran 2000 (not yet
843 finalized), and OpenMP.
844
845 @node Index
846 @unnumbered Index
847
848 @printindex cp
849
850 @bye