OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [fortran/] [gfortran.texi] - Blame information for rev 12

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 12 jlechner
\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
51 Franklin Street, Fifth Floor
73
Boston, MA 02110-1301 USA
74
 
75
@insertcopying
76
@end ifinfo
77
 
78
 
79
@setchapternewpage odd
80
@titlepage
81
@title Using GNU Fortran 95
82
@sp 2
83
@center The gfortran team
84
@page
85
@vskip 0pt plus 1filll
86
For the @value{version-GCC} Version*
87
@sp 1
88
Published by the Free Software Foundation @*
89
51 Franklin Street, Fifth Floor@*
90
Boston, MA 02110-1301, USA@*
91
@c Last printed ??ber, 19??.@*
92
@c Printed copies are available for $? each.@*
93
@c ISBN ???
94
@sp 1
95
@insertcopying
96
@end titlepage
97
@summarycontents
98
@contents
99
@page
100
 
101
@node Top
102
@top Introduction
103
@cindex Introduction
104
 
105
This manual documents the use of @command{gfortran},
106
the GNU Fortran 95 compiler. You can find in this manual how to invoke
107
@command{gfortran}, as well as its features and incompatibilities.
108
 
109
@ifset DEVELOPMENT
110
@emph{Warning:} This document, and the compiler it describes, are still
111
under development.  While efforts are made to keep it up-to-date, it might
112
not accurately reflect the status of the most recent @command{gfortran}.
113
@end ifset
114
 
115
@comment
116
@comment  When you add a new menu item, please keep the right hand
117
@comment  aligned to the same column.  Do not use tabs.  This provides
118
@comment  better formatting.
119
@comment
120
@menu
121
* Getting Started::      What you should know about @command{gfortran}.
122
* GFORTRAN and GCC::     You can compile Fortran, C, or other programs.
123
* GFORTRAN and G77::     Why we chose to start from scratch.
124
* Invoking GFORTRAN::    Command options supported by @command{gfortran}.
125
* Project Status::       Status of @command{gfortran}, roadmap, proposed extensions.
126
* Contributing::         How you can help.
127
* Standards::            Standards supported by @command{gfortran}
128
* Runtime::              Influencing runtime behavior with environment variables.
129
* Extensions::           Language extensions implemented by @command{gfortran}
130
* Intrinsic Procedures:: Intrinsic procedures supported by @command{gfortran}
131
* Copying::              GNU General Public License says
132
                         how you can copy and share GNU Fortran.
133
* GNU Free Documentation License::
134
                         How you can copy and share this manual.
135
* Funding::              How to help assure continued work for free software.
136
* Index::                Index of this documentation.
137
@end menu
138
 
139
 
140
 
141
@c ---------------------------------------------------------------------
142
@c Getting Started
143
@c ---------------------------------------------------------------------
144
 
145
@node Getting Started
146
@chapter Getting Started
147
 
148
Gfortran is the GNU Fortran 95 compiler front end,
149
designed initially as a free replacement for,
150
or alternative to, the unix @command{f95} command;
151
@command{gfortran} is the command you'll use to invoke the compiler.
152
 
153
Gfortran is still in an early state of development.
154
@command{gfortran} can generate code for most constructs and expressions,
155
but much work remains to be done.
156
 
157
When @command{gfortran} is finished,
158
it will do everything you expect from any decent compiler:
159
 
160
@itemize @bullet
161
@item
162
Read a user's program,
163
stored in a file and containing instructions written
164
in Fortran 77, Fortran 90 or Fortran 95.
165
This file contains @dfn{source code}.
166
 
167
@item
168
Translate the user's program into instructions a computer
169
can carry out more quickly than it takes to translate the
170
instructions in the first
171
place.  The result after compilation of a program is
172
@dfn{machine code},
173
code designed to be efficiently translated and processed
174
by a machine such as your computer.
175
Humans usually aren't as good writing machine code
176
as they are at writing Fortran (or C++, Ada, or Java),
177
because is easy to make tiny mistakes writing machine code.
178
 
179
@item
180
Provide the user with information about the reasons why
181
the compiler is unable to create a binary from the source code.
182
Usually this will be the case if the source code is flawed.
183
When writing Fortran, it is easy to make big mistakes.
184
The Fortran 90 requires that the compiler can point out
185
mistakes to the user.
186
An incorrect usage of the language causes an @dfn{error message}.
187
 
188
The compiler will also attempt to diagnose cases where the
189
user's program contains a correct usage of the language,
190
but instructs the computer to do something questionable.
191
This kind of diagnostics message is called a @dfn{warning message}.
192
 
193
@item
194
Provide optional information about the translation passes
195
from the source code to machine code.
196
This can help a user of the compiler to find the cause of
197
certain bugs which may not be obvious in the source code,
198
but may be more easily found at a lower level compiler output.
199
It also helps developers to find bugs in the compiler itself.
200
 
201
@item
202
Provide information in the generated machine code that can
203
make it easier to find bugs in the program (using a debugging tool,
204
called a @dfn{debugger}, such as the GNU Debugger @command{gdb}).
205
 
206
@item
207
Locate and gather machine code already generated to
208
perform actions requested by statements in the user's program.
209
This machine code is organized into @dfn{modules} and is located
210
and @dfn{linked} to the user program.
211
@end itemize
212
 
213
Gfortran consists of several components:
214
 
215
@itemize @bullet
216
@item
217
A version of the @command{gcc} command
218
(which also might be installed as the system's @command{cc} command)
219
that also understands and accepts Fortran source code.
220
The @command{gcc} command is the @dfn{driver} program for
221
all the languages in the GNU Compiler Collection (GCC);
222
With @command{gcc},
223
you can compile the source code of any language for
224
which a front end is available in GCC.
225
 
226
@item
227
The @command{gfortran} command itself,
228
which also might be installed as the
229
system's @command{f95} command.
230
@command{gfortran} is just another driver program,
231
but specifically for the Fortran 95 compiler only.
232
The difference with @command{gcc} is that @command{gfortran}
233
will automatically link the correct libraries to your program.
234
 
235
@item
236
A collection of run-time libraries.
237
These libraries contain the machine code needed to support
238
capabilities of the Fortran language that are not directly
239
provided by the machine code generated by the
240
@command{gfortran} compilation phase,
241
such as intrinsic functions and subroutines,
242
and routines for interaction with files and the operating system.
243
@c and mechanisms to spawn,
244
@c unleash and pause threads in parallelized code.
245
 
246
@item
247
The Fortran compiler itself, (@command{f951}).
248
This is the gfortran parser and code generator,
249
linked to and interfaced with the GCC backend library.
250
@command{f951} ``translates'' the source code to
251
assembler code.  You would typically not use this
252
program directly;
253
instead, the @command{gcc} or @command{gfortran} driver
254
programs will call it for you.
255
@end itemize
256
 
257
 
258
 
259
@c ---------------------------------------------------------------------
260
@c GFORTRAN and GCC
261
@c ---------------------------------------------------------------------
262
 
263
@node GFORTRAN and GCC
264
@chapter GFORTRAN and GCC
265
@cindex GNU Compiler Collection
266
 
267
GCC used to be the GNU ``C'' Compiler,
268
but is now known as the @dfn{GNU Compiler Collection}.
269
GCC provides the GNU system with a very versatile
270
compiler middle end (shared optimization passes),
271
and back ends (code generators) for many different
272
computer architectures and operating systems.
273
The code of the middle end and back end are shared by all
274
compiler front ends that are in the GNU Compiler Collection.
275
 
276
A GCC front end is essentially a source code parser
277
and an intermediate code generator.  The code generator translates the
278
semantics of the source code into a language independent form called
279
@dfn{GENERIC}.
280
 
281
The parser takes a source file written in a
282
particular computer language, reads and parses it,
283
and tries to make sure that the source code conforms to
284
the language rules.
285
Once the correctness of a program has been established,
286
the compiler will build a data structure known as the
287
@dfn{Abstract Syntax tree},
288
or just @dfn{AST} or ``tree'' for short.
289
This data structure represents the whole program
290
or a subroutine or a function.
291
The ``tree'' is passed to the GCC middle end,
292
which will perform optimization passes on it.  The optimized AST is then
293
handed off too the back end which assembles the program unit.
294
 
295
Different phases in this translation process can be,
296
and in fact @emph{are} merged in many compiler front ends.
297
GNU Fortran 95 has a strict separation between the
298
parser and code generator.
299
 
300
The goal of the gfortran project is to build a new front end for GCC.
301
Specifically, a Fortran 95 front end.
302
In a non-gfortran installation,
303
@command{gcc} will not be able to compile Fortran 95 source code
304
(only the ``C'' front end has to be compiled if you want to build GCC,
305
all other languages are optional).
306
If you build GCC with gfortran, @command{gcc} will recognize
307
@file{.f/.f90/.f95} source files and accepts Fortran 95 specific
308
command line options.
309
 
310
 
311
 
312
@c ---------------------------------------------------------------------
313
@c GFORTRAN and G77
314
@c ---------------------------------------------------------------------
315
 
316
@node GFORTRAN and G77
317
@chapter GFORTRAN and G77
318
@cindex Fortran 77
319
@cindex G77
320
 
321
Why do we write a compiler front end from scratch?
322
There's a fine Fortran 77 compiler in the
323
GNU Compiler Collection that accepts some features
324
of the Fortran 90 standard as extensions.
325
Why not start from there and revamp it?
326
 
327
One of the reasons is that Craig Burley, the author of G77,
328
has decided to stop working on the G77 front end.
329
On @uref{http://world.std.com/~burley/g77-why.html,
330
Craig explains the reasons for his decision to stop working on G77}
331
in one of the pages in his homepage.
332
Among the reasons is a lack of interest in improvements to
333
@command{g77}.
334
Users appear to be quite satisfied with @command{g77} as it is.
335
While @command{g77} is still being maintained (by Toon Moene),
336
it is unlikely that sufficient people will be willing
337
to completely rewrite the existing code.
338
 
339
But there are other reasons to start from scratch.
340
Many people, including Craig Burley,
341
no longer agreed with certain design decisions in the G77 front end.
342
Also, the interface of @command{g77} to the back end is written in
343
a style which is confusing and not up to date on recommended practice.
344
In fact, a full rewrite had already been planned for GCC 3.0.
345
 
346
When Craig decided to stop,
347
it just seemed to be a better idea to start a new project from scratch,
348
because it was expected to be easier to maintain code we
349
develop ourselves than to do a major overhaul of @command{g77} first,
350
and then build a Fortran 95 compiler out of it.
351
 
352
@include invoke.texi
353
 
354
@c ---------------------------------------------------------------------
355
@c Project Status
356
@c ---------------------------------------------------------------------
357
 
358
@node Project Status
359
@chapter Project Status
360
 
361
@quotation
362
As soon as gfortran can parse all of the statements correctly,
363
it will be in the ``larva'' state.
364
When we generate code, the ``puppa'' state.
365
When gfortran is done,
366
we'll see if it will be a beautiful butterfly,
367
or just a big bug....
368
 
369
--Andy Vaught, April 2000
370
@end quotation
371
 
372
The start of the GNU Fortran 95 project was announced on
373
the GCC homepage in March 18, 2000
374
(even though Andy had already been working on it for a while,
375
of course).
376
 
377
Gfortran is currently reaching the stage where is is able to compile real
378
world programs.  However it is still under development and has many rough
379
edges.
380
 
381
@menu
382
* Compiler Status::
383
* Library Status::
384
* Proposed Extensions::
385
@end menu
386
 
387
@node Compiler Status
388
@section Compiler Status
389
 
390
@table @emph
391
@item Front end
392
This is the part of gfortran which parses a source file, verifies that it
393
is valid Fortran 95, performs compile time replacement of constants
394
(PARAMETER variables) and reads and generate module files. This is
395
almost complete. Every Fortran 95 source should be accepted, and most
396
none-Fortran 95 source should be rejected. If you find a source file where
397
this is not true, please tell us. You can use the -fsyntax-only switch to
398
make gfortran quit after running the front end, effectively reducing it to
399
a syntax checker.
400
 
401
@item Middle end interface
402
These are the parts of gfortran that take the parse tree generated by the
403
front end and translate it to the GENERIC form required by the GCC back
404
end. Work is ongoing in these parts of gfortran, but a large part has
405
already been completed.
406
@end table
407
 
408
@node Library Status
409
@section Library Status
410
 
411
Some intrinsic functions map directly to library functions, and in most
412
cases the name of the library function used depends on the type of the
413
arguments.  For some intrinsics we generate inline code, and for others,
414
such as sin, cos and sqrt, we rely on the backend to use special
415
instructions in the floating point unit of the CPU if available, or to
416
fall back to a call to libm if these are not available.
417
 
418
Implementation of some non-elemental intrinsic functions (eg. DOT_PRODUCT,
419
AVERAGE) is not yet optimal. This is hard because we have to make decisions
420
whether to use inline code (good for small arrays as no function call
421
overhead occurs) or generate function calls (good for large arrays as it
422
allows use of hand-optimized assembly routines, SIMD instructions, etc.)
423
 
424
The IO library is in a mostly usable state.  Unformatted I/O for
425
@code{REAL(KIND=10)} variables is currently not recommended.
426
 
427
Array intrinsics mostly work.
428
 
429
@node Proposed Extensions
430
@section Proposed Extensions
431
 
432
Here's a list of proposed extensions for @command{gfortran}, in no particular
433
order.  Most of these are necessary to be fully compatible with
434
existing Fortran compilers, but they are not part of the official
435
J3 Fortran 95 standard.
436
 
437
@subsection Compiler extensions:
438
@itemize @bullet
439
@item
440
Flag for defining the kind number for default logicals.
441
 
442
@item
443
User-specified alignment rules for structures.
444
@item
445
Flag to generate @code{Makefile} info.
446
 
447
@item
448
Automatically extend single precision constants to double.
449
 
450
@item
451
Compile code that conserves memory by dynamically allocating common and
452
module storage either on stack or heap.
453
 
454
@item
455
Flag to cause the compiler to distinguish between upper and lower case
456
names.  The Fortran 95 standard does not distinguish them.
457
 
458
@item
459
Compile flag to generate code for array conformance checking (suggest -CC).
460
 
461
@item
462
User control of symbol names (underscores, etc).
463
 
464
@item
465
Compile setting for maximum size of stack frame size before spilling
466
parts to static or heap.
467
 
468
@item
469
Flag to force local variables into static space.
470
 
471
@item
472
Flag to force local variables onto stack.
473
 
474
@item
475
Flag to compile lines beginning with ``D''.
476
 
477
@item
478
Flag to ignore lines beginning with ``D''.
479
 
480
@item
481
Flag for maximum errors before ending compile.
482
 
483
@item
484
Generate code to check for null pointer dereferences -- prints locus of
485
dereference instead of segfaulting.  There was some discussion about this
486
option in the g95 development mailing list.
487
 
488
@item
489
Allow setting the default unit number.
490
 
491
@item
492
Option to initialize otherwise uninitialized integer and floating
493
point variables.
494
 
495
@item
496
Support for OpenMP directives.  This also requires support from the runtime
497
library and the rest of the compiler.
498
 
499
@item
500
Support for Fortran 200x. This includes several new features including
501
floating point exceptions, extended use of allocatable arrays, C
502
interoperability, Parameterizer data types and function pointers.
503
@end itemize
504
 
505
 
506
@subsection Environment Options
507
@itemize @bullet
508
@item
509
Pluggable library modules for random numbers, linear algebra.
510
LA should use BLAS calling conventions.
511
 
512
@item
513
Environment variables controlling actions on arithmetic exceptions like
514
overflow, underflow, precision loss -- Generate NaN, abort, default.
515
action.
516
 
517
@item
518
Set precision for fp units that support it (i387).
519
 
520
@item
521
Variable for setting fp rounding mode.
522
 
523
@item
524
Variable to fill uninitialized variables with a user-defined bit
525
pattern.
526
 
527
@item
528
Environment variable controlling filename that is opened for that unit
529
number.
530
 
531
@item
532
Environment variable to clear/trash memory being freed.
533
 
534
@item
535
Environment variable to control tracing of allocations and frees.
536
 
537
@item
538
Environment variable to display allocated memory at normal program end.
539
 
540
@item
541
Environment variable for filename for * IO-unit.
542
 
543
@item
544
Environment variable for temporary file directory.
545
 
546
@item
547
Environment variable forcing standard output to be line buffered (unix).
548
 
549
@end itemize
550
 
551
@node Runtime
552
@chapter Runtime:  Influencing runtime behavior with environment variables
553
@cindex Runtime
554
 
555
The behaviour of the @command{gfortran} can be influenced by
556
environment variables.
557
 
558
Malformed environment variables are silently ignored.
559
 
560
@menu
561
* GFORTRAN_STDIN_UNIT:: Unit number for standard input
562
* GFORTRAN_STDOUT_UNIT:: Unit number for standard output
563
* GFORTRAN_STDERR_UNIT:: Unit number for standard error
564
* GFORTRAN_USE_STDERR:: Send library output to standard error
565
* GFORTRAN_TMPDIR:: Directory for scratch files
566
* GFORTRAN_UNBUFFERED_ALL:: Don't buffer output
567
* GFORTRAN_SHOW_LOCUS::  Show location for runtime errors
568
* GFORTRAN_OPTIONAL_PLUS:: Print leading + where permitted
569
* GFORTRAN_DEFAULT_RECL:: Default record length for new files
570
* GFORTRAN_LIST_SEPARATOR::  Separator for list output
571
* GFORTRAN_CONVERT_UNIT::  Set endianness for unformatted I/O
572
@end menu
573
 
574
@node GFORTRAN_STDIN_UNIT
575
@section GFORTRAN_STDIN_UNIT -- Unit number for standard input
576
 
577
This environment variable can be used to select the unit number
578
preconnected to standard input.  This must be a positive integer.
579
The default value is 5.
580
 
581
@node GFORTRAN_STDOUT_UNIT
582
@section GFORTRAN_STDOUT_UNIT -- Unit number for standard output
583
 
584
This environment variable can be used to select the unit number
585
preconnected to standard output.  This must be a positive integer.
586
The default value is 6.
587
 
588
@node GFORTRAN_STDERR_UNIT
589
@section GFORTRAN_STDERR_UNIT -- Unit number for standard error
590
 
591
This environment variable can be used to select the unit number
592
preconnected to standard error.  This must be a positive integer.
593
The default value is 0.
594
 
595
@node GFORTRAN_USE_STDERR
596
@section GFORTRAN_USE_STDERR:: Send library output to standard error
597
 
598
This environment variable controls where library output is sent.
599
If the first letter is 'y', 'Y' or '1', standard error is used.
600
If the first letter is 'n', 'N' or '0', standard output is used.
601
 
602
@node GFORTRAN_TMPDIR
603
@section GFORTRAN_TMPDIR -- Directory for scratch files
604
 
605
This environment variable controls where scratch files are
606
created.  Default is '/tmp'.
607
 
608
@node GFORTRAN_UNBUFFERED_ALL
609
@section GFORTRAN_UNBUFFERED_ALL -- Don't buffer output
610
 
611
This environment variable controls wether all output is unbuffered.
612
If the first letter is 'y', 'Y' or '1', all output is unbuffered.
613
This will slow down large writes.  If the first letter is 'n', 'N' or '0',
614
output is bufferred.  This is the default.
615
 
616
@node GFORTRAN_SHOW_LOCUS
617
@section GFORTRAN_SHOW_LOCUS -- Show location for runtime errors
618
 
619
If the first letter is 'y', 'Y' or '1', filename and line numbers
620
for runtime errors are printed.  If the first letter is 'n', 'N'
621
or '0', don't print filename and line numbers for runtime errors.
622
The default is to print the location.
623
 
624
@node GFORTRAN_OPTIONAL_PLUS
625
@section GFORTRAN_OPTIONAL_PLUS -- Print leading + where permitted
626
 
627
If the first letter is 'y', 'Y' or '1', a plus sign is printed
628
where permitted by the Fortran standard.  If the first lettter
629
is 'n', 'N' or '0', a plus sign is not printed in most cases.
630
Default is not to print plus signs.
631
 
632
@node GFORTRAN_DEFAULT_RECL
633
@section GFORTRAN_DEFAULT_RECL -- Default record lenght for new files
634
 
635
This environment variable specifies the default record length for
636
files which are opened without a @code{RECL} tag in the @code{OPEN}
637
statement.  This must be a positive integer.  The default value is
638
1073741824.
639
 
640
@node GFORTRAN_LIST_SEPARATOR
641
@section GFORTRAN_LIST_SEPARATOR -- Separator for list output
642
 
643
This environment variable specifies the separator when writing
644
list-directed output.  It may contain any number of spaces and
645
at most one comma.  If you specify this on the command line,
646
be sure to quote spaces, as in
647
@smallexample
648
$ GFORTRAN_LIST_SEPARATOR='  ,  ' ./a.out
649
@end smallexample
650
when @code{a.out} is the gfortran program that you want to run.
651
Default is a single space.
652
 
653
@node GFORTRAN_CONVERT_UNIT
654
@section GFORTRAN_CONVERT_UNIT -- Set endianness for unformatted I/O
655
 
656
By setting the @code{GFORTRAN_CONVERT_UNIT variable}, it is possible
657
to change the representation of data for unformatted files.
658
The syntax for the @code{GFORTRAN_CONVERT_UNIT} variable is:
659
@smallexample
660
GFORTRAN_CONVERT_UNIT: mode | mode ';' exception ;
661
mode: 'native' | 'swap' | 'big_endian' | 'little_endian' ;
662
exception: mode ':' unit_list | unit_list ;
663
unit_list: unit_spec | unit_list unit_spec ;
664
unit_spec: INTEGER | INTEGER '-' INTEGER ;
665
@end smallexample
666
The variable consists of an optional default mode, followed by
667
a list of optional exceptions, which are separated by semicolons
668
from the preceding default and each other.  Each exception consists
669
of a format and a comma-separated list of units.  Valid values for
670
the modes are the same as for the @code{CONVERT} specifier:
671
 
672
@itemize @w{}
673
@item @code{NATIVE} Use the native format.  This is the default.
674
@item @code{SWAP} Swap between little- and big-endian.
675
@item @code{LITTLE_ENDIAN} Use the little-endian format
676
        for unformatted files.
677
@item @code{BIG_ENDIAN} Use the big-endian format for unformatted files.
678
@end itemize
679
A missing mode for an exception is taken to mean @code{BIG_ENDIAN}.
680
Examples of values for @code{GFORTRAN_CONVERT_UNIT} are:
681
@itemize @w{}
682
@item @code{'big_endian'}  Do all unformatted I/O in big_endian mode.
683
@item @code{'little_endian;native:10-20,25'}  Do all unformatted I/O
684
in little_endian mode, except for units 10 to 20 and 25, which are in
685
native format.
686
@item @code{'10-20'}  Units 10 to 20 are big-endian, the rest is native.
687
@end itemize
688
 
689
Setting the environment variables should be done on the command
690
line or via the @code{export}
691
command for @code{sh}-compatible shells and via @code{setenv}
692
for @code{csh}-compatible shells.
693
 
694
Example for @code{sh}:
695
@smallexample
696
$ gfortran foo.f90
697
$ GFORTRAN_CONVERT_UNIT='big_endian;native:10-20' ./a.out
698
@end smallexample
699
 
700
Example code for @code{csh}:
701
@smallexample
702
% gfortran foo.f90
703
% setenv GFORTRAN_CONVERT_UNIT 'big_endian;native:10-20'
704
% ./a.out
705
@end smallexample
706
 
707
Using anything but the native representation for unformatted data
708
carries a significant speed overhead.  If speed in this area matters
709
to you, it is best if you use this only for data that needs to be
710
portable.
711
 
712
@xref{CONVERT specifier}, for an alternative way to specify the
713
data representation for unformatted files.  @xref{Runtime Options}, for
714
setting a default data representation for the whole program.  The
715
@code{CONVERT} specifier overrides the @code{-fconvert} compile options.
716
 
717
@c ---------------------------------------------------------------------
718
@c Extensions
719
@c ---------------------------------------------------------------------
720
 
721
@c Maybe this chapter should be merged with the 'Standards' section,
722
@c whenever that is written :-)
723
 
724
@node Extensions
725
@chapter Extensions
726
@cindex Extension
727
 
728
@command{gfortran} implements a number of extensions over standard
729
Fortran. This chapter contains information on their syntax and
730
meaning.  There are currently two categories of @command{gfortran}
731
extensions, those that provide functionality beyond that provided
732
by any standard, and those that are supported by @command{gfortran}
733
purely for backward compatibility with legacy compilers.  By default,
734
@option{-std=gnu} allows the compiler to accept both types of
735
extensions, but to warn about the use of the latter.  Specifying
736
either @option{-std=f95} or @option{-std=f2003} disables both types
737
of extensions, and @option{-std=legacy} allows both without warning.
738
 
739
@menu
740
* Old-style kind specifications::
741
* Old-style variable initialization::
742
* Extensions to namelist::
743
* X format descriptor::
744
* Commas in FORMAT specifications::
745
* I/O item lists::
746
* Hexadecimal constants::
747
* Real array indices::
748
* Unary operators::
749
* Implicitly interconvert LOGICAL and INTEGER::
750
* Hollerith constants support::
751
* Cray pointers::
752
* CONVERT specifier::
753
@end menu
754
 
755
@node Old-style kind specifications
756
@section Old-style kind specifications
757
@cindex Kind specifications
758
 
759
@command{gfortran} allows old-style kind specifications in
760
declarations. These look like:
761
@smallexample
762
      TYPESPEC*k x,y,z
763
@end smallexample
764
where @code{TYPESPEC} is a basic type, and where @code{k} is a valid kind
765
number for that type. The statement then declares @code{x}, @code{y}
766
and @code{z} to be of type @code{TYPESPEC} with kind @code{k}. In
767
other words, it is equivalent to the standard conforming declaration
768
@smallexample
769
      TYPESPEC(k) x,y,z
770
@end smallexample
771
 
772
@node Old-style variable initialization
773
@section Old-style variable initialization
774
@cindex Initialization
775
 
776
@command{gfortran} allows old-style initialization of variables of the
777
form:
778
@smallexample
779
      INTEGER*4 i/1/,j/2/
780
      REAL*8 x(2,2) /3*0.,1./
781
@end smallexample
782
These are only allowed in declarations without double colons
783
(@code{::}), as these were introduced in Fortran 90 which also
784
introduced a new syntax for variable initializations. The syntax for
785
the individual initializers is as for the @code{DATA} statement, but
786
unlike in a @code{DATA} statement, an initializer only applies to the
787
variable immediately preceding. In other words, something like
788
@code{INTEGER I,J/2,3/} is not valid.
789
 
790
Examples of standard conforming code equivalent to the above example, are:
791
@smallexample
792
! Fortran 90
793
      INTEGER(4) :: i = 1, j = 2
794
      REAL(8) :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
795
! Fortran 77
796
      INTEGER  i, j
797
      DOUBLE PRECISION x(2,2)
798
      DATA i,j,x /1,2,3*0.,1./
799
@end smallexample
800
 
801
@node Extensions to namelist
802
@section Extensions to namelist
803
@cindex Namelist
804
 
805
@command{gfortran} fully supports the Fortran 95 standard for namelist I/O
806
including array qualifiers, substrings and fully qualified derived types.
807
The output from a namelist write is compatible with namelist read.  The
808
output has all names in upper case and indentation to column 1 after the
809
namelist name.  Two extensions are permitted:
810
 
811
Old-style use of $ instead of &
812
@smallexample
813
$MYNML
814
 X(:)%Y(2) = 1.0 2.0 3.0
815
 CH(1:4) = "abcd"
816
$END
817
@end smallexample
818
 
819
It should be noticed that the default terminator is / rather than &END.
820
 
821
Querying of the namelist when inputting from stdin. After at least
822
one space, entering ? sends to stdout the namelist name and the names of
823
the variables in the namelist:
824
@smallexample
825
?
826
 
827
&mynml
828
 x
829
 x%y
830
 ch
831
&end
832
@end smallexample
833
 
834
Entering =? outputs the namelist to stdout, as if WRITE (*,NML = mynml)
835
had been called:
836
@smallexample
837
=?
838
 
839
&MYNML
840
 X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
841
 X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
842
 X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
843
 CH=abcd,  /
844
@end smallexample
845
 
846
To aid this dialog, when input is from stdin, errors send their
847
messages to stderr and execution continues, even if IOSTAT is set.
848
 
849
PRINT namelist is permitted.  This causes an error if -std=f95 is used.
850
@smallexample
851
PROGRAM test_print
852
  REAL, dimension (4)  ::  x = (/1.0, 2.0, 3.0, 4.0/)
853
  NAMELIST /mynml/ x
854
  PRINT mynml
855
END PROGRAM test_print
856
@end smallexample
857
 
858
@node X format descriptor
859
@section X format descriptor
860
@cindex X format descriptor
861
 
862
To support legacy codes, @command{gfortran} permits the count field
863
of the X edit descriptor in FORMAT statements to be omitted.  When
864
omitted, the count is implicitly assumed to be one.
865
 
866
@smallexample
867
       PRINT 10, 2, 3
868
10     FORMAT (I1, X, I1)
869
@end smallexample
870
 
871
@node Commas in FORMAT specifications
872
@section Commas in FORMAT specifications
873
@cindex Commas in FORMAT specifications
874
 
875
To support legacy codes, @command{gfortran} allows the comma separator
876
to be omitted immediately before and after character string edit
877
descriptors in FORMAT statements.
878
 
879
@smallexample
880
       PRINT 10, 2, 3
881
10     FORMAT ('FOO='I1' BAR='I2)
882
@end smallexample
883
 
884
@node I/O item lists
885
@section I/O item lists
886
@cindex I/O item lists
887
 
888
To support legacy codes, @command{gfortran} allows the input item list
889
of the READ statement, and the output item lists of the WRITE and PRINT
890
statements to start with a comma.
891
 
892
@node Hexadecimal constants
893
@section Hexadecimal constants
894
@cindex Hexadecimal constants
895
 
896
As a GNU extension, @command{gfortran} allows hexadecimal constants to
897
be specified using the X prefix, in addition to the standard Z prefix.
898
 
899
@node Real array indices
900
@section Real array indices
901
@cindex Real array indices
902
 
903
As a GNU extension, @command{gfortran} allows arrays to be indexed using
904
real types, whose values are implicitly converted to integers.
905
 
906
@node Unary operators
907
@section Unary operators
908
@cindex Unary operators
909
 
910
As a GNU extension, @command{gfortran} allows unary plus and unary
911
minus operators to appear as the second operand of binary arithmetic
912
operators without the need for parenthesis.
913
 
914
@smallexample
915
       X = Y * -Z
916
@end smallexample
917
 
918
@node Implicitly interconvert LOGICAL and INTEGER
919
@section Implicitly interconvert LOGICAL and INTEGER
920
@cindex Implicitly interconvert LOGICAL and INTEGER
921
 
922
As a GNU extension for backwards compatibility with other compilers,
923
@command{gfortran} allows the implicit conversion of LOGICALs to INTEGERs
924
and vice versa.  When converting from a LOGICAL to an INTEGER, the numeric
925
value of @code{.FALSE.} is zero, and that of @code{.TRUE.} is one.  When
926
converting from INTEGER to LOGICAL, the value zero is interpreted as
927
@code{.FALSE.} and any nonzero value is interpreted as @code{.TRUE.}.
928
 
929
@smallexample
930
       INTEGER*4 i
931
       i = .FALSE.
932
@end smallexample
933
 
934
@node Hollerith constants support
935
@section Hollerith constants support
936
@cindex Hollerith constants
937
 
938
A Hollerith constant is a string of characters preceded by the letter @samp{H}
939
or @samp{h}, and there must be an literal, unsigned, nonzero default integer
940
constant indicating the number of characters in the string. Hollerith constants
941
are stored as byte strings, one character per byte.
942
 
943
@command{gfortran} supports Hollerith constants. They can be used as the right
944
hands in the @code{DATA} statement and @code{ASSIGN} statement, also as the
945
arguments. The left hands can be of Integer, Real, Complex and Logical type.
946
The constant will be padded or truncated to fit the size of left hand.
947
 
948
Valid Hollerith constants examples:
949
@smallexample
950
complex*16 x(2)
951
data x /16Habcdefghijklmnop, 16Hqrstuvwxyz012345/
952
call foo (4H abc)
953
x(1) = 16Habcdefghijklmnop
954
@end smallexample
955
 
956
Invalid Hollerith constants examples:
957
@smallexample
958
integer*4 a
959
a = 8H12345678 ! The Hollerith constant is too long. It will be truncated.
960
a = 0H         ! At least one character needed.
961
@end smallexample
962
 
963
@node Cray pointers
964
@section Cray pointers
965
@cindex Cray pointers
966
 
967
Cray pointers are part of a non-standard extension that provides a
968
C-like pointer in Fortran.  This is accomplished through a pair of
969
variables: an integer "pointer" that holds a memory address, and a
970
"pointee" that is used to dereference the pointer.
971
 
972
Pointer/pointee pairs are declared in statements of the form:
973
@smallexample
974
        pointer ( <pointer> , <pointee> )
975
@end smallexample
976
or,
977
@smallexample
978
        pointer ( <pointer1> , <pointee1> ), ( <pointer2> , <pointee2> ), ...
979
@end smallexample
980
The pointer is an integer that is intended to hold a memory address.
981
The pointee may be an array or scalar.  A pointee can be an assumed
982
size array -- that is, the last dimension may be left unspecified by
983
using a '*' in place of a value -- but a pointee cannot be an assumed
984
shape array.  No space is allocated for the pointee.
985
 
986
The pointee may have its type declared before or after the pointer
987
statement, and its array specification (if any) may be declared
988
before, during, or after the pointer statement.  The pointer may be
989
declared as an integer prior to the pointer statement.  However, some
990
machines have default integer sizes that are different than the size
991
of a pointer, and so the following code is not portable:
992
@smallexample
993
        integer ipt
994
        pointer (ipt, iarr)
995
@end smallexample
996
If a pointer is declared with a kind that is too small, the compiler
997
will issue a warning; the resulting binary will probably not work
998
correctly, because the memory addresses stored in the pointers may be
999
truncated.  It is safer to omit the first line of the above example;
1000
if explicit declaration of ipt's type is omitted, then the compiler
1001
will ensure that ipt is an integer variable large enough to hold a
1002
pointer.
1003
 
1004
Pointer arithmetic is valid with Cray pointers, but it is not the same
1005
as C pointer arithmetic.  Cray pointers are just ordinary integers, so
1006
the user is responsible for determining how many bytes to add to a
1007
pointer in order to increment it.  Consider the following example:
1008
@smallexample
1009
        real target(10)
1010
        real pointee(10)
1011
        pointer (ipt, pointee)
1012
        ipt = loc (target)
1013
        ipt = ipt + 1
1014
@end smallexample
1015
The last statement does not set ipt to the address of
1016
@code{target(1)}, as one familiar with C pointer arithmetic might
1017
expect.  Adding 1 to ipt just adds one byte to the address stored in
1018
ipt.
1019
 
1020
Any expression involving the pointee will be translated to use the
1021
value stored in the pointer as the base address.
1022
 
1023
To get the address of elements, this extension provides an intrinsic
1024
function loc(), loc() is essentially the C '&' operator, except the
1025
address is cast to an integer type:
1026
@smallexample
1027
        real ar(10)
1028
        pointer(ipt, arpte(10))
1029
        real arpte
1030
        ipt = loc(ar)  ! Makes arpte is an alias for ar
1031
        arpte(1) = 1.0 ! Sets ar(1) to 1.0
1032
@end smallexample
1033
The pointer can also be set by a call to a malloc-type
1034
function.  There is no malloc intrinsic implemented as part of the
1035
Cray pointer extension, but it might be a useful future addition to
1036
@command{gfortran}.  Even without an intrinsic malloc function,
1037
dynamic memory allocation can be combined with Cray pointers by
1038
calling a short C function:
1039
@smallexample
1040
mymalloc.c:
1041
 
1042
        void mymalloc_(void **ptr, int *nbytes)
1043
        @{
1044
            *ptr = malloc(*nbytes);
1045
            return;
1046
        @}
1047
 
1048
caller.f:
1049
 
1050
        program caller
1051
        integer ipinfo;
1052
        real*4 data
1053
        pointer (ipdata, data(1024))
1054
        call mymalloc(ipdata,4*1024)
1055
        end
1056
@end smallexample
1057
Cray pointees often are used to alias an existing variable.  For
1058
example:
1059
@smallexample
1060
        integer target(10)
1061
        integer iarr(10)
1062
        pointer (ipt, iarr)
1063
        ipt = loc(target)
1064
@end smallexample
1065
As long as ipt remains unchanged, iarr is now an alias for target.
1066
The optimizer, however, will not detect this aliasing, so it is unsafe
1067
to use iarr and target simultaneously.  Using a pointee in any way
1068
that violates the Fortran aliasing rules or assumptions is illegal.
1069
It is the user's responsibility to avoid doing this; the compiler
1070
works under the assumption that no such aliasing occurs.
1071
 
1072
Cray pointers will work correctly when there is no aliasing (i.e.,
1073
when they're used to access a dynamically allocated block of memory),
1074
and also in any routine where a pointee is used, but any variable with
1075
which it shares storage is not used.  Code that violates these rules
1076
may not run as the user intends.  This is not a bug in the optimizer;
1077
any code that violates the aliasing rules is illegal.  (Note that this
1078
is not unique to gfortran; any Fortran compiler that supports Cray
1079
pointers will ``incorrectly'' optimize code with illegal aliasing.)
1080
 
1081
There are a number of restrictions on the attributes that can be
1082
applied to Cray pointers and pointees.  Pointees may not have the
1083
attributes ALLOCATABLE, INTENT, OPTIONAL, DUMMY, TARGET, EXTERNAL,
1084
INTRINSIC, or POINTER.  Pointers may not have the attributes
1085
DIMENSION, POINTER, TARGET, ALLOCATABLE, EXTERNAL, or INTRINSIC.
1086
Pointees may not occur in more than one pointer statement.  A pointee
1087
cannot be a pointer.  Pointees cannot occur in equivalence, common, or
1088
data statements.
1089
 
1090
A pointer may be modified during the course of a program, and this
1091
will change the location to which the pointee refers.  However, when
1092
pointees are passed as arguments, they are treated as ordinary
1093
variables in the invoked function.  Subsequent changes to the pointer
1094
will not change the base address of the array that was passed.
1095
 
1096
@node CONVERT specifier
1097
@section CONVERT specifier
1098
@cindex CONVERT specifier
1099
 
1100
gfortran allows the conversion of unformatted data between little-
1101
and big-endian representation to facilitate moving of data
1102
between different systems.  The conversion can be indicated with
1103
the @code{CONVERT} specifier on the @code{OPEN} statement.
1104
@xref{GFORTRAN_CONVERT_UNIT}, for an alternative way of specifying
1105
the data format via an environment variable.
1106
 
1107
Valid values for @code{CONVERT} are:
1108
@itemize @w{}
1109
@item @code{CONVERT='NATIVE'} Use the native format.  This is the default.
1110
@item @code{CONVERT='SWAP'} Swap between little- and big-endian.
1111
@item @code{CONVERT='LITTLE_ENDIAN'} Use the little-endian representation
1112
        for unformatted files.
1113
@item @code{CONVERT='BIG_ENDIAN'} Use the big-endian representation for
1114
        unformatted files.
1115
@end itemize
1116
 
1117
Using the option could look like this:
1118
@smallexample
1119
  open(file='big.dat',form='unformatted',access='sequential', &
1120
       convert='big_endian')
1121
@end smallexample
1122
 
1123
The value of the conversion can be queried by using
1124
@code{INQUIRE(CONVERT=ch)}.  The values returned are
1125
@code{'BIG_ENDIAN'} and @code{'LITTLE_ENDIAN'}.
1126
 
1127
@code{CONVERT} works between big- and little-endian for
1128
@code{INTEGER} values of all supported kinds and for @code{REAL}
1129
on IEEE sytems of kinds 4 and 8.  Conversion between different
1130
``extended double'' types on different architectures such as
1131
m68k and x86_64, which gfortran
1132
supports as @code{REAL(KIND=10)} will probably not work.
1133
 
1134
@emph{Note that the values specified via the GFORTRAN_CONVERT_UNIT
1135
environment variable will override the CONVERT specifier in the
1136
open statement}.  This is to give control over data formats to
1137
a user who does not have the source code of his program available.
1138
 
1139
Using anything but the native representation for unformatted data
1140
carries a significant speed overhead.  If speed in this area matters
1141
to you, it is best if you use this only for data that needs to be
1142
portable.
1143
 
1144
@c ---------------------------------------------------------------------
1145
@include intrinsic.texi
1146
@c ---------------------------------------------------------------------
1147
 
1148
@c ---------------------------------------------------------------------
1149
@c Contributing
1150
@c ---------------------------------------------------------------------
1151
 
1152
@node Contributing
1153
@chapter Contributing
1154
@cindex Contributing
1155
 
1156
Free software is only possible if people contribute to efforts
1157
to create it.
1158
We're always in need of more people helping out with ideas
1159
and comments, writing documentation and contributing code.
1160
 
1161
If you want to contribute to GNU Fortran 95,
1162
have a look at the long lists of projects you can take on.
1163
Some of these projects are small,
1164
some of them are large;
1165
some are completely orthogonal to the rest of what is
1166
happening on @command{gfortran},
1167
but others are ``mainstream'' projects in need of enthusiastic hackers.
1168
All of these projects are important!
1169
We'll eventually get around to the things here,
1170
but they are also things doable by someone who is willing and able.
1171
 
1172
@menu
1173
* Contributors::
1174
* Projects::
1175
@end menu
1176
 
1177
 
1178
@node Contributors
1179
@section Contributors to GNU Fortran 95
1180
@cindex Contributors
1181
@cindex Credits
1182
@cindex Authors
1183
 
1184
Most of the parser was hand-crafted by @emph{Andy Vaught}, who is
1185
also the initiator of the whole project.  Thanks Andy!
1186
Most of the interface with GCC was written by @emph{Paul Brook}.
1187
 
1188
The following individuals have contributed code and/or
1189
ideas and significant help to the gfortran project
1190
(in no particular order):
1191
 
1192
@itemize @minus
1193
@item Andy Vaught
1194
@item Katherine Holcomb
1195
@item Tobias Schlüter
1196
@item Steven Bosscher
1197
@item Toon Moene
1198
@item Tim Prince
1199
@item Niels Kristian Bech Jensen
1200
@item Steven Johnson
1201
@item Paul Brook
1202
@item Feng Wang
1203
@item Bud Davis
1204
@item Paul Thomas
1205
@item François-Xavier Coudert
1206
@item Steve Kargl
1207
@item Jerry Delisle
1208
@item Janne Blomqvist
1209
@item Erik Edelmann
1210
@item Thomas Koenig
1211
@item Asher Langton
1212
@end itemize
1213
 
1214
The following people have contributed bug reports,
1215
smaller or larger patches,
1216
and much needed feedback and encouragement for the
1217
@command{gfortran} project:
1218
 
1219
@itemize @minus
1220
@item Erik Schnetter
1221
@item Bill Clodius
1222
@item Kate Hedstrom
1223
@end itemize
1224
 
1225
Many other individuals have helped debug,
1226
test and improve @command{gfortran} over the past few years,
1227
and we welcome you to do the same!
1228
If you already have done so,
1229
and you would like to see your name listed in the
1230
list above, please contact us.
1231
 
1232
 
1233
@node Projects
1234
@section Projects
1235
 
1236
@table @emph
1237
 
1238
@item Help build the test suite
1239
Solicit more code for donation to the test suite.
1240
We can keep code private on request.
1241
 
1242
@item Bug hunting/squishing
1243
Find bugs and write more test cases!
1244
Test cases are especially very welcome,
1245
because it allows us to concentrate on fixing bugs
1246
instead of isolating them.
1247
 
1248
@item Smaller projects (``bug'' fixes):
1249
  @itemize @minus
1250
  @item Allow init exprs to be numbers raised to integer powers.
1251
  @item Implement correct rounding.
1252
  @item Implement F restrictions on Fortran 95 syntax.
1253
  @item See about making Emacs-parsable error messages.
1254
  @end itemize
1255
@end table
1256
 
1257
If you wish to work on the runtime libraries,
1258
please contact a project maintainer.
1259
@c TODO: email!
1260
 
1261
 
1262
@c ---------------------------------------------------------------------
1263
@c Standards
1264
@c ---------------------------------------------------------------------
1265
 
1266
@node Standards
1267
@chapter Standards
1268
@cindex Standards
1269
 
1270
The GNU Fortran 95 Compiler aims to be a conforming implementation of
1271
ISO/IEC 1539:1997 (Fortran 95).
1272
 
1273
In the future it may also support other variants of and extensions to
1274
the Fortran language.  These include ANSI Fortran 77, ISO Fortran 90,
1275
ISO Fortran 2003 and OpenMP.
1276
 
1277
@menu
1278
* Fortran 2003 status::
1279
@end menu
1280
 
1281
@node Fortran 2003 status
1282
@section Fortran 2003 status
1283
 
1284
Although @command{gfortran} focuses on implementing the Fortran 95
1285
standard for the time being, a few Fortran 2003 features are currently
1286
available.
1287
 
1288
@itemize
1289
@item
1290
Intrinsics @code{command_argument_count}, @code{get_command},
1291
@code{get_command_argument}, and @code{get_environment_variable}.
1292
 
1293
@item
1294
@cindex Array constructors
1295
@cindex @code{[...]}
1296
Array constructors using square brackets. That is, @code{[...]} rather
1297
than @code{(/.../)}.
1298
 
1299
@item
1300
@cindex @code{FLUSH} statement
1301
@code{FLUSH} statement.
1302
 
1303
@item
1304
@cindex @code{IOMSG=} specifier
1305
@code{IOMSG=} specifier for I/O statements.
1306
 
1307
@item
1308
@cindex @code{ENUM} statement
1309
@cindex @code{ENUMERATOR} statement
1310
@cindex @command{-fshort-enums}
1311
Support for the declaration of enumeration constants via the
1312
@code{ENUM} and @code{ENUMERATOR} statements.  Interoperability with
1313
@command{gcc} is guaranteed also for the case where the
1314
@command{-fshort-enums} command line option is given.
1315
 
1316
@end itemize
1317
 
1318
 
1319
@c ---------------------------------------------------------------------
1320
@c GNU General Public License
1321
@c ---------------------------------------------------------------------
1322
 
1323
@include gpl.texi
1324
 
1325
 
1326
 
1327
@c ---------------------------------------------------------------------
1328
@c GNU Free Documentation License
1329
@c ---------------------------------------------------------------------
1330
 
1331
@include fdl.texi
1332
 
1333
 
1334
 
1335
@c ---------------------------------------------------------------------
1336
@c Funding Free Software
1337
@c ---------------------------------------------------------------------
1338
 
1339
@include funding.texi
1340
 
1341
@c ---------------------------------------------------------------------
1342
@c Index
1343
@c ---------------------------------------------------------------------
1344
 
1345
@node Index
1346
@unnumbered Index
1347
 
1348
@printindex cp
1349
 
1350
@bye

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.