diff -Nrcpad gcc-4.2.2/gcc/fortran/ChangeLog gcc-4.2.3/gcc/fortran/ChangeLog
*** gcc-4.2.2/gcc/fortran/ChangeLog	Sun Oct  7 21:19:56 2007
--- gcc-4.2.3/gcc/fortran/ChangeLog	Fri Feb  1 16:52:03 2008
***************
*** 1,3 ****
--- 1,20 ----
+ 2008-02-01  Release Manager
+ 
+ 	* GCC 4.2.3 released.
+ 
+ 2007-10-25  Thomas Koenig  <tkoenig@gcc.gnu.org>
+ 	    Paul Thomas  <pault@gcc.gnu.org>
+ 
+ 	PR fortran/32298
+ 	PR fortran/31726
+ 	PR fortran/33354
+ 	Backport from trunk
+ 	* trans-intrinsic.c (gfc_conv_intrinsic_minmaxloc): Calculate
+ 	the offset between the loop counter and the position as
+ 	defined. Add the offset within the loop so that the mask acts
+ 	correctly.  Do not advance the location on the basis that it
+ 	is zero.
+ 
  2007-10-07  Release Manager
  
  	* GCC 4.2.2 released.
diff -Nrcpad gcc-4.2.2/gcc/fortran/gfortran.info gcc-4.2.3/gcc/fortran/gfortran.info
*** gcc-4.2.2/gcc/fortran/gfortran.info	Sun Oct  7 22:08:27 2007
--- gcc-4.2.3/gcc/fortran/gfortran.info	Thu Jan  1 00:00:00 1970
***************
*** 1,12532 ****
- This is doc/gfortran.info, produced by makeinfo version 4.8 from
- /scratch/mitchell/gcc-releases/gcc-4.2.2/gcc-4.2.2/gcc/fortran/gfortran.texi.
- 
-    Copyright (C) 1999-2007 Free Software Foundation, Inc.
- 
-    Permission is granted to copy, distribute and/or modify this document
- under the terms of the GNU Free Documentation License, Version 1.1 or
- any later version published by the Free Software Foundation; with the
- Invariant Sections being "GNU General Public License" and "Funding Free
- Software", the Front-Cover texts being (a) (see below), and with the
- Back-Cover Texts being (b) (see below).  A copy of the license is
- included in the section entitled "GNU Free Documentation License".
- 
-    (a) The FSF's Front-Cover Text is:
- 
-    A GNU Manual
- 
-    (b) The FSF's Back-Cover Text is:
- 
-    You have freedom to copy and modify this GNU Manual, like GNU
- software.  Copies published by the Free Software Foundation raise
- funds for GNU development.
- 
- INFO-DIR-SECTION Software development
- START-INFO-DIR-ENTRY
- * gfortran: (gfortran).                  The GNU Fortran Compiler.
- END-INFO-DIR-ENTRY
-    This file documents the use and the internals of the GNU Fortran
- compiler, (`gfortran').
- 
-    Published by the Free Software Foundation 51 Franklin Street, Fifth
- Floor Boston, MA 02110-1301 USA
- 
-    Copyright (C) 1999-2007 Free Software Foundation, Inc.
- 
-    Permission is granted to copy, distribute and/or modify this document
- under the terms of the GNU Free Documentation License, Version 1.1 or
- any later version published by the Free Software Foundation; with the
- Invariant Sections being "GNU General Public License" and "Funding Free
- Software", the Front-Cover texts being (a) (see below), and with the
- Back-Cover Texts being (b) (see below).  A copy of the license is
- included in the section entitled "GNU Free Documentation License".
- 
-    (a) The FSF's Front-Cover Text is:
- 
-    A GNU Manual
- 
-    (b) The FSF's Back-Cover Text is:
- 
-    You have freedom to copy and modify this GNU Manual, like GNU
- software.  Copies published by the Free Software Foundation raise
- funds for GNU development.
- 
- 
- File: gfortran.info,  Node: Top,  Next: Introduction,  Up: (dir)
- 
- Introduction
- ************
- 
- This manual documents the use of `gfortran', the GNU Fortran compiler.
- You can find in this manual how to invoke `gfortran', as well as its
- features and incompatibilities.
- 
- * Menu:
- 
- * Introduction::
- 
- Part I: Invoking GNU Fortran
- * Invoking GNU Fortran:: Command options supported by `gfortran'.
- * Runtime::              Influencing runtime behavior with environment variables.
- 
- Part II: Language Reference
- * Fortran 2003 status::  Fortran 2003 features supported by GNU Fortran.
- * Extensions::           Language extensions implemented by GNU Fortran.
- * Intrinsic Procedures:: Intrinsic procedures supported by GNU Fortran.
- 
- * Contributing::         How you can help.
- * Copying::              GNU General Public License says
-                          how you can copy and share GNU Fortran.
- * GNU Free Documentation License::
- 		         How you can copy and share this manual.
- * Funding::              How to help assure continued work for free software.
- * Option Index::         Index of command line options
- * Keyword Index::        Index of concepts
- 
- 
- File: gfortran.info,  Node: Introduction,  Next: Invoking GNU Fortran,  Prev: Top,  Up: Top
- 
- 1 Introduction
- **************
- 
- The GNU Fortran compiler front end was designed initially as a free
- replacement for, or alternative to, the unix `f95' command; `gfortran'
- is the command you'll use to invoke the compiler.
- 
- * Menu:
- 
- * About GNU Fortran::    What you should know about the GNU Fortran compiler.
- * GNU Fortran and GCC::  You can compile Fortran, C, or other programs.
- * GNU Fortran and G77::  Why we chose to start from scratch.
- * Project Status::       Status of GNU Fortran, roadmap, proposed extensions.
- * Standards::	         Standards supported by GNU Fortran.
- 
- 
- File: gfortran.info,  Node: About GNU Fortran,  Next: GNU Fortran and GCC,  Up: Introduction
- 
- 1.1 About GNU Fortran
- =====================
- 
- The GNU Fortran compiler is still in an early state of development.  It
- can generate code for most constructs and expressions, but much work
- remains to be done.
- 
-    When the GNU Fortran compiler is finished, it will do everything you
- expect from any decent compiler:
- 
-    * Read a user's program, stored in a file and containing
-      instructions written in Fortran 77, Fortran 90, Fortran 95 or
-      Fortran 2003.  This file contains "source code".
- 
-    * Translate the user's program into instructions a computer can
-      carry out more quickly than it takes to translate the instructions
-      in the first place.  The result after compilation of a program is
-      "machine code", code designed to be efficiently translated and
-      processed by a machine such as your computer.  Humans usually
-      aren't as good writing machine code as they are at writing Fortran
-      (or C++, Ada, or Java), because is easy to make tiny mistakes
-      writing machine code.
- 
-    * Provide the user with information about the reasons why the
-      compiler is unable to create a binary from the source code.
-      Usually this will be the case if the source code is flawed.  When
-      writing Fortran, it is easy to make big mistakes.  The Fortran 90
-      requires that the compiler can point out mistakes to the user.  An
-      incorrect usage of the language causes an "error message".
- 
-      The compiler will also attempt to diagnose cases where the user's
-      program contains a correct usage of the language, but instructs
-      the computer to do something questionable.  This kind of
-      diagnostics message is called a "warning message".
- 
-    * Provide optional information about the translation passes from the
-      source code to machine code.  This can help a user of the compiler
-      to find the cause of certain bugs which may not be obvious in the
-      source code, but may be more easily found at a lower level
-      compiler output.  It also helps developers to find bugs in the
-      compiler itself.
- 
-    * Provide information in the generated machine code that can make it
-      easier to find bugs in the program (using a debugging tool, called
-      a "debugger", such as the GNU Debugger `gdb').
- 
-    * Locate and gather machine code already generated to perform
-      actions requested by statements in the user's program.  This
-      machine code is organized into "modules" and is located and
-      "linked" to the user program.
- 
-    The GNU Fortran compiler consists of several components:
- 
-    * A version of the `gcc' command (which also might be installed as
-      the system's `cc' command) that also understands and accepts
-      Fortran source code.  The `gcc' command is the "driver" program for
-      all the languages in the GNU Compiler Collection (GCC); With `gcc',
-      you can compile the source code of any language for which a front
-      end is available in GCC.
- 
-    * The `gfortran' command itself, which also might be installed as the
-      system's `f95' command.  `gfortran' is just another driver program,
-      but specifically for the Fortran compiler only.  The difference
-      with `gcc' is that `gfortran' will automatically link the correct
-      libraries to your program.
- 
-    * A collection of run-time libraries.  These libraries contain the
-      machine code needed to support capabilities of the Fortran
-      language that are not directly provided by the machine code
-      generated by the `gfortran' compilation phase, such as intrinsic
-      functions and subroutines, and routines for interaction with files
-      and the operating system.
- 
-    * The Fortran compiler itself, (`f951').  This is the GNU Fortran
-      parser and code generator, linked to and interfaced with the GCC
-      backend library.  `f951' "translates" the source code to assembler
-      code.  You would typically not use this program directly; instead,
-      the `gcc' or `gfortran' driver programs will call it for you.
- 
- 
- File: gfortran.info,  Node: GNU Fortran and GCC,  Next: GNU Fortran and G77,  Prev: About GNU Fortran,  Up: Introduction
- 
- 1.2 GNU Fortran and GCC
- =======================
- 
- GNU Fortran is a part of GCC, the "GNU Compiler Collection".  GCC
- consists of a collection of front ends for various languages, which
- translate the source code into a language-independent form called
- "GENERIC".  This is then processed by a common middle end which
- provides optimization, and then passed to one of a collection of back
- ends which generate code for different computer architectures and
- operating systems.
- 
-    Functionally, this is implemented with a driver program (`gcc')
- which provides the command-line interface for the compiler.  It calls
- the relevant compiler front-end program (e.g., `f951' for Fortran) for
- each file in the source code, and then calls the assembler and linker
- as appropriate to produce the compiled output. In a copy of GCC which
- has been compiled with Fortran language support enabled, `gcc' will
- recognize files with `.f', `.f90', `.f95', and `.f03' extensions as
- Fortran source code, and compile it accordingly.  A `gfortran' driver
- program is also provided, which is identical to `gcc' except that it
- automatically links the Fortran runtime libraries into the compiled
- program.
- 
-    This manual specifically documents the Fortran front end, which
- handles the programming language's syntax and semantics.  The aspects
- of GCC which relate to the optimization passes and the back-end code
- generation are documented in the GCC manual; see *Note Introduction:
- (gcc)Top.  The two manuals together provide a complete reference for
- the GNU Fortran compiler.
- 
- 
- File: gfortran.info,  Node: GNU Fortran and G77,  Next: Project Status,  Prev: GNU Fortran and GCC,  Up: Introduction
- 
- 1.3 GNU Fortran and G77
- =======================
- 
- The GNU Fortran compiler is the successor to `g77', the Fortran 77
- front end included in GCC prior to version 4.  It is an entirely new
- program that has been designed to provide Fortran 95 support and
- extensibility for future Fortran language standards, as well as
- providing backwards compatibility for Fortran 77 and nearly all of the
- GNU language extensions supported by `g77'.
- 
- 
- File: gfortran.info,  Node: Project Status,  Next: Standards,  Prev: GNU Fortran and G77,  Up: Introduction
- 
- 1.4 Project Status
- ==================
- 
-      As soon as `gfortran' can parse all of the statements correctly,
-      it will be in the "larva" state.  When we generate code, the
-      "puppa" state.  When `gfortran' is done, we'll see if it will be a
-      beautiful butterfly, or just a big bug....
- 
-      -Andy Vaught, April 2000
- 
-    The start of the GNU Fortran 95 project was announced on the GCC
- homepage in March 18, 2000 (even though Andy had already been working
- on it for a while, of course).
- 
-    The GNU Fortran compiler is able to compile nearly all
- standard-compliant Fortran 95, Fortran 90, and Fortran 77 programs,
- including a number of standard and non-standard extensions, and can be
- used on real-world programs.  In particular, the supported extensions
- include OpenMP, Cray-style pointers, and several Fortran 2003 features
- such as enumeration, stream I/O, and some of the enhancements to
- allocatable array support from TR 15581.  However, it is still under
- development and has a few remaining rough edges.
- 
-    At present, the GNU Fortran compiler passes the NIST Fortran 77 Test
- Suite (http://www.fortran-2000.com/ArnaudRecipes/fcvs21_f95.html), and
- produces acceptable results on the LAPACK Test Suite
- (http://www.netlib.org/lapack/faq.html#1.21).  It also provides
- respectable performance on the Polyhedron Fortran compiler benchmarks
- (http://www.polyhedron.com/pb05.html) and the Livermore Fortran Kernels
- test
- (http://www.llnl.gov/asci_benchmarks/asci/limited/lfk/README.html).  It
- has been used to compile a number of large real-world programs,
- including the HIRLAM weather-forecasting code
- (http://mysite.verizon.net/serveall/moene.pdf) and the Tonto quantum
- chemistry package (http://www.theochem.uwa.edu.au/tonto/); see
- `http://gcc.gnu.org/wiki/GfortranApps' for an extended list.
- 
-    Among other things, the GNU Fortran compiler is intended as a
- replacement for G77.  At this point, nearly all programs that could be
- compiled with G77 can be compiled with GNU Fortran, although there are
- a few minor known regressions.
- 
-    The primary work remaining to be done on GNU Fortran falls into three
- categories: bug fixing (primarily regarding the treatment of invalid
- code and providing useful error messages), improving the compiler
- optimizations and the performance of compiled code, and extending the
- compiler to support future standards--in particular, Fortran 2003.
- 
- 
- File: gfortran.info,  Node: Standards,  Prev: Project Status,  Up: Introduction
- 
- 1.5 Standards
- =============
- 
- The GNU Fortran compiler implements ISO/IEC 1539:1997 (Fortran 95).  As
- such, it can also compile essentially all standard-compliant Fortran 90
- and Fortran 77 programs.   It also supports the ISO/IEC TR-15581
- enhancements to allocatable arrays, and the OpenMP Application Program
- Interface v2.5 (http://www.openmp.org/drupal/mp-documents/spec25.pdf)
- specification.
- 
-    In the future, the GNU Fortran compiler may also support other
- standard variants of and extensions to the Fortran language.  These
- include ISO/IEC 1539-1:2004 (Fortran 2003).
- 
- 
- File: gfortran.info,  Node: Invoking GNU Fortran,  Next: Runtime,  Prev: Introduction,  Up: Top
- 
- 2 GNU Fortran Command Options
- *****************************
- 
- The `gfortran' command supports all the options supported by the `gcc'
- command.  Only options specific to GNU Fortran are documented here.
- 
-    *Note GCC Command Options: (gcc)Invoking GCC, for information on the
- non-Fortran-specific aspects of the `gcc' command (and, therefore, the
- `gfortran' command).
- 
-    All GCC and GNU Fortran options are accepted both by `gfortran' and
- by `gcc' (as well as any other drivers built at the same time, such as
- `g++'), since adding GNU Fortran to the GCC distribution enables
- acceptance of GNU Fortran options by all of the relevant drivers.
- 
-    In some cases, options have positive and negative forms; the
- negative form of `-ffoo' would be `-fno-foo'.  This manual documents
- only one of these two forms, whichever one is not the default.
- 
- * Menu:
- 
- * Option Summary::      Brief list of all `gfortran' options,
-                         without explanations.
- * Fortran Dialect Options::  Controlling the variant of Fortran language
-                              compiled.
- * Error and Warning Options::     How picky should the compiler be?
- * Debugging Options::   Symbol tables, measurements, and debugging dumps.
- * Directory Options::   Where to find module files
- * Runtime Options::     Influencing runtime behavior
- * Code Gen Options::    Specifying conventions for function calls, data layout
-                         and register usage.
- * Environment Variables:: Environment variables that affect `gfortran'.
- 
- 
- File: gfortran.info,  Node: Option Summary,  Next: Fortran Dialect Options,  Up: Invoking GNU Fortran
- 
- 2.1 Option summary
- ==================
- 
- Here is a summary of all the options specific to GNU Fortran, grouped
- by type.  Explanations are in the following sections.
- 
- _Fortran Language Options_
-      *Note Options controlling Fortran dialect: Fortran Dialect Options.
-           -fall-intrinsics  -ffree-form  -fno-fixed-form
-           -fdollar-ok  -fimplicit-none  -fmax-identifier-length
-           -std=STD -fd-lines-as-code  -fd-lines-as-comments
-           -ffixed-line-length-N  -ffixed-line-length-none
-           -ffree-line-length-N  -ffree-line-length-none
-           -fdefault-double-8  -fdefault-integer-8  -fdefault-real-8
-           -fcray-pointer  -fopenmp  -frange-check -fno-backslash
- 
- _Error and Warning Options_
-      *Note Options to request or suppress errors and warnings: Error
-      and Warning Options.
-           -fmax-errors=N
-           -fsyntax-only  -pedantic  -pedantic-errors
-           -Wall  -Waliasing  -Wampersand  -Wcharacter-truncation  -Wconversion
-           -Wimplicit-interface  -Wline-truncation  -Wnonstd-intrinsics  -Wsurprising
-           -Wno-tabs  -Wunderflow
- 
- _Debugging Options_
-      *Note Options for debugging your program or GNU Fortran: Debugging
-      Options.
-           -fdump-parse-tree  -ffpe-trap=LIST
- 
- _Directory Options_
-      *Note Options for directory search: Directory Options.
-           -IDIR  -JDIR  -MDIR
- 
- _Runtime Options_
-      *Note Options for influencing runtime behavior: Runtime Options.
-           -fconvert=CONVERSION  -frecord-marker=LENGTH
-           -fmax-subrecord-length=LENGTH
- 
- _Code Generation Options_
-      *Note Options for code generation conventions: Code Gen Options.
-           -fno-automatic  -ff2c  -fno-underscoring
-           -fsecond-underscore
-           -fbounds-check  -fmax-stack-var-size=N
-           -fpack-derived  -frepack-arrays  -fshort-enums
- 
- 
- * Menu:
- 
- * Fortran Dialect Options::  Controlling the variant of Fortran language
-                              compiled.
- * Error and Warning Options::     How picky should the compiler be?
- * Debugging Options::   Symbol tables, measurements, and debugging dumps.
- * Directory Options::   Where to find module files
- * Runtime Options::     Influencing runtime behavior
- * Code Gen Options::    Specifying conventions for function calls, data layout
-                         and register usage.
- 
- 
- File: gfortran.info,  Node: Fortran Dialect Options,  Next: Error and Warning Options,  Prev: Option Summary,  Up: Invoking GNU Fortran
- 
- 2.2 Options controlling Fortran dialect
- =======================================
- 
- The following options control the details of the Fortran dialect
- accepted by the compiler:
- 
- `-ffree-form'
- 
- `-ffixed-form'
-      Specify the layout used by the source file.  The free form layout
-      was introduced in Fortran 90.  Fixed form was traditionally used in
-      older Fortran programs.  When neither option is specified, the
-      source form is determined by the file extension.
- 
- `-fall-intrinsics'
-      Accept all of the intrinsic procedures provided in libgfortran
-      without regard to the setting of `-std'.  In particular, this
-      option can be quite useful with `-std=f95'.  Additionally,
-      `gfortran' will ignore `-Wnonstd-intrinsics'.
- 
- `-fd-lines-as-code'
- 
- `-fd-lines-as-comments'
-      Enable special treatment for lines beginning with `d' or `D' in
-      fixed form sources.  If the `-fd-lines-as-code' option is given
-      they are treated as if the first column contained a blank.  If the
-      `-fd-lines-as-comments' option is given, they are treated as
-      comment lines.
- 
- `-fdefault-double-8'
-      Set the `DOUBLE PRECISION' type to an 8 byte wide type.
- 
- `-fdefault-integer-8'
-      Set the default integer and logical types to an 8 byte wide type.
-      Do nothing if this is already the default.
- 
- `-fdefault-real-8'
-      Set the default real type to an 8 byte wide type.  Do nothing if
-      this is already the default.
- 
- `-fdollar-ok'
-      Allow `$' as a valid character in a symbol name.
- 
- `-fno-backslash'
-      Change the interpretation of backslashes in string literals from
-      "C-style" escape characters to a single backslash character.
- 
- `-ffixed-line-length-N'
-      Set column after which characters are ignored in typical fixed-form
-      lines in the source file, and through which spaces are assumed (as
-      if padded to that length) after the ends of short fixed-form lines.
- 
-      Popular values for N include 72 (the standard and the default), 80
-      (card image), and 132 (corresponding to "extended-source" options
-      in some popular compilers).  N may also be `none', meaning that
-      the entire line is meaningful and that continued character
-      constants never have implicit spaces appended to them to fill out
-      the line.  `-ffixed-line-length-0' means the same thing as
-      `-ffixed-line-length-none'.
- 
- `-ffree-line-length-N'
-      Set column after which characters are ignored in typical free-form
-      lines in the source file. The default value is 132.  N may be
-      `none', meaning that the entire line is meaningful.
-      `-ffree-line-length-0' means the same thing as
-      `-ffree-line-length-none'.
- 
- `-fmax-identifier-length=N'
-      Specify the maximum allowed identifier length. Typical values are
-      31 (Fortran 95) and 63 (Fortran 2003).
- 
- `-fimplicit-none'
-      Specify that no implicit typing is allowed, unless overridden by
-      explicit `IMPLICIT' statements.  This is the equivalent of adding
-      `implicit none' to the start of every procedure.
- 
- `-fcray-pointer'
-      Enable the Cray pointer extension, which provides C-like pointer
-      functionality.
- 
- `-fopenmp'
-      Enable the OpenMP extensions.  This includes OpenMP `!$omp'
-      directives in free form and `c$omp', `*$omp' and `!$omp'
-      directives in fixed form, `!$' conditional compilation sentinels
-      in free form and `c$', `*$' and `!$' sentinels in fixed form, and
-      when linking arranges for the OpenMP runtime library to be linked
-      in.
- 
- `-frange-check'
-      Enable range checking on results of simplification of constant
-      expressions during compilation.  For example, by default, GNU
-      Fortran will give an overflow error at compile time when
-      simplifying `a = EXP(1000)'. With `-fno-range-check', no error
-      will be given and the variable `a' will be assigned the value
-      `+Infinity'.  Similarly, `DATA i/Z'FFFFFFFF'/' will result in an
-      integer overflow on most systems, but with `-fno-range-check' the
-      value will "wrap around" and `i' will be initialized to -1 instead.
- 
- `-std=STD'
-      Specify the standard to which the program is expected to conform,
-      which may be one of `f95', `f2003', `gnu', or `legacy'.  The
-      default value for STD is `gnu', which specifies a superset of the
-      Fortran 95 standard that includes all of the extensions supported
-      by GNU Fortran, although warnings will be given for obsolete
-      extensions not recommended for use in new code.  The `legacy' value
-      is equivalent but without the warnings for obsolete extensions,
-      and may be useful for old non-standard programs.  The `f95' and
-      `f2003' values specify strict conformance to the Fortran 95 and
-      Fortran 2003 standards, respectively; errors are given for all
-      extensions beyond the relevant language standard, and warnings are
-      given for the Fortran 77 features that are permitted but
-      obsolescent in later standards.
- 
- 
- 
- File: gfortran.info,  Node: Error and Warning Options,  Next: Debugging Options,  Prev: Fortran Dialect Options,  Up: Invoking GNU Fortran
- 
- 2.3 Options to request or suppress errors and warnings
- ======================================================
- 
- Errors are diagnostic messages that report that the GNU Fortran compiler
- cannot compile the relevant piece of source code.  The compiler will
- continue to process the program in an attempt to report further errors
- to aid in debugging, but will not produce any compiled output.
- 
-    Warnings are diagnostic messages that report constructions which are
- not inherently erroneous but which are risky or suggest there is likely
- to be a bug in the program.  Unless `-Werror' is specified, they do not
- prevent compilation of the program.
- 
-    You can request many specific warnings with options beginning `-W',
- for example `-Wimplicit' to request warnings on implicit declarations.
- Each of these specific warning options also has a negative form
- beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'.
- This manual lists only one of the two forms, whichever is not the
- default.
- 
-    These options control the amount and kinds of errors and warnings
- produced by GNU Fortran:
- 
- `-fmax-errors-N'
-      Limits the maximum number of error messages to N, at which point
-      GNU Fortran bails out rather than attempting to continue
-      processing the source code.  If N is 0, there is no limit on the
-      number of error messages produced.
- 
- `-fsyntax-only'
-      Check the code for syntax errors, but don't do anything beyond
-      that.
- 
- `-pedantic'
-      Issue warnings for uses of extensions to Fortran 95.  `-pedantic'
-      also applies to C-language constructs where they occur in GNU
-      Fortran source files, such as use of `\e' in a character constant
-      within a directive like `#include'.
- 
-      Valid Fortran 95 programs should compile properly with or without
-      this option.  However, without this option, certain GNU extensions
-      and traditional Fortran features are supported as well.  With this
-      option, many of them are rejected.
- 
-      Some users try to use `-pedantic' to check programs for
-      conformance.  They soon find that it does not do quite what they
-      want--it finds some nonstandard practices, but not all.  However,
-      improvements to GNU Fortran in this area are welcome.
- 
-      This should be used in conjunction with `-std=f95' or `-std=f2003'.
- 
- `-pedantic-errors'
-      Like `-pedantic', except that errors are produced rather than
-      warnings.
- 
- `-Wall'
-      Enables commonly used warning options pertaining to usage that we
-      recommend avoiding and that we believe are easy to avoid.  This
-      currently includes `-Waliasing', `-Wampersand', `-Wsurprising',
-      `-Wnonstd-intrinsics', `-Wno-tabs', and `-Wline-truncation'.
- 
- `-Waliasing'
-      Warn about possible aliasing of dummy arguments. Specifically, it
-      warns if the same actual argument is associated with a dummy
-      argument with `INTENT(IN)' and a dummy argument with `INTENT(OUT)'
-      in a call with an explicit interface.
- 
-      The following example will trigger the warning.
-             interface
-               subroutine bar(a,b)
-                 integer, intent(in) :: a
-                 integer, intent(out) :: b
-               end subroutine
-             end interface
-             integer :: a
- 
-             call bar(a,a)
- 
- `-Wampersand'
-      Warn about missing ampersand in continued character constants. The
-      warning is given with `-Wampersand', `-pedantic', `-std=f95', and
-      `-std=f2003'. Note: With no ampersand given in a continued
-      character constant, GNU Fortran assumes continuation at the first
-      non-comment, non-whitespace character after the ampersand that
-      initiated the continuation.
- 
- `-Wcharacter-truncation'
-      Warn when a character assignment will truncate the assigned string.
- 
- `-Wconversion'
-      Warn about implicit conversions between different types.
- 
- `-Wimplicit-interface'
-      Warn if a procedure is called without an explicit interface.  Note
-      this only checks that an explicit interface is present.  It does
-      not check that the declared interfaces are consistent across
-      program units.
- 
- `-Wnonstd-intrinsics'
-      Warn if the user tries to use an intrinsic that does not belong to
-      the standard the user has chosen via the `-std' option.
- 
- `-Wsurprising'
-      Produce a warning when "suspicious" code constructs are
-      encountered.  While technically legal these usually indicate that
-      an error has been made.
- 
-      This currently produces a warning under the following
-      circumstances:
- 
-         * An INTEGER SELECT construct has a CASE that can never be
-           matched as its lower value is greater than its upper value.
- 
-         * A LOGICAL SELECT construct has three CASE statements.
- 
- `-Wtabs'
-      By default, tabs are accepted as whitespace, but tabs are not
-      members of the Fortran Character Set.  `-Wno-tabs' will cause a
-      warning to be issued if a tab is encountered. Note, `-Wno-tabs' is
-      active for `-pedantic', `-std=f95', `-std=f2003', and `-Wall'.
- 
- `-Wunderflow'
-      Produce a warning when numerical constant expressions are
-      encountered, which yield an UNDERFLOW during compilation.
- 
- `-Werror'
-      Turns all warnings into errors.
- 
-    *Note Options to Request or Suppress Errors and Warnings: (gcc)Error
- and Warning Options, for information on more options offered by the GBE
- shared by `gfortran', `gcc' and other GNU compilers.
- 
-    Some of these have no effect when compiling programs written in
- Fortran.
- 
- 
- File: gfortran.info,  Node: Debugging Options,  Next: Directory Options,  Prev: Error and Warning Options,  Up: Invoking GNU Fortran
- 
- 2.4 Options for debugging your program or GNU Fortran
- =====================================================
- 
- GNU Fortran has various special options that are used for debugging
- either your program or the GNU Fortran compiler.
- 
- `-fdump-parse-tree'
-      Output the internal parse tree before starting code generation.
-      Only really useful for debugging the GNU Fortran compiler itself.
- 
- `-ffpe-trap=LIST'
-      Specify a list of IEEE exceptions when a Floating Point Exception
-      (FPE) should be raised.  On most systems, this will result in a
-      SIGFPE signal being sent and the program being interrupted,
-      producing a core file useful for debugging.  LIST is a (possibly
-      empty) comma-separated list of the following IEEE exceptions:
-      `invalid' (invalid floating point operation, such as
-      `SQRT(-1.0)'), `zero' (division by zero), `overflow' (overflow in
-      a floating point operation), `underflow' (underflow in a floating
-      point operation), `precision' (loss of precision during operation)
-      and `denormal' (operation produced a denormal value).
- 
-    *Note Options for Debugging Your Program or GCC: (gcc)Debugging
- Options, for more information on debugging options.
- 
- 
- File: gfortran.info,  Node: Directory Options,  Next: Runtime Options,  Prev: Debugging Options,  Up: Invoking GNU Fortran
- 
- 2.5 Options for directory search
- ================================
- 
- These options affect how GNU Fortran searches for files specified by
- the `INCLUDE' directive and where it searches for previously compiled
- modules.
- 
-    It also affects the search paths used by `cpp' when used to
- preprocess Fortran source.
- 
- `-IDIR'
-      These affect interpretation of the `INCLUDE' directive (as well as
-      of the `#include' directive of the `cpp' preprocessor).
- 
-      Also note that the general behavior of `-I' and `INCLUDE' is
-      pretty much the same as of `-I' with `#include' in the `cpp'
-      preprocessor, with regard to looking for `header.gcc' files and
-      other such things.
- 
-      This path is also used to search for `.mod' files when previously
-      compiled modules are required by a `USE' statement.
- 
-      *Note Options for Directory Search: (gcc)Directory Options, for
-      information on the `-I' option.
- 
- `-MDIR'
- 
- `-JDIR'
-      This option specifies where to put `.mod' files for compiled
-      modules.  It is also added to the list of directories to searched
-      by an `USE' statement.
- 
-      The default is the current directory.
- 
-      `-J' is an alias for `-M' to avoid conflicts with existing GCC
-      options.
- 
- 
- File: gfortran.info,  Node: Runtime Options,  Next: Code Gen Options,  Prev: Directory Options,  Up: Invoking GNU Fortran
- 
- 2.6 Influencing runtime behavior
- ================================
- 
- These options affect the runtime behavior of programs compiled with GNU
- Fortran.
- `-fconvert=CONVERSION'
-      Specify the representation of data for unformatted files.  Valid
-      values for conversion are: `native', the default; `swap', swap
-      between big- and little-endian; `big-endian', use big-endian
-      representation for unformatted files; `little-endian', use
-      little-endian representation for unformatted files.
- 
-      _This option has an effect only when used in the main program.
-      The `CONVERT' specifier and the GFORTRAN_CONVERT_UNIT environment
-      variable override the default specified by `-fconvert'._
- 
- `-frecord-marker=LENGTH'
-      Specify the length of record markers for unformatted files.  Valid
-      values for LENGTH are 4 and 8.  Default is 4.  _This is different
-      from previous versions of `gfortran'_, which specified a default
-      record marker length of 8 on most systems.  If you want to read or
-      write files compatible with earlier versions of `gfortran', use
-      `-frecord-marker=8'.
- 
- `-fmax-subrecord-length=LENGTH'
-      Specify the maximum length for a subrecord.  The maximum permitted
-      value for length is 2147483639, which is also the default.  Only
-      really useful for use by the gfortran testsuite.
- 
- 
- File: gfortran.info,  Node: Code Gen Options,  Next: Environment Variables,  Prev: Runtime Options,  Up: Invoking GNU Fortran
- 
- 2.7 Options for code generation conventions
- ===========================================
- 
- These machine-independent options control the interface conventions
- used in code generation.
- 
-    Most of them have both positive and negative forms; the negative form
- of `-ffoo' would be `-fno-foo'.  In the table below, only one of the
- forms is listed--the one which is not the default.  You can figure out
- the other form by either removing `no-' or adding it.
- 
- `-fno-automatic'
-      Treat each program unit as if the `SAVE' statement was specified
-      for every local variable and array referenced in it. Does not
-      affect common blocks. (Some Fortran compilers provide this option
-      under the name `-static'.)
- 
- `-ff2c'
-      Generate code designed to be compatible with code generated by
-      `g77' and `f2c'.
- 
-      The calling conventions used by `g77' (originally implemented in
-      `f2c') require functions that return type default `REAL' to
-      actually return the C type `double', and functions that return
-      type `COMPLEX' to return the values via an extra argument in the
-      calling sequence that points to where to store the return value.
-      Under the default GNU calling conventions, such functions simply
-      return their results as they would in GNU C--default `REAL'
-      functions return the C type `float', and `COMPLEX' functions
-      return the GNU C type `complex'.  Additionally, this option
-      implies the `-fsecond-underscore' option, unless
-      `-fno-second-underscore' is explicitly requested.
- 
-      This does not affect the generation of code that interfaces with
-      the `libgfortran' library.
- 
-      _Caution:_ It is not a good idea to mix Fortran code compiled with
-      `-ff2c' with code compiled with the default `-fno-f2c' calling
-      conventions as, calling `COMPLEX' or default `REAL' functions
-      between program parts which were compiled with different calling
-      conventions will break at execution time.
- 
-      _Caution:_ This will break code which passes intrinsic functions
-      of type default `REAL' or `COMPLEX' as actual arguments, as the
-      library implementations use the `-fno-f2c' calling conventions.
- 
- `-fno-underscoring'
-      Do not transform names of entities specified in the Fortran source
-      file by appending underscores to them.
- 
-      With `-funderscoring' in effect, GNU Fortran appends one
-      underscore to external names with no underscores.  This is done to
-      ensure compatibility with code produced by many UNIX Fortran
-      compilers.
- 
-      _Caution_: The default behavior of GNU Fortran is incompatible
-      with `f2c' and `g77', please use the `-ff2c' option if you want
-      object files compiled with GNU Fortran to be compatible with
-      object code created with these tools.
- 
-      Use of `-fno-underscoring' is not recommended unless you are
-      experimenting with issues such as integration of GNU Fortran into
-      existing system environments (vis-a-vis existing libraries, tools,
-      and so on).
- 
-      For example, with `-funderscoring', and assuming other defaults
-      like `-fcase-lower' and that `j()' and `max_count()' are external
-      functions while `my_var' and `lvar' are local variables, a
-      statement like
-           I = J() + MAX_COUNT (MY_VAR, LVAR)
-      is implemented as something akin to:
-           i = j_() + max_count__(&my_var__, &lvar);
- 
-      With `-fno-underscoring', the same statement is implemented as:
- 
-           i = j() + max_count(&my_var, &lvar);
- 
-      Use of `-fno-underscoring' allows direct specification of
-      user-defined names while debugging and when interfacing GNU Fortran
-      code with other languages.
- 
-      Note that just because the names match does _not_ mean that the
-      interface implemented by GNU Fortran for an external name matches
-      the interface implemented by some other language for that same
-      name.  That is, getting code produced by GNU Fortran to link to
-      code produced by some other compiler using this or any other
-      method can be only a small part of the overall solution--getting
-      the code generated by both compilers to agree on issues other than
-      naming can require significant effort, and, unlike naming
-      disagreements, linkers normally cannot detect disagreements in
-      these other areas.
- 
-      Also, note that with `-fno-underscoring', the lack of appended
-      underscores introduces the very real possibility that a
-      user-defined external name will conflict with a name in a system
-      library, which could make finding unresolved-reference bugs quite
-      difficult in some cases--they might occur at program run time, and
-      show up only as buggy behavior at run time.
- 
-      In future versions of GNU Fortran we hope to improve naming and
-      linking issues so that debugging always involves using the names
-      as they appear in the source, even if the names as seen by the
-      linker are mangled to prevent accidental linking between
-      procedures with incompatible interfaces.
- 
- `-fsecond-underscore'
-      By default, GNU Fortran appends an underscore to external names.
-      If this option is used GNU Fortran appends two underscores to
-      names with underscores and one underscore to external names with
-      no underscores.  GNU Fortran also appends two underscores to
-      internal names with underscores to avoid naming collisions with
-      external names.
- 
-      This option has no effect if `-fno-underscoring' is in effect.  It
-      is implied by the `-ff2c' option.
- 
-      Otherwise, with this option, an external name such as `MAX_COUNT'
-      is implemented as a reference to the link-time external symbol
-      `max_count__', instead of `max_count_'.  This is required for
-      compatibility with `g77' and `f2c', and is implied by use of the
-      `-ff2c' option.
- 
- `-fbounds-check'
-      Enable generation of run-time checks for array subscripts and
-      against the declared minimum and maximum values.  It also checks
-      array indices for assumed and deferred shape arrays against the
-      actual allocated bounds.
- 
-      In the future this may also include other forms of checking, e.g.,
-      checking substring references.
- 
- `-fmax-stack-var-size=N'
-      This option specifies the size in bytes of the largest array that
-      will be put on the stack.
- 
-      This option currently only affects local arrays declared with
-      constant bounds, and may not apply to all character variables.
-      Future versions of GNU Fortran may improve this behavior.
- 
-      The default value for N is 32768.
- 
- `-fpack-derived'
-      This option tells GNU Fortran to pack derived type members as
-      closely as possible.  Code compiled with this option is likely to
-      be incompatible with code compiled without this option, and may
-      execute slower.
- 
- `-frepack-arrays'
-      In some circumstances GNU Fortran may pass assumed shape array
-      sections via a descriptor describing a noncontiguous area of
-      memory.  This option adds code to the function prologue to repack
-      the data into a contiguous block at runtime.
- 
-      This should result in faster accesses to the array.  However it
-      can introduce significant overhead to the function call,
-      especially  when the passed data is noncontiguous.
- 
- `-fshort-enums'
-      This option is provided for interoperability with C code that was
-      compiled with the `-fshort-enums' option.  It will make GNU
-      Fortran choose the smallest `INTEGER' kind a given enumerator set
-      will fit in, and give all its enumerators this kind.
- 
- 
-    *Note Options for Code Generation Conventions: (gcc)Code Gen
- Options, for information on more options offered by the GBE shared by
- `gfortran', `gcc', and other GNU compilers.
- 
- 
- File: gfortran.info,  Node: Environment Variables,  Prev: Code Gen Options,  Up: Invoking GNU Fortran
- 
- 2.8 Environment variables affecting `gfortran'
- ==============================================
- 
- The `gfortran' compiler currently does not make use of any environment
- variables to control its operation above and beyond those that affect
- the operation of `gcc'.
- 
-    *Note Environment Variables Affecting GCC: (gcc)Environment
- Variables, for information on environment variables.
- 
-    *Note Runtime::, for environment variables that affect the run-time
- behavior of programs compiled with GNU Fortran.
- 
- 
- File: gfortran.info,  Node: Runtime,  Next: Fortran 2003 status,  Prev: Invoking GNU Fortran,  Up: Top
- 
- 3 Runtime:  Influencing runtime behavior with environment variables
- *******************************************************************
- 
- The behavior of the `gfortran' can be influenced by environment
- variables.
- 
-    Malformed environment variables are silently ignored.
- 
- * Menu:
- 
- * GFORTRAN_STDIN_UNIT:: Unit number for standard input
- * GFORTRAN_STDOUT_UNIT:: Unit number for standard output
- * GFORTRAN_STDERR_UNIT:: Unit number for standard error
- * GFORTRAN_USE_STDERR:: Send library output to standard error
- * GFORTRAN_TMPDIR:: Directory for scratch files
- * GFORTRAN_UNBUFFERED_ALL:: Don't buffer output
- * GFORTRAN_SHOW_LOCUS::  Show location for runtime errors
- * GFORTRAN_OPTIONAL_PLUS:: Print leading + where permitted
- * GFORTRAN_DEFAULT_RECL:: Default record length for new files
- * GFORTRAN_LIST_SEPARATOR::  Separator for list output
- * GFORTRAN_CONVERT_UNIT::  Set endianness for unformatted I/O
- 
- 
- File: gfortran.info,  Node: GFORTRAN_STDIN_UNIT,  Next: GFORTRAN_STDOUT_UNIT,  Up: Runtime
- 
- 3.1 `GFORTRAN_STDIN_UNIT'--Unit number for standard input
- =========================================================
- 
- This environment variable can be used to select the unit number
- preconnected to standard input.  This must be a positive integer.  The
- default value is 5.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_STDOUT_UNIT,  Next: GFORTRAN_STDERR_UNIT,  Prev: GFORTRAN_STDIN_UNIT,  Up: Runtime
- 
- 3.2 `GFORTRAN_STDOUT_UNIT'--Unit number for standard output
- ===========================================================
- 
- This environment variable can be used to select the unit number
- preconnected to standard output.  This must be a positive integer.  The
- default value is 6.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_STDERR_UNIT,  Next: GFORTRAN_USE_STDERR,  Prev: GFORTRAN_STDOUT_UNIT,  Up: Runtime
- 
- 3.3 `GFORTRAN_STDERR_UNIT'--Unit number for standard error
- ==========================================================
- 
- This environment variable can be used to select the unit number
- preconnected to standard error.  This must be a positive integer.  The
- default value is 0.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_USE_STDERR,  Next: GFORTRAN_TMPDIR,  Prev: GFORTRAN_STDERR_UNIT,  Up: Runtime
- 
- 3.4 `GFORTRAN_USE_STDERR'--Send library output to standard error
- ================================================================
- 
- This environment variable controls where library output is sent.  If
- the first letter is `y', `Y' or `1', standard error is used. If the
- first letter is `n', `N' or `0', standard output is used.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_TMPDIR,  Next: GFORTRAN_UNBUFFERED_ALL,  Prev: GFORTRAN_USE_STDERR,  Up: Runtime
- 
- 3.5 `GFORTRAN_TMPDIR'--Directory for scratch files
- ==================================================
- 
- This environment variable controls where scratch files are created.  If
- this environment variable is missing, GNU Fortran searches for the
- environment variable `TMP'.  If this is also missing, the default is
- `/tmp'.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_UNBUFFERED_ALL,  Next: GFORTRAN_SHOW_LOCUS,  Prev: GFORTRAN_TMPDIR,  Up: Runtime
- 
- 3.6 `GFORTRAN_UNBUFFERED_ALL'--Don't buffer output
- ==================================================
- 
- This environment variable controls whether all output is unbuffered.
- If the first letter is `y', `Y' or `1', all output is unbuffered. This
- will slow down large writes.  If the first letter is `n', `N'  or `0',
- output is buffered.  This is the default.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_SHOW_LOCUS,  Next: GFORTRAN_OPTIONAL_PLUS,  Prev: GFORTRAN_UNBUFFERED_ALL,  Up: Runtime
- 
- 3.7 `GFORTRAN_SHOW_LOCUS'--Show location for runtime errors
- ===========================================================
- 
- If the first letter is `y', `Y' or `1', filename and line numbers for
- runtime errors are printed.  If the first letter is `n', `N' or `0',
- don't print filename and line numbers for runtime errors. The default
- is to print the location.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_OPTIONAL_PLUS,  Next: GFORTRAN_DEFAULT_RECL,  Prev: GFORTRAN_SHOW_LOCUS,  Up: Runtime
- 
- 3.8 `GFORTRAN_OPTIONAL_PLUS'--Print leading + where permitted
- =============================================================
- 
- If the first letter is `y', `Y' or `1', a plus sign is printed where
- permitted by the Fortran standard.  If the first letter is `n', `N' or
- `0', a plus sign is not printed in most cases. Default is not to print
- plus signs.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_DEFAULT_RECL,  Next: GFORTRAN_LIST_SEPARATOR,  Prev: GFORTRAN_OPTIONAL_PLUS,  Up: Runtime
- 
- 3.9 `GFORTRAN_DEFAULT_RECL'--Default record length for new files
- ================================================================
- 
- This environment variable specifies the default record length, in
- bytes, for files which are opened without a `RECL' tag in the `OPEN'
- statement.  This must be a positive integer.  The default value is
- 1073741824 bytes (1 GB).
- 
- 
- File: gfortran.info,  Node: GFORTRAN_LIST_SEPARATOR,  Next: GFORTRAN_CONVERT_UNIT,  Prev: GFORTRAN_DEFAULT_RECL,  Up: Runtime
- 
- 3.10 `GFORTRAN_LIST_SEPARATOR'--Separator for list output
- =========================================================
- 
- This environment variable specifies the separator when writing
- list-directed output.  It may contain any number of spaces and at most
- one comma.  If you specify this on the command line, be sure to quote
- spaces, as in
-      $ GFORTRAN_LIST_SEPARATOR='  ,  ' ./a.out
-    when `a.out' is the compiled Fortran program that you want to run.
- Default is a single space.
- 
- 
- File: gfortran.info,  Node: GFORTRAN_CONVERT_UNIT,  Prev: GFORTRAN_LIST_SEPARATOR,  Up: Runtime
- 
- 3.11 `GFORTRAN_CONVERT_UNIT'--Set endianness for unformatted I/O
- ================================================================
- 
- By setting the `GFORTRAN_CONVERT_UNIT' variable, it is possible to
- change the representation of data for unformatted files.  The syntax
- for the `GFORTRAN_CONVERT_UNIT' variable is:
-      GFORTRAN_CONVERT_UNIT: mode | mode ';' exception | exception ;
-      mode: 'native' | 'swap' | 'big_endian' | 'little_endian' ;
-      exception: mode ':' unit_list | unit_list ;
-      unit_list: unit_spec | unit_list unit_spec ;
-      unit_spec: INTEGER | INTEGER '-' INTEGER ;
-    The variable consists of an optional default mode, followed by a
- list of optional exceptions, which are separated by semicolons from the
- preceding default and each other.  Each exception consists of a format
- and a comma-separated list of units.  Valid values for the modes are
- the same as for the `CONVERT' specifier:
- 
-      `NATIVE' Use the native format.  This is the default.
- 
-      `SWAP' Swap between little- and big-endian.
- 
-      `LITTLE_ENDIAN' Use the little-endian format         for
-      unformatted files.
- 
-      `BIG_ENDIAN' Use the big-endian format for unformatted files.
-    A missing mode for an exception is taken to mean `BIG_ENDIAN'.
- Examples of values for `GFORTRAN_CONVERT_UNIT' are:
-      `'big_endian''  Do all unformatted I/O in big_endian mode.
- 
-      `'little_endian;native:10-20,25''  Do all unformatted I/O in
-      little_endian mode, except for units 10 to 20 and 25, which are in
-      native format.
- 
-      `'10-20''  Units 10 to 20 are big-endian, the rest is native.
- 
-    Setting the environment variables should be done on the command line
- or via the `export' command for `sh'-compatible shells and via `setenv'
- for `csh'-compatible shells.
- 
-    Example for `sh':
-      $ gfortran foo.f90
-      $ GFORTRAN_CONVERT_UNIT='big_endian;native:10-20' ./a.out
- 
-    Example code for `csh':
-      % gfortran foo.f90
-      % setenv GFORTRAN_CONVERT_UNIT 'big_endian;native:10-20'
-      % ./a.out
- 
-    Using anything but the native representation for unformatted data
- carries a significant speed overhead.  If speed in this area matters to
- you, it is best if you use this only for data that needs to be portable.
- 
-    *Note CONVERT specifier::, for an alternative way to specify the
- data representation for unformatted files.  *Note Runtime Options::, for
- setting a default data representation for the whole program.  The
- `CONVERT' specifier overrides the `-fconvert' compile options.
- 
-    _Note that the values specified via the GFORTRAN_CONVERT_UNIT
- environment variable will override the CONVERT specifier in the open
- statement_.  This is to give control over data formats to users who do
- not have the source code of their program available.
- 
- 
- File: gfortran.info,  Node: Fortran 2003 status,  Next: Extensions,  Prev: Runtime,  Up: Top
- 
- 4 Fortran 2003 Status
- *********************
- 
- Although GNU Fortran focuses on implementing the Fortran 95 standard
- for the time being, a few Fortran 2003 features are currently available.
- 
-    * Intrinsics `command_argument_count', `get_command',
-      `get_command_argument', `get_environment_variable', and
-      `move_alloc'.
- 
-    * Array constructors using square brackets. That is, `[...]' rather
-      than `(/.../)'.
- 
-    * `FLUSH' statement.
- 
-    * `IOMSG=' specifier for I/O statements.
- 
-    * Support for the declaration of enumeration constants via the
-      `ENUM' and `ENUMERATOR' statements.  Interoperability with `gcc'
-      is guaranteed also for the case where the `-fshort-enums' command
-      line option is given.
- 
-    * TR 15581:
-         * `ALLOCATABLE' dummy arguments.
- 
-         * `ALLOCATABLE' function results
- 
-         * `ALLOCATABLE' components of derived types
- 
-    * The `OPEN' statement supports the `ACCESS='STREAM'' specifier,
-      allowing I/O without any record structure.
- 
- 
- 
- File: gfortran.info,  Node: Extensions,  Next: Intrinsic Procedures,  Prev: Fortran 2003 status,  Up: Top
- 
- 5 Extensions
- ************
- 
- GNU Fortran implements a number of extensions over standard Fortran.
- This chapter contains information on their syntax and meaning.  There
- are currently two categories of GNU Fortran extensions, those that
- provide functionality beyond that provided by any standard, and those
- that are supported by GNU Fortran purely for backward compatibility
- with legacy compilers.  By default, `-std=gnu' allows the compiler to
- accept both types of extensions, but to warn about the use of the
- latter.  Specifying either `-std=f95' or `-std=f2003' disables both
- types of extensions, and `-std=legacy' allows both without warning.
- 
- * Menu:
- 
- * Old-style kind specifications::
- * Old-style variable initialization::
- * Extensions to namelist::
- * X format descriptor without count field::
- * Commas in FORMAT specifications::
- * Missing period in FORMAT specifications::
- * I/O item lists::
- * BOZ literal constants::
- * Real array indices::
- * Unary operators::
- * Implicitly convert LOGICAL and INTEGER values::
- * Hollerith constants support::
- * Cray pointers::
- * CONVERT specifier::
- * OpenMP::
- 
- 
- File: gfortran.info,  Node: Old-style kind specifications,  Next: Old-style variable initialization,  Up: Extensions
- 
- 5.1 Old-style kind specifications
- =================================
- 
- GNU Fortran allows old-style kind specifications in declarations. These
- look like:
-            TYPESPEC*size x,y,z
-    where `TYPESPEC' is a basic type (`INTEGER', `REAL', etc.), and
- where `size' is a byte count corresponding to the storage size of a
- valid kind for that type.  (For `COMPLEX' variables, `size' is the
- total size of the real and imaginary parts.)  The statement then
- declares `x', `y' and `z' to be of type `TYPESPEC' with the appropriate
- kind.  This is equivalent to the standard-conforming declaration
-            TYPESPEC(k) x,y,z
-    where `k' is equal to `size' for most types, but is equal to
- `size/2' for the `COMPLEX' type.
- 
- 
- File: gfortran.info,  Node: Old-style variable initialization,  Next: Extensions to namelist,  Prev: Old-style kind specifications,  Up: Extensions
- 
- 5.2 Old-style variable initialization
- =====================================
- 
- GNU Fortran allows old-style initialization of variables of the form:
-            INTEGER i/1/,j/2/
-            REAL x(2,2) /3*0.,1./
-    The syntax for the initializers is as for the `DATA' statement, but
- unlike in a `DATA' statement, an initializer only applies to the
- variable immediately preceding the initialization.  In other words,
- something like `INTEGER I,J/2,3/' is not valid.  This style of
- initialization is only allowed in declarations without double colons
- (`::'); the double colons were introduced in Fortran 90, which also
- introduced a standard syntax for initializing variables in type
- declarations.
- 
-    Examples of standard-conforming code equivalent to the above example
- are:
-      ! Fortran 90
-            INTEGER :: i = 1, j = 2
-            REAL :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
-      ! Fortran 77
-            INTEGER i, j
-            REAL x(2,2)
-            DATA i/1/, j/2/, x/3*0.,1./
- 
-    Note that variables which are explicitly initialized in declarations
- or in `DATA' statements automatically acquire the `SAVE' attribute.
- 
- 
- File: gfortran.info,  Node: Extensions to namelist,  Next: X format descriptor without count field,  Prev: Old-style variable initialization,  Up: Extensions
- 
- 5.3 Extensions to namelist
- ==========================
- 
- GNU Fortran fully supports the Fortran 95 standard for namelist I/O
- including array qualifiers, substrings and fully qualified derived
- types.  The output from a namelist write is compatible with namelist
- read.  The output has all names in upper case and indentation to column
- 1 after the namelist name.  Two extensions are permitted:
- 
-    Old-style use of `$' instead of `&'
-      $MYNML
-       X(:)%Y(2) = 1.0 2.0 3.0
-       CH(1:4) = "abcd"
-      $END
- 
-    It should be noted that the default terminator is `/' rather than
- `&END'.
- 
-    Querying of the namelist when inputting from stdin. After at least
- one space, entering `?' sends to stdout the namelist name and the names
- of the variables in the namelist:
-       ?
- 
-      &mynml
-       x
-       x%y
-       ch
-      &end
- 
-    Entering `=?' outputs the namelist to stdout, as if `WRITE(*,NML =
- mynml)' had been called:
-      =?
- 
-      &MYNML
-       X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
-       X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
-       X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
-       CH=abcd,  /
- 
-    To aid this dialog, when input is from stdin, errors send their
- messages to stderr and execution continues, even if `IOSTAT' is set.
- 
-    `PRINT' namelist is permitted.  This causes an error if `-std=f95'
- is used.
-      PROGRAM test_print
-        REAL, dimension (4)  ::  x = (/1.0, 2.0, 3.0, 4.0/)
-        NAMELIST /mynml/ x
-        PRINT mynml
-      END PROGRAM test_print
- 
-    Expanded namelist reads are permitted.  This causes an error if
- `-std=f95' is used.  In the following example, the first element of the
- array will be given the value 0.00 and the two succeeding elements will
- be given the values 1.00 and 2.00.
-      &MYNML
-        X(1,1) = 0.00 , 1.00 , 2.00
-      /
- 
- 
- File: gfortran.info,  Node: X format descriptor without count field,  Next: Commas in FORMAT specifications,  Prev: Extensions to namelist,  Up: Extensions
- 
- 5.4 `X' format descriptor without count field
- =============================================
- 
- To support legacy codes, GNU Fortran permits the count field of the `X'
- edit descriptor in `FORMAT' statements to be omitted.  When omitted,
- the count is implicitly assumed to be one.
- 
-             PRINT 10, 2, 3
-      10     FORMAT (I1, X, I1)
- 
- 
- File: gfortran.info,  Node: Commas in FORMAT specifications,  Next: Missing period in FORMAT specifications,  Prev: X format descriptor without count field,  Up: Extensions
- 
- 5.5 Commas in `FORMAT' specifications
- =====================================
- 
- To support legacy codes, GNU Fortran allows the comma separator to be
- omitted immediately before and after character string edit descriptors
- in `FORMAT' statements.
- 
-             PRINT 10, 2, 3
-      10     FORMAT ('FOO='I1' BAR='I2)
- 
- 
- File: gfortran.info,  Node: Missing period in FORMAT specifications,  Next: I/O item lists,  Prev: Commas in FORMAT specifications,  Up: Extensions
- 
- 5.6 Missing period in `FORMAT' specifications
- =============================================
- 
- To support legacy codes, GNU Fortran allows missing periods in format
- specifications if and only if `-std=legacy' is given on the command
- line.  This is considered non-conforming code and is discouraged.
- 
-             REAL :: value
-             READ(*,10) value
-      10     FORMAT ('F4')
- 
- 
- File: gfortran.info,  Node: I/O item lists,  Next: BOZ literal constants,  Prev: Missing period in FORMAT specifications,  Up: Extensions
- 
- 5.7 I/O item lists
- ==================
- 
- To support legacy codes, GNU Fortran allows the input item list of the
- `READ' statement, and the output item lists of the `WRITE' and `PRINT'
- statements, to start with a comma.
- 
- 
- File: gfortran.info,  Node: BOZ literal constants,  Next: Real array indices,  Prev: I/O item lists,  Up: Extensions
- 
- 5.8 BOZ literal constants
- =========================
- 
- As an extension, GNU Fortran allows hexadecimal BOZ literal constants to
- be specified using the X prefix, in addition to the standard Z prefix.
- BOZ literal constants can also be specified by adding a suffix to the
- string. For example, `Z'ABC'' and `'ABC'Z' are equivalent.
- 
-    The Fortran standard restricts the appearance of a BOZ literal
- constant to the `DATA' statement, and it is expected to be assigned to
- an `INTEGER' variable.  GNU Fortran permits a BOZ literal to appear in
- any initialization expression as well as assignment statements.
- 
-    Attempts to use a BOZ literal constant to do a bitwise
- initialization of a variable can lead to confusion.  A BOZ literal
- constant is converted to an `INTEGER' value with the kind type with the
- largest decimal representation, and this value is then converted
- numerically to the type and kind of the variable in question.  Thus,
- one should not expect a bitwise copy of the BOZ literal constant to be
- assigned to a `REAL' variable.
- 
-    Similarly, initializing an `INTEGER' variable with a statement such
- as `DATA i/Z'FFFFFFFF'/' will produce an integer overflow rather than
- the desired result of -1 when `i' is a 32-bit integer on a system that
- supports 64-bit integers.  The `-fno-range-check' option can be used as
- a workaround for legacy code that initializes integers in this manner.
- 
- 
- File: gfortran.info,  Node: Real array indices,  Next: Unary operators,  Prev: BOZ literal constants,  Up: Extensions
- 
- 5.9 Real array indices
- ======================
- 
- As an extension, GNU Fortran allows the use of `REAL' expressions or
- variables as array indices.
- 
- 
- File: gfortran.info,  Node: Unary operators,  Next: Implicitly convert LOGICAL and INTEGER values,  Prev: Real array indices,  Up: Extensions
- 
- 5.10 Unary operators
- ====================
- 
- As an extension, GNU Fortran allows unary plus and unary minus operators
- to appear as the second operand of binary arithmetic operators without
- the need for parenthesis.
- 
-             X = Y * -Z
- 
- 
- File: gfortran.info,  Node: Implicitly convert LOGICAL and INTEGER values,  Next: Hollerith constants support,  Prev: Unary operators,  Up: Extensions
- 
- 5.11 Implicitly convert `LOGICAL' and `INTEGER' values
- ======================================================
- 
- As an extension for backwards compatibility with other compilers, GNU
- Fortran allows the implicit conversion of `LOGICAL' values to `INTEGER'
- values and vice versa.  When converting from a `LOGICAL' to an
- `INTEGER', `.FALSE.' is interpreted as zero, and `.TRUE.' is
- interpreted as one.  When converting from `INTEGER' to `LOGICAL', the
- value zero is interpreted as `.FALSE.' and any nonzero value is
- interpreted as `.TRUE.'.
- 
-             INTEGER :: i = 1
-             IF (i) PRINT *, 'True'
- 
- 
- File: gfortran.info,  Node: Hollerith constants support,  Next: Cray pointers,  Prev: Implicitly convert LOGICAL and INTEGER values,  Up: Extensions
- 
- 5.12 Hollerith constants support
- ================================
- 
- GNU Fortran supports Hollerith constants in assignments, function
- arguments, and `DATA' and `ASSIGN' statements.  A Hollerith constant is
- written as a string of characters preceded by an integer constant
- indicating the character count, and the letter `H' or `h', and stored
- in bytewise fashion in a numeric (`INTEGER', `REAL', or `complex') or
- `LOGICAL' variable.  The constant will be padded or truncated to fit
- the size of the variable in which it is stored.
- 
-    Examples of valid uses of Hollerith constants:
-            complex*16 x(2)
-            data x /16Habcdefghijklmnop, 16Hqrstuvwxyz012345/
-            x(1) = 16HABCDEFGHIJKLMNOP
-            call foo (4h abc)
- 
-    Invalid Hollerith constants examples:
-            integer*4 a
-            a = 8H12345678 ! Valid, but the Hollerith constant will be truncated.
-            a = 0H         ! At least one character is needed.
- 
-    In general, Hollerith constants were used to provide a rudimentary
- facility for handling character strings in early Fortran compilers,
- prior to the introduction of `CHARACTER' variables in Fortran 77; in
- those cases, the standard-compliant equivalent is to convert the
- program to use proper character strings.  On occasion, there may be a
- case where the intent is specifically to initialize a numeric variable
- with a given byte sequence.  In these cases, the same result can be
- obtained by using the `TRANSFER' statement, as in this example.
-            INTEGER(KIND=4) :: a
-            a = TRANSFER ("abcd", a)     ! equivalent to: a = 4Habcd
- 
- 
- File: gfortran.info,  Node: Cray pointers,  Next: CONVERT specifier,  Prev: Hollerith constants support,  Up: Extensions
- 
- 5.13 Cray pointers
- ==================
- 
- Cray pointers are part of a non-standard extension that provides a
- C-like pointer in Fortran.  This is accomplished through a pair of
- variables: an integer "pointer" that holds a memory address, and a
- "pointee" that is used to dereference the pointer.
- 
-    Pointer/pointee pairs are declared in statements of the form:
-              pointer ( <pointer> , <pointee> )
-    or,
-              pointer ( <pointer1> , <pointee1> ), ( <pointer2> , <pointee2> ), ...
-    The pointer is an integer that is intended to hold a memory address.
- The pointee may be an array or scalar.  A pointee can be an assumed
- size array--that is, the last dimension may be left unspecified by
- using a `*' in place of a value--but a pointee cannot be an assumed
- shape array.  No space is allocated for the pointee.
- 
-    The pointee may have its type declared before or after the pointer
- statement, and its array specification (if any) may be declared before,
- during, or after the pointer statement.  The pointer may be declared as
- an integer prior to the pointer statement.  However, some machines have
- default integer sizes that are different than the size of a pointer,
- and so the following code is not portable:
-              integer ipt
-              pointer (ipt, iarr)
-    If a pointer is declared with a kind that is too small, the compiler
- will issue a warning; the resulting binary will probably not work
- correctly, because the memory addresses stored in the pointers may be
- truncated.  It is safer to omit the first line of the above example; if
- explicit declaration of ipt's type is omitted, then the compiler will
- ensure that ipt is an integer variable large enough to hold a pointer.
- 
-    Pointer arithmetic is valid with Cray pointers, but it is not the
- same as C pointer arithmetic.  Cray pointers are just ordinary
- integers, so the user is responsible for determining how many bytes to
- add to a pointer in order to increment it.  Consider the following
- example:
-              real target(10)
-              real pointee(10)
-              pointer (ipt, pointee)
-              ipt = loc (target)
-              ipt = ipt + 1
-    The last statement does not set `ipt' to the address of `target(1)',
- as it would in C pointer arithmetic.  Adding `1' to `ipt' just adds one
- byte to the address stored in `ipt'.
- 
-    Any expression involving the pointee will be translated to use the
- value stored in the pointer as the base address.
- 
-    To get the address of elements, this extension provides an intrinsic
- function `LOC()'.  The `LOC()' function is equivalent to the `&'
- operator in C, except the address is cast to an integer type:
-              real ar(10)
-              pointer(ipt, arpte(10))
-              real arpte
-              ipt = loc(ar)  ! Makes arpte is an alias for ar
-              arpte(1) = 1.0 ! Sets ar(1) to 1.0
-    The pointer can also be set by a call to the `MALLOC' intrinsic (see
- *Note MALLOC::).
- 
-    Cray pointees often are used to alias an existing variable.  For
- example:
-              integer target(10)
-              integer iarr(10)
-              pointer (ipt, iarr)
-              ipt = loc(target)
-    As long as `ipt' remains unchanged, `iarr' is now an alias for
- `target'. The optimizer, however, will not detect this aliasing, so it
- is unsafe to use `iarr' and `target' simultaneously.  Using a pointee
- in any way that violates the Fortran aliasing rules or assumptions is
- illegal. It is the user's responsibility to avoid doing this; the
- compiler works under the assumption that no such aliasing occurs.
- 
-    Cray pointers will work correctly when there is no aliasing (i.e.,
- when they are used to access a dynamically allocated block of memory),
- and also in any routine where a pointee is used, but any variable with
- which it shares storage is not used.  Code that violates these rules
- may not run as the user intends.  This is not a bug in the optimizer;
- any code that violates the aliasing rules is illegal.  (Note that this
- is not unique to GNU Fortran; any Fortran compiler that supports Cray
- pointers will "incorrectly" optimize code with illegal aliasing.)
- 
-    There are a number of restrictions on the attributes that can be
- applied to Cray pointers and pointees.  Pointees may not have the
- `ALLOCATABLE', `INTENT', `OPTIONAL', `DUMMY', `TARGET', `INTRINSIC', or
- `POINTER' attributes. Pointers may not have the `DIMENSION', `POINTER',
- `TARGET', `ALLOCATABLE', `EXTERNAL', or `INTRINSIC' attributes.
- Pointees may not occur in more than one pointer statement.  A pointee
- cannot be a pointer.  Pointees cannot occur in equivalence, common, or
- data statements.
- 
-    A Cray pointer may also point to a function or a subroutine.  For
- example, the following excerpt is valid:
-        implicit none
-        external sub
-        pointer (subptr,subpte)
-        external subpte
-        subptr = loc(sub)
-        call subpte()
-        [...]
-        subroutine sub
-        [...]
-        end subroutine sub
- 
-    A pointer may be modified during the course of a program, and this
- will change the location to which the pointee refers.  However, when
- pointees are passed as arguments, they are treated as ordinary
- variables in the invoked function.  Subsequent changes to the pointer
- will not change the base address of the array that was passed.
- 
- 
- File: gfortran.info,  Node: CONVERT specifier,  Next: OpenMP,  Prev: Cray pointers,  Up: Extensions
- 
- 5.14 CONVERT specifier
- ======================
- 
- GNU Fortran allows the conversion of unformatted data between little-
- and big-endian representation to facilitate moving of data between
- different systems.  The conversion can be indicated with the `CONVERT'
- specifier on the `OPEN' statement.  *Note GFORTRAN_CONVERT_UNIT::, for
- an alternative way of specifying the data format via an environment
- variable.
- 
-    Valid values for `CONVERT' are:
-      `CONVERT='NATIVE'' Use the native format.  This is the default.
- 
-      `CONVERT='SWAP'' Swap between little- and big-endian.
- 
-      `CONVERT='LITTLE_ENDIAN'' Use the little-endian representation
-         for unformatted files.
- 
-      `CONVERT='BIG_ENDIAN'' Use the big-endian representation for
-       unformatted files.
- 
-    Using the option could look like this:
-        open(file='big.dat',form='unformatted',access='sequential', &
-             convert='big_endian')
- 
-    The value of the conversion can be queried by using
- `INQUIRE(CONVERT=ch)'.  The values returned are `'BIG_ENDIAN'' and
- `'LITTLE_ENDIAN''.
- 
-    `CONVERT' works between big- and little-endian for `INTEGER' values
- of all supported kinds and for `REAL' on IEEE systems of kinds 4 and 8.
- Conversion between different "extended double" types on different
- architectures such as m68k and x86_64, which GNU Fortran supports as
- `REAL(KIND=10)' and `REAL(KIND=16)', will probably not work.
- 
-    _Note that the values specified via the GFORTRAN_CONVERT_UNIT
- environment variable will override the CONVERT specifier in the open
- statement_.  This is to give control over data formats to users who do
- not have the source code of their program available.
- 
-    Using anything but the native representation for unformatted data
- carries a significant speed overhead.  If speed in this area matters to
- you, it is best if you use this only for data that needs to be portable.
- 
- 
- File: gfortran.info,  Node: OpenMP,  Prev: CONVERT specifier,  Up: Extensions
- 
- 5.15 OpenMP
- ===========
- 
- GNU Fortran attempts to be OpenMP Application Program Interface v2.5
- compatible when invoked with the `-fopenmp' option.  GNU Fortran then
- generates parallelized code according to the OpenMP directives used in
- the source.  The OpenMP Fortran runtime library routines are provided
- both in a form of a Fortran 90 module named `omp_lib' and in a form of
- a Fortran `include' file named `omp_lib.h'.
- 
-    For details refer to the actual OpenMP Application Program Interface
- v2.5 (http://www.openmp.org/drupal/mp-documents/spec25.pdf)
- specification.
- 
- 
- File: gfortran.info,  Node: Intrinsic Procedures,  Next: Contributing,  Prev: Extensions,  Up: Top
- 
- 6 Intrinsic Procedures
- **********************
- 
- * Menu:
- 
- * Introduction:         Introduction to Intrinsics
- * `ABORT':         ABORT,     Abort the program
- * `ABS':           ABS,       Absolute value
- * `ACCESS':        ACCESS,    Checks file access modes
- * `ACHAR':         ACHAR,     Character in ASCII collating sequence
- * `ACOS':          ACOS,      Arccosine function
- * `ACOSH':         ACOSH,     Hyperbolic arccosine function
- * `ADJUSTL':       ADJUSTL,   Left adjust a string
- * `ADJUSTR':       ADJUSTR,   Right adjust a string
- * `AIMAG':         AIMAG,     Imaginary part of complex number
- * `AINT':          AINT,      Truncate to a whole number
- * `ALARM':         ALARM,     Set an alarm clock
- * `ALL':           ALL,       Determine if all values are true
- * `ALLOCATED':     ALLOCATED, Status of allocatable entity
- * `AND':           AND,       Bitwise logical AND
- * `ANINT':         ANINT,     Nearest whole number
- * `ANY':           ANY,       Determine if any values are true
- * `ASIN':          ASIN,      Arcsine function
- * `ASINH':         ASINH,     Hyperbolic arcsine function
- * `ASSOCIATED':    ASSOCIATED, Status of a pointer or pointer/target pair
- * `ATAN':          ATAN,      Arctangent function
- * `ATAN2':         ATAN2,     Arctangent function
- * `ATANH':         ATANH,     Hyperbolic arctangent function
- * `BESJ0':         BESJ0,     Bessel function of the first kind of order 0
- * `BESJ1':         BESJ1,     Bessel function of the first kind of order 1
- * `BESJN':         BESJN,     Bessel function of the first kind
- * `BESY0':         BESY0,     Bessel function of the second kind of order 0
- * `BESY1':         BESY1,     Bessel function of the second kind of order 1
- * `BESYN':         BESYN,     Bessel function of the second kind
- * `BIT_SIZE':      BIT_SIZE,  Bit size inquiry function
- * `BTEST':         BTEST,     Bit test function
- * `CEILING':       CEILING,   Integer ceiling function
- * `CHAR':          CHAR,      Integer-to-character conversion function
- * `CHDIR':         CHDIR,     Change working directory
- * `CHMOD':         CHMOD,     Change access permissions of files
- * `CMPLX':         CMPLX,     Complex conversion function
- * `COMMAND_ARGUMENT_COUNT': COMMAND_ARGUMENT_COUNT, Get number of command line arguments
- * `COMPLEX':       COMPLEX,   Complex conversion function
- * `CONJG':         CONJG,     Complex conjugate function
- * `COS':           COS,       Cosine function
- * `COSH':          COSH,      Hyperbolic cosine function
- * `COUNT':         COUNT,     Count occurrences of TRUE in an array
- * `CPU_TIME':      CPU_TIME,  CPU time subroutine
- * `CSHIFT':        CSHIFT,    Circular shift elements of an array
- * `CTIME':         CTIME,     Subroutine (or function) to convert a time into a string
- * `DATE_AND_TIME': DATE_AND_TIME, Date and time subroutine
- * `DBLE':          DBLE,      Double precision conversion function
- * `DCMPLX':        DCMPLX,    Double complex conversion function
- * `DFLOAT':        DFLOAT,    Double precision conversion function
- * `DIGITS':        DIGITS,    Significant digits function
- * `DIM':           DIM,       Positive difference
- * `DOT_PRODUCT':   DOT_PRODUCT, Dot product function
- * `DPROD':         DPROD,     Double product function
- * `DREAL':         DREAL,     Double real part function
- * `DTIME':         DTIME,     Execution time subroutine (or function)
- * `EOSHIFT':       EOSHIFT,   End-off shift elements of an array
- * `EPSILON':       EPSILON,   Epsilon function
- * `ERF':           ERF,       Error function
- * `ERFC':          ERFC,      Complementary error function
- * `ETIME':         ETIME,     Execution time subroutine (or function)
- * `EXIT':          EXIT,      Exit the program with status.
- * `EXP':           EXP,       Exponential function
- * `EXPONENT':      EXPONENT,  Exponent function
- * `FDATE':         FDATE,     Subroutine (or function) to get the current time as a string
- * `FGET':          FGET,      Read a single character in stream mode from stdin
- * `FGETC':         FGETC,     Read a single character in stream mode
- * `FLOAT':         FLOAT,     Convert integer to default real
- * `FLOOR':         FLOOR,     Integer floor function
- * `FLUSH':         FLUSH,     Flush I/O unit(s)
- * `FNUM':          FNUM,      File number function
- * `FPUT':          FPUT,      Write a single character in stream mode to stdout
- * `FPUTC':         FPUTC,     Write a single character in stream mode
- * `FRACTION':      FRACTION,  Fractional part of the model representation
- * `FREE':          FREE,      Memory de-allocation subroutine
- * `FSEEK':         FSEEK,     Low level file positioning subroutine
- * `FSTAT':         FSTAT,     Get file status
- * `FTELL':         FTELL,     Current stream position
- * `GERROR':        GERROR,    Get last system error message
- * `GETARG':        GETARG,    Get command line arguments
- * `GET_COMMAND':   GET_COMMAND, Get the entire command line
- * `GET_COMMAND_ARGUMENT': GET_COMMAND_ARGUMENT, Get command line arguments
- * `GETCWD':        GETCWD,    Get current working directory
- * `GETENV':        GETENV,    Get an environmental variable
- * `GET_ENVIRONMENT_VARIABLE': GET_ENVIRONMENT_VARIABLE, Get an environmental variable
- * `GETGID':        GETGID,    Group ID function
- * `GETLOG':        GETLOG,    Get login name
- * `GETPID':        GETPID,    Process ID function
- * `GETUID':        GETUID,    User ID function
- * `GMTIME':        GMTIME,    Convert time to GMT info
- * `HOSTNM':        HOSTNM,    Get system host name
- * `HUGE':          HUGE,      Largest number of a kind
- * `IACHAR':        IACHAR,    Code in ASCII collating sequence
- * `IAND':          IAND,      Bitwise logical and
- * `IARGC':         IARGC,     Get the number of command line arguments
- * `IBCLR':         IBCLR,     Clear bit
- * `IBITS':         IBITS,     Bit extraction
- * `IBSET':         IBSET,     Set bit
- * `ICHAR':         ICHAR,     Character-to-integer conversion function
- * `IDATE':         IDATE,     Current local time (day/month/year)
- * `IEOR':          IEOR,      Bitwise logical exclusive or
- * `IERRNO':        IERRNO,    Function to get the last system error number
- * `INDEX':         INDEX,     Position of a substring within a string
- * `INT':           INT,       Convert to integer type
- * `INT2':          INT2,      Convert to 16-bit integer type
- * `INT8':          INT8,      Convert to 64-bit integer type
- * `IOR':           IOR,       Bitwise logical or
- * `IRAND':         IRAND,     Integer pseudo-random number
- * `ISATTY':        ISATTY,    Whether a unit is a terminal device
- * `ISHFT':         ISHFT,     Shift bits
- * `ISHFTC':        ISHFTC,    Shift bits circularly
- * `ITIME':         ITIME,     Current local time (hour/minutes/seconds)
- * `KILL':          KILL,      Send a signal to a process
- * `KIND':          KIND,      Kind of an entity
- * `LBOUND':        LBOUND,    Lower dimension bounds of an array
- * `LEN':           LEN,       Length of a character entity
- * `LEN_TRIM':      LEN_TRIM,  Length of a character entity without trailing blank characters
- * `LGE':           LGE,       Lexical greater than or equal
- * `LGT':           LGT,       Lexical greater than
- * `LINK':          LINK,      Create a hard link
- * `LLE':           LLE,       Lexical less than or equal
- * `LLT':           LLT,       Lexical less than
- * `LNBLNK':        LNBLNK,    Index of the last non-blank character in a string
- * `LOC':           LOC,       Returns the address of a variable
- * `LOG':           LOG,       Logarithm function
- * `LOG10':         LOG10,     Base 10 logarithm function
- * `LOGICAL':       LOGICAL,   Convert to logical type
- * `LONG':          LONG,      Convert to integer type
- * `LSHIFT':        LSHIFT,    Left shift bits
- * `LSTAT':         LSTAT,     Get file status
- * `LTIME':         LTIME,     Convert time to local time info
- * `MALLOC':        MALLOC,    Dynamic memory allocation function
- * `MATMUL':        MATMUL,    matrix multiplication
- * `MAX':           MAX,       Maximum value of an argument list
- * `MAXEXPONENT':   MAXEXPONENT, Maximum exponent of a real kind
- * `MAXLOC':        MAXLOC,    Location of the maximum value within an array
- * `MAXVAL':        MAXVAL,    Maximum value of an array
- * `MCLOCK':        MCLOCK,    Time function
- * `MCLOCK8':       MCLOCK8,   Time function (64-bit)
- * `MERGE':         MERGE,     Merge arrays
- * `MIN':           MIN,       Minimum value of an argument list
- * `MINEXPONENT':   MINEXPONENT, Minimum exponent of a real kind
- * `MINLOC':        MINLOC,    Location of the minimum value within an array
- * `MINVAL':        MINVAL,    Minimum value of an array
- * `MOD':           MOD,       Remainder function
- * `MODULO':        MODULO,    Modulo function
- * `MOVE_ALLOC':    MOVE_ALLOC, Move allocation from one object to another
- * `MVBITS':        MVBITS,    Move bits from one integer to another
- * `NEAREST':       NEAREST,   Nearest representable number
- * `NEW_LINE':      NEW_LINE,  New line character
- * `NINT':          NINT,      Nearest whole number
- * `NOT':           NOT,       Logical negation
- * `NULL':          NULL,      Function that returns an disassociated pointer
- * `OR':            OR,        Bitwise logical OR
- * `PACK':          PACK,      Pack an array into an array of rank one
- * `PERROR':        PERROR,    Print system error message
- * `PRECISION':     PRECISION, Decimal precision of a real kind
- * `PRESENT':       PRESENT,   Determine whether an optional dummy argument is specified
- * `PRODUCT':       PRODUCT,   Product of array elements
- * `RADIX':         RADIX,     Base of a data model
- * `RANDOM_NUMBER': RANDOM_NUMBER, Pseudo-random number
- * `RANDOM_SEED':   RANDOM_SEED, Initialize a pseudo-random number sequence
- * `RAND':          RAND,      Real pseudo-random number
- * `RANGE':         RANGE,     Decimal exponent range of a real kind
- * `RAN':           RAN,       Real pseudo-random number
- * `REAL':          REAL,      Convert to real type
- * `RENAME':        RENAME,    Rename a file
- * `REPEAT':        REPEAT,    Repeated string concatenation
- * `RESHAPE':       RESHAPE,   Function to reshape an array
- * `RRSPACING':     RRSPACING, Reciprocal of the relative spacing
- * `RSHIFT':        RSHIFT,    Right shift bits
- * `SCALE':         SCALE,     Scale a real value
- * `SCAN':          SCAN,      Scan a string for the presence of a set of characters
- * `SECNDS':        SECNDS,    Time function
- * `SECOND':        SECOND,    CPU time function
- * `SELECTED_INT_KIND': SELECTED_INT_KIND,  Choose integer kind
- * `SELECTED_REAL_KIND': SELECTED_REAL_KIND,  Choose real kind
- * `SET_EXPONENT':  SET_EXPONENT, Set the exponent of the model
- * `SHAPE':         SHAPE,     Determine the shape of an array
- * `SIGN':          SIGN,      Sign copying function
- * `SIGNAL':        SIGNAL,    Signal handling subroutine (or function)
- * `SIN':           SIN,       Sine function
- * `SINH':          SINH,      Hyperbolic sine function
- * `SIZE':          SIZE,      Function to determine the size of an array
- * `SLEEP':         SLEEP,     Sleep for the specified number of seconds
- * `SNGL':          SNGL,      Convert double precision real to default real
- * `SPACING':       SPACING,   Smallest distance between two numbers of a given type
- * `SPREAD':        SPREAD,    Add a dimension to an array
- * `SQRT':          SQRT,      Square-root function
- * `SRAND':         SRAND,     Reinitialize the random number generator
- * `STAT':          STAT,      Get file status
- * `SUM':           SUM,       Sum of array elements
- * `SYMLNK':        SYMLNK,    Create a symbolic link
- * `SYSTEM':        SYSTEM,    Execute a shell command
- * `SYSTEM_CLOCK':  SYSTEM_CLOCK, Time function
- * `TAN':           TAN,       Tangent function
- * `TANH':          TANH,      Hyperbolic tangent function
- * `TIME':          TIME,      Time function
- * `TIME8':         TIME8,     Time function (64-bit)
- * `TINY':          TINY,      Smallest positive number of a real kind
- * `TRANSFER':      TRANSFER,  Transfer bit patterns
- * `TRANSPOSE':     TRANSPOSE, Transpose an array of rank two
- * `TRIM':          TRIM,      Remove trailing blank characters of a string
- * `TTYNAM':        TTYNAM,    Get the name of a terminal device.
- * `UBOUND':        UBOUND,    Upper dimension bounds of an array
- * `UMASK':         UMASK,     Set the file creation mask
- * `UNLINK':        UNLINK,    Remove a file from the file system
- * `UNPACK':        UNPACK,    Unpack an array of rank one into an array
- * `VERIFY':        VERIFY,    Scan a string for the absence of a set of characters
- * `XOR':           XOR,       Bitwise logical exclusive or
- 
- 
- File: gfortran.info,  Node: Introduction to Intrinsics,  Next: ABORT,  Up: Intrinsic Procedures
- 
- 6.1 Introduction to intrinsic procedures
- ========================================
- 
- The intrinsic procedures provided by GNU Fortran include all of the
- intrinsic procedures required by the Fortran 95 standard, a set of
- intrinsic procedures for backwards compatibility with G77, and a small
- selection of intrinsic procedures from the Fortran 2003 standard.  Any
- conflict between a description here and a description in either the
- Fortran 95 standard or the Fortran 2003 standard is unintentional, and
- the standard(s) should be considered authoritative.
- 
-    The enumeration of the `KIND' type parameter is processor defined in
- the Fortran 95 standard.  GNU Fortran defines the default integer type
- and default real type by `INTEGER(KIND=4)' and `REAL(KIND=4)',
- respectively.  The standard mandates that both data types shall have
- another kind, which have more precision.  On typical target
- architectures supported by `gfortran', this kind type parameter is
- `KIND=8'.  Hence, `REAL(KIND=8)' and `DOUBLE PRECISION' are equivalent.
- In the description of generic intrinsic procedures, the kind type
- parameter will be specified by `KIND=*', and in the description of
- specific names for an intrinsic procedure the kind type parameter will
- be explicitly given (e.g., `REAL(KIND=4)' or `REAL(KIND=8)').  Finally,
- for brevity the optional `KIND=' syntax will be omitted.
- 
-    Many of the intrinsic procedures take one or more optional arguments.
- This document follows the convention used in the Fortran 95 standard,
- and denotes such arguments by square brackets.
- 
-    GNU Fortran offers the `-std=f95' and `-std=gnu' options, which can
- be used to restrict the set of intrinsic procedures to a given
- standard.  By default, `gfortran' sets the `-std=gnu' option, and so
- all intrinsic procedures described here are accepted.  There is one
- caveat.  For a select group of intrinsic procedures, `g77' implemented
- both a function and a subroutine.  Both classes have been implemented
- in `gfortran' for backwards compatibility with `g77'.  It is noted here
- that these functions and subroutines cannot be intermixed in a given
- subprogram.  In the descriptions that follow, the applicable standard
- for each intrinsic procedure is noted.
- 
- 
- File: gfortran.info,  Node: ABORT,  Next: ABS,  Prev: Introduction to Intrinsics,  Up: Intrinsic Procedures
- 
- 6.2 `ABORT' -- Abort the program
- ================================
- 
- _Description_:
-      `ABORT' causes immediate termination of the program.  On operating
-      systems that support a core dump, `ABORT' will produce a core dump,
-      which is suitable for debugging purposes.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL ABORT'
- 
- _Return value_:
-      Does not return.
- 
- _Example_:
-           program test_abort
-             integer :: i = 1, j = 2
-             if (i /= j) call abort
-           end program test_abort
- 
- _See also_:
-      *Note EXIT::, *Note KILL::
- 
- 
- 
- File: gfortran.info,  Node: ABS,  Next: ACCESS,  Prev: ABORT,  Up: Intrinsic Procedures
- 
- 6.3 `ABS' -- Absolute value
- ===========================
- 
- _Description_:
-      `ABS(X)' computes the absolute value of `X'.
- 
- _Standard_:
-      F77 and later, has overloads that are GNU extensions
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ABS(X)'
- 
- _Arguments_:
-      X          The type of the argument shall be an
-                 `INTEGER(*)', `REAL(*)', or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of the same type and kind as the argument
-      except the return value is `REAL(*)' for a `COMPLEX(*)' argument.
- 
- _Example_:
-           program test_abs
-             integer :: i = -1
-             real :: x = -1.e0
-             complex :: z = (-1.e0,0.e0)
-             i = abs(i)
-             x = abs(x)
-             x = abs(z)
-           end program test_abs
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `CABS(Z)'     `COMPLEX(4)   `REAL(4)'     F77 and later
-                    Z'                          
-      `DABS(X)'     `REAL(8)      `REAL(8)'     F77 and later
-                    X'                          
-      `IABS(I)'     `INTEGER(4)   `INTEGER(4)'  F77 and later
-                    I'                          
-      `ZABS(Z)'     `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    Z'                          
-      `CDABS(Z)'    `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    Z'                          
- 
- 
- File: gfortran.info,  Node: ACCESS,  Next: ACHAR,  Prev: ABS,  Up: Intrinsic Procedures
- 
- 6.4 `ACCESS' -- Checks file access modes
- ========================================
- 
- _Description_:
-      `ACCESS(NAME, MODE)' checks whether the file NAME exists, is
-      readable, writable or executable. Except for the executable check,
-      `ACCESS' can be replaced by Fortran 95's `INQUIRE'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = ACCESS(NAME, MODE)'
- 
- _Arguments_:
-      NAME       Scalar `CHARACTER' with the file name.
-                 Tailing blank are ignored unless the character
-                 `achar(0)' is present, then all characters up
-                 to and excluding `achar(0)' are used as file
-                 name.
-      MODE       Scalar `CHARACTER' with the file access mode,
-                 may be any concatenation of `"r"' (readable),
-                 `"w"' (writable) and `"x"' (executable), or `"
-                 "' to check for existence.
- 
- _Return value_:
-      Returns a scalar `INTEGER', which is `0' if the file is accessible
-      in the given mode; otherwise or if an invalid argument has been
-      given for `MODE' the value `1' is returned.
- 
- _Example_:
-           program access_test
-             implicit none
-             character(len=*), parameter :: file  = 'test.dat'
-             character(len=*), parameter :: file2 = 'test.dat  '//achar(0)
-             if(access(file,' ') == 0) print *, trim(file),' is exists'
-             if(access(file,'r') == 0) print *, trim(file),' is readable'
-             if(access(file,'w') == 0) print *, trim(file),' is writable'
-             if(access(file,'x') == 0) print *, trim(file),' is executable'
-             if(access(file2,'rwx') == 0) &
-               print *, trim(file2),' is readable, writable and executable'
-           end program access_test
- 
- _Specific names_:
- 
- _See also_:
- 
- 
- File: gfortran.info,  Node: ACHAR,  Next: ACOS,  Prev: ACCESS,  Up: Intrinsic Procedures
- 
- 6.5 `ACHAR' -- Character in ASCII collating sequence
- ====================================================
- 
- _Description_:
-      `ACHAR(I)' returns the character located at position `I' in the
-      ASCII collating sequence.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ACHAR(I)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `CHARACTER' with a length of one.  The
-      kind type parameter is the same as  `KIND('A')'.
- 
- _Example_:
-           program test_achar
-             character c
-             c = achar(32)
-           end program test_achar
- 
- _Note_:
-      See *Note ICHAR:: for a discussion of converting between numerical
-      values and formatted string representations.
- 
- _See also_:
-      *Note CHAR::, *Note IACHAR::, *Note ICHAR::
- 
- 
- 
- File: gfortran.info,  Node: ACOS,  Next: ACOSH,  Prev: ACHAR,  Up: Intrinsic Procedures
- 
- 6.6 `ACOS' -- Arccosine function
- ================================
- 
- _Description_:
-      `ACOS(X)' computes the arccosine of X (inverse of `COS(X)').
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ACOS(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' with a magnitude
-                 that is less than one.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range  0
-      \leq \acos(x) \leq \pi. The kind type parameter is the same as X.
- 
- _Example_:
-           program test_acos
-             real(8) :: x = 0.866_8
-             x = acos(x)
-           end program test_acos
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DACOS(X)'    `REAL(8) X'   `REAL(8)'     F77 and later
- 
- _See also_:
-      Inverse function: *Note COS::
- 
- 
- 
- File: gfortran.info,  Node: ACOSH,  Next: ADJUSTL,  Prev: ACOS,  Up: Intrinsic Procedures
- 
- 6.7 `ACOSH' -- Hyperbolic arccosine function
- ============================================
- 
- _Description_:
-      `ACOSH(X)' computes the hyperbolic arccosine of X (inverse of
-      `COSH(X)').
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ACOSH(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' with a magnitude
-                 that is greater or equal to one.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range 0
-      \leq \acosh (x) \leq \infty.
- 
- _Example_:
-           PROGRAM test_acosh
-             REAL(8), DIMENSION(3) :: x = (/ 1.0, 2.0, 3.0 /)
-             WRITE (*,*) ACOSH(x)
-           END PROGRAM
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DACOSH(X)'   `REAL(8) X'   `REAL(8)'     GNU extension
- 
- _See also_:
-      Inverse function: *Note COSH::
- 
- 
- File: gfortran.info,  Node: ADJUSTL,  Next: ADJUSTR,  Prev: ACOSH,  Up: Intrinsic Procedures
- 
- 6.8 `ADJUSTL' -- Left adjust a string
- =====================================
- 
- _Description_:
-      `ADJUSTL(STR)' will left adjust a string by removing leading
-      spaces.  Spaces are inserted at the end of the string as needed.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ADJUSTL(STR)'
- 
- _Arguments_:
-      STR        The type shall be `CHARACTER'.
- 
- _Return value_:
-      The return value is of type `CHARACTER' where leading spaces are
-      removed and the same number of spaces are inserted on the end of
-      STR.
- 
- _Example_:
-           program test_adjustl
-             character(len=20) :: str = '   gfortran'
-             str = adjustl(str)
-             print *, str
-           end program test_adjustl
- 
- _See also_:
-      *Note ADJUSTR::, *Note TRIM::
- 
- 
- File: gfortran.info,  Node: ADJUSTR,  Next: AIMAG,  Prev: ADJUSTL,  Up: Intrinsic Procedures
- 
- 6.9 `ADJUSTR' -- Right adjust a string
- ======================================
- 
- _Description_:
-      `ADJUSTR(STR)' will right adjust a string by removing trailing
-      spaces.  Spaces are inserted at the start of the string as needed.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ADJUSTR(STR)'
- 
- _Arguments_:
-      STR        The type shall be `CHARACTER'.
- 
- _Return value_:
-      The return value is of type `CHARACTER' where trailing spaces are
-      removed and the same number of spaces are inserted at the start of
-      STR.
- 
- _Example_:
-           program test_adjustr
-             character(len=20) :: str = 'gfortran'
-             str = adjustr(str)
-             print *, str
-           end program test_adjustr
- 
- _See also_:
-      *Note ADJUSTL::, *Note TRIM::
- 
- 
- File: gfortran.info,  Node: AIMAG,  Next: AINT,  Prev: ADJUSTR,  Up: Intrinsic Procedures
- 
- 6.10 `AIMAG' -- Imaginary part of complex number
- ================================================
- 
- _Description_:
-      `AIMAG(Z)' yields the imaginary part of complex argument `Z'.  The
-      `IMAG(Z)' and `IMAGPART(Z)' intrinsic functions are provided for
-      compatibility with `g77', and their use in new code is strongly
-      discouraged.
- 
- _Standard_:
-      F77 and later, has overloads that are GNU extensions
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = AIMAG(Z)'
- 
- _Arguments_:
-      Z          The type of the argument shall be `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of type real with the kind type parameter of
-      the argument.
- 
- _Example_:
-           program test_aimag
-             complex(4) z4
-             complex(8) z8
-             z4 = cmplx(1.e0_4, 0.e0_4)
-             z8 = cmplx(0.e0_8, 1.e0_8)
-             print *, aimag(z4), dimag(z8)
-           end program test_aimag
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DIMAG(Z)'    `COMPLEX(8)   `REAL(8)'     GNU extension
-                    Z'                          
-      `IMAG(Z)'     `COMPLEX(*)   `REAL(*)'     GNU extension
-                    Z'                          
-      `IMAGPART(Z)' `COMPLEX(*)   `REAL(*)'     GNU extension
-                    Z'                          
- 
- 
- File: gfortran.info,  Node: AINT,  Next: ALARM,  Prev: AIMAG,  Up: Intrinsic Procedures
- 
- 6.11 `AINT' -- Truncate to a whole number
- =========================================
- 
- _Description_:
-      `AINT(X [, KIND])' truncates its argument to a whole number.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = AINT(X [, KIND])'
- 
- _Arguments_:
-      X          The type of the argument shall be `REAL(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is of type real with the kind type parameter of
-      the argument if the optional KIND is absent; otherwise, the kind
-      type parameter will be given by KIND.  If the magnitude of X is
-      less than one, then `AINT(X)' returns zero.  If the magnitude is
-      equal to or greater than one, then it returns the largest whole
-      number that does not exceed its magnitude.  The sign is the same
-      as the sign of X.
- 
- _Example_:
-           program test_aint
-             real(4) x4
-             real(8) x8
-             x4 = 1.234E0_4
-             x8 = 4.321_8
-             print *, aint(x4), dint(x8)
-             x8 = aint(x4,8)
-           end program test_aint
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DINT(X)'     `REAL(8) X'   `REAL(8)'     F77 and later
- 
- 
- File: gfortran.info,  Node: ALARM,  Next: ALL,  Prev: AINT,  Up: Intrinsic Procedures
- 
- 6.12 `ALARM' -- Execute a routine after a given delay
- =====================================================
- 
- _Description_:
-      `ALARM(SECONDS, HANDLER [, STATUS])' causes external subroutine
-      HANDLER to be executed after a delay of SECONDS by using
-      `alarm(2)' to set up a signal and `signal(2)' to catch it. If
-      STATUS is supplied, it will be returned with the number of seconds
-      remaining until any previously scheduled alarm was due to be
-      delivered, or zero if there was no previously scheduled alarm.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL ALARM(SECONDS, HANDLER [, STATUS])'
- 
- _Arguments_:
-      SECONDS    The type of the argument shall be a scalar
-                 `INTEGER'. It is `INTENT(IN)'.
-      HANDLER    Signal handler (`INTEGER FUNCTION' or
-                 `SUBROUTINE') or dummy/global `INTEGER'
-                 scalar. The scalar values may be either
-                 `SIG_IGN=1' to ignore the alarm generated or
-                 `SIG_DFL=0' to set the default action. It is
-                 `INTENT(IN)'.
-      STATUS     (Optional) STATUS shall be a scalar variable
-                 of the default `INTEGER' kind. It is
-                 `INTENT(OUT)'.
- 
- _Example_:
-           program test_alarm
-             external handler_print
-             integer i
-             call alarm (3, handler_print, i)
-             print *, i
-             call sleep(10)
-           end program test_alarm
-      This will cause the external routine HANDLER_PRINT to be called
-      after 3 seconds.
- 
- 
- File: gfortran.info,  Node: ALL,  Next: ALLOCATED,  Prev: ALARM,  Up: Intrinsic Procedures
- 
- 6.13 `ALL' -- All values in MASK along DIM are true
- ===================================================
- 
- _Description_:
-      `ALL(MASK [, DIM])' determines if all the values are true in MASK
-      in the array along dimension DIM.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = ALL(MASK [, DIM])'
- 
- _Arguments_:
-      MASK       The type of the argument shall be `LOGICAL(*)'
-                 and it shall not be scalar.
-      DIM        (Optional) DIM shall be a scalar integer with
-                 a value that lies between one and the rank of
-                 MASK.
- 
- _Return value_:
-      `ALL(MASK)' returns a scalar value of type `LOGICAL(*)' where the
-      kind type parameter is the same as the kind type parameter of
-      MASK.  If DIM is present, then `ALL(MASK, DIM)' returns an array
-      with the rank of MASK minus 1.  The shape is determined from the
-      shape of MASK where the DIM dimension is elided.
- 
-     (A)
-           `ALL(MASK)' is true if all elements of MASK are true.  It
-           also is true if MASK has zero size; otherwise, it is false.
- 
-     (B)
-           If the rank of MASK is one, then `ALL(MASK,DIM)' is equivalent
-           to `ALL(MASK)'.  If the rank is greater than one, then
-           `ALL(MASK,DIM)' is determined by applying `ALL' to the array
-           sections.
- 
- _Example_:
-           program test_all
-             logical l
-             l = all((/.true., .true., .true./))
-             print *, l
-             call section
-             contains
-               subroutine section
-                 integer a(2,3), b(2,3)
-                 a = 1
-                 b = 1
-                 b(2,2) = 2
-                 print *, all(a .eq. b, 1)
-                 print *, all(a .eq. b, 2)
-               end subroutine section
-           end program test_all
- 
- 
- File: gfortran.info,  Node: ALLOCATED,  Next: AND,  Prev: ALL,  Up: Intrinsic Procedures
- 
- 6.14 `ALLOCATED' -- Status of an allocatable entity
- ===================================================
- 
- _Description_:
-      `ALLOCATED(X)' checks the status of whether X is allocated.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = ALLOCATED(X)'
- 
- _Arguments_:
-      X          The argument shall be an `ALLOCATABLE' array.
- 
- _Return value_:
-      The return value is a scalar `LOGICAL' with the default logical
-      kind type parameter.  If X is allocated, `ALLOCATED(X)' is
-      `.TRUE.'; otherwise, it returns the `.TRUE.'
- 
- _Example_:
-           program test_allocated
-             integer :: i = 4
-             real(4), allocatable :: x(:)
-             if (allocated(x) .eqv. .false.) allocate(x(i))
-           end program test_allocated
- 
- 
- File: gfortran.info,  Node: AND,  Next: ANINT,  Prev: ALLOCATED,  Up: Intrinsic Procedures
- 
- 6.15 `AND' -- Bitwise logical AND
- =================================
- 
- _Description_:
-      Bitwise logical `AND'.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77.  For integer arguments, programmers should consider
-      the use of the *Note IAND:: intrinsic defined by the Fortran
-      standard.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = AND(I, J)'
- 
- _Arguments_:
-      I          The type shall be either `INTEGER(*)' or
-                 `LOGICAL'.
-      J          The type shall be either `INTEGER(*)' or
-                 `LOGICAL'.
- 
- _Return value_:
-      The return type is either `INTEGER(*)' or `LOGICAL' after
-      cross-promotion of the arguments.
- 
- _Example_:
-           PROGRAM test_and
-             LOGICAL :: T = .TRUE., F = .FALSE.
-             INTEGER :: a, b
-             DATA a / Z'F' /, b / Z'3' /
- 
-             WRITE (*,*) AND(T, T), AND(T, F), AND(F, T), AND(F, F)
-             WRITE (*,*) AND(a, b)
-           END PROGRAM
- 
- _See also_:
-      F95 elemental function: *Note IAND::
- 
- 
- File: gfortran.info,  Node: ANINT,  Next: ANY,  Prev: AND,  Up: Intrinsic Procedures
- 
- 6.16 `ANINT' -- Nearest whole number
- ====================================
- 
- _Description_:
-      `ANINT(X [, KIND])' rounds its argument to the nearest whole
-      number.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ANINT(X [, KIND])'
- 
- _Arguments_:
-      X          The type of the argument shall be `REAL(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is of type real with the kind type parameter of
-      the argument if the optional KIND is absent; otherwise, the kind
-      type parameter will be given by KIND.  If X is greater than zero,
-      then `ANINT(X)' returns `AINT(X+0.5)'.  If X is less than or equal
-      to zero, then it returns `AINT(X-0.5)'.
- 
- _Example_:
-           program test_anint
-             real(4) x4
-             real(8) x8
-             x4 = 1.234E0_4
-             x8 = 4.321_8
-             print *, anint(x4), dnint(x8)
-             x8 = anint(x4,8)
-           end program test_anint
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DNINT(X)'    `REAL(8) X'   `REAL(8)'     F77 and later
- 
- 
- File: gfortran.info,  Node: ANY,  Next: ASIN,  Prev: ANINT,  Up: Intrinsic Procedures
- 
- 6.17 `ANY' -- Any value in MASK along DIM is true
- =================================================
- 
- _Description_:
-      `ANY(MASK [, DIM])' determines if any of the values in the logical
-      array MASK along dimension DIM are `.TRUE.'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = ANY(MASK [, DIM])'
- 
- _Arguments_:
-      MASK       The type of the argument shall be `LOGICAL(*)'
-                 and it shall not be scalar.
-      DIM        (Optional) DIM shall be a scalar integer with
-                 a value that lies between one and the rank of
-                 MASK.
- 
- _Return value_:
-      `ANY(MASK)' returns a scalar value of type `LOGICAL(*)' where the
-      kind type parameter is the same as the kind type parameter of
-      MASK.  If DIM is present, then `ANY(MASK, DIM)' returns an array
-      with the rank of MASK minus 1.  The shape is determined from the
-      shape of MASK where the DIM dimension is elided.
- 
-     (A)
-           `ANY(MASK)' is true if any element of MASK is true;
-           otherwise, it is false.  It also is false if MASK has zero
-           size.
- 
-     (B)
-           If the rank of MASK is one, then `ANY(MASK,DIM)' is equivalent
-           to `ANY(MASK)'.  If the rank is greater than one, then
-           `ANY(MASK,DIM)' is determined by applying `ANY' to the array
-           sections.
- 
- _Example_:
-           program test_any
-             logical l
-             l = any((/.true., .true., .true./))
-             print *, l
-             call section
-             contains
-               subroutine section
-                 integer a(2,3), b(2,3)
-                 a = 1
-                 b = 1
-                 b(2,2) = 2
-                 print *, any(a .eq. b, 1)
-                 print *, any(a .eq. b, 2)
-               end subroutine section
-           end program test_any
- 
- 
- File: gfortran.info,  Node: ASIN,  Next: ASINH,  Prev: ANY,  Up: Intrinsic Procedures
- 
- 6.18 `ASIN' -- Arcsine function
- ===============================
- 
- _Description_:
-      `ASIN(X)' computes the arcsine of its X (inverse of `SIN(X)').
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ASIN(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and a magnitude
-                 that is less than one.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range
-      -\pi / 2 \leq \asin (x) \leq \pi / 2.  The kind type parameter is
-      the same as X.
- 
- _Example_:
-           program test_asin
-             real(8) :: x = 0.866_8
-             x = asin(x)
-           end program test_asin
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DASIN(X)'    `REAL(8) X'   `REAL(8)'     F77 and later
- 
- _See also_:
-      Inverse function: *Note SIN::
- 
- 
- 
- File: gfortran.info,  Node: ASINH,  Next: ASSOCIATED,  Prev: ASIN,  Up: Intrinsic Procedures
- 
- 6.19 `ASINH' -- Hyperbolic arcsine function
- ===========================================
- 
- _Description_:
-      `ASINH(X)' computes the hyperbolic arcsine of X (inverse of
-      `SINH(X)').
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ASINH(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', with X a real
-                 number.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range
-      -\infty \leq \asinh (x) \leq \infty.
- 
- _Example_:
-           PROGRAM test_asinh
-             REAL(8), DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
-             WRITE (*,*) ASINH(x)
-           END PROGRAM
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DASINH(X)'   `REAL(8) X'   `REAL(8)'     GNU extension.
- 
- _See also_:
-      Inverse function: *Note SINH::
- 
- 
- File: gfortran.info,  Node: ASSOCIATED,  Next: ATAN,  Prev: ASINH,  Up: Intrinsic Procedures
- 
- 6.20 `ASSOCIATED' -- Status of a pointer or pointer/target pair
- ===============================================================
- 
- _Description_:
-      `ASSOCIATED(PTR [, TGT])' determines the status of the pointer PTR
-      or if PTR is associated with the target TGT.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = ASSOCIATED(PTR [, TGT])'
- 
- _Arguments_:
-      PTR        PTR shall have the `POINTER' attribute and it
-                 can be of any type.
-      TGT        (Optional) TGT shall be a `POINTER' or a
-                 `TARGET'.  It must have the same type, kind
-                 type parameter, and array rank as PTR.
-      The status of neither PTR nor TGT can be undefined.
- 
- _Return value_:
-      `ASSOCIATED(PTR)' returns a scalar value of type `LOGICAL(4)'.
-      There are several cases:
-     (A) If the optional TGT is not present, then `ASSOCIATED(PTR)'
-           is true if PTR is associated with a target; otherwise, it
-           returns false.
- 
-     (B) If TGT is present and a scalar target, the result is true if
-           TGT is not a 0 sized storage sequence and the target
-           associated with PTR occupies the same storage units.  If PTR
-           is disassociated, then the result is false.
- 
-     (C) If TGT is present and an array target, the result is true if
-           TGT and PTR have the same shape, are not 0 sized arrays, are
-           arrays whose elements are not 0 sized storage sequences, and
-           TGT and PTR occupy the same storage units in array element
-           order.  As in case(B), the result is false, if PTR is
-           disassociated.
- 
-     (D) If TGT is present and an scalar pointer, the result is true if
-           target associated with PTR and the target associated with TGT
-           are not 0 sized storage sequences and occupy the same storage
-           units.  The result is false, if either TGT or PTR is
-           disassociated.
- 
-     (E) If TGT is present and an array pointer, the result is true if
-           target associated with PTR and the target associated with TGT
-           have the same shape, are not 0 sized arrays, are arrays whose
-           elements are not 0 sized storage sequences, and TGT and PTR
-           occupy the same storage units in array element order.  The
-           result is false, if either TGT or PTR is disassociated.
- 
- _Example_:
-           program test_associated
-              implicit none
-              real, target  :: tgt(2) = (/1., 2./)
-              real, pointer :: ptr(:)
-              ptr => tgt
-              if (associated(ptr)     .eqv. .false.) call abort
-              if (associated(ptr,tgt) .eqv. .false.) call abort
-           end program test_associated
- 
- _See also_:
-      *Note NULL::
- 
- 
- File: gfortran.info,  Node: ATAN,  Next: ATAN2,  Prev: ASSOCIATED,  Up: Intrinsic Procedures
- 
- 6.21 `ATAN' -- Arctangent function
- ==================================
- 
- _Description_:
-      `ATAN(X)' computes the arctangent of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ATAN(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range  -
-      \pi / 2 \leq \atan (x) \leq \pi / 2.
- 
- _Example_:
-           program test_atan
-             real(8) :: x = 2.866_8
-             x = atan(x)
-           end program test_atan
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DATAN(X)'    `REAL(8) X'   `REAL(8)'     F77 and later
- 
- _See also_:
-      Inverse function: *Note TAN::
- 
- 
- 
- File: gfortran.info,  Node: ATAN2,  Next: ATANH,  Prev: ATAN,  Up: Intrinsic Procedures
- 
- 6.22 `ATAN2' -- Arctangent function
- ===================================
- 
- _Description_:
-      `ATAN2(Y,X)' computes the arctangent of the complex number X + i Y.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ATAN2(Y,X)'
- 
- _Arguments_:
-      Y          The type shall be `REAL(*)'.
-      X          The type and kind type parameter shall be the
-                 same as Y.  If Y is zero, then X must be
-                 nonzero.
- 
- _Return value_:
-      The return value has the same type and kind type parameter as Y.
-      It is the principal value of the complex number X + i Y.  If X is
-      nonzero, then it lies in the range -\pi \le \atan (x) \leq \pi.
-      The sign is positive if Y is positive.  If Y is zero, then the
-      return value is zero if X is positive and \pi if X is negative.
-      Finally, if X is zero, then the magnitude of the result is \pi/2.
- 
- _Example_:
-           program test_atan2
-             real(4) :: x = 1.e0_4, y = 0.5e0_4
-             x = atan2(y,x)
-           end program test_atan2
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DATAN2(X)'   `REAL(8) X'   `REAL(8)'     F77 and later
- 
- 
- File: gfortran.info,  Node: ATANH,  Next: BESJ0,  Prev: ATAN2,  Up: Intrinsic Procedures
- 
- 6.23 `ATANH' -- Hyperbolic arctangent function
- ==============================================
- 
- _Description_:
-      `ATANH(X)' computes the hyperbolic arctangent of X (inverse of
-      `TANH(X)').
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ATANH(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' with a magnitude
-                 that is less than or equal to one.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range
-      -\infty \leq \atanh(x) \leq \infty.
- 
- _Example_:
-           PROGRAM test_atanh
-             REAL, DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
-             WRITE (*,*) ATANH(x)
-           END PROGRAM
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DATANH(X)'   `REAL(8) X'   `REAL(8)'     GNU extension
- 
- _See also_:
-      Inverse function: *Note TANH::
- 
- 
- File: gfortran.info,  Node: BESJ0,  Next: BESJ1,  Prev: ATANH,  Up: Intrinsic Procedures
- 
- 6.24 `BESJ0' -- Bessel function of the first kind of order 0
- ============================================================
- 
- _Description_:
-      `BESJ0(X)' computes the Bessel function of the first kind of order
-      0 of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BESJ0(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range  -
-      0.4027... \leq Bessel (0,x) \leq 1.
- 
- _Example_:
-           program test_besj0
-             real(8) :: x = 0.0_8
-             x = besj0(x)
-           end program test_besj0
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DBESJ0(X)'   `REAL(8) X'   `REAL(8)'     GNU extension
- 
- 
- File: gfortran.info,  Node: BESJ1,  Next: BESJN,  Prev: BESJ0,  Up: Intrinsic Procedures
- 
- 6.25 `BESJ1' -- Bessel function of the first kind of order 1
- ============================================================
- 
- _Description_:
-      `BESJ1(X)' computes the Bessel function of the first kind of order
-      1 of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BESJ1(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range  -
-      0.5818... \leq Bessel (0,x) \leq 0.5818 .
- 
- _Example_:
-           program test_besj1
-             real(8) :: x = 1.0_8
-             x = besj1(x)
-           end program test_besj1
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DBESJ1(X)'   `REAL(8) X'   `REAL(8)'     GNU extension
- 
- 
- File: gfortran.info,  Node: BESJN,  Next: BESY0,  Prev: BESJ1,  Up: Intrinsic Procedures
- 
- 6.26 `BESJN' -- Bessel function of the first kind
- =================================================
- 
- _Description_:
-      `BESJN(N, X)' computes the Bessel function of the first kind of
-      order N of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BESJN(N, X)'
- 
- _Arguments_:
-      N          The type shall be `INTEGER(*)', and it shall
-                 be scalar.
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is a scalar of type `REAL(*)'.
- 
- _Example_:
-           program test_besjn
-             real(8) :: x = 1.0_8
-             x = besjn(5,x)
-           end program test_besjn
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DBESJN(X)'   `INTEGER(*)   `REAL(8)'     GNU extension
-                    N'                          
-                    `REAL(8) X'                 
- 
- 
- File: gfortran.info,  Node: BESY0,  Next: BESY1,  Prev: BESJN,  Up: Intrinsic Procedures
- 
- 6.27 `BESY0' -- Bessel function of the second kind of order 0
- =============================================================
- 
- _Description_:
-      `BESY0(X)' computes the Bessel function of the second kind of
-      order 0 of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BESY0(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is a scalar of type `REAL(*)'.
- 
- _Example_:
-           program test_besy0
-             real(8) :: x = 0.0_8
-             x = besy0(x)
-           end program test_besy0
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DBESY0(X)'   `REAL(8) X'   `REAL(8)'     GNU extension
- 
- 
- File: gfortran.info,  Node: BESY1,  Next: BESYN,  Prev: BESY0,  Up: Intrinsic Procedures
- 
- 6.28 `BESY1' -- Bessel function of the second kind of order 1
- =============================================================
- 
- _Description_:
-      `BESY1(X)' computes the Bessel function of the second kind of
-      order 1 of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BESY1(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is a scalar of type `REAL(*)'.
- 
- _Example_:
-           program test_besy1
-             real(8) :: x = 1.0_8
-             x = besy1(x)
-           end program test_besy1
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DBESY1(X)'   `REAL(8) X'   `REAL(8)'     GNU extension
- 
- 
- File: gfortran.info,  Node: BESYN,  Next: BIT_SIZE,  Prev: BESY1,  Up: Intrinsic Procedures
- 
- 6.29 `BESYN' -- Bessel function of the second kind
- ==================================================
- 
- _Description_:
-      `BESYN(N, X)' computes the Bessel function of the second kind of
-      order N of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BESYN(N, X)'
- 
- _Arguments_:
-      N          The type shall be `INTEGER(*)', and it shall
-                 be scalar.
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is a scalar of type `REAL(*)'.
- 
- _Example_:
-           program test_besyn
-             real(8) :: x = 1.0_8
-             x = besyn(5,x)
-           end program test_besyn
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DBESYN(N,X)' `INTEGER(*)   `REAL(8)'     GNU extension
-                    N'                          
-                    `REAL(8)                    
-                    X'                          
- 
- 
- File: gfortran.info,  Node: BIT_SIZE,  Next: BTEST,  Prev: BESYN,  Up: Intrinsic Procedures
- 
- 6.30 `BIT_SIZE' -- Bit size inquiry function
- ============================================
- 
- _Description_:
-      `BIT_SIZE(I)' returns the number of bits (integer precision plus
-      sign bit) represented by the type of I.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = BIT_SIZE(I)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)'
- 
- _Example_:
-           program test_bit_size
-               integer :: i = 123
-               integer :: size
-               size = bit_size(i)
-               print *, size
-           end program test_bit_size
- 
- 
- File: gfortran.info,  Node: BTEST,  Next: CEILING,  Prev: BIT_SIZE,  Up: Intrinsic Procedures
- 
- 6.31 `BTEST' -- Bit test function
- =================================
- 
- _Description_:
-      `BTEST(I,POS)' returns logical `.TRUE.' if the bit at POS in I is
-      set.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = BTEST(I, POS)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      POS        The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `LOGICAL'
- 
- _Example_:
-           program test_btest
-               integer :: i = 32768 + 1024 + 64
-               integer :: pos
-               logical :: bool
-               do pos=0,16
-                   bool = btest(i, pos)
-                   print *, pos, bool
-               end do
-           end program test_btest
- 
- 
- File: gfortran.info,  Node: CEILING,  Next: CHAR,  Prev: BTEST,  Up: Intrinsic Procedures
- 
- 6.32 `CEILING' -- Integer ceiling function
- ==========================================
- 
- _Description_:
-      `CEILING(X)' returns the least integer greater than or equal to X.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = CEILING(X [, KIND])'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is of type `INTEGER(KIND)'
- 
- _Example_:
-           program test_ceiling
-               real :: x = 63.29
-               real :: y = -63.59
-               print *, ceiling(x) ! returns 64
-               print *, ceiling(y) ! returns -63
-           end program test_ceiling
- 
- _See also_:
-      *Note FLOOR::, *Note NINT::
- 
- 
- 
- File: gfortran.info,  Node: CHAR,  Next: CHDIR,  Prev: CEILING,  Up: Intrinsic Procedures
- 
- 6.33 `CHAR' -- Character conversion function
- ============================================
- 
- _Description_:
-      `CHAR(I [, KIND])' returns the character represented by the
-      integer I.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = CHAR(I [, KIND])'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is of type `CHARACTER(1)'
- 
- _Example_:
-           program test_char
-               integer :: i = 74
-               character(1) :: c
-               c = char(i)
-               print *, i, c ! returns 'J'
-           end program test_char
- 
- _Note_:
-      See *Note ICHAR:: for a discussion of converting between numerical
-      values and formatted string representations.
- 
- _See also_:
-      *Note ACHAR::, *Note IACHAR::, *Note ICHAR::
- 
- 
- 
- File: gfortran.info,  Node: CHDIR,  Next: CHMOD,  Prev: CHAR,  Up: Intrinsic Procedures
- 
- 6.34 `CHDIR' -- Change working directory
- ========================================
- 
- _Description_:
-      Change current working directory to a specified path.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL CHDIR(NAME [, STATUS])'
-      `STATUS = CHDIR(NAME)'
- 
- _Arguments_:
-      NAME       The type shall be `CHARACTER(*)' and shall
-                                    specify a valid path
-                 within the file system.
-      STATUS     (Optional) `INTEGER' status flag of the default
-                                        kind.  Returns 0 on
-                 success, and a system specific
-                        and non-zero error code otherwise.
- 
- _Example_:
-           PROGRAM test_chdir
-             CHARACTER(len=255) :: path
-             CALL getcwd(path)
-             WRITE(*,*) TRIM(path)
-             CALL chdir("/tmp")
-             CALL getcwd(path)
-             WRITE(*,*) TRIM(path)
-           END PROGRAM
- 
- _See also_:
-      *Note GETCWD::
- 
- 
- File: gfortran.info,  Node: CHMOD,  Next: CMPLX,  Prev: CHDIR,  Up: Intrinsic Procedures
- 
- 6.35 `CHMOD' -- Change access permissions of files
- ==================================================
- 
- _Description_:
-      `CHMOD' changes the permissions of a file. This function invokes
-      `/bin/chmod' and might therefore not work on all platforms.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL CHMOD(NAME, MODE[, STATUS])'
-      `STATUS = CHMOD(NAME, MODE)'
- 
- _Arguments_:
-      NAME       Scalar `CHARACTER' with the file name.
-                 Trailing blanks are ignored unless the
-                 character `achar(0)' is present, then all
-                 characters up to and excluding `achar(0)' are
-                 used as the file name.
-      MODE       Scalar `CHARACTER' giving the file permission.
-                 MODE uses the same syntax as the MODE argument
-                 of `/bin/chmod'.
-      STATUS     (optional) scalar `INTEGER', which is `0' on
-                 success and non-zero otherwise.
- 
- _Return value_:
-      In either syntax, STATUS is set to `0' on success and non-zero
-      otherwise.
- 
- _Example_:
-      `CHMOD' as subroutine
-           program chmod_test
-             implicit none
-             integer :: status
-             call chmod('test.dat','u+x',status)
-             print *, 'Status: ', status
-           end program chmod_test
-      `CHMOD' as function:
-           program chmod_test
-             implicit none
-             integer :: status
-             status = chmod('test.dat','u+x')
-             print *, 'Status: ', status
-           end program chmod_test
- 
- 
- 
- File: gfortran.info,  Node: CMPLX,  Next: COMMAND_ARGUMENT_COUNT,  Prev: CHMOD,  Up: Intrinsic Procedures
- 
- 6.36 `CMPLX' -- Complex conversion function
- ===========================================
- 
- _Description_:
-      `CMPLX(X [, Y [, KIND]])' returns a complex number where X is
-      converted to the real component.  If Y is present it is converted
-      to the imaginary component.  If Y is not present then the
-      imaginary component is set to 0.0.  If X is complex then Y must
-      not be present.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = CMPLX(X [, Y [, KIND]])'
- 
- _Arguments_:
-      X          The type may be `INTEGER(*)', `REAL(*)',
-                             or `COMPLEX(*)'.
-      Y          (Optional; only allowed if X is not
-                        `COMPLEX(*)'.)  May be `INTEGER(*)'
-                   or `REAL(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is of `COMPLEX' type, with a kind equal to KIND
-      if it is specified.  If KIND is not specified, the result is of
-      the default `COMPLEX' kind, regardless of the kinds of X and Y.
- 
- _Example_:
-           program test_cmplx
-               integer :: i = 42
-               real :: x = 3.14
-               complex :: z
-               z = cmplx(i, x)
-               print *, z, cmplx(x)
-           end program test_cmplx
- 
- _See also_:
-      *Note COMPLEX::
- 
- 
- File: gfortran.info,  Node: COMMAND_ARGUMENT_COUNT,  Next: COMPLEX,  Prev: CMPLX,  Up: Intrinsic Procedures
- 
- 6.37 `COMMAND_ARGUMENT_COUNT' -- Get number of command line arguments
- =====================================================================
- 
- _Description_:
-      `COMMAND_ARGUMENT_COUNT()' returns the number of arguments passed
-      on the command line when the containing program was invoked.
- 
- _Standard_:
-      F2003
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = COMMAND_ARGUMENT_COUNT()'
- 
- _Arguments_:
-      None       
- 
- _Return value_:
-      The return value is of type `INTEGER(4)'
- 
- _Example_:
-           program test_command_argument_count
-               integer :: count
-               count = command_argument_count()
-               print *, count
-           end program test_command_argument_count
- 
- _See also_:
-      *Note GET_COMMAND::, *Note GET_COMMAND_ARGUMENT::
- 
- 
- File: gfortran.info,  Node: COMPLEX,  Next: CONJG,  Prev: COMMAND_ARGUMENT_COUNT,  Up: Intrinsic Procedures
- 
- 6.38 `COMPLEX' -- Complex conversion function
- =============================================
- 
- _Description_:
-      `COMPLEX(X, Y)' returns a complex number where X is converted to
-      the real component and Y is converted to the imaginary component.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = COMPLEX(X, Y)'
- 
- _Arguments_:
-      X          The type may be `INTEGER(*)' or `REAL(*)'.
-      Y          The type may be `INTEGER(*)' or `REAL(*)'.
- 
- _Return value_:
-      If X and Y are both of `INTEGER' type, then the return value is of
-      default `COMPLEX' type.
- 
-      If X and Y are of `REAL' type, or one is of `REAL' type and one is
-      of `INTEGER' type, then the return value is of `COMPLEX' type with
-      a kind equal to that of the `REAL' argument with the highest
-      precision.
- 
- _Example_:
-           program test_complex
-               integer :: i = 42
-               real :: x = 3.14
-               print *, complex(i, x)
-           end program test_complex
- 
- _See also_:
-      *Note CMPLX::
- 
- 
- File: gfortran.info,  Node: CONJG,  Next: COS,  Prev: COMPLEX,  Up: Intrinsic Procedures
- 
- 6.39 `CONJG' -- Complex conjugate function
- ==========================================
- 
- _Description_:
-      `CONJG(Z)' returns the conjugate of Z.  If Z is `(x, y)' then the
-      result is `(x, -y)'
- 
- _Standard_:
-      F77 and later, has overloads that are GNU extensions
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `Z = CONJG(Z)'
- 
- _Arguments_:
-      Z          The type shall be `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of type `COMPLEX(*)'.
- 
- _Example_:
-           program test_conjg
-               complex :: z = (2.0, 3.0)
-               complex(8) :: dz = (2.71_8, -3.14_8)
-               z= conjg(z)
-               print *, z
-               dz = dconjg(dz)
-               print *, dz
-           end program test_conjg
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DCONJG(Z)'   `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    Z'                          
- 
- 
- File: gfortran.info,  Node: COS,  Next: COSH,  Prev: CONJG,  Up: Intrinsic Procedures
- 
- 6.40 `COS' -- Cosine function
- =============================
- 
- _Description_:
-      `COS(X)' computes the cosine of X.
- 
- _Standard_:
-      F77 and later, has overloads that are GNU extensions
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = COS(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it lies in the range  -1
-      \leq \cos (x) \leq 1.  The kind type parameter is the same as X.
- 
- _Example_:
-           program test_cos
-             real :: x = 0.0
-             x = cos(x)
-           end program test_cos
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DCOS(X)'     `REAL(8) X'   `REAL(8)'     F77 and later
-      `CCOS(X)'     `COMPLEX(4)   `COMPLEX(4)'  F77 and later
-                    X'                          
-      `ZCOS(X)'     `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    X'                          
-      `CDCOS(X)'    `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    X'                          
- 
- _See also_:
-      Inverse function: *Note ACOS::
- 
- 
- 
- File: gfortran.info,  Node: COSH,  Next: COUNT,  Prev: COS,  Up: Intrinsic Procedures
- 
- 6.41 `COSH' -- Hyperbolic cosine function
- =========================================
- 
- _Description_:
-      `COSH(X)' computes the hyperbolic cosine of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `X = COSH(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and it is positive ( \cosh
-      (x) \geq 0 .
- 
- _Example_:
-           program test_cosh
-             real(8) :: x = 1.0_8
-             x = cosh(x)
-           end program test_cosh
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DCOSH(X)'    `REAL(8) X'   `REAL(8)'     F77 and later
- 
- _See also_:
-      Inverse function: *Note ACOSH::
- 
- 
- 
- File: gfortran.info,  Node: COUNT,  Next: CPU_TIME,  Prev: COSH,  Up: Intrinsic Procedures
- 
- 6.42 `COUNT' -- Count function
- ==============================
- 
- _Description_:
-      `COUNT(MASK [, DIM])' counts the number of `.TRUE.' elements of
-      MASK along the dimension of DIM.  If DIM is omitted it is taken to
-      be `1'.  DIM is a scaler of type `INTEGER' in the range of 1 /leq
-      DIM /leq n) where n is the rank of MASK.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = COUNT(MASK [, DIM])'
- 
- _Arguments_:
-      MASK       The type shall be `LOGICAL'.
-      DIM        The type shall be `INTEGER'.
- 
- _Return value_:
-      The return value is of type `INTEGER' with rank equal to that of
-      MASK.
- 
- _Example_:
-           program test_count
-               integer, dimension(2,3) :: a, b
-               logical, dimension(2,3) :: mask
-               a = reshape( (/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /))
-               b = reshape( (/ 0, 7, 3, 4, 5, 8 /), (/ 2, 3 /))
-               print '(3i3)', a(1,:)
-               print '(3i3)', a(2,:)
-               print *
-               print '(3i3)', b(1,:)
-               print '(3i3)', b(2,:)
-               print *
-               mask = a.ne.b
-               print '(3l3)', mask(1,:)
-               print '(3l3)', mask(2,:)
-               print *
-               print '(3i3)', count(mask)
-               print *
-               print '(3i3)', count(mask, 1)
-               print *
-               print '(3i3)', count(mask, 2)
-           end program test_count
- 
- 
- File: gfortran.info,  Node: CPU_TIME,  Next: CSHIFT,  Prev: COUNT,  Up: Intrinsic Procedures
- 
- 6.43 `CPU_TIME' -- CPU elapsed time in seconds
- ==============================================
- 
- _Description_:
-      Returns a `REAL(*)' value representing the elapsed CPU time in
-      seconds.  This is useful for testing segments of code to determine
-      execution time.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL CPU_TIME(TIME)'
- 
- _Arguments_:
-      TIME       The type shall be `REAL(*)' with `INTENT(OUT)'.
- 
- _Return value_:
-      None
- 
- _Example_:
-           program test_cpu_time
-               real :: start, finish
-               call cpu_time(start)
-                   ! put code to test here
-               call cpu_time(finish)
-               print '("Time = ",f6.3," seconds.")',finish-start
-           end program test_cpu_time
- 
- _See also_:
-      *Note SYSTEM_CLOCK::, *Note DATE_AND_TIME::
- 
- 
- File: gfortran.info,  Node: CSHIFT,  Next: CTIME,  Prev: CPU_TIME,  Up: Intrinsic Procedures
- 
- 6.44 `CSHIFT' -- Circular shift elements of an array
- ====================================================
- 
- _Description_:
-      `CSHIFT(ARRAY, SHIFT [, DIM])' performs a circular shift on
-      elements of ARRAY along the dimension of DIM.  If DIM is omitted
-      it is taken to be `1'.  DIM is a scaler of type `INTEGER' in the
-      range of 1 /leq DIM /leq n) where n is the rank of ARRAY.  If the
-      rank of ARRAY is one, then all elements of ARRAY are shifted by
-      SHIFT places.  If rank is greater than one, then all complete rank
-      one sections of ARRAY along the given dimension are shifted.
-      Elements shifted out one end of each rank one section are shifted
-      back in the other end.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      transformational function
- 
- _Syntax_:
-      `RESULT = CSHIFT(A, SHIFT [, DIM])'
- 
- _Arguments_:
-      ARRAY      May be any type, not scaler.
-      SHIFT      The type shall be `INTEGER'.
-      DIM        The type shall be `INTEGER'.
- 
- _Return value_:
-      Returns an array of same type and rank as the ARRAY argument.
- 
- _Example_:
-           program test_cshift
-               integer, dimension(3,3) :: a
-               a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
-               print '(3i3)', a(1,:)
-               print '(3i3)', a(2,:)
-               print '(3i3)', a(3,:)
-               a = cshift(a, SHIFT=(/1, 2, -1/), DIM=2)
-               print *
-               print '(3i3)', a(1,:)
-               print '(3i3)', a(2,:)
-               print '(3i3)', a(3,:)
-           end program test_cshift
- 
- 
- File: gfortran.info,  Node: CTIME,  Next: DATE_AND_TIME,  Prev: CSHIFT,  Up: Intrinsic Procedures
- 
- 6.45 `CTIME' -- Convert a time into a string
- ============================================
- 
- _Description_:
-      `CTIME' converts a system time value, such as returned by
-      `TIME8()', to a string of the form `Sat Aug 19 18:13:14 1995'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL CTIME(TIME, RESULT)'.
-      `RESULT = CTIME(TIME)', (not recommended).
- 
- _Arguments_:
-      TIME       The type shall be of type `INTEGER(KIND=8)'.
-      RESULT     The type shall be of type `CHARACTER'.
- 
- _Return value_:
-      The converted date and time as a string.
- 
- _Example_:
-           program test_ctime
-               integer(8) :: i
-               character(len=30) :: date
-               i = time8()
- 
-               ! Do something, main part of the program
- 
-               call ctime(i,date)
-               print *, 'Program was started on ', date
-           end program test_ctime
- 
- _See Also_:
-      *Note GMTIME::, *Note LTIME::, *Note TIME::, *Note TIME8::
- 
- 
- File: gfortran.info,  Node: DATE_AND_TIME,  Next: DBLE,  Prev: CTIME,  Up: Intrinsic Procedures
- 
- 6.46 `DATE_AND_TIME' -- Date and time subroutine
- ================================================
- 
- _Description_:
-      `DATE_AND_TIME(DATE, TIME, ZONE, VALUES)' gets the corresponding
-      date and time information from the real-time system clock.  DATE is
-      `INTENT(OUT)' and has form ccyymmdd.  TIME is `INTENT(OUT)' and
-      has form hhmmss.sss.  ZONE is `INTENT(OUT)' and has form (+-)hhmm,
-      representing the difference with respect to Coordinated Universal
-      Time (UTC).  Unavailable time and date parameters return blanks.
- 
-      VALUES is `INTENT(OUT)' and provides the following:
- 
-                 `VALUE(1)':          The year
-                 `VALUE(2)':          The month
-                 `VALUE(3)':          The day of the month
-                 `VALUE(4)':          Time difference with UTC
-                                      in minutes
-                 `VALUE(5)':          The hour of the day
-                 `VALUE(6)':          The minutes of the hour
-                 `VALUE(7)':          The seconds of the minute
-                 `VALUE(8)':          The milliseconds of the
-                                      second
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL DATE_AND_TIME([DATE, TIME, ZONE, VALUES])'
- 
- _Arguments_:
-      DATE       (Optional) The type shall be `CHARACTER(8)' or
-                 larger.
-      TIME       (Optional) The type shall be `CHARACTER(10)'
-                 or larger.
-      ZONE       (Optional) The type shall be `CHARACTER(5)' or
-                 larger.
-      VALUES     (Optional) The type shall be `INTEGER(8)'.
- 
- _Return value_:
-      None
- 
- _Example_:
-           program test_time_and_date
-               character(8)  :: date
-               character(10) :: time
-               character(5)  :: zone
-               integer,dimension(8) :: values
-               ! using keyword arguments
-               call date_and_time(date,time,zone,values)
-               call date_and_time(DATE=date,ZONE=zone)
-               call date_and_time(TIME=time)
-               call date_and_time(VALUES=values)
-               print '(a,2x,a,2x,a)', date, time, zone
-               print '(8i5))', values
-           end program test_time_and_date
- 
- _See also_:
-      *Note CPU_TIME::, *Note SYSTEM_CLOCK::
- 
- 
- File: gfortran.info,  Node: DBLE,  Next: DCMPLX,  Prev: DATE_AND_TIME,  Up: Intrinsic Procedures
- 
- 6.47 `DBLE' -- Double conversion function
- =========================================
- 
- _Description_:
-      `DBLE(X)' Converts X to double precision real type.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = DBLE(X)'
- 
- _Arguments_:
-      X          The type shall be `INTEGER(*)', `REAL(*)',
-                               or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of type double precision real.
- 
- _Example_:
-           program test_dble
-               real    :: x = 2.18
-               integer :: i = 5
-               complex :: z = (2.3,1.14)
-               print *, dble(x), dble(i), dble(z)
-           end program test_dble
- 
- _See also_:
-      *Note DFLOAT::, *Note FLOAT::, *Note REAL::
- 
- 
- File: gfortran.info,  Node: DCMPLX,  Next: DFLOAT,  Prev: DBLE,  Up: Intrinsic Procedures
- 
- 6.48 `DCMPLX' -- Double complex conversion function
- ===================================================
- 
- _Description_:
-      `DCMPLX(X [,Y])' returns a double complex number where X is
-      converted to the real component.  If Y is present it is converted
-      to the imaginary component.  If Y is not present then the
-      imaginary component is set to 0.0.  If X is complex then Y must
-      not be present.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = DCMPLX(X [, Y])'
- 
- _Arguments_:
-      X          The type may be `INTEGER(*)', `REAL(*)',
-                             or `COMPLEX(*)'.
-      Y          (Optional if X is not `COMPLEX(*)'.) May be
-                                `INTEGER(*)' or `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `COMPLEX(8)'
- 
- _Example_:
-           program test_dcmplx
-               integer :: i = 42
-               real :: x = 3.14
-               complex :: z
-               z = cmplx(i, x)
-               print *, dcmplx(i)
-               print *, dcmplx(x)
-               print *, dcmplx(z)
-               print *, dcmplx(x,i)
-           end program test_dcmplx
- 
- 
- File: gfortran.info,  Node: DFLOAT,  Next: DIGITS,  Prev: DCMPLX,  Up: Intrinsic Procedures
- 
- 6.49 `DFLOAT' -- Double conversion function
- ===========================================
- 
- _Description_:
-      `DFLOAT(X)' Converts X to double precision real type.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = DFLOAT(X)'
- 
- _Arguments_:
-      X          The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type double precision real.
- 
- _Example_:
-           program test_dfloat
-               integer :: i = 5
-               print *, dfloat(i)
-           end program test_dfloat
- 
- _See also_:
-      *Note DBLE::, *Note FLOAT::, *Note REAL::
- 
- 
- File: gfortran.info,  Node: DIGITS,  Next: DIM,  Prev: DFLOAT,  Up: Intrinsic Procedures
- 
- 6.50 `DIGITS' -- Significant digits function
- ============================================
- 
- _Description_:
-      `DIGITS(X)' returns the number of significant digits of the
-      internal model representation of X.  For example, on a system
-      using a 32-bit floating point representation, a default real
-      number would likely return 24.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = DIGITS(X)'
- 
- _Arguments_:
-      X          The type may be `INTEGER(*)' or `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER'.
- 
- _Example_:
-           program test_digits
-               integer :: i = 12345
-               real :: x = 3.143
-               real(8) :: y = 2.33
-               print *, digits(i)
-               print *, digits(x)
-               print *, digits(y)
-           end program test_digits
- 
- 
- File: gfortran.info,  Node: DIM,  Next: DOT_PRODUCT,  Prev: DIGITS,  Up: Intrinsic Procedures
- 
- 6.51 `DIM' -- Positive difference
- =================================
- 
- _Description_:
-      `DIM(X,Y)' returns the difference `X-Y' if the result is positive;
-      otherwise returns zero.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = DIM(X, Y)'
- 
- _Arguments_:
-      X          The type shall be `INTEGER(*)' or `REAL(*)'
-      Y          The type shall be the same type and kind as X.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' or `REAL(*)'.
- 
- _Example_:
-           program test_dim
-               integer :: i
-               real(8) :: x
-               i = dim(4, 15)
-               x = dim(4.345_8, 2.111_8)
-               print *, i
-               print *, x
-           end program test_dim
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `IDIM(X,Y)'   `INTEGER(4)   `INTEGER(4)'  F77 and later
-                    X,Y'                        
-      `DDIM(X,Y)'   `REAL(8)      `REAL(8)'     F77 and later
-                    X,Y'                        
- 
- 
- File: gfortran.info,  Node: DOT_PRODUCT,  Next: DPROD,  Prev: DIM,  Up: Intrinsic Procedures
- 
- 6.52 `DOT_PRODUCT' -- Dot product function
- ==========================================
- 
- _Description_:
-      `DOT_PRODUCT(X,Y)' computes the dot product multiplication of two
-      vectors X and Y.  The two vectors may be either numeric or logical
-      and must be arrays of rank one and of equal size. If the vectors
-      are `INTEGER(*)' or `REAL(*)', the result is `SUM(X*Y)'. If the
-      vectors are `COMPLEX(*)', the result is `SUM(CONJG(X)*Y)'. If the
-      vectors are `LOGICAL', the result is `ANY(X.AND.Y)'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = DOT_PRODUCT(X, Y)'
- 
- _Arguments_:
-      X          The type shall be numeric or `LOGICAL', rank 1.
-      Y          The type shall be numeric or `LOGICAL', rank 1.
- 
- _Return value_:
-      If the arguments are numeric, the return value is a scaler of
-      numeric type, `INTEGER(*)', `REAL(*)', or `COMPLEX(*)'.  If the
-      arguments are `LOGICAL', the return value is `.TRUE.' or `.FALSE.'.
- 
- _Example_:
-           program test_dot_prod
-               integer, dimension(3) :: a, b
-               a = (/ 1, 2, 3 /)
-               b = (/ 4, 5, 6 /)
-               print '(3i3)', a
-               print *
-               print '(3i3)', b
-               print *
-               print *, dot_product(a,b)
-           end program test_dot_prod
- 
- 
- File: gfortran.info,  Node: DPROD,  Next: DREAL,  Prev: DOT_PRODUCT,  Up: Intrinsic Procedures
- 
- 6.53 `DPROD' -- Double product function
- =======================================
- 
- _Description_:
-      `DPROD(X,Y)' returns the product `X*Y'.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = DPROD(X, Y)'
- 
- _Arguments_:
-      X          The type shall be `REAL'.
-      Y          The type shall be `REAL'.
- 
- _Return value_:
-      The return value is of type `REAL(8)'.
- 
- _Example_:
-           program test_dprod
-               real :: x = 5.2
-               real :: y = 2.3
-               real(8) :: d
-               d = dprod(x,y)
-               print *, d
-           end program test_dprod
- 
- 
- File: gfortran.info,  Node: DREAL,  Next: DTIME,  Prev: DPROD,  Up: Intrinsic Procedures
- 
- 6.54 `DREAL' -- Double real part function
- =========================================
- 
- _Description_:
-      `DREAL(Z)' returns the real part of complex variable Z.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = DREAL(Z)'
- 
- _Arguments_:
-      Z          The type shall be `COMPLEX(8)'.
- 
- _Return value_:
-      The return value is of type `REAL(8)'.
- 
- _Example_:
-           program test_dreal
-               complex(8) :: z = (1.3_8,7.2_8)
-               print *, dreal(z)
-           end program test_dreal
- 
- _See also_:
-      *Note AIMAG::
- 
- 
- 
- File: gfortran.info,  Node: DTIME,  Next: EOSHIFT,  Prev: DREAL,  Up: Intrinsic Procedures
- 
- 6.55 `DTIME' -- Execution time subroutine (or function)
- =======================================================
- 
- _Description_:
-      `DTIME(TARRAY, RESULT)' initially returns the number of seconds of
-      runtime since the start of the process's execution in RESULT.
-      TARRAY returns the user and system components of this time in
-      `TARRAY(1)' and `TARRAY(2)' respectively. RESULT is equal to
-      `TARRAY(1) + TARRAY(2)'.
- 
-      Subsequent invocations of `DTIME' return values accumulated since
-      the previous invocation.
- 
-      On some systems, the underlying timings are represented using
-      types with sufficiently small limits that overflows (wrap around)
-      are possible, such as 32-bit types. Therefore, the values returned
-      by this intrinsic might be, or become, negative, or numerically
-      less than previous values, during a single run of the compiled
-      program.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      TARRAY and RESULT are `INTENT(OUT)' and provide the following:
- 
-                 `TARRAY(1)':         User time in seconds.
-                 `TARRAY(2)':         System time in seconds.
-                 `RESULT':            Run time since start in
-                                      seconds.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL DTIME(TARRAY, RESULT)'.
-      `RESULT = DTIME(TARRAY)', (not recommended).
- 
- _Arguments_:
-      TARRAY     The type shall be `REAL, DIMENSION(2)'.
-      RESULT     The type shall be `REAL'.
- 
- _Return value_:
-      Elapsed time in seconds since the start of program execution.
- 
- _Example_:
-           program test_dtime
-               integer(8) :: i, j
-               real, dimension(2) :: tarray
-               real :: result
-               call dtime(tarray, result)
-               print *, result
-               print *, tarray(1)
-               print *, tarray(2)
-               do i=1,100000000    ! Just a delay
-                   j = i * i - i
-               end do
-               call dtime(tarray, result)
-               print *, result
-               print *, tarray(1)
-               print *, tarray(2)
-           end program test_dtime
- 
- 
- File: gfortran.info,  Node: EOSHIFT,  Next: EPSILON,  Prev: DTIME,  Up: Intrinsic Procedures
- 
- 6.56 `EOSHIFT' -- End-off shift elements of an array
- ====================================================
- 
- _Description_:
-      `EOSHIFT(ARRAY, SHIFT[,BOUNDARY, DIM])' performs an end-off shift
-      on elements of ARRAY along the dimension of DIM.  If DIM is
-      omitted it is taken to be `1'.  DIM is a scaler of type `INTEGER'
-      in the range of 1 /leq DIM /leq n) where n is the rank of ARRAY.
-      If the rank of ARRAY is one, then all elements of ARRAY are
-      shifted by SHIFT places.  If rank is greater than one, then all
-      complete rank one sections of ARRAY along the given dimension are
-      shifted.  Elements shifted out one end of each rank one section
-      are dropped.  If BOUNDARY is present then the corresponding value
-      of from BOUNDARY is copied back in the other end.  If BOUNDARY is
-      not present then the following are copied in depending on the type
-      of ARRAY.
- 
-      _Array     _Boundary Value_
-      Type_      
-      Numeric    0 of the type and kind of ARRAY.
-      Logical    `.FALSE.'.
-      Character(LEN)LEN blanks.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      transformational function
- 
- _Syntax_:
-      `RESULT = EOSHIFT(A, SHIFT [, BOUNDARY, DIM])'
- 
- _Arguments_:
-      ARRAY      May be any type, not scaler.
-      SHIFT      The type shall be `INTEGER'.
-      BOUNDARY   Same type as ARRAY.
-      DIM        The type shall be `INTEGER'.
- 
- _Return value_:
-      Returns an array of same type and rank as the ARRAY argument.
- 
- _Example_:
-           program test_eoshift
-               integer, dimension(3,3) :: a
-               a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
-               print '(3i3)', a(1,:)
-               print '(3i3)', a(2,:)
-               print '(3i3)', a(3,:)
-               a = EOSHIFT(a, SHIFT=(/1, 2, 1/), BOUNDARY=-5, DIM=2)
-               print *
-               print '(3i3)', a(1,:)
-               print '(3i3)', a(2,:)
-               print '(3i3)', a(3,:)
-           end program test_eoshift
- 
- 
- File: gfortran.info,  Node: EPSILON,  Next: ERF,  Prev: EOSHIFT,  Up: Intrinsic Procedures
- 
- 6.57 `EPSILON' -- Epsilon function
- ==================================
- 
- _Description_:
-      `EPSILON(X)' returns a nearly negligible number relative to `1'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = EPSILON(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of same type as the argument.
- 
- _Example_:
-           program test_epsilon
-               real :: x = 3.143
-               real(8) :: y = 2.33
-               print *, EPSILON(x)
-               print *, EPSILON(y)
-           end program test_epsilon
- 
- 
- File: gfortran.info,  Node: ERF,  Next: ERFC,  Prev: EPSILON,  Up: Intrinsic Procedures
- 
- 6.58 `ERF' -- Error function
- ============================
- 
- _Description_:
-      `ERF(X)' computes the error function of X.
- 
- _Standard_:
-      GNU Extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ERF(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is a scalar of type `REAL(*)' and it is positive
-      ( - 1 \leq erf (x) \leq 1 .
- 
- _Example_:
-           program test_erf
-             real(8) :: x = 0.17_8
-             x = erf(x)
-           end program test_erf
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DERF(X)'     `REAL(8) X'   `REAL(8)'     GNU extension
- 
- 
- File: gfortran.info,  Node: ERFC,  Next: ETIME,  Prev: ERF,  Up: Intrinsic Procedures
- 
- 6.59 `ERFC' -- Error function
- =============================
- 
- _Description_:
-      `ERFC(X)' computes the complementary error function of X.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ERFC(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)', and it shall be
-                 scalar.
- 
- _Return value_:
-      The return value is a scalar of type `REAL(*)' and it is positive
-      ( 0 \leq erfc (x) \leq 2 .
- 
- _Example_:
-           program test_erfc
-             real(8) :: x = 0.17_8
-             x = erfc(x)
-           end program test_erfc
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DERFC(X)'    `REAL(8) X'   `REAL(8)'     GNU extension
- 
- 
- File: gfortran.info,  Node: ETIME,  Next: EXIT,  Prev: ERFC,  Up: Intrinsic Procedures
- 
- 6.60 `ETIME' -- Execution time subroutine (or function)
- =======================================================
- 
- _Description_:
-      `ETIME(TARRAY, RESULT)' returns the number of seconds of runtime
-      since the start of the process's execution in RESULT.  TARRAY
-      returns the user and system components of this time in `TARRAY(1)'
-      and `TARRAY(2)' respectively. RESULT is equal to `TARRAY(1) +
-      TARRAY(2)'.
- 
-      On some systems, the underlying timings are represented using
-      types with sufficiently small limits that overflows (wrap around)
-      are possible, such as 32-bit types. Therefore, the values returned
-      by this intrinsic might be, or become, negative, or numerically
-      less than previous values, during a single run of the compiled
-      program.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      TARRAY and RESULT are `INTENT(OUT)' and provide the following:
- 
-                 `TARRAY(1)':         User time in seconds.
-                 `TARRAY(2)':         System time in seconds.
-                 `RESULT':            Run time since start in seconds.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL ETIME(TARRAY, RESULT)'.
-      `RESULT = ETIME(TARRAY)', (not recommended).
- 
- _Arguments_:
-      TARRAY     The type shall be `REAL, DIMENSION(2)'.
-      RESULT     The type shall be `REAL'.
- 
- _Return value_:
-      Elapsed time in seconds since the start of program execution.
- 
- _Example_:
-           program test_etime
-               integer(8) :: i, j
-               real, dimension(2) :: tarray
-               real :: result
-               call ETIME(tarray, result)
-               print *, result
-               print *, tarray(1)
-               print *, tarray(2)
-               do i=1,100000000    ! Just a delay
-                   j = i * i - i
-               end do
-               call ETIME(tarray, result)
-               print *, result
-               print *, tarray(1)
-               print *, tarray(2)
-           end program test_etime
- 
- _See also_:
-      *Note CPU_TIME::
- 
- 
- 
- File: gfortran.info,  Node: EXIT,  Next: EXP,  Prev: ETIME,  Up: Intrinsic Procedures
- 
- 6.61 `EXIT' -- Exit the program with status.
- ============================================
- 
- _Description_:
-      `EXIT' causes immediate termination of the program with status.
-      If status is omitted it returns the canonical _success_ for the
-      system.  All Fortran I/O units are closed.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL EXIT([STATUS])'
- 
- _Arguments_:
-      STATUS     Shall be an `INTEGER' of the default kind.
- 
- _Return value_:
-      `STATUS' is passed to the parent process on exit.
- 
- _Example_:
-           program test_exit
-             integer :: STATUS = 0
-             print *, 'This program is going to exit.'
-             call EXIT(STATUS)
-           end program test_exit
- 
- _See also_:
-      *Note ABORT::, *Note KILL::
- 
- 
- File: gfortran.info,  Node: EXP,  Next: EXPONENT,  Prev: EXIT,  Up: Intrinsic Procedures
- 
- 6.62 `EXP' -- Exponential function
- ==================================
- 
- _Description_:
-      `EXP(X)' computes the base e exponential of X.
- 
- _Standard_:
-      F77 and later, has overloads that are GNU extensions
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = EXP(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value has same type and kind as X.
- 
- _Example_:
-           program test_exp
-             real :: x = 1.0
-             x = exp(x)
-           end program test_exp
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DEXP(X)'     `REAL(8) X'   `REAL(8)'     F77 and later
-      `CEXP(X)'     `COMPLEX(4)   `COMPLEX(4)'  F77 and later
-                    X'                          
-      `ZEXP(X)'     `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    X'                          
-      `CDEXP(X)'    `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    X'                          
- 
- 
- File: gfortran.info,  Node: EXPONENT,  Next: FDATE,  Prev: EXP,  Up: Intrinsic Procedures
- 
- 6.63 `EXPONENT' -- Exponent function
- ====================================
- 
- _Description_:
-      `EXPONENT(X)' returns the value of the exponent part of X. If X is
-      zero the value returned is zero.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = EXPONENT(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type default `INTEGER'.
- 
- _Example_:
-           program test_exponent
-             real :: x = 1.0
-             integer :: i
-             i = exponent(x)
-             print *, i
-             print *, exponent(0.0)
-           end program test_exponent
- 
- 
- File: gfortran.info,  Node: FDATE,  Next: FGET,  Prev: EXPONENT,  Up: Intrinsic Procedures
- 
- 6.64 `FDATE' -- Get the current time as a string
- ================================================
- 
- _Description_:
-      `FDATE(DATE)' returns the current date (using the same format as
-      `CTIME') in DATE. It is equivalent to `CALL CTIME(DATE, TIME())'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      DATE is an `INTENT(OUT)' `CHARACTER' variable.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FDATE(DATE)'.
-      `DATE = FDATE()', (not recommended).
- 
- _Arguments_:
-      DATE       The type shall be of type `CHARACTER'.
- 
- _Return value_:
-      The current date as a string.
- 
- _Example_:
-           program test_fdate
-               integer(8) :: i, j
-               character(len=30) :: date
-               call fdate(date)
-               print *, 'Program started on ', date
-               do i = 1, 100000000 ! Just a delay
-                   j = i * i - i
-               end do
-               call fdate(date)
-               print *, 'Program ended on ', date
-           end program test_fdate
- 
- 
- File: gfortran.info,  Node: FLOAT,  Next: FLOOR,  Prev: FGETC,  Up: Intrinsic Procedures
- 
- 6.65 `FLOAT' -- Convert integer to default real
- ===============================================
- 
- _Description_:
-      `FLOAT(I)' converts the integer I to a default real value.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = FLOAT(I)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type default `REAL'.
- 
- _Example_:
-           program test_float
-               integer :: i = 1
-               if (float(i) /= 1.) call abort
-           end program test_float
- 
- _See also_:
-      *Note DBLE::, *Note DFLOAT::, *Note REAL::
- 
- 
- File: gfortran.info,  Node: FGET,  Next: FGETC,  Prev: FDATE,  Up: Intrinsic Procedures
- 
- 6.66 `FGET' -- Read a single character in stream mode from stdin
- ================================================================
- 
- _Description_:
-      Read a single character in stream mode from stdin by bypassing
-      normal formatted output. Stream I/O should not be mixed with
-      normal record-oriented (formatted or unformatted) I/O on the same
-      unit; the results are unpredictable.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      Note that the `FGET' intrinsic is provided for backwards
-      compatibility with `g77'.  GNU Fortran provides the Fortran 2003
-      Stream facility.  Programmers should consider the use of new
-      stream IO feature in new code for future portability. See also
-      *Note Fortran 2003 status::.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FGET(C [, STATUS])'
- 
- _Arguments_:
-      C          The type shall be `CHARACTER'.
-      STATUS     (Optional) status flag of type `INTEGER'.
-                                    Returns 0 on success, -1
-                 on end-of-file, and a
-                 system specific positive error code otherwise.
- 
- _Example_:
-           PROGRAM test_fget
-             INTEGER, PARAMETER :: strlen = 100
-             INTEGER :: status, i = 1
-             CHARACTER(len=strlen) :: str = ""
- 
-             WRITE (*,*) 'Enter text:'
-             DO
-               CALL fget(str(i:i), status)
-               if (status /= 0 .OR. i > strlen) exit
-               i = i + 1
-             END DO
-             WRITE (*,*) TRIM(str)
-           END PROGRAM
- 
- _See also_:
-      *Note FGETC::, *Note FPUT::, *Note FPUTC::
- 
- 
- File: gfortran.info,  Node: FGETC,  Next: FLOAT,  Prev: FGET,  Up: Intrinsic Procedures
- 
- 6.67 `FGETC' -- Read a single character in stream mode
- ======================================================
- 
- _Description_:
-      Read a single character in stream mode by bypassing normal
-      formatted output.  Stream I/O should not be mixed with normal
-      record-oriented (formatted or unformatted) I/O on the same unit;
-      the results are unpredictable.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      Note that the `FGET' intrinsic is provided for backwards
-      compatibility with `g77'.  GNU Fortran provides the Fortran 2003
-      Stream facility.  Programmers should consider the use of new
-      stream IO feature in new code for future portability. See also
-      *Note Fortran 2003 status::.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FGETC(UNIT, C [, STATUS])'
- 
- _Arguments_:
-      UNIT       The type shall be `INTEGER'.
-      C          The type shall be `CHARACTER'.
-      STATUS     (Optional) status flag of type `INTEGER'.
-                 Returns 0 on success,
-                 -1 on end-of-file and a system specific
-                 positive error code otherwise.
- 
- _Example_:
-           PROGRAM test_fgetc
-             INTEGER :: fd = 42, status
-             CHARACTER :: c
- 
-             OPEN(UNIT=fd, FILE="/etc/passwd", ACTION="READ", STATUS = "OLD")
-             DO
-               CALL fgetc(fd, c, status)
-               IF (status /= 0) EXIT
-               call fput(c)
-             END DO
-             CLOSE(UNIT=fd)
-           END PROGRAM
- 
- _See also_:
-      *Note FGET::, *Note FPUT::, *Note FPUTC::
- 
- 
- File: gfortran.info,  Node: FLOOR,  Next: FLUSH,  Prev: FLOAT,  Up: Intrinsic Procedures
- 
- 6.68 `FLOOR' -- Integer floor function
- ======================================
- 
- _Description_:
-      `FLOOR(X)' returns the greatest integer less than or equal to X.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = FLOOR(X [, KIND])'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is of type `INTEGER(KIND)'
- 
- _Example_:
-           program test_floor
-               real :: x = 63.29
-               real :: y = -63.59
-               print *, floor(x) ! returns 63
-               print *, floor(y) ! returns -64
-           end program test_floor
- 
- _See also_:
-      *Note CEILING::, *Note NINT::
- 
- 
- 
- File: gfortran.info,  Node: FLUSH,  Next: FNUM,  Prev: FLOOR,  Up: Intrinsic Procedures
- 
- 6.69 `FLUSH' -- Flush I/O unit(s)
- =================================
- 
- _Description_:
-      Flushes Fortran unit(s) currently open for output. Without the
-      optional argument, all units are flushed, otherwise just the unit
-      specified.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL FLUSH(UNIT)'
- 
- _Arguments_:
-      UNIT       (Optional) The type shall be `INTEGER'.
- 
- _Note_:
-      Beginning with the Fortran 2003 standard, there is a `FLUSH'
-      statement that should be preferred over the `FLUSH' intrinsic.
- 
- 
- 
- File: gfortran.info,  Node: FNUM,  Next: FPUT,  Prev: FLUSH,  Up: Intrinsic Procedures
- 
- 6.70 `FNUM' -- File number function
- ===================================
- 
- _Description_:
-      `FNUM(UNIT)' returns the POSIX file descriptor number
-      corresponding to the open Fortran I/O unit `UNIT'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = FNUM(UNIT)'
- 
- _Arguments_:
-      UNIT       The type shall be `INTEGER'.
- 
- _Return value_:
-      The return value is of type `INTEGER'
- 
- _Example_:
-           program test_fnum
-             integer :: i
-             open (unit=10, status = "scratch")
-             i = fnum(10)
-             print *, i
-             close (10)
-           end program test_fnum
- 
- 
- File: gfortran.info,  Node: FPUT,  Next: FPUTC,  Prev: FNUM,  Up: Intrinsic Procedures
- 
- 6.71 `FPUT' -- Write a single character in stream mode to stdout
- ================================================================
- 
- _Description_:
-      Write a single character in stream mode to stdout by bypassing
-      normal formatted output. Stream I/O should not be mixed with
-      normal record-oriented (formatted or unformatted) I/O on the same
-      unit; the results are unpredictable.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      Note that the `FGET' intrinsic is provided for backwards
-      compatibility with `g77'.  GNU Fortran provides the Fortran 2003
-      Stream facility.  Programmers should consider the use of new
-      stream IO feature in new code for future portability. See also
-      *Note Fortran 2003 status::.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FPUT(C [, STATUS])'
- 
- _Arguments_:
-      C          The type shall be `CHARACTER'.
-      STATUS     (Optional) status flag of type `INTEGER'.
-                 Returns 0 on success,
-                 -1 on end-of-file and a system specific
-                 positive error code otherwise.
- 
- _Example_:
-           PROGRAM test_fput
-             CHARACTER(len=10) :: str = "gfortran"
-             INTEGER :: i
-             DO i = 1, len_trim(str)
-               CALL fput(str(i:i))
-             END DO
-           END PROGRAM
- 
- _See also_:
-      *Note FPUTC::, *Note FGET::, *Note FGETC::
- 
- 
- File: gfortran.info,  Node: FPUTC,  Next: FRACTION,  Prev: FPUT,  Up: Intrinsic Procedures
- 
- 6.72 `FPUTC' -- Write a single character in stream mode
- =======================================================
- 
- _Description_:
-      Write a single character in stream mode by bypassing normal
-      formatted output. Stream I/O should not be mixed with normal
-      record-oriented (formatted or unformatted) I/O on the same unit;
-      the results are unpredictable.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
-      Note that the `FGET' intrinsic is provided for backwards
-      compatibility with `g77'.  GNU Fortran provides the Fortran 2003
-      Stream facility.  Programmers should consider the use of new
-      stream IO feature in new code for future portability. See also
-      *Note Fortran 2003 status::.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FPUTC(UNIT, C [, STATUS])'
- 
- _Arguments_:
-      UNIT       The type shall be `INTEGER'.
-      C          The type shall be `CHARACTER'.
-      STATUS     (Optional) status flag of type `INTEGER'.
-                 Returns 0 on success,
-                 -1 on end-of-file and a system specific
-                 positive error code otherwise.
- 
- _Example_:
-           PROGRAM test_fputc
-             CHARACTER(len=10) :: str = "gfortran"
-             INTEGER :: fd = 42, i
- 
-             OPEN(UNIT = fd, FILE = "out", ACTION = "WRITE", STATUS="NEW")
-             DO i = 1, len_trim(str)
-               CALL fputc(fd, str(i:i))
-             END DO
-             CLOSE(fd)
-           END PROGRAM
- 
- _See also_:
-      *Note FPUT::, *Note FGET::, *Note FGETC::
- 
- 
- File: gfortran.info,  Node: FRACTION,  Next: FREE,  Prev: FPUTC,  Up: Intrinsic Procedures
- 
- 6.73 `FRACTION' -- Fractional part of the model representation
- ==============================================================
- 
- _Description_:
-      `FRACTION(X)' returns the fractional part of the model
-      representation of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `Y = FRACTION(X)'
- 
- _Arguments_:
-      X          The type of the argument shall be a `REAL'.
- 
- _Return value_:
-      The return value is of the same type and kind as the argument.
-      The fractional part of the model representation of `X' is returned;
-      it is `X * RADIX(X)**(-EXPONENT(X))'.
- 
- _Example_:
-           program test_fraction
-             real :: x
-             x = 178.1387e-4
-             print *, fraction(x), x * radix(x)**(-exponent(x))
-           end program test_fraction
- 
- 
- 
- File: gfortran.info,  Node: FREE,  Next: FSEEK,  Prev: FRACTION,  Up: Intrinsic Procedures
- 
- 6.74 `FREE' -- Frees memory
- ===========================
- 
- _Description_:
-      Frees memory previously allocated by `MALLOC()'. The `FREE'
-      intrinsic is an extension intended to be used with Cray pointers,
-      and is provided in GNU Fortran to allow user to compile legacy
-      code. For new code using Fortran 95 pointers, the memory
-      de-allocation intrinsic is `DEALLOCATE'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL FREE(PTR)'
- 
- _Arguments_:
-      PTR        The type shall be `INTEGER'. It represents the
-                 location of the memory that should be
-                 de-allocated.
- 
- _Return value_:
-      None
- 
- _Example_:
-      See `MALLOC' for an example.
- 
- _See also_:
-      *Note MALLOC::
- 
- 
- File: gfortran.info,  Node: FSEEK,  Next: FSTAT,  Prev: FREE,  Up: Intrinsic Procedures
- 
- 6.75 `FSEEK' -- Low level file positioning subroutine
- =====================================================
- 
- Not yet implemented in GNU Fortran.
- 
- _Description_:
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
- 
- _Arguments_:
- 
- _Return value_:
- 
- _Example_:
- 
- _Specific names_:
- 
- _See also_:
-      g77 features lacking in gfortran
-      (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19292)
- 
- 
- 
- File: gfortran.info,  Node: FSTAT,  Next: FTELL,  Prev: FSEEK,  Up: Intrinsic Procedures
- 
- 6.76 `FSTAT' -- Get file status
- ===============================
- 
- _Description_:
-      `FSTAT' is identical to *Note STAT::, except that information
-      about an already opened file is obtained.
- 
-      The elements in `BUFF' are the same as described by *Note STAT::.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FSTAT(UNIT, BUFF [, STATUS])'
- 
- _Arguments_:
-      UNIT       An open I/O unit number of type `INTEGER'.
-      BUFF       The type shall be `INTEGER(4), DIMENSION(13)'.
-      STATUS     (Optional) status flag of type `INTEGER(4)'.
-                 Returns 0                         on success
-                 and a system specific error code otherwise.
- 
- _Example_:
-      See *Note STAT:: for an example.
- 
- _See also_:
-      To stat a link: *Note LSTAT::, to stat a file: *Note STAT::
- 
- 
- File: gfortran.info,  Node: FTELL,  Next: GERROR,  Prev: FSTAT,  Up: Intrinsic Procedures
- 
- 6.77 `FTELL' -- Current stream position
- =======================================
- 
- _Description_:
-      Retrieves the current position within an open file.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL FTELL(UNIT, OFFSET)'
-      `OFFSET = FTELL(UNIT)'
- 
- _Arguments_:
-      OFFSET     Shall of type `INTEGER'.
-      UNIT       Shall of type `INTEGER'.
- 
- _Return value_:
-      In either syntax, OFFSET is set to the current offset of unit
-      number UNIT, or to -1 if the unit is not currently open.
- 
- _Example_:
-           PROGRAM test_ftell
-             INTEGER :: i
-             OPEN(10, FILE="temp.dat")
-             CALL ftell(10,i)
-             WRITE(*,*) i
-           END PROGRAM
- 
- _See also_:
-      *Note FSEEK::
- 
- 
- File: gfortran.info,  Node: GERROR,  Next: GETARG,  Prev: FTELL,  Up: Intrinsic Procedures
- 
- 6.78 `GERROR' -- Get last system error message
- ==============================================
- 
- _Description_:
-      Returns the system error message corresponding to the last system
-      error.  This resembles the functionality of `strerror(3)' in C.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GERROR(RESULT)'
- 
- _Arguments_:
-      RESULT     Shall of type `CHARACTER(*)'.
- 
- _Example_:
-           PROGRAM test_gerror
-             CHARACTER(len=100) :: msg
-             CALL gerror(msg)
-             WRITE(*,*) msg
-           END PROGRAM
- 
- _See also_:
-      *Note IERRNO::, *Note PERROR::
- 
- 
- File: gfortran.info,  Node: GETARG,  Next: GET_COMMAND,  Prev: GERROR,  Up: Intrinsic Procedures
- 
- 6.79 `GETARG' -- Get command line arguments
- ===========================================
- 
- _Description_:
-      Retrieve the Nth argument that was passed on the command line when
-      the containing program was invoked.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77.  In new code, programmers should consider the use
-      of the *Note GET_COMMAND_ARGUMENT:: intrinsic defined by the
-      Fortran 2003 standard.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GETARG(N, ARG)'
- 
- _Arguments_:
-      N          Shall be of type `INTEGER(4)', N \geq 0
-      ARG        Shall be of type `CHARACTER(*)'.
- 
- _Return value_:
-      After `GETARG' returns, the ARG argument holds the Nth command
-      line argument. If ARG can not hold the argument, it is truncated
-      to fit the length of ARG. If there are less than N arguments
-      specified at the command line, ARG will be filled with blanks.  If
-      N = 0, ARG is set to the name of the program (on systems that
-      support this feature).
- 
- _Example_:
-           PROGRAM test_getarg
-             INTEGER :: i
-             CHARACTER(len=32) :: arg
- 
-             DO i = 1, iargc()
-               CALL getarg(i, arg)
-               WRITE (*,*) arg
-             END DO
-           END PROGRAM
- 
- _See also_:
-      GNU Fortran 77 compatibility function: *Note IARGC::
- 
-      F2003 functions and subroutines: *Note GET_COMMAND::, *Note
-      GET_COMMAND_ARGUMENT::, *Note COMMAND_ARGUMENT_COUNT::
- 
- 
- File: gfortran.info,  Node: GET_COMMAND,  Next: GET_COMMAND_ARGUMENT,  Prev: GETARG,  Up: Intrinsic Procedures
- 
- 6.80 `GET_COMMAND' -- Get the entire command line
- =================================================
- 
- _Description_:
-      Retrieve the entire command line that was used to invoke the
-      program.
- 
- _Standard_:
-      F2003
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GET_COMMAND(CMD)'
- 
- _Arguments_:
-      CMD        Shall be of type `CHARACTER(*)'.
- 
- _Return value_:
-      Stores the entire command line that was used to invoke the program
-      in ARG.  If ARG is not large enough, the command will be truncated.
- 
- _Example_:
-           PROGRAM test_get_command
-             CHARACTER(len=255) :: cmd
-             CALL get_command(cmd)
-             WRITE (*,*) TRIM(cmd)
-           END PROGRAM
- 
- _See also_:
-      *Note GET_COMMAND_ARGUMENT::, *Note COMMAND_ARGUMENT_COUNT::
- 
- 
- File: gfortran.info,  Node: GET_COMMAND_ARGUMENT,  Next: GETCWD,  Prev: GET_COMMAND,  Up: Intrinsic Procedures
- 
- 6.81 `GET_COMMAND_ARGUMENT' -- Get command line arguments
- =========================================================
- 
- _Description_:
-      Retrieve the Nth argument that was passed on the command line when
-      the containing program was invoked.
- 
- _Standard_:
-      F2003
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GET_COMMAND_ARGUMENT(N, ARG)'
- 
- _Arguments_:
-      N          Shall be of type `INTEGER(4)', N \geq 0
-      ARG        Shall be of type `CHARACTER(*)'.
- 
- _Return value_:
-      After `GET_COMMAND_ARGUMENT' returns, the ARG argument holds the
-      Nth command line argument. If ARG can not hold the argument, it is
-      truncated to fit the length of ARG. If there are less than N
-      arguments specified at the command line, ARG will be filled with
-      blanks.  If N = 0, ARG is set to the name of the program (on
-      systems that support this feature).
- 
- _Example_:
-           PROGRAM test_get_command_argument
-             INTEGER :: i
-             CHARACTER(len=32) :: arg
- 
-             i = 0
-             DO
-               CALL get_command_argument(i, arg)
-               IF (LEN_TRIM(arg) == 0) EXIT
- 
-               WRITE (*,*) TRIM(arg)
-               i = i+1
-             END DO
-           END PROGRAM
- 
- _See also_:
-      *Note GET_COMMAND::, *Note COMMAND_ARGUMENT_COUNT::
- 
- 
- File: gfortran.info,  Node: GETCWD,  Next: GETENV,  Prev: GET_COMMAND_ARGUMENT,  Up: Intrinsic Procedures
- 
- 6.82 `GETCWD' -- Get current working directory
- ==============================================
- 
- _Description_:
-      Get current working directory.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL GETCWD(CWD [, STATUS])'
- 
- _Arguments_:
-      CWD        The type shall be `CHARACTER(*)'.
-      STATUS     (Optional) status flag. Returns 0 on success,
-                                       a system specific and
-                 non-zero error code otherwise.
- 
- _Example_:
-           PROGRAM test_getcwd
-             CHARACTER(len=255) :: cwd
-             CALL getcwd(cwd)
-             WRITE(*,*) TRIM(cwd)
-           END PROGRAM
- 
- _See also_:
-      *Note CHDIR::
- 
- 
- File: gfortran.info,  Node: GETENV,  Next: GET_ENVIRONMENT_VARIABLE,  Prev: GETCWD,  Up: Intrinsic Procedures
- 
- 6.83 `GETENV' -- Get an environmental variable
- ==============================================
- 
- _Description_:
-      Get the VALUE of the environmental variable ENVVAR.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77.  In new code, programmers should consider the use
-      of the *Note GET_ENVIRONMENT_VARIABLE:: intrinsic defined by the
-      Fortran 2003 standard.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GETENV(ENVVAR, VALUE)'
- 
- _Arguments_:
-      ENVVAR     Shall be of type `CHARACTER(*)'.
-      VALUE      Shall be of type `CHARACTER(*)'.
- 
- _Return value_:
-      Stores the value of ENVVAR in VALUE. If VALUE is not large enough
-      to hold the data, it is truncated. If ENVVAR is not set, VALUE
-      will be filled with blanks.
- 
- _Example_:
-           PROGRAM test_getenv
-             CHARACTER(len=255) :: homedir
-             CALL getenv("HOME", homedir)
-             WRITE (*,*) TRIM(homedir)
-           END PROGRAM
- 
- _See also_:
-      *Note GET_ENVIRONMENT_VARIABLE::
- 
- 
- File: gfortran.info,  Node: GET_ENVIRONMENT_VARIABLE,  Next: GETGID,  Prev: GETENV,  Up: Intrinsic Procedures
- 
- 6.84 `GET_ENVIRONMENT_VARIABLE' -- Get an environmental variable
- ================================================================
- 
- _Description_:
-      Get the VALUE of the environmental variable ENVVAR.
- 
- _Standard_:
-      F2003
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GET_ENVIRONMENT_VARIABLE(ENVVAR, VALUE)'
- 
- _Arguments_:
-      ENVVAR     Shall be of type `CHARACTER(*)'.
-      VALUE      Shall be of type `CHARACTER(*)'.
- 
- _Return value_:
-      Stores the value of ENVVAR in VALUE. If VALUE is not large enough
-      to hold the data, it is truncated. If ENVVAR is not set, VALUE
-      will be filled with blanks.
- 
- _Example_:
-           PROGRAM test_getenv
-             CHARACTER(len=255) :: homedir
-             CALL get_environment_variable("HOME", homedir)
-             WRITE (*,*) TRIM(homedir)
-           END PROGRAM
- 
- 
- File: gfortran.info,  Node: GETGID,  Next: GETLOG,  Prev: GET_ENVIRONMENT_VARIABLE,  Up: Intrinsic Procedures
- 
- 6.85 `GETGID' -- Group ID function
- ==================================
- 
- _Description_:
-      Returns the numerical group ID of the current process.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = GETGID()'
- 
- _Return value_:
-      The return value of `GETGID' is an `INTEGER' of the default kind.
- 
- _Example_:
-      See `GETPID' for an example.
- 
- _See also_:
-      *Note GETPID::, *Note GETUID::
- 
- 
- File: gfortran.info,  Node: GETLOG,  Next: GETPID,  Prev: GETGID,  Up: Intrinsic Procedures
- 
- 6.86 `GETLOG' -- Get login name
- ===============================
- 
- _Description_:
-      Gets the username under which the program is running.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GETLOG(LOGIN)'
- 
- _Arguments_:
-      LOGIN      Shall be of type `CHARACTER(*)'.
- 
- _Return value_:
-      Stores the current user name in LOGIN.  (On systems where the
-      `getlogin(3)' function is not implemented, this will return a
-      blank string.)
- 
- _Example_:
-           PROGRAM TEST_GETLOG
-             CHARACTER(32) :: login
-             CALL GETLOG(login)
-             WRITE(*,*) login
-           END PROGRAM
- 
- _See also_:
-      *Note GETUID::
- 
- 
- File: gfortran.info,  Node: GETPID,  Next: GETUID,  Prev: GETLOG,  Up: Intrinsic Procedures
- 
- 6.87 `GETPID' -- Process ID function
- ====================================
- 
- _Description_:
-      Returns the numerical process identifier of the current process.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = GETPID()'
- 
- _Return value_:
-      The return value of `GETPID' is an `INTEGER' of the default kind.
- 
- _Example_:
-           program info
-             print *, "The current process ID is ", getpid()
-             print *, "Your numerical user ID is ", getuid()
-             print *, "Your numerical group ID is ", getgid()
-           end program info
- 
- _See also_:
-      *Note GETGID::, *Note GETUID::
- 
- 
- File: gfortran.info,  Node: GETUID,  Next: GMTIME,  Prev: GETPID,  Up: Intrinsic Procedures
- 
- 6.88 `GETUID' -- User ID function
- =================================
- 
- _Description_:
-      Returns the numerical user ID of the current process.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = GETUID()'
- 
- _Return value_:
-      The return value of `GETUID' is an `INTEGER' of the default kind.
- 
- _Example_:
-      See `GETPID' for an example.
- 
- _See also_:
-      *Note GETPID::, *Note GETLOG::
- 
- 
- File: gfortran.info,  Node: GMTIME,  Next: HOSTNM,  Prev: GETUID,  Up: Intrinsic Procedures
- 
- 6.89 `GMTIME' -- Convert time to GMT info
- =========================================
- 
- _Description_:
-      Given a system time value STIME (as provided by the `TIME8()'
-      intrinsic), fills TARRAY with values extracted from it appropriate
-      to the UTC time zone (Universal Coordinated Time, also known in
-      some countries as GMT, Greenwich Mean Time), using `gmtime(3)'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL GMTIME(STIME, TARRAY)'
- 
- _Arguments_:
-      STIME      An `INTEGER(*)' scalar expression
-                           corresponding to a system time, with
-                 `INTENT(IN)'.
-      TARRAY     A default `INTEGER' array with 9 elements,
-                                    with `INTENT(OUT)'.
- 
- _Return value_:
-      The elements of TARRAY are assigned as follows:
-        1. Seconds after the minute, range 0-59 or 0-61 to allow for leap
-                seconds
- 
-        2. Minutes after the hour, range 0-59
- 
-        3. Hours past midnight, range 0-23
- 
-        4. Day of month, range 0-31
- 
-        5. Number of months since January, range 0-12
- 
-        6. Years since 1900
- 
-        7. Number of days since Sunday, range 0-6
- 
-        8. Days since January 1
- 
-        9. Daylight savings indicator: positive if daylight savings is in
-                effect, zero if not, and negative if the information is
-           not       available.
- 
- _See also_:
-      *Note CTIME::, *Note LTIME::, *Note TIME::, *Note TIME8::
- 
- 
- 
- File: gfortran.info,  Node: HOSTNM,  Next: HUGE,  Prev: GMTIME,  Up: Intrinsic Procedures
- 
- 6.90 `HOSTNM' -- Get system host name
- =====================================
- 
- _Description_:
-      Retrieves the host name of the system on which the program is
-      running.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL HOSTNM(NAME[, STATUS])'
-      `STATUS = HOSTNM(NAME)'
- 
- _Arguments_:
-      NAME       Shall of type `CHARACTER(*)'.
-      STATUS     (Optional) status flag of type `INTEGER'.
-                                     Returns 0 on success, or
-                 a system specific error
-                  code otherwise.
- 
- _Return value_:
-      In either syntax, NAME is set to the current hostname if it can be
-      obtained, or to a blank string otherwise.
- 
- 
- 
- File: gfortran.info,  Node: HUGE,  Next: IACHAR,  Prev: HOSTNM,  Up: Intrinsic Procedures
- 
- 6.91 `HUGE' -- Largest number of a kind
- =======================================
- 
- _Description_:
-      `HUGE(X)' returns the largest number that is not an infinity in
-      the model of the type of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = HUGE(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL' or `INTEGER'.
- 
- _Return value_:
-      The return value is of the same type and kind as X
- 
- _Example_:
-           program test_huge_tiny
-             print *, huge(0), huge(0.0), huge(0.0d0)
-             print *, tiny(0.0), tiny(0.0d0)
-           end program test_huge_tiny
- 
- 
- File: gfortran.info,  Node: IACHAR,  Next: IAND,  Prev: HUGE,  Up: Intrinsic Procedures
- 
- 6.92 `IACHAR' -- Code in ASCII collating sequence
- =================================================
- 
- _Description_:
-      `IACHAR(C)' returns the code for the ASCII character in the first
-      character position of `C'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IACHAR(C)'
- 
- _Arguments_:
-      C          Shall be a scalar `CHARACTER', with
-                 `INTENT(IN)'
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           program test_iachar
-             integer i
-             i = iachar(' ')
-           end program test_iachar
- 
- _Note_:
-      See *Note ICHAR:: for a discussion of converting between numerical
-      values and formatted string representations.
- 
- _See also_:
-      *Note ACHAR::, *Note CHAR::, *Note ICHAR::
- 
- 
- 
- File: gfortran.info,  Node: IAND,  Next: IARGC,  Prev: IACHAR,  Up: Intrinsic Procedures
- 
- 6.93 `IAND' -- Bitwise logical and
- ==================================
- 
- _Description_:
-      Bitwise logical `AND'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IAND(I, J)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      J          The type shall be `INTEGER(*)', of the same
-                 kind as I.  (As a GNU extension, different
-                 kinds are also permitted.)
- 
- _Return value_:
-      The return type is `INTEGER(*)', of the same kind as the
-      arguments.  (If the argument kinds differ, it is of the same kind
-      as the larger argument.)
- 
- _Example_:
-           PROGRAM test_iand
-             INTEGER :: a, b
-             DATA a / Z'F' /, b / Z'3' /
-             WRITE (*,*) IAND(a, b)
-           END PROGRAM
- 
- _See also_:
-      *Note IOR::, *Note IEOR::, *Note IBITS::, *Note IBSET::, *Note
-      IBCLR::, *Note NOT::
- 
- 
- 
- File: gfortran.info,  Node: IARGC,  Next: IBCLR,  Prev: IAND,  Up: Intrinsic Procedures
- 
- 6.94 `IARGC' -- Get the number of command line arguments
- ========================================================
- 
- _Description_:
-      `IARGC()' returns the number of arguments passed on the command
-      line when the containing program was invoked.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77.  In new code, programmers should consider the use
-      of the *Note COMMAND_ARGUMENT_COUNT:: intrinsic defined by the
-      Fortran 2003 standard.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = IARGC()'
- 
- _Arguments_:
-      None.
- 
- _Return value_:
-      The number of command line arguments, type `INTEGER(4)'.
- 
- _Example_:
-      See *Note GETARG::
- 
- _See also_:
-      GNU Fortran 77 compatibility subroutine: *Note GETARG::
- 
-      F2003 functions and subroutines: *Note GET_COMMAND::, *Note
-      GET_COMMAND_ARGUMENT::, *Note COMMAND_ARGUMENT_COUNT::
- 
- 
- File: gfortran.info,  Node: IBCLR,  Next: IBITS,  Prev: IARGC,  Up: Intrinsic Procedures
- 
- 6.95 `IBCLR' -- Clear bit
- =========================
- 
- _Description_:
-      `IBCLR' returns the value of I with the bit at position POS set to
-      zero.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IBCLR(I, POS)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      POS        The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note IBITS::, *Note IBSET::, *Note IAND::, *Note IOR::, *Note
-      IEOR::, *Note MVBITS::
- 
- 
- 
- File: gfortran.info,  Node: IBITS,  Next: IBSET,  Prev: IBCLR,  Up: Intrinsic Procedures
- 
- 6.96 `IBITS' -- Bit extraction
- ==============================
- 
- _Description_:
-      `IBITS' extracts a field of length LEN from I, starting from bit
-      position POS and extending left for LEN bits.  The result is
-      right-justified and the remaining bits are zeroed.  The value of
-      `POS+LEN' must be less than or equal to the value `BIT_SIZE(I)'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IBITS(I, POS, LEN)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      POS        The type shall be `INTEGER(*)'.
-      LEN        The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note BIT_SIZE::, *Note IBCLR::, *Note IBSET::, *Note IAND::,
-      *Note IOR::, *Note IEOR::
- 
- 
- File: gfortran.info,  Node: IBSET,  Next: ICHAR,  Prev: IBITS,  Up: Intrinsic Procedures
- 
- 6.97 `IBSET' -- Set bit
- =======================
- 
- _Description_:
-      `IBSET' returns the value of I with the bit at position POS set to
-      one.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IBSET(I, POS)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      POS        The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note IBCLR::, *Note IBITS::, *Note IAND::, *Note IOR::, *Note
-      IEOR::, *Note MVBITS::
- 
- 
- 
- File: gfortran.info,  Node: ICHAR,  Next: IDATE,  Prev: IBSET,  Up: Intrinsic Procedures
- 
- 6.98 `ICHAR' -- Character-to-integer conversion function
- ========================================================
- 
- _Description_:
-      `ICHAR(C)' returns the code for the character in the first
-      character position of `C' in the system's native character set.
-      The correspondence between characters and their codes is not
-      necessarily the same across different GNU Fortran implementations.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ICHAR(C)'
- 
- _Arguments_:
-      C          Shall be a scalar `CHARACTER', with
-                 `INTENT(IN)'
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           program test_ichar
-             integer i
-             i = ichar(' ')
-           end program test_ichar
- 
- _Note_:
-      No intrinsic exists to convert between a numeric value and a
-      formatted character string representation - for instance, given the
-      `CHARACTER' value `'154'', obtaining an `INTEGER' or `REAL' value
-      with the value 154, or vice versa. Instead, this functionality is
-      provided by internal-file I/O, as in the following example:
-           program read_val
-             integer value
-             character(len=10) string, string2
-             string = '154'
- 
-             ! Convert a string to a numeric value
-             read (string,'(I10)') value
-             print *, value
- 
-             ! Convert a value to a formatted string
-             write (string2,'(I10)') value
-             print *, string2
-           end program read_val
- 
- _See also_:
-      *Note ACHAR::, *Note CHAR::, *Note IACHAR::
- 
- 
- 
- File: gfortran.info,  Node: IDATE,  Next: IEOR,  Prev: ICHAR,  Up: Intrinsic Procedures
- 
- 6.99 `IDATE' -- Get current local time subroutine (day/month/year)
- ==================================================================
- 
- _Description_:
-      `IDATE(TARRAY)' Fills TARRAY with the numerical values at the
-      current local time. The day (in the range 1-31), month (in the
-      range 1-12), and year appear in elements 1, 2, and 3 of TARRAY,
-      respectively.  The year has four significant digits.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL IDATE(TARRAY)'
- 
- _Arguments_:
-      TARRAY     The type shall be `INTEGER, DIMENSION(3)' and
-                 the kind shall be the default integer kind.
- 
- _Return value_:
-      Does not return.
- 
- _Example_:
-           program test_idate
-             integer, dimension(3) :: tarray
-             call idate(tarray)
-             print *, tarray(1)
-             print *, tarray(2)
-             print *, tarray(3)
-           end program test_idate
- 
- 
- File: gfortran.info,  Node: IEOR,  Next: IERRNO,  Prev: IDATE,  Up: Intrinsic Procedures
- 
- 6.100 `IEOR' -- Bitwise logical exclusive or
- ============================================
- 
- _Description_:
-      `IEOR' returns the bitwise boolean exclusive-OR of I and J.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IEOR(I, J)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      J          The type shall be `INTEGER(*)', of the same
-                 kind as I.  (As a GNU extension, different
-                 kinds are also permitted.)
- 
- _Return value_:
-      The return type is `INTEGER(*)', of the same kind as the
-      arguments.  (If the argument kinds differ, it is of the same kind
-      as the larger argument.)
- 
- _See also_:
-      *Note IOR::, *Note IAND::, *Note IBITS::, *Note IBSET::, *Note
-      IBCLR::, *Note NOT::
- 
- 
- File: gfortran.info,  Node: IERRNO,  Next: INDEX,  Prev: IEOR,  Up: Intrinsic Procedures
- 
- 6.101 `IERRNO' -- Get the last system error number
- ==================================================
- 
- _Description_:
-      Returns the last system error number, as given by the C `errno()'
-      function.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = IERRNO()'
- 
- _Arguments_:
-      None.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _See also_:
-      *Note PERROR::
- 
- 
- File: gfortran.info,  Node: INDEX,  Next: INT,  Prev: IERRNO,  Up: Intrinsic Procedures
- 
- 6.102 `INDEX' -- Position of a substring within a string
- ========================================================
- 
- _Description_:
-      Returns the position of the start of the first occurrence of string
-      SUBSTRING as a substring in STRING, counting from one.  If
-      SUBSTRING is not present in STRING, zero is returned.  If the BACK
-      argument is present and true, the return value is the start of the
-      last occurrence rather than the first.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = INDEX(STRING, SUBSTRING [, BACK])'
- 
- _Arguments_:
-      STRING     Shall be a scalar `CHARACTER(*)', with
-                 `INTENT(IN)'
-      SUBSTRING  Shall be a scalar `CHARACTER(*)', with
-                 `INTENT(IN)'
-      BACK       (Optional) Shall be a scalar `LOGICAL(*)', with
-                 `INTENT(IN)'
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _See also_:
-      *Note SCAN::, *Note VERIFY::
- 
- 
- File: gfortran.info,  Node: INT,  Next: INT2,  Prev: INDEX,  Up: Intrinsic Procedures
- 
- 6.103 `INT' -- Convert to integer type
- ======================================
- 
- _Description_:
-      Convert to integer type
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = INT(A [, KIND))'
- 
- _Arguments_:
-      A          Shall be of type `INTEGER(*)',
-                      `REAL(*)', or `COMPLEX(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      These functions return a `INTEGER(*)' variable or array under the
-      following rules:
- 
-     (A)
-           If A is of type `INTEGER(*)', `INT(A) = A'
- 
-     (B)
-           If A is of type `REAL(*)' and |A| < 1, `INT(A)' equals `0'.
-           If |A| \geq 1, then `INT(A)' equals the largest integer that
-           does not exceed the range of A and whose sign is the same as
-           the sign of A.
- 
-     (C)
-           If A is of type `COMPLEX(*)', rule B is applied to the real
-           part of A.
- 
- _Example_:
-           program test_int
-             integer :: i = 42
-             complex :: z = (-3.7, 1.0)
-             print *, int(i)
-             print *, int(z), int(z,8)
-           end program
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `IFIX(A)'     `REAL(4) A'   `INTEGER'     F77 and later
-      `IDINT(A)'    `REAL(8) A'   `INTEGER'     F77 and later
- 
- 
- 
- File: gfortran.info,  Node: INT2,  Next: INT8,  Prev: INT,  Up: Intrinsic Procedures
- 
- 6.104 `INT2' -- Convert to 16-bit integer type
- ==============================================
- 
- _Description_:
-      Convert to a `KIND=2' integer type. This is equivalent to the
-      standard `INT' intrinsic with an optional argument of `KIND=2',
-      and is only included for backwards compatibility.
- 
-      The `SHORT' intrinsic is equivalent to `INT2'.
- 
- _Standard_:
-      GNU extension.
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = INT2(A)'
- 
- _Arguments_:
-      A          Shall be of type `INTEGER(*)',
-                      `REAL(*)', or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is a `INTEGER(2)' variable.
- 
- _See also_:
-      *Note INT::, *Note INT8::, *Note LONG::
- 
- 
- File: gfortran.info,  Node: INT8,  Next: IOR,  Prev: INT2,  Up: Intrinsic Procedures
- 
- 6.105 `INT8' -- Convert to 64-bit integer type
- ==============================================
- 
- _Description_:
-      Convert to a `KIND=8' integer type. This is equivalent to the
-      standard `INT' intrinsic with an optional argument of `KIND=8',
-      and is only included for backwards compatibility.
- 
- _Standard_:
-      GNU extension.
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = INT8(A)'
- 
- _Arguments_:
-      A          Shall be of type `INTEGER(*)',
-                      `REAL(*)', or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is a `INTEGER(8)' variable.
- 
- _See also_:
-      *Note INT::, *Note INT2::, *Note LONG::
- 
- 
- File: gfortran.info,  Node: IOR,  Next: IRAND,  Prev: INT8,  Up: Intrinsic Procedures
- 
- 6.106 `IOR' -- Bitwise logical or
- =================================
- 
- _Description_:
-      `IEOR' returns the bitwise boolean OR of I and J.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = IEOR(I, J)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      J          The type shall be `INTEGER(*)', of the same
-                 kind as I.  (As a GNU extension, different
-                 kinds are also permitted.)
- 
- _Return value_:
-      The return type is `INTEGER(*)', of the same kind as the
-      arguments.  (If the argument kinds differ, it is of the same kind
-      as the larger argument.)
- 
- _See also_:
-      *Note IEOR::, *Note IAND::, *Note IBITS::, *Note IBSET::, *Note
-      IBCLR::, *Note NOT::
- 
- 
- File: gfortran.info,  Node: IRAND,  Next: ISATTY,  Prev: IOR,  Up: Intrinsic Procedures
- 
- 6.107 `IRAND' -- Integer pseudo-random number
- =============================================
- 
- _Description_:
-      `IRAND(FLAG)' returns a pseudo-random number from a uniform
-      distribution between 0 and a system-dependent limit (which is in
-      most cases 2147483647). If FLAG is 0, the next number in the
-      current sequence is returned; if FLAG is 1, the generator is
-      restarted by `CALL SRAND(0)'; if FLAG has any other value, it is
-      used as a new seed with `SRAND'.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77. It implements a simple modulo generator as provided
-      by `g77'. For new code, one should consider the use of *Note
-      RANDOM_NUMBER:: as it implements a superior algorithm.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = IRAND(FLAG)'
- 
- _Arguments_:
-      FLAG       Shall be a scalar `INTEGER' of kind 4.
- 
- _Return value_:
-      The return value is of `INTEGER(kind=4)' type.
- 
- _Example_:
-           program test_irand
-             integer,parameter :: seed = 86456
- 
-             call srand(seed)
-             print *, irand(), irand(), irand(), irand()
-             print *, irand(seed), irand(), irand(), irand()
-           end program test_irand
- 
- 
- 
- File: gfortran.info,  Node: ISATTY,  Next: ISHFT,  Prev: IRAND,  Up: Intrinsic Procedures
- 
- 6.108 `ISATTY' -- Whether a unit is a terminal device.
- ======================================================
- 
- _Description_:
-      Determine whether a unit is connected to a terminal device.
- 
- _Standard_:
-      GNU extension.
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = ISATTY(UNIT)'
- 
- _Arguments_:
-      UNIT       Shall be a scalar `INTEGER(*)'.
- 
- _Return value_:
-      Returns `.TRUE.' if the UNIT is connected to a terminal device,
-      `.FALSE.' otherwise.
- 
- _Example_:
-           PROGRAM test_isatty
-             INTEGER(kind=1) :: unit
-             DO unit = 1, 10
-               write(*,*) isatty(unit=unit)
-             END DO
-           END PROGRAM
- 
- _See also_:
-      *Note TTYNAM::
- 
- 
- File: gfortran.info,  Node: ISHFT,  Next: ISHFTC,  Prev: ISATTY,  Up: Intrinsic Procedures
- 
- 6.109 `ISHFT' -- Shift bits
- ===========================
- 
- _Description_:
-      `ISHFT' returns a value corresponding to I with all of the bits
-      shifted SHIFT places.  A value of SHIFT greater than zero
-      corresponds to a left shift, a value of zero corresponds to no
-      shift, and a value less than zero corresponds to a right shift.
-      If the absolute value of SHIFT is greater than `BIT_SIZE(I)', the
-      value is undefined.  Bits shifted out from the left end or right
-      end are lost; zeros are shifted in from the opposite end.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ISHFT(I, SHIFT)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      SHIFT      The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note ISHFTC::
- 
- 
- File: gfortran.info,  Node: ISHFTC,  Next: ITIME,  Prev: ISHFT,  Up: Intrinsic Procedures
- 
- 6.110 `ISHFTC' -- Shift bits circularly
- =======================================
- 
- _Description_:
-      `ISHFTC' returns a value corresponding to I with the rightmost
-      SIZE bits shifted circularly SHIFT places; that is, bits shifted
-      out one end are shifted into the opposite end.  A value of SHIFT
-      greater than zero corresponds to a left shift, a value of zero
-      corresponds to no shift, and a value less than zero corresponds to
-      a right shift.  The absolute value of SHIFT must be less than
-      SIZE.  If the SIZE argument is omitted, it is taken to be
-      equivalent to `BIT_SIZE(I)'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = ISHFTC(I, SHIFT [, SIZE])'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      SHIFT      The type shall be `INTEGER(*)'.
-      SIZE       (Optional) The type shall be `INTEGER(*)'; the
-                 value must be greater than zero and less than
-                 or equal to `BIT_SIZE(I)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note ISHFT::
- 
- 
- File: gfortran.info,  Node: ITIME,  Next: KILL,  Prev: ISHFTC,  Up: Intrinsic Procedures
- 
- 6.111 `ITIME' -- Get current local time subroutine (hour/minutes/seconds)
- =========================================================================
- 
- _Description_:
-      `IDATE(TARRAY)' Fills TARRAY with the numerical values at the
-      current local time. The hour (in the range 1-24), minute (in the
-      range 1-60), and seconds (in the range 1-60) appear in elements 1,
-      2, and 3 of TARRAY, respectively.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL ITIME(TARRAY)'
- 
- _Arguments_:
-      TARRAY     The type shall be `INTEGER, DIMENSION(3)' and
-                 the kind shall be the default integer kind.
- 
- _Return value_:
-      Does not return.
- 
- _Example_:
-           program test_itime
-             integer, dimension(3) :: tarray
-             call itime(tarray)
-             print *, tarray(1)
-             print *, tarray(2)
-             print *, tarray(3)
-           end program test_itime
- 
- 
- File: gfortran.info,  Node: KILL,  Next: KIND,  Prev: ITIME,  Up: Intrinsic Procedures
- 
- 6.112 `KILL' -- Send a signal to a process
- ==========================================
- 
- _Description_:
- 
- _Standard_:
-      Sends the signal specified by SIGNAL to the process PID.  See
-      `kill(2)'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL KILL(PID, SIGNAL [, STATUS])'
- 
- _Arguments_:
-      PID        Shall be a scalar `INTEGER', with `INTENT(IN)'
-      SIGNAL     Shall be a scalar `INTEGER', with `INTENT(IN)'
-      STATUS     (Optional) status flag of type `INTEGER(4)' or
-                                        `INTEGER(8)'. Returns
-                 0 on success, or a
-                 system-specific error code otherwise.
- 
- _See also_:
-      *Note ABORT::, *Note EXIT::
- 
- 
- File: gfortran.info,  Node: KIND,  Next: LBOUND,  Prev: KILL,  Up: Intrinsic Procedures
- 
- 6.113 `KIND' -- Kind of an entity
- =================================
- 
- _Description_:
-      `KIND(X)' returns the kind value of the entity X.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `K = KIND(X)'
- 
- _Arguments_:
-      X          Shall be of type `LOGICAL', `INTEGER', `REAL',
-                 `COMPLEX' or `CHARACTER'.
- 
- _Return value_:
-      The return value is a scalar of type `INTEGER' and of the default
-      integer kind.
- 
- _Example_:
-           program test_kind
-             integer,parameter :: kc = kind(' ')
-             integer,parameter :: kl = kind(.true.)
- 
-             print *, "The default character kind is ", kc
-             print *, "The default logical kind is ", kl
-           end program test_kind
- 
- 
- 
- File: gfortran.info,  Node: LBOUND,  Next: LEN,  Prev: KIND,  Up: Intrinsic Procedures
- 
- 6.114 `LBOUND' -- Lower dimension bounds of an array
- ====================================================
- 
- _Description_:
-      Returns the lower bounds of an array, or a single lower bound
-      along the DIM dimension.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = LBOUND(ARRAY [, DIM])'
- 
- _Arguments_:
-      ARRAY      Shall be an array, of any type.
-      DIM        (Optional) Shall be a scalar `INTEGER(*)'.
- 
- _Return value_:
-      If DIM is absent, the result is an array of the lower bounds of
-      ARRAY.  If DIM is present, the result is a scalar corresponding to
-      the lower bound of the array along that dimension.  If ARRAY is an
-      expression rather than a whole array or array structure component,
-      or if it has a zero extent along the relevant dimension, the lower
-      bound is taken to be 1.
- 
- _See also_:
-      *Note UBOUND::
- 
- 
- File: gfortran.info,  Node: LEN,  Next: LEN_TRIM,  Prev: LBOUND,  Up: Intrinsic Procedures
- 
- 6.115 `LEN' -- Length of a character entity
- ===========================================
- 
- _Description_:
-      Returns the length of a character string.  If STRING is an array,
-      the length of an element of STRING is returned.  Note that STRING
-      need not be defined when this intrinsic is invoked, since only the
-      length, not the content, of STRING is needed.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `L = LEN(STRING)'
- 
- _Arguments_:
-      STRING     Shall be a scalar or array of type
-                 `CHARACTER(*)', with `INTENT(IN)'
- 
- _Return value_:
-      The return value is an `INTEGER' of the default kind.
- 
- _See also_:
-      *Note LEN_TRIM::, *Note ADJUSTL::, *Note ADJUSTR::
- 
- 
- File: gfortran.info,  Node: LEN_TRIM,  Next: LGE,  Prev: LEN,  Up: Intrinsic Procedures
- 
- 6.116 `LEN_TRIM' -- Length of a character entity without trailing blank characters
- ==================================================================================
- 
- _Description_:
-      Returns the length of a character string, ignoring any trailing
-      blanks.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LEN_TRIM(STRING)'
- 
- _Arguments_:
-      STRING     Shall be a scalar of type `CHARACTER(*)', with
-                 `INTENT(IN)'
- 
- _Return value_:
-      The return value is an `INTEGER' of the default kind.
- 
- _See also_:
-      *Note LEN::, *Note ADJUSTL::, *Note ADJUSTR::
- 
- 
- File: gfortran.info,  Node: LGE,  Next: LGT,  Prev: LEN_TRIM,  Up: Intrinsic Procedures
- 
- 6.117 `LGE' -- Lexical greater than or equal
- ============================================
- 
- _Description_:
-      Determines whether one string is lexically greater than or equal to
-      another string, where the two strings are interpreted as containing
-      ASCII character codes.  If the String A and String B are not the
-      same length, the shorter is compared as if spaces were appended to
-      it to form a value that has the same length as the longer.
- 
-      In general, the lexical comparison intrinsics `LGE', `LGT', `LLE',
-      and `LLT' differ from the corresponding intrinsic operators
-      `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the
-      processor's character ordering (which is not ASCII on some
-      targets), whereas the former always use the ASCII ordering.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LGE(STRING_A, STRING_B)'
- 
- _Arguments_:
-      STRING_A   Shall be of default `CHARACTER' type.
-      STRING_B   Shall be of default `CHARACTER' type.
- 
- _Return value_:
-      Returns `.TRUE.' if `STRING_A >= STRING_B', and `.FALSE.'
-      otherwise, based on the ASCII ordering.
- 
- _See also_:
-      *Note LGT::, *Note LLE::, *Note LLT::
- 
- 
- File: gfortran.info,  Node: LGT,  Next: LINK,  Prev: LGE,  Up: Intrinsic Procedures
- 
- 6.118 `LGT' -- Lexical greater than
- ===================================
- 
- _Description_:
-      Determines whether one string is lexically greater than another
-      string, where the two strings are interpreted as containing ASCII
-      character codes.  If the String A and String B are not the same
-      length, the shorter is compared as if spaces were appended to it
-      to form a value that has the same length as the longer.
- 
-      In general, the lexical comparison intrinsics `LGE', `LGT', `LLE',
-      and `LLT' differ from the corresponding intrinsic operators
-      `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the
-      processor's character ordering (which is not ASCII on some
-      targets), whereas the former always use the ASCII ordering.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LGT(STRING_A, STRING_B)'
- 
- _Arguments_:
-      STRING_A   Shall be of default `CHARACTER' type.
-      STRING_B   Shall be of default `CHARACTER' type.
- 
- _Return value_:
-      Returns `.TRUE.' if `STRING_A > STRING_B', and `.FALSE.'
-      otherwise, based on the ASCII ordering.
- 
- _See also_:
-      *Note LGE::, *Note LLE::, *Note LLT::
- 
- 
- File: gfortran.info,  Node: LINK,  Next: LLE,  Prev: LGT,  Up: Intrinsic Procedures
- 
- 6.119 `LINK' -- Create a hard link
- ==================================
- 
- _Description_:
-      Makes a (hard) link from file PATH1 to PATH2. A null character
-      (`CHAR(0)') can be used to mark the end of the names in PATH1 and
-      PATH2; otherwise, trailing blanks in the file names are ignored.
-      If the STATUS argument is supplied, it contains 0 on success or a
-      nonzero error code upon return; see `link(2)'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL LINK(PATH1, PATH2 [, STATUS])'
-      `STATUS = LINK(PATH1, PATH2)'
- 
- _Arguments_:
-      PATH1      Shall be of default `CHARACTER' type.
-      PATH2      Shall be of default `CHARACTER' type.
-      STATUS     (Optional) Shall be of default `INTEGER' type.
- 
- _See also_:
-      *Note SYMLNK::, *Note UNLINK::
- 
- 
- File: gfortran.info,  Node: LLE,  Next: LLT,  Prev: LINK,  Up: Intrinsic Procedures
- 
- 6.120 `LLE' -- Lexical less than or equal
- =========================================
- 
- _Description_:
-      Determines whether one string is lexically less than or equal to
-      another string, where the two strings are interpreted as
-      containing ASCII character codes.  If the String A and String B
-      are not the same length, the shorter is compared as if spaces were
-      appended to it to form a value that has the same length as the
-      longer.
- 
-      In general, the lexical comparison intrinsics `LGE', `LGT', `LLE',
-      and `LLT' differ from the corresponding intrinsic operators
-      `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the
-      processor's character ordering (which is not ASCII on some
-      targets), whereas the former always use the ASCII ordering.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LLE(STRING_A, STRING_B)'
- 
- _Arguments_:
-      STRING_A   Shall be of default `CHARACTER' type.
-      STRING_B   Shall be of default `CHARACTER' type.
- 
- _Return value_:
-      Returns `.TRUE.' if `STRING_A <= STRING_B', and `.FALSE.'
-      otherwise, based on the ASCII ordering.
- 
- _See also_:
-      *Note LGE::, *Note LGT::, *Note LLT::
- 
- 
- File: gfortran.info,  Node: LLT,  Next: LNBLNK,  Prev: LLE,  Up: Intrinsic Procedures
- 
- 6.121 `LLT' -- Lexical less than
- ================================
- 
- _Description_:
-      Determines whether one string is lexically less than another
-      string, where the two strings are interpreted as containing ASCII
-      character codes.  If the String A and String B are not the same
-      length, the shorter is compared as if spaces were appended to it
-      to form a value that has the same length as the longer.
- 
-      In general, the lexical comparison intrinsics `LGE', `LGT', `LLE',
-      and `LLT' differ from the corresponding intrinsic operators
-      `.GE.', `.GT.', `.LE.', and `.LT.', in that the latter use the
-      processor's character ordering (which is not ASCII on some
-      targets), whereas the former always use the ASCII ordering.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LLT(STRING_A, STRING_B)'
- 
- _Arguments_:
-      STRING_A   Shall be of default `CHARACTER' type.
-      STRING_B   Shall be of default `CHARACTER' type.
- 
- _Return value_:
-      Returns `.TRUE.' if `STRING_A < STRING_B', and `.FALSE.'
-      otherwise, based on the ASCII ordering.
- 
- _See also_:
-      *Note LGE::, *Note LGT::, *Note LLE::
- 
- 
- File: gfortran.info,  Node: LNBLNK,  Next: LOC,  Prev: LLT,  Up: Intrinsic Procedures
- 
- 6.122 `LNBLNK' -- Index of the last non-blank character in a string
- ===================================================================
- 
- _Description_:
-      Returns the length of a character string, ignoring any trailing
-      blanks.  This is identical to the standard `LEN_TRIM' intrinsic,
-      and is only included for backwards compatibility.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LNBLNK(STRING)'
- 
- _Arguments_:
-      STRING     Shall be a scalar of type `CHARACTER(*)', with
-                 `INTENT(IN)'
- 
- _Return value_:
-      The return value is of `INTEGER(kind=4)' type.
- 
- _See also_:
-      *Note INDEX::, *Note LEN_TRIM::
- 
- 
- File: gfortran.info,  Node: LOC,  Next: LOG,  Prev: LNBLNK,  Up: Intrinsic Procedures
- 
- 6.123 `LOC' -- Returns the address of a variable
- ================================================
- 
- _Description_:
-      `LOC(X)' returns the address of X as an integer.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = LOC(X)'
- 
- _Arguments_:
-      X          Variable of any type.
- 
- _Return value_:
-      The return value is of type `INTEGER', with a `KIND' corresponding
-      to the size (in bytes) of a memory address on the target machine.
- 
- _Example_:
-           program test_loc
-             integer :: i
-             real :: r
-             i = loc(r)
-             print *, i
-           end program test_loc
- 
- 
- File: gfortran.info,  Node: LOG,  Next: LOG10,  Prev: LOC,  Up: Intrinsic Procedures
- 
- 6.124 `LOG' -- Logarithm function
- =================================
- 
- _Description_:
-      `LOG(X)' computes the logarithm of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LOG(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' or `COMPLEX(*)'.  The kind
-      type parameter is the same as X.
- 
- _Example_:
-           program test_log
-             real(8) :: x = 1.0_8
-             complex :: z = (1.0, 2.0)
-             x = log(x)
-             z = log(z)
-           end program test_log
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `ALOG(X)'     `REAL(4) X'   `REAL(4)'     f95, gnu
-      `DLOG(X)'     `REAL(8) X'   `REAL(8)'     f95, gnu
-      `CLOG(X)'     `COMPLEX(4)   `COMPLEX(4)'  f95, gnu
-                    X'                          
-      `ZLOG(X)'     `COMPLEX(8)   `COMPLEX(8)'  f95, gnu
-                    X'                          
-      `CDLOG(X)'    `COMPLEX(8)   `COMPLEX(8)'  f95, gnu
-                    X'                          
- 
- 
- File: gfortran.info,  Node: LOG10,  Next: LOGICAL,  Prev: LOG,  Up: Intrinsic Procedures
- 
- 6.125 `LOG10' -- Base 10 logarithm function
- ===========================================
- 
- _Description_:
-      `LOG10(X)' computes the base 10 logarithm of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LOG10(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' or `COMPLEX(*)'.  The kind
-      type parameter is the same as X.
- 
- _Example_:
-           program test_log10
-             real(8) :: x = 10.0_8
-             x = log10(x)
-           end program test_log10
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `ALOG10(X)'   `REAL(4) X'   `REAL(4)'     F95 and later
-      `DLOG10(X)'   `REAL(8) X'   `REAL(8)'     F95 and later
- 
- 
- File: gfortran.info,  Node: LOGICAL,  Next: LONG,  Prev: LOG10,  Up: Intrinsic Procedures
- 
- 6.126 `LOGICAL' -- Convert to logical type
- ==========================================
- 
- _Description_:
-      Converts one kind of `LOGICAL' variable to another.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LOGICAL(L [, KIND])'
- 
- _Arguments_:
-      L          The type shall be `LOGICAL(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      The return value is a `LOGICAL' value equal to L, with a kind
-      corresponding to KIND, or of the default logical kind if KIND is
-      not given.
- 
- _See also_:
-      *Note INT::, *Note REAL::, *Note CMPLX::
- 
- 
- File: gfortran.info,  Node: LONG,  Next: LSHIFT,  Prev: LOGICAL,  Up: Intrinsic Procedures
- 
- 6.127 `LONG' -- Convert to integer type
- =======================================
- 
- _Description_:
-      Convert to a `KIND=4' integer type, which is the same size as a C
-      `long' integer.  This is equivalent to the standard `INT'
-      intrinsic with an optional argument of `KIND=4', and is only
-      included for backwards compatibility.
- 
- _Standard_:
-      GNU extension.
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LONG(A)'
- 
- _Arguments_:
-      A          Shall be of type `INTEGER(*)',
-                      `REAL(*)', or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is a `INTEGER(4)' variable.
- 
- _See also_:
-      *Note INT::, *Note INT2::, *Note INT8::
- 
- 
- File: gfortran.info,  Node: LSHIFT,  Next: LSTAT,  Prev: LONG,  Up: Intrinsic Procedures
- 
- 6.128 `LSHIFT' -- Left shift bits
- =================================
- 
- _Description_:
-      `LSHIFT' returns a value corresponding to I with all of the bits
-      shifted left by SHIFT places.  If the absolute value of SHIFT is
-      greater than `BIT_SIZE(I)', the value is undefined.  Bits shifted
-      out from the left end are lost; zeros are shifted in from the
-      opposite end.
- 
-      This function has been superseded by the `ISHFT' intrinsic, which
-      is standard in Fortran 95 and later.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = LSHIFT(I, SHIFT)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      SHIFT      The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note ISHFT::, *Note ISHFTC::, *Note RSHIFT::
- 
- 
- 
- File: gfortran.info,  Node: LSTAT,  Next: LTIME,  Prev: LSHIFT,  Up: Intrinsic Procedures
- 
- 6.129 `LSTAT' -- Get file status
- ================================
- 
- _Description_:
-      `LSTAT' is identical to *Note STAT::, except that if path is a
-      symbolic link, then the link itself is statted, not the file that
-      it refers to.
- 
-      The elements in `BUFF' are the same as described by *Note STAT::.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL LSTAT(FILE, BUFF [, STATUS])'
- 
- _Arguments_:
-      FILE       The type shall be `CHARACTER(*)', a valid path
-                 within the file system.
-      BUFF       The type shall be `INTEGER(4), DIMENSION(13)'.
-      STATUS     (Optional) status flag of type `INTEGER(4)'.
-                 Returns 0                         on success
-                 and a system specific error code otherwise.
- 
- _Example_:
-      See *Note STAT:: for an example.
- 
- _See also_:
-      To stat an open file: *Note FSTAT::, to stat a file: *Note STAT::
- 
- 
- File: gfortran.info,  Node: LTIME,  Next: MALLOC,  Prev: LSTAT,  Up: Intrinsic Procedures
- 
- 6.130 `LTIME' -- Convert time to local time info
- ================================================
- 
- _Description_:
-      Given a system time value STIME (as provided by the `TIME8()'
-      intrinsic), fills TARRAY with values extracted from it appropriate
-      to the local time zone using `localtime(3)'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL LTIME(STIME, TARRAY)'
- 
- _Arguments_:
-      STIME      An `INTEGER(*)' scalar expression
-                           corresponding to a system time, with
-                 `INTENT(IN)'.
-      TARRAY     A default `INTEGER' array with 9 elements,
-                                    with `INTENT(OUT)'.
- 
- _Return value_:
-      The elements of TARRAY are assigned as follows:
-        1. Seconds after the minute, range 0-59 or 0-61 to allow for leap
-                seconds
- 
-        2. Minutes after the hour, range 0-59
- 
-        3. Hours past midnight, range 0-23
- 
-        4. Day of month, range 0-31
- 
-        5. Number of months since January, range 0-12
- 
-        6. Years since 1900
- 
-        7. Number of days since Sunday, range 0-6
- 
-        8. Days since January 1
- 
-        9. Daylight savings indicator: positive if daylight savings is in
-                effect, zero if not, and negative if the information is
-           not       available.
- 
- _See also_:
-      *Note CTIME::, *Note GMTIME::, *Note TIME::, *Note TIME8::
- 
- 
- 
- File: gfortran.info,  Node: MALLOC,  Next: MATMUL,  Prev: LTIME,  Up: Intrinsic Procedures
- 
- 6.131 `MALLOC' -- Allocate dynamic memory
- =========================================
- 
- _Description_:
-      `MALLOC(SIZE)' allocates SIZE bytes of dynamic memory and returns
-      the address of the allocated memory. The `MALLOC' intrinsic is an
-      extension intended to be used with Cray pointers, and is provided
-      in GNU Fortran to allow the user to compile legacy code. For new
-      code using Fortran 95 pointers, the memory allocation intrinsic is
-      `ALLOCATE'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `PTR = MALLOC(SIZE)'
- 
- _Arguments_:
-      SIZE       The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(K)', with K such that
-      variables of type `INTEGER(K)' have the same size as C pointers
-      (`sizeof(void *)').
- 
- _Example_:
-      The following example demonstrates the use of `MALLOC' and `FREE'
-      with Cray pointers. This example is intended to run on 32-bit
-      systems, where the default integer kind is suitable to store
-      pointers; on 64-bit systems, ptr_x would need to be declared as
-      `integer(kind=8)'.
- 
-           program test_malloc
-             integer i
-             integer ptr_x
-             real*8 x(*), z
-             pointer(ptr_x,x)
- 
-             ptr_x = malloc(20*8)
-             do i = 1, 20
-               x(i) = sqrt(1.0d0 / i)
-             end do
-             z = 0
-             do i = 1, 20
-               z = z + x(i)
-               print *, z
-             end do
-             call free(ptr_x)
-           end program test_malloc
- 
- _See also_:
-      *Note FREE::
- 
- 
- File: gfortran.info,  Node: MATMUL,  Next: MAX,  Prev: MALLOC,  Up: Intrinsic Procedures
- 
- 6.132 `MATMUL' -- matrix multiplication
- =======================================
- 
- _Description_:
-      Performs a matrix multiplication on numeric or logical arguments.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = MATMUL(MATRIX_A, MATRIX_B)'
- 
- _Arguments_:
-      MATRIX_A   An array of `INTEGER(*)',
-                     `REAL(*)', `COMPLEX(*)', or
-                 `LOGICAL(*)' type, with a rank of 			  one or two.
-      MATRIX_B   An array of `INTEGER(*)',
-                     `REAL(*)', or `COMPLEX(*)' type if
-                  MATRIX_A is of a numeric type; 			  otherwise,
-                 an array of `LOGICAL(*)' 			  type. The
-                 rank shall be one or two, and the 			  first (or
-                 only) dimension of MATRIX_B 			  shall be
-                 equal to the last (or only)
-                 dimension of MATRIX_A.
- 
- _Return value_:
-      The matrix product of MATRIX_A and MATRIX_B.  The type and kind of
-      the result follow the usual type and kind promotion rules, as for
-      the `*' or `.AND.' operators.
- 
- _See also_:
- 
- 
- File: gfortran.info,  Node: MAX,  Next: MAXEXPONENT,  Prev: MATMUL,  Up: Intrinsic Procedures
- 
- 6.133 `MAX' -- Maximum value of an argument list
- ================================================
- 
- _Description_:
-      Returns the argument with the largest (most positive) value.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = MAX(A1, A2 [, A3 [, ...]])'
- 
- _Arguments_:
-      A1         The type shall be `INTEGER(*)' or
-                                `REAL(*)'.
-      A2, A3,    An expression of the same type and kind
-      ...                             as A1.  (As a GNU
-                 extension, 			     arguments of different
-                 kinds are 			     permitted.)
- 
- _Return value_:
-      The return value corresponds to the maximum value among the
-      arguments, and has the same type and kind as the first argument.
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `MAX0(I)'     `INTEGER(4)   `INTEGER(4)'  F77 and later
-                    I'                          
-      `AMAX0(I)'    `INTEGER(4)   `REAL(MAX(X))'F77 and later
-                    I'                          
-      `MAX1(X)'     `REAL(*) X'   `INT(MAX(X))' F77 and later
-      `AMAX1(X)'    `REAL(4)      `REAL(4)'     F77 and later
-                    X'                          
-      `DMAX1(X)'    `REAL(8)      `REAL(8)'     F77 and later
-                    X'                          
- 
- _See also_:
-      *Note MAXLOC:: *Note MAXVAL::, *Note MIN::
- 
- 
- 
- File: gfortran.info,  Node: MAXEXPONENT,  Next: MAXLOC,  Prev: MAX,  Up: Intrinsic Procedures
- 
- 6.134 `MAXEXPONENT' -- Maximum exponent of a real kind
- ======================================================
- 
- _Description_:
-      `MAXEXPONENT(X)' returns the maximum exponent in the model of the
-      type of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = MAXEXPONENT(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL'.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           program exponents
-             real(kind=4) :: x
-             real(kind=8) :: y
- 
-             print *, minexponent(x), maxexponent(x)
-             print *, minexponent(y), maxexponent(y)
-           end program exponents
- 
- 
- File: gfortran.info,  Node: MAXLOC,  Next: MAXVAL,  Prev: MAXEXPONENT,  Up: Intrinsic Procedures
- 
- 6.135 `MAXLOC' -- Location of the maximum value within an array
- ===============================================================
- 
- _Description_:
-      Determines the location of the element in the array with the
-      maximum value, or, if the DIM argument is supplied, determines the
-      locations of the maximum element along each row of the array in the
-      DIM direction.  If MASK is present, only the elements for which
-      MASK is `.TRUE.' are considered.  If more than one element in the
-      array has the maximum value, the location returned is that of the
-      first such element in array element order.  If the array has zero
-      size, or all of the elements of MASK are `.FALSE.', then the
-      result is an array of zeroes.  Similarly, if DIM is supplied and
-      all of the elements of MASK along a given row are zero, the result
-      value for that row is zero.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = MAXLOC(ARRAY, DIM [, MASK])'
-      `RESULT = MAXLOC(ARRAY [, MASK])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of type `INTEGER(*)',
-                                `REAL(*)', or `CHARACTER(*)'.
-      DIM        (Optional) Shall be a scalar of type
-                             `INTEGER(*)', with a value
-                 between one 		       and the rank of
-                 ARRAY, inclusive.  It 		       may not be an
-                 optional dummy argument.
-      MASK       Shall be an array of type `LOGICAL(*)',
-                                and conformable with ARRAY.
- 
- _Return value_:
-      If DIM is absent, the result is a rank-one array with a length
-      equal to the rank of ARRAY.  If DIM is present, the result is an
-      array with a rank one less than the rank of ARRAY, and a size
-      corresponding to the size of ARRAY with the DIM dimension removed.
-      If DIM is present and ARRAY has a rank of one, the result is a
-      scalar.  In all cases, the result is of default `INTEGER' type.
- 
- _See also_:
-      *Note MAX::, *Note MAXVAL::
- 
- 
- 
- File: gfortran.info,  Node: MAXVAL,  Next: MCLOCK,  Prev: MAXLOC,  Up: Intrinsic Procedures
- 
- 6.136 `MAXVAL' -- Maximum value of an array
- ===========================================
- 
- _Description_:
-      Determines the maximum value of the elements in an array value,
-      or, if the DIM argument is supplied, determines the maximum value
-      along each row of the array in the DIM direction.  If MASK is
-      present, only the elements for which MASK is `.TRUE.' are
-      considered.  If the array has zero size, or all of the elements of
-      MASK are `.FALSE.', then the result is the most negative number of
-      the type and kind of ARRAY if ARRAY is numeric, or a string of
-      nulls if ARRAY is of character type.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = MAXVAL(ARRAY, DIM [, MASK])'
-      `RESULT = MAXVAL(ARRAY [, MASK])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of type `INTEGER(*)',
-                                `REAL(*)', or `CHARACTER(*)'.
-      DIM        (Optional) Shall be a scalar of type
-                             `INTEGER(*)', with a value
-                 between one 		       and the rank of
-                 ARRAY, inclusive.  It 		       may not be an
-                 optional dummy argument.
-      MASK       Shall be an array of type `LOGICAL(*)',
-                                and conformable with ARRAY.
- 
- _Return value_:
-      If DIM is absent, or if ARRAY has a rank of one, the result is a
-      scalar.  If DIM is present, the result is an array with a rank one
-      less than the rank of ARRAY, and a size corresponding to the size
-      of ARRAY with the DIM dimension removed.  In all cases, the result
-      is of the same type and kind as ARRAY.
- 
- _See also_:
-      *Note MAX::, *Note MAXLOC::
- 
- 
- File: gfortran.info,  Node: MCLOCK,  Next: MCLOCK8,  Prev: MAXVAL,  Up: Intrinsic Procedures
- 
- 6.137 `MCLOCK' -- Time function
- ===============================
- 
- _Description_:
-      Returns the number of clock ticks since the start of the process,
-      based on the UNIX function `clock(3)'.
- 
-      This intrinsic is not fully portable, such as to systems with
-      32-bit `INTEGER' types but supporting times wider than 32 bits.
-      Therefore, the values returned by this intrinsic might be, or
-      become, negative, or numerically less than previous values, during
-      a single run of the compiled program.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = MCLOCK()'
- 
- _Return value_:
-      The return value is a scalar of type `INTEGER(4)', equal to the
-      number of clock ticks since the start of the process, or `-1' if
-      the system does not support `clock(3)'.
- 
- _See also_:
-      *Note CTIME::, *Note GMTIME::, *Note LTIME::, *Note MCLOCK::,
-      *Note TIME::
- 
- 
- 
- File: gfortran.info,  Node: MCLOCK8,  Next: MERGE,  Prev: MCLOCK,  Up: Intrinsic Procedures
- 
- 6.138 `MCLOCK8' -- Time function (64-bit)
- =========================================
- 
- _Description_:
-      Returns the number of clock ticks since the start of the process,
-      based on the UNIX function `clock(3)'.
- 
-      _Warning:_ this intrinsic does not increase the range of the timing
-      values over that returned by `clock(3)'. On a system with a 32-bit
-      `clock(3)', `MCLOCK8()' will return a 32-bit value, even though it
-      is converted to a 64-bit `INTEGER(8)' value. That means overflows
-      of the 32-bit value can still occur. Therefore, the values
-      returned by this intrinsic might be or become negative or
-      numerically less than previous values during a single run of the
-      compiled program.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = MCLOCK8()'
- 
- _Return value_:
-      The return value is a scalar of type `INTEGER(8)', equal to the
-      number of clock ticks since the start of the process, or `-1' if
-      the system does not support `clock(3)'.
- 
- _See also_:
-      *Note CTIME::, *Note GMTIME::, *Note LTIME::, *Note MCLOCK::,
-      *Note TIME8::
- 
- 
- 
- File: gfortran.info,  Node: MERGE,  Next: MIN,  Prev: MCLOCK8,  Up: Intrinsic Procedures
- 
- 6.139 `MERGE' -- Merge variables
- ================================
- 
- _Description_:
-      Select values from two arrays according to a logical mask.  The
-      result is equal to TSOURCE if MASK is `.TRUE.', or equal to
-      FSOURCE if it is `.FALSE.'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = MERGE(TSOURCE, FSOURCE, MASK)'
- 
- _Arguments_:
-      TSOURCE    May be of any type.
-      FSOURCE    Shall be of the same type and type parameters
-                                        as TSOURCE.
-      MASK       Shall be of type `LOGICAL(*)'.
- 
- _Return value_:
-      The result is of the same type and type parameters as TSOURCE.
- 
- 
- 
- File: gfortran.info,  Node: MIN,  Next: MINEXPONENT,  Prev: MERGE,  Up: Intrinsic Procedures
- 
- 6.140 `MIN' -- Minimum value of an argument list
- ================================================
- 
- _Description_:
-      Returns the argument with the smallest (most negative) value.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = MIN(A1, A2 [, A3, ...])'
- 
- _Arguments_:
-      A1         The type shall be `INTEGER(*)' or
-                                `REAL(*)'.
-      A2, A3,    An expression of the same type and kind
-      ...                             as A1.  (As a GNU
-                 extension, 			     arguments of different
-                 kinds are 			     permitted.)
- 
- _Return value_:
-      The return value corresponds to the maximum value among the
-      arguments, and has the same type and kind as the first argument.
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `MIN0(I)'     `INTEGER(4)   `INTEGER(4)'  F77 and later
-                    I'                          
-      `AMIN0(I)'    `INTEGER(4)   `REAL(MIN(X))'F77 and later
-                    I'                          
-      `MIN1(X)'     `REAL(*) X'   `INT(MIN(X))' F77 and later
-      `AMIN1(X)'    `REAL(4)      `REAL(4)'     F77 and later
-                    X'                          
-      `DMIN1(X)'    `REAL(8)      `REAL(8)'     F77 and later
-                    X'                          
- 
- _See also_:
-      *Note MAX::, *Note MINLOC::, *Note MINVAL::
- 
- 
- File: gfortran.info,  Node: MINEXPONENT,  Next: MINLOC,  Prev: MIN,  Up: Intrinsic Procedures
- 
- 6.141 `MINEXPONENT' -- Minimum exponent of a real kind
- ======================================================
- 
- _Description_:
-      `MINEXPONENT(X)' returns the minimum exponent in the model of the
-      type of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = MINEXPONENT(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL'.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-      See `MAXEXPONENT' for an example.
- 
- 
- File: gfortran.info,  Node: MINLOC,  Next: MINVAL,  Prev: MINEXPONENT,  Up: Intrinsic Procedures
- 
- 6.142 `MINLOC' -- Location of the minimum value within an array
- ===============================================================
- 
- _Description_:
-      Determines the location of the element in the array with the
-      minimum value, or, if the DIM argument is supplied, determines the
-      locations of the minimum element along each row of the array in the
-      DIM direction.  If MASK is present, only the elements for which
-      MASK is `.TRUE.' are considered.  If more than one element in the
-      array has the minimum value, the location returned is that of the
-      first such element in array element order.  If the array has zero
-      size, or all of the elements of MASK are `.FALSE.', then the
-      result is an array of zeroes.  Similarly, if DIM is supplied and
-      all of the elements of MASK along a given row are zero, the result
-      value for that row is zero.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = MINLOC(ARRAY, DIM [, MASK])'
-      `RESULT = MINLOC(ARRAY [, MASK])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of type `INTEGER(*)',
-                                `REAL(*)', or `CHARACTER(*)'.
-      DIM        (Optional) Shall be a scalar of type
-                             `INTEGER(*)', with a value
-                 between one 		       and the rank of
-                 ARRAY, inclusive.  It 		       may not be an
-                 optional dummy argument.
-      MASK       Shall be an array of type `LOGICAL(*)',
-                                and conformable with ARRAY.
- 
- _Return value_:
-      If DIM is absent, the result is a rank-one array with a length
-      equal to the rank of ARRAY.  If DIM is present, the result is an
-      array with a rank one less than the rank of ARRAY, and a size
-      corresponding to the size of ARRAY with the DIM dimension removed.
-      If DIM is present and ARRAY has a rank of one, the result is a
-      scalar.  In all cases, the result is of default `INTEGER' type.
- 
- _See also_:
-      *Note MIN::, *Note MINVAL::
- 
- 
- 
- File: gfortran.info,  Node: MINVAL,  Next: MOD,  Prev: MINLOC,  Up: Intrinsic Procedures
- 
- 6.143 `MINVAL' -- Minimum value of an array
- ===========================================
- 
- _Description_:
-      Determines the minimum value of the elements in an array value,
-      or, if the DIM argument is supplied, determines the minimum value
-      along each row of the array in the DIM direction.  If MASK is
-      present, only the elements for which MASK is `.TRUE.' are
-      considered.  If the array has zero size, or all of the elements of
-      MASK are `.FALSE.', then the result is `HUGE(ARRAY)' if ARRAY is
-      numeric, or a string of `CHAR(255)' characters if ARRAY is of
-      character type.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = MINVAL(ARRAY, DIM [, MASK])'
-      `RESULT = MINVAL(ARRAY [, MASK])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of type `INTEGER(*)',
-                                `REAL(*)', or `CHARACTER(*)'.
-      DIM        (Optional) Shall be a scalar of type
-                             `INTEGER(*)', with a value
-                 between one 		       and the rank of
-                 ARRAY, inclusive.  It 		       may not be an
-                 optional dummy argument.
-      MASK       Shall be an array of type `LOGICAL(*)',
-                                and conformable with ARRAY.
- 
- _Return value_:
-      If DIM is absent, or if ARRAY has a rank of one, the result is a
-      scalar.  If DIM is present, the result is an array with a rank one
-      less than the rank of ARRAY, and a size corresponding to the size
-      of ARRAY with the DIM dimension removed.  In all cases, the result
-      is of the same type and kind as ARRAY.
- 
- _See also_:
-      *Note MIN::, *Note MINLOC::
- 
- 
- 
- File: gfortran.info,  Node: MOD,  Next: MODULO,  Prev: MINVAL,  Up: Intrinsic Procedures
- 
- 6.144 `MOD' -- Remainder function
- =================================
- 
- _Description_:
-      `MOD(A,P)' computes the remainder of the division of A by P. It is
-      calculated as `A - (INT(A/P) * P)'.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = MOD(A, P)'
- 
- _Arguments_:
-      A          Shall be a scalar of type `INTEGER' or `REAL'
-      P          Shall be a scalar of the same type as A and not
-                 equal to zero
- 
- _Return value_:
-      The kind of the return value is the result of cross-promoting the
-      kinds of the arguments.
- 
- _Example_:
-           program test_mod
-             print *, mod(17,3)
-             print *, mod(17.5,5.5)
-             print *, mod(17.5d0,5.5)
-             print *, mod(17.5,5.5d0)
- 
-             print *, mod(-17,3)
-             print *, mod(-17.5,5.5)
-             print *, mod(-17.5d0,5.5)
-             print *, mod(-17.5,5.5d0)
- 
-             print *, mod(17,-3)
-             print *, mod(17.5,-5.5)
-             print *, mod(17.5d0,-5.5)
-             print *, mod(17.5,-5.5d0)
-           end program test_mod
- 
- _Specific names_:
-      Name          Arguments     Return type   Standard
-      `AMOD(A,P)'   `REAL(4)'     `REAL(4)'     F95 and later
-      `DMOD(A,P)'   `REAL(8)'     `REAL(8)'     F95 and later
- 
- 
- File: gfortran.info,  Node: MODULO,  Next: MOVE_ALLOC,  Prev: MOD,  Up: Intrinsic Procedures
- 
- 6.145 `MODULO' -- Modulo function
- =================================
- 
- _Description_:
-      `MODULO(A,P)' computes the A modulo P.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = MODULO(A, P)'
- 
- _Arguments_:
-      A          Shall be a scalar of type `INTEGER' or `REAL'
-      P          Shall be a scalar of the same type and kind as
-                 A
- 
- _Return value_:
-      The type and kind of the result are those of the arguments.
-     If A and P are of type `INTEGER':
-           `MODULO(A,P)' has the value R such that `A=Q*P+R', where Q is
-           an integer and R is between 0 (inclusive) and P (exclusive).
- 
-     If A and P are of type `REAL':
-           `MODULO(A,P)' has the value of `A - FLOOR (A / P) * P'.
-      In all cases, if P is zero the result is processor-dependent.
- 
- _Example_:
-           program test_modulo
-             print *, modulo(17,3)
-             print *, modulo(17.5,5.5)
- 
-             print *, modulo(-17,3)
-             print *, modulo(-17.5,5.5)
- 
-             print *, modulo(17,-3)
-             print *, modulo(17.5,-5.5)
-           end program
- 
- 
- 
- File: gfortran.info,  Node: MOVE_ALLOC,  Next: MVBITS,  Prev: MODULO,  Up: Intrinsic Procedures
- 
- 6.146 `MOVE_ALLOC' -- Move allocation from one object to another
- ================================================================
- 
- _Description_:
-      `MOVE_ALLOC(SRC, DEST)' moves the allocation from SRC to DEST.
-      SRC will become deallocated in the process.
- 
- _Standard_:
-      F2003 and later
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL MOVE_ALLOC(SRC, DEST)'
- 
- _Arguments_:
-      SRC        `ALLOCATABLE', `INTENT(INOUT)', may be
-                              of any type and kind.
-      DEST       `ALLOCATABLE', `INTENT(OUT)', shall be
-                              of the same type, kind and rank
-                 as SRC
- 
- _Return value_:
-      None
- 
- _Example_:
-           program test_move_alloc
-               integer, allocatable :: a(:), b(:)
- 
-               allocate(a(3))
-               a = [ 1, 2, 3 ]
-               call move_alloc(a, b)
-               print *, allocated(a), allocated(b)
-               print *, b
-           end program test_move_alloc
- 
- 
- File: gfortran.info,  Node: MVBITS,  Next: NEAREST,  Prev: MOVE_ALLOC,  Up: Intrinsic Procedures
- 
- 6.147 `MVBITS' -- Move bits from one integer to another
- =======================================================
- 
- _Description_:
-      Moves LEN bits from positions FROMPOS through `FROMPOS+LEN-1' of
-      FROM to positions TOPOS through `TOPOS+LEN-1' of TO. The portion
-      of argument TO not affected by the movement of bits is unchanged.
-      The values of `FROMPOS+LEN-1' and `TOPOS+LEN-1' must be less than
-      `BIT_SIZE(FROM)'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental subroutine
- 
- _Syntax_:
-      `CALL MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)'
- 
- _Arguments_:
-      FROM       The type shall be `INTEGER(*)'.
-      FROMPOS    The type shall be `INTEGER(*)'.
-      LEN        The type shall be `INTEGER(*)'.
-      TO         The type shall be `INTEGER(*)', of the
-                                 same kind as FROM.
-      TOPOS      The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as
-      FROM.
- 
- _See also_:
-      *Note IBCLR::, *Note IBSET::, *Note IBITS::, *Note IAND::, *Note
-      IOR::, *Note IEOR::
- 
- 
- 
- File: gfortran.info,  Node: NEAREST,  Next: NEW_LINE,  Prev: MVBITS,  Up: Intrinsic Procedures
- 
- 6.148 `NEAREST' -- Nearest representable number
- ===============================================
- 
- _Description_:
-      `NEAREST(X, S)' returns the processor-representable number nearest
-      to `X' in the direction indicated by the sign of `S'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = NEAREST(X, S)'
- 
- _Arguments_:
-      X          Shall be of type `REAL'.
-      S          (Optional) shall be of type `REAL' and not
-                 equal to zero.
- 
- _Return value_:
-      The return value is of the same type as `X'. If `S' is positive,
-      `NEAREST' returns the processor-representable number greater than
-      `X' and nearest to it. If `S' is negative, `NEAREST' returns the
-      processor-representable number smaller than `X' and nearest to it.
- 
- _Example_:
-           program test_nearest
-             real :: x, y
-             x = nearest(42.0, 1.0)
-             y = nearest(42.0, -1.0)
-             write (*,"(3(G20.15))") x, y, x - y
-           end program test_nearest
- 
- 
- File: gfortran.info,  Node: NEW_LINE,  Next: NINT,  Prev: NEAREST,  Up: Intrinsic Procedures
- 
- 6.149 `NEW_LINE' -- New line character
- ======================================
- 
- _Description_:
-      `NEW_LINE(C)' returns the new-line character.
- 
- _Standard_:
-      F2003 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = NEW_LINE(C)'
- 
- _Arguments_:
-      C          The argument shall be a scalar or array of the
-                                      type `CHARACTER'.
- 
- _Return value_:
-      Returns a CHARACTER scalar of length one with the new-line
-      character of the same kind as parameter C.
- 
- _Example_:
-           program newline
-             implicit none
-             write(*,'(A)') 'This is record 1.'//NEW_LINE('A')//'This is record 2.'
-           end program newline
- 
- 
- File: gfortran.info,  Node: NINT,  Next: NOT,  Prev: NEW_LINE,  Up: Intrinsic Procedures
- 
- 6.150 `NINT' -- Nearest whole number
- ====================================
- 
- _Description_:
-      `NINT(X)' rounds its argument to the nearest whole number.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = NINT(X)'
- 
- _Arguments_:
-      X          The type of the argument shall be `REAL'.
- 
- _Return value_:
-      Returns A with the fractional portion of its magnitude eliminated
-      by rounding to the nearest whole number and with its sign
-      preserved, converted to an `INTEGER' of the default kind.
- 
- _Example_:
-           program test_nint
-             real(4) x4
-             real(8) x8
-             x4 = 1.234E0_4
-             x8 = 4.321_8
-             print *, nint(x4), idnint(x8)
-           end program test_nint
- 
- _Specific names_:
-      Name              Argument          Standard
-      `IDNINT(X)'       `REAL(8)'         F95 and later
- 
- _See also_:
-      *Note CEILING::, *Note FLOOR::
- 
- 
- 
- File: gfortran.info,  Node: NOT,  Next: NULL,  Prev: NINT,  Up: Intrinsic Procedures
- 
- 6.151 `NOT' -- Logical negation
- ===============================
- 
- _Description_:
-      `NOT' returns the bitwise boolean inverse of I.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = NOT(I)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return type is `INTEGER(*)', of the same kind as the argument.
- 
- _See also_:
-      *Note IAND::, *Note IEOR::, *Note IOR::, *Note IBITS::, *Note
-      IBSET::, *Note IBCLR::
- 
- 
- 
- File: gfortran.info,  Node: NULL,  Next: OR,  Prev: NOT,  Up: Intrinsic Procedures
- 
- 6.152 `NULL' -- Function that returns an disassociated pointer
- ==============================================================
- 
- _Description_:
-      Returns a disassociated pointer.
- 
-      If MOLD is present, a dissassociated pointer of the same type is
-      returned, otherwise the type is determined by context.
- 
-      In Fortran 95, MOLD is optional. Please note that F2003 includes
-      cases where it is required.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `PTR => NULL([MOLD])'
- 
- _Arguments_:
-      MOLD       (Optional) shall be a pointer of any
-                 association status and of any type.
- 
- _Return value_:
-      A disassociated pointer.
- 
- _Example_:
-           REAL, POINTER, DIMENSION(:) :: VEC => NULL ()
- 
- _See also_:
-      *Note ASSOCIATED::
- 
- 
- File: gfortran.info,  Node: OR,  Next: PACK,  Prev: NULL,  Up: Intrinsic Procedures
- 
- 6.153 `OR' -- Bitwise logical OR
- ================================
- 
- _Description_:
-      Bitwise logical `OR'.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77.  For integer arguments, programmers should consider
-      the use of the *Note IOR:: intrinsic defined by the Fortran
-      standard.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = OR(X, Y)'
- 
- _Arguments_:
-      X          The type shall be either `INTEGER(*)' or
-                 `LOGICAL'.
-      Y          The type shall be either `INTEGER(*)' or
-                 `LOGICAL'.
- 
- _Return value_:
-      The return type is either `INTEGER(*)' or `LOGICAL' after
-      cross-promotion of the arguments.
- 
- _Example_:
-           PROGRAM test_or
-             LOGICAL :: T = .TRUE., F = .FALSE.
-             INTEGER :: a, b
-             DATA a / Z'F' /, b / Z'3' /
- 
-             WRITE (*,*) OR(T, T), OR(T, F), OR(F, T), OR(F, F)
-             WRITE (*,*) OR(a, b)
-           END PROGRAM
- 
- _See also_:
-      F95 elemental function: *Note IOR::
- 
- 
- File: gfortran.info,  Node: PACK,  Next: PERROR,  Prev: OR,  Up: Intrinsic Procedures
- 
- 6.154 `PACK' -- Pack an array into an array of rank one
- =======================================================
- 
- _Description_:
-      Stores the elements of ARRAY in an array of rank one.
- 
-      The beginning of the resulting array is made up of elements whose
-      MASK equals `TRUE'. Afterwards, positions are filled with elements
-      taken from VECTOR.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = PACK(ARRAY, MASK[,VECTOR]'
- 
- _Arguments_:
-      ARRAY      Shall be an array of any type.
-      MASK       Shall be an array of type `LOGICAL' and of the
-                 same size as ARRAY. Alternatively, it may be a
-                 `LOGICAL' scalar.
-      VECTOR     (Optional) shall be an array of the same type
-                 as ARRAY and of rank one. If present, the
-                 number of elements in VECTOR shall be equal to
-                 or greater than the number of true elements in
-                 MASK. If MASK is scalar, the number of
-                 elements in VECTOR shall be equal to or
-                 greater than the number of elements in ARRAY.
- 
- _Return value_:
-      The result is an array of rank one and the same type as that of
-      ARRAY.  If VECTOR is present, the result size is that of VECTOR,
-      the number of `TRUE' values in MASK otherwise.
- 
- _Example_:
-      Gathering non-zero elements from an array:
-           PROGRAM test_pack_1
-             INTEGER :: m(6)
-             m = (/ 1, 0, 0, 0, 5, 0 /)
-             WRITE(*, FMT="(6(I0, ' '))") pack(m, m /= 0)  ! "1 5"
-           END PROGRAM
- 
-      Gathering non-zero elements from an array and appending elements
-      from VECTOR:
-           PROGRAM test_pack_2
-             INTEGER :: m(4)
-             m = (/ 1, 0, 0, 2 /)
-             WRITE(*, FMT="(4(I0, ' '))") pack(m, m /= 0, (/ 0, 0, 3, 4 /))  ! "1 2 3 4"
-           END PROGRAM
- 
- _See also_:
-      *Note UNPACK::
- 
- 
- File: gfortran.info,  Node: PERROR,  Next: PRECISION,  Prev: PACK,  Up: Intrinsic Procedures
- 
- 6.155 `PERROR' -- Print system error message
- ============================================
- 
- _Description_:
-      Prints (on the C `stderr' stream) a newline-terminated error
-      message corresponding to the last system error. This is prefixed by
-      STRING, a colon and a space. See `perror(3)'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL PERROR(STRING)'
- 
- _Arguments_:
-      STRING     A scalar of default `CHARACTER' type.
- 
- _See also_:
-      *Note IERRNO::
- 
- 
- File: gfortran.info,  Node: PRECISION,  Next: PRESENT,  Prev: PERROR,  Up: Intrinsic Procedures
- 
- 6.156 `PRECISION' -- Decimal precision of a real kind
- =====================================================
- 
- _Description_:
-      `PRECISION(X)' returns the decimal precision in the model of the
-      type of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = PRECISION(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL' or `COMPLEX'.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           program prec_and_range
-             real(kind=4) :: x(2)
-             complex(kind=8) :: y
- 
-             print *, precision(x), range(x)
-             print *, precision(y), range(y)
-           end program prec_and_range
- 
- 
- File: gfortran.info,  Node: PRESENT,  Next: PRODUCT,  Prev: PRECISION,  Up: Intrinsic Procedures
- 
- 6.157 `PRESENT' -- Determine whether an optional dummy argument is specified
- ============================================================================
- 
- _Description_:
-      Determines whether an optional dummy argument is present.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = PRESENT(A)'
- 
- _Arguments_:
-      A          May be of any type and may be a pointer,
-                 scalar or array value, or a dummy procedure.
-                 It shall be the name of an optional dummy
-                 argument accessible within the current
-                 subroutine or function.
- 
- _Return value_:
-      Returns either `TRUE' if the optional argument A is present, or
-      `FALSE' otherwise.
- 
- _Example_:
-           PROGRAM test_present
-             WRITE(*,*) f(), f(42)      ! "F T"
-           CONTAINS
-             LOGICAL FUNCTION f(x)
-               INTEGER, INTENT(IN), OPTIONAL :: x
-               f = PRESENT(x)
-             END FUNCTION
-           END PROGRAM
- 
- 
- File: gfortran.info,  Node: PRODUCT,  Next: RADIX,  Prev: PRESENT,  Up: Intrinsic Procedures
- 
- 6.158 `PRODUCT' -- Product of array elements
- ============================================
- 
- _Description_:
-      Multiplies the elements of ARRAY along dimension DIM if the
-      corresponding element in MASK is `TRUE'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = PRODUCT(ARRAY[, MASK])' `RESULT = PRODUCT(ARRAY, DIM[,
-      MASK])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of type `INTEGER(*)',
-                 `REAL(*)' or `COMPLEX(*)'.
-      DIM        (Optional) shall be a scalar of type `INTEGER'
-                 with a value in the range from 1 to n, where n
-                 equals the rank of ARRAY.
-      MASK       (Optional) shall be of type `LOGICAL' and
-                 either be a scalar or an array of the same
-                 shape as ARRAY.
- 
- _Return value_:
-      The result is of the same type as ARRAY.
- 
-      If DIM is absent, a scalar with the product of all elements in
-      ARRAY is returned. Otherwise, an array of rank n-1, where n equals
-      the rank of ARRAY, and a shape similar to that of ARRAY with
-      dimension DIM dropped is returned.
- 
- _Example_:
-           PROGRAM test_product
-             INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /)
-             print *, PRODUCT(x)                    ! all elements, product = 120
-             print *, PRODUCT(x, MASK=MOD(x, 2)==1) ! odd elements, product = 15
-           END PROGRAM
- 
- _See also_:
-      *Note SUM::
- 
- 
- File: gfortran.info,  Node: RADIX,  Next: RANDOM_NUMBER,  Prev: PRODUCT,  Up: Intrinsic Procedures
- 
- 6.159 `RADIX' -- Base of a model number
- =======================================
- 
- _Description_:
-      `RADIX(X)' returns the base of the model representing the entity X.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = RADIX(X)'
- 
- _Arguments_:
-      X          Shall be of type `INTEGER' or `REAL'
- 
- _Return value_:
-      The return value is a scalar of type `INTEGER' and of the default
-      integer kind.
- 
- _Example_:
-           program test_radix
-             print *, "The radix for the default integer kind is", radix(0)
-             print *, "The radix for the default real kind is", radix(0.0)
-           end program test_radix
- 
- 
- 
- File: gfortran.info,  Node: RAN,  Next: REAL,  Prev: RANGE,  Up: Intrinsic Procedures
- 
- 6.160 `RAN' -- Real pseudo-random number
- ========================================
- 
- _Description_:
-      For compatibility with HP FORTRAN 77/iX, the `RAN' intrinsic is
-      provided as an alias for `RAND'.  See *Note RAND:: for complete
-      documentation.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _See also_:
-      *Note RAND::, *Note RANDOM_NUMBER::
- 
- 
- File: gfortran.info,  Node: RAND,  Next: RANGE,  Prev: RANDOM_SEED,  Up: Intrinsic Procedures
- 
- 6.161 `RAND' -- Real pseudo-random number
- =========================================
- 
- _Description_:
-      `RAND(FLAG)' returns a pseudo-random number from a uniform
-      distribution between 0 and 1. If FLAG is 0, the next number in the
-      current sequence is returned; if FLAG is 1, the generator is
-      restarted by `CALL SRAND(0)'; if FLAG has any other value, it is
-      used as a new seed with `SRAND'.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77. It implements a simple modulo generator as provided
-      by `g77'. For new code, one should consider the use of *Note
-      RANDOM_NUMBER:: as it implements a superior algorithm.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = RAND(FLAG)'
- 
- _Arguments_:
-      FLAG       Shall be a scalar `INTEGER' of kind 4.
- 
- _Return value_:
-      The return value is of `REAL' type and the default kind.
- 
- _Example_:
-           program test_rand
-             integer,parameter :: seed = 86456
- 
-             call srand(seed)
-             print *, rand(), rand(), rand(), rand()
-             print *, rand(seed), rand(), rand(), rand()
-           end program test_rand
- 
- _See also_:
-      *Note SRAND::, *Note RANDOM_NUMBER::
- 
- 
- 
- File: gfortran.info,  Node: RANDOM_NUMBER,  Next: RANDOM_SEED,  Prev: RADIX,  Up: Intrinsic Procedures
- 
- 6.162 `RANDOM_NUMBER' -- Pseudo-random number
- =============================================
- 
- _Description_:
-      Returns a single pseudorandom number or an array of pseudorandom
-      numbers from the uniform distribution over the range  0 \leq x < 1.
- 
-      The runtime-library implementes George Marsaglia's KISS (Keep It
-      Simple Stupid) random number generator (RNG). This RNG combines:
-        1. The congruential generator x(n) = 69069 \cdot x(n-1) +
-           1327217885 with a period of 2^32,
- 
-        2. A 3-shift shift-register generator with a period of 2^32 - 1,
- 
-        3. Two 16-bit multiply-with-carry generators with a period of
-           597273182964842497 > 2^59.
-           The overall period exceeds 2^123.
- 
-      Please note, this RNG is thread safe if used within OpenMP
-      directives, i. e. its state will be consistent while called from
-      multiple threads.  However, the KISS generator does not create
-      random numbers in parallel from multiple sources, but in sequence
-      from a single source. If an OpenMP-enabled application heavily
-      relies on random numbers, one should consider employing a
-      dedicated parallel random number generator instead.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `RANDOM_NUMBER(HARVEST)'
- 
- _Arguments_:
-      HARVEST    Shall be a scalar or an array of type
-                 `REAL(*)'.
- 
- _Example_:
-           program test_random_number
-             REAL :: r(5,5)
-             CALL init_random_seed()         ! see example of RANDOM_SEED
-             CALL RANDOM_NUMBER(r)
-           end program
- 
- _See also_:
-      *Note RANDOM_SEED::
- 
- 
- File: gfortran.info,  Node: RANDOM_SEED,  Next: RAND,  Prev: RANDOM_NUMBER,  Up: Intrinsic Procedures
- 
- 6.163 `RANDOM_SEED' -- Initialize a pseudo-random number sequence
- =================================================================
- 
- _Description_:
-      Restarts or queries the state of the pseudorandom number generator
-      used by `RANDOM_NUMBER'.
- 
-      If `RANDOM_SEED' is called without arguments, it is initialized to
-      a default state. The example below shows how to initialize the
-      random seed based on the system's time.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL RANDOM_SEED(SIZE, PUT, GET)'
- 
- _Arguments_:
-      SIZE       (Optional) Shall be a scalar and of type
-                 default `INTEGER', with `INTENT(OUT)'. It
-                 specifies the minimum size of the arrays used
-                 with the PUT and GET arguments.
-      PUT        (Optional) Shall be an array of type default
-                 `INTEGER' and rank one. It is `INTENT(IN)' and
-                 the size of the array must be larger than or
-                 equal to the number returned by the SIZE
-                 argument.
-      GET        (Optional) Shall be an array of type default
-                 `INTEGER' and rank one. It is `INTENT(OUT)'
-                 and the size of the array must be larger than
-                 or equal to the number returned by the SIZE
-                 argument.
- 
- _Example_:
-           SUBROUTINE init_random_seed()
-             INTEGER :: i, n, clock
-             INTEGER, DIMENSION(:), ALLOCATABLE :: seed
- 
-             CALL RANDOM_SEED(size = n)
-             ALLOCATE(seed(n))
- 
-             CALL SYSTEM_CLOCK(COUNT=clock)
- 
-             seed = clock + 37 * (/ (i - 1, i = 1, n) /)
-             CALL RANDOM_SEED(PUT = seed)
- 
-             DEALLOCATE(seed)
-           END SUBROUTINE
- 
- _See also_:
-      *Note RANDOM_NUMBER::
- 
- 
- File: gfortran.info,  Node: RANGE,  Next: RAN,  Prev: RAND,  Up: Intrinsic Procedures
- 
- 6.164 `RANGE' -- Decimal exponent range of a real kind
- ======================================================
- 
- _Description_:
-      `RANGE(X)' returns the decimal exponent range in the model of the
-      type of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = RANGE(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL' or `COMPLEX'.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-      See `PRECISION' for an example.
- 
- 
- File: gfortran.info,  Node: REAL,  Next: RENAME,  Prev: RAN,  Up: Intrinsic Procedures
- 
- 6.165 `REAL' -- Convert to real type
- ====================================
- 
- _Description_:
-      `REAL(X [, KIND])' converts its argument X to a real type.  The
-      `REALPART(X)' function is provided for compatibility with `g77',
-      and its use is strongly discouraged.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = REAL(X [, KIND])'
-      `RESULT = REALPART(Z)'
- 
- _Arguments_:
-      X          Shall be `INTEGER(*)', `REAL(*)', or
-                            `COMPLEX(*)'.
-      KIND       (Optional) An `INTEGER(*)' initialization
-                                 expression indicating the
-                 kind parameter of 		      the result.
- 
- _Return value_:
-      These functions return a `REAL(*)' variable or array under the
-      following rules:
- 
-     (A)
-           `REAL(X)' is converted to a default real type if X is an
-           integer or real variable.
- 
-     (B)
-           `REAL(X)' is converted to a real type with the kind type
-           parameter of X if X is a complex variable.
- 
-     (C)
-           `REAL(X, KIND)' is converted to a real type with kind type
-           parameter KIND if X is a complex, integer, or real variable.
- 
- _Example_:
-           program test_real
-             complex :: x = (1.0, 2.0)
-             print *, real(x), real(x,8), realpart(x)
-           end program test_real
- 
- _See also_:
-      *Note DBLE::, *Note DFLOAT::, *Note FLOAT::
- 
- 
- 
- File: gfortran.info,  Node: RENAME,  Next: REPEAT,  Prev: REAL,  Up: Intrinsic Procedures
- 
- 6.166 `RENAME' -- Rename a file
- ===============================
- 
- _Description_:
-      Renames a file from file PATH1 to PATH2. A null character
-      (`CHAR(0)') can be used to mark the end of the names in PATH1 and
-      PATH2; otherwise, trailing blanks in the file names are ignored.
-      If the STATUS argument is supplied, it contains 0 on success or a
-      nonzero error code upon return; see `rename(2)'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL RENAME(PATH1, PATH2 [, STATUS])'
-      `STATUS = RENAME(PATH1, PATH2)'
- 
- _Arguments_:
-      PATH1      Shall be of default `CHARACTER' type.
-      PATH2      Shall be of default `CHARACTER' type.
-      STATUS     (Optional) Shall be of default `INTEGER' type.
- 
- _See also_:
-      *Note LINK::
- 
- 
- 
- File: gfortran.info,  Node: REPEAT,  Next: RESHAPE,  Prev: RENAME,  Up: Intrinsic Procedures
- 
- 6.167 `REPEAT' -- Repeated string concatenation
- ===============================================
- 
- _Description_:
-      Concatenates NCOPIES copies of a string.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = REPEAT(STRING, NCOPIES)'
- 
- _Arguments_:
-      STRING     Shall be scalar and of type `CHARACTER(*)'.
-      NCOPIES    Shall be scalar and of type `INTEGER(*)'.
- 
- _Return value_:
-      A new scalar of type `CHARACTER' built up from NCOPIES copies of
-      STRING.
- 
- _Example_:
-           program test_repeat
-             write(*,*) repeat("x", 5)   ! "xxxxx"
-           end program
- 
- 
- File: gfortran.info,  Node: RESHAPE,  Next: RRSPACING,  Prev: REPEAT,  Up: Intrinsic Procedures
- 
- 6.168 `RESHAPE' -- Function to reshape an array
- ===============================================
- 
- _Description_:
-      Reshapes SOURCE to correspond to SHAPE. If necessary, the new
-      array may be padded with elements from PAD or permuted as defined
-      by ORDER.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = RESHAPE(SOURCE, SHAPE[, PAD, ORDER])'
- 
- _Arguments_:
-      SOURCE     Shall be an array of any type.
-      SHAPE      Shall be of type `INTEGER' and an array of
-                 rank one. Its values must be positive or zero.
-      PAD        (Optional) shall be an array of the same type
-                 as SOURCE.
-      ORDER      (Optional) shall be of type `INTEGER' and an
-                 array of the same shape as SHAPE. Its values
-                 shall be a permutation of the numbers from 1
-                 to n, where n is the size of SHAPE. If ORDER
-                 is absent, the natural ordering shall be
-                 assumed.
- 
- _Return value_:
-      The result is an array of shape SHAPE with the same type as SOURCE.
- 
- _Example_:
-           PROGRAM test_reshape
-             INTEGER, DIMENSION(4) :: x
-             WRITE(*,*) SHAPE(x)                       ! prints "4"
-             WRITE(*,*) SHAPE(RESHAPE(x, (/2, 2/)))    ! prints "2 2"
-           END PROGRAM
- 
- _See also_:
-      *Note SHAPE::
- 
- 
- File: gfortran.info,  Node: RRSPACING,  Next: RSHIFT,  Prev: RESHAPE,  Up: Intrinsic Procedures
- 
- 6.169 `RRSPACING' -- Reciprocal of the relative spacing
- =======================================================
- 
- _Description_:
-      `RRSPACING(X)' returns the  reciprocal of the relative spacing of
-      model numbers near X.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = RRSPACING(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL'.
- 
- _Return value_:
-      The return value is of the same type and kind as X.  The value
-      returned is equal to `ABS(FRACTION(X)) *
-      FLOAT(RADIX(X))**DIGITS(X)'.
- 
- _See also_:
-      *Note SPACING::
- 
- 
- File: gfortran.info,  Node: RSHIFT,  Next: SCALE,  Prev: RRSPACING,  Up: Intrinsic Procedures
- 
- 6.170 `RSHIFT' -- Right shift bits
- ==================================
- 
- _Description_:
-      `RSHIFT' returns a value corresponding to I with all of the bits
-      shifted right by SHIFT places.  If the absolute value of SHIFT is
-      greater than `BIT_SIZE(I)', the value is undefined.  Bits shifted
-      out from the left end are lost; zeros are shifted in from the
-      opposite end.
- 
-      This function has been superseded by the `ISHFT' intrinsic, which
-      is standard in Fortran 95 and later.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = RSHIFT(I, SHIFT)'
- 
- _Arguments_:
-      I          The type shall be `INTEGER(*)'.
-      SHIFT      The type shall be `INTEGER(*)'.
- 
- _Return value_:
-      The return value is of type `INTEGER(*)' and of the same kind as I.
- 
- _See also_:
-      *Note ISHFT::, *Note ISHFTC::, *Note LSHIFT::
- 
- 
- 
- File: gfortran.info,  Node: SCALE,  Next: SCAN,  Prev: RSHIFT,  Up: Intrinsic Procedures
- 
- 6.171 `SCALE' -- Scale a real value
- ===================================
- 
- _Description_:
-      `SCALE(X,I)' returns `X * RADIX(X)**I'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SCALE(X, I)'
- 
- _Arguments_:
-      X          The type of the argument shall be a `REAL'.
-      I          The type of the argument shall be a `INTEGER'.
- 
- _Return value_:
-      The return value is of the same type and kind as X.  Its value is
-      `X * RADIX(X)**I'.
- 
- _Example_:
-           program test_scale
-             real :: x = 178.1387e-4
-             integer :: i = 5
-             print *, scale(x,i), x*radix(x)**i
-           end program test_scale
- 
- 
- 
- File: gfortran.info,  Node: SCAN,  Next: SECNDS,  Prev: SCALE,  Up: Intrinsic Procedures
- 
- 6.172 `SCAN' -- Scan a string for the presence of a set of characters
- =====================================================================
- 
- _Description_:
-      Scans a STRING for any of the characters in a SET of characters.
- 
-      If BACK is either absent or equals `FALSE', this function returns
-      the position of the leftmost character of STRING that is in SET.
-      If BACK equals `TRUE', the rightmost position is returned. If no
-      character of SET is found in STRING, the result is zero.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SCAN(STRING, SET[, BACK])'
- 
- _Arguments_:
-      STRING     Shall be of type `CHARACTER(*)'.
-      SET        Shall be of type `CHARACTER(*)'.
-      BACK       (Optional) shall be of type `LOGICAL'.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           PROGRAM test_scan
-             WRITE(*,*) SCAN("FORTRAN", "AO")          ! 2, found 'O'
-             WRITE(*,*) SCAN("FORTRAN", "AO", .TRUE.)  ! 6, found 'A'
-             WRITE(*,*) SCAN("FORTRAN", "C++")         ! 0, found none
-           END PROGRAM
- 
- _See also_:
-      *Note INDEX::, *Note VERIFY::
- 
- 
- File: gfortran.info,  Node: SECNDS,  Next: SECOND,  Prev: SCAN,  Up: Intrinsic Procedures
- 
- 6.173 `SECNDS' -- Time function
- ===============================
- 
- _Description_:
-      `SECNDS(X)' gets the time in seconds from the real-time system
-      clock.  X is a reference time, also in seconds. If this is zero,
-      the time in seconds from midnight is returned. This function is
-      non-standard and its use is discouraged.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = SECNDS (X)'
- 
- _Arguments_:
-      T          Shall be of type `REAL(4)'.
-      X          Shall be of type `REAL(4)'.
- 
- _Return value_:
-      None
- 
- _Example_:
-           program test_secnds
-               integer :: i
-               real(4) :: t1, t2
-               print *, secnds (0.0)   ! seconds since midnight
-               t1 = secnds (0.0)       ! reference time
-               do i = 1, 10000000      ! do something
-               end do
-               t2 = secnds (t1)        ! elapsed time
-               print *, "Something took ", t2, " seconds."
-           end program test_secnds
- 
- 
- File: gfortran.info,  Node: SECOND,  Next: SELECTED_INT_KIND,  Prev: SECNDS,  Up: Intrinsic Procedures
- 
- 6.174 `SECOND' -- CPU time function
- ===================================
- 
- _Description_:
-      Returns a `REAL(4)' value representing the elapsed CPU time in
-      seconds.  This provides the same functionality as the standard
-      `CPU_TIME' intrinsic, and is only included for backwards
-      compatibility.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL SECOND(TIME)'
-      `TIME = SECOND()'
- 
- _Arguments_:
-      TIME       Shall be of type `REAL(4)'.
- 
- _Return value_:
-      In either syntax, TIME is set to the process's current runtime in
-      seconds.
- 
- _See also_:
-      *Note CPU_TIME::
- 
- 
- 
- File: gfortran.info,  Node: SELECTED_INT_KIND,  Next: SELECTED_REAL_KIND,  Prev: SECOND,  Up: Intrinsic Procedures
- 
- 6.175 `SELECTED_INT_KIND' -- Choose integer kind
- ================================================
- 
- _Description_:
-      `SELECTED_INT_KIND(I)' return the kind value of the smallest
-      integer type that can represent all values ranging from -10^I
-      (exclusive) to 10^I (exclusive). If there is no integer kind that
-      accommodates this range, `SELECTED_INT_KIND' returns -1.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = SELECTED_INT_KIND(I)'
- 
- _Arguments_:
-      I          Shall be a scalar and of type `INTEGER'.
- 
- _Example_:
-           program large_integers
-             integer,parameter :: k5 = selected_int_kind(5)
-             integer,parameter :: k15 = selected_int_kind(15)
-             integer(kind=k5) :: i5
-             integer(kind=k15) :: i15
- 
-             print *, huge(i5), huge(i15)
- 
-             ! The following inequalities are always true
-             print *, huge(i5) >= 10_k5**5-1
-             print *, huge(i15) >= 10_k15**15-1
-           end program large_integers
- 
- 
- File: gfortran.info,  Node: SELECTED_REAL_KIND,  Next: SET_EXPONENT,  Prev: SELECTED_INT_KIND,  Up: Intrinsic Procedures
- 
- 6.176 `SELECTED_REAL_KIND' -- Choose real kind
- ==============================================
- 
- _Description_:
-      `SELECTED_REAL_KIND(P,R)' return the kind value of a real data type
-      with decimal precision greater of at least `P' digits and exponent
-      range greater at least `R'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = SELECTED_REAL_KIND(P, R)'
- 
- _Arguments_:
-      P          (Optional) shall be a scalar and of type
-                 `INTEGER'.
-      R          (Optional) shall be a scalar and of type
-                 `INTEGER'.
-      At least one argument shall be present.
- 
- _Return value_:
-      `SELECTED_REAL_KIND' returns the value of the kind type parameter
-      of a real data type with decimal precision of at least `P' digits
-      and a decimal exponent range of at least `R'. If more than one
-      real data type meet the criteria, the kind of the data type with
-      the smallest decimal precision is returned. If no real data type
-      matches the criteria, the result is
-     -1 if the processor does not support a real data type with a
-           precision greater than or equal to `P'
- 
-     -2 if the processor does not support a real type with an exponent
-           range greater than or equal to `R'
- 
-     -3 if neither is supported.
- 
- _Example_:
-           program real_kinds
-             integer,parameter :: p6 = selected_real_kind(6)
-             integer,parameter :: p10r100 = selected_real_kind(10,100)
-             integer,parameter :: r400 = selected_real_kind(r=400)
-             real(kind=p6) :: x
-             real(kind=p10r100) :: y
-             real(kind=r400) :: z
- 
-             print *, precision(x), range(x)
-             print *, precision(y), range(y)
-             print *, precision(z), range(z)
-           end program real_kinds
- 
- 
- File: gfortran.info,  Node: SET_EXPONENT,  Next: SHAPE,  Prev: SELECTED_REAL_KIND,  Up: Intrinsic Procedures
- 
- 6.177 `SET_EXPONENT' -- Set the exponent of the model
- =====================================================
- 
- _Description_:
-      `SET_EXPONENT(X, I)' returns the real number whose fractional part
-      is that that of X and whose exponent part is I.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SET_EXPONENT(X, I)'
- 
- _Arguments_:
-      X          Shall be of type `REAL'.
-      I          Shall be of type `INTEGER'.
- 
- _Return value_:
-      The return value is of the same type and kind as X.  The real
-      number whose fractional part is that that of X and whose exponent
-      part if I is returned; it is `FRACTION(X) * RADIX(X)**I'.
- 
- _Example_:
-           PROGRAM test_setexp
-             REAL :: x = 178.1387e-4
-             INTEGER :: i = 17
-             PRINT *, SET_EXPONENT(x, i), FRACTION(x) * RADIX(x)**i
-           END PROGRAM
- 
- 
- 
- File: gfortran.info,  Node: SHAPE,  Next: SIGN,  Prev: SET_EXPONENT,  Up: Intrinsic Procedures
- 
- 6.178 `SHAPE' -- Determine the shape of an array
- ================================================
- 
- _Description_:
-      Determines the shape of an array.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = SHAPE(SOURCE)'
- 
- _Arguments_:
-      SOURCE     Shall be an array or scalar of any type.  If
-                 SOURCE is a pointer it must be associated and
-                 allocatable arrays must be allocated.
- 
- _Return value_:
-      An `INTEGER' array of rank one with as many elements as SOURCE has
-      dimensions. The elements of the resulting array correspond to the
-      extend of SOURCE along the respective dimensions. If SOURCE is a
-      scalar, the result is the rank one array of size zero.
- 
- _Example_:
-           PROGRAM test_shape
-             INTEGER, DIMENSION(-1:1, -1:2) :: A
-             WRITE(*,*) SHAPE(A)             ! (/ 3, 4 /)
-             WRITE(*,*) SIZE(SHAPE(42))      ! (/ /)
-           END PROGRAM
- 
- _See also_:
-      *Note RESHAPE::, *Note SIZE::
- 
- 
- File: gfortran.info,  Node: SIGN,  Next: SIGNAL,  Prev: SHAPE,  Up: Intrinsic Procedures
- 
- 6.179 `SIGN' -- Sign copying function
- =====================================
- 
- _Description_:
-      `SIGN(A,B)' returns the value of A with the sign of B.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SIGN(A, B)'
- 
- _Arguments_:
-      A          Shall be of type `INTEGER' or `REAL'
-      B          Shall be of the same type and kind as A
- 
- _Return value_:
-      The kind of the return value is that of A and B.  If B\ge 0 then
-      the result is `ABS(A)', else it is `-ABS(A)'.
- 
- _Example_:
-           program test_sign
-             print *, sign(-12,1)
-             print *, sign(-12,0)
-             print *, sign(-12,-1)
- 
-             print *, sign(-12.,1.)
-             print *, sign(-12.,0.)
-             print *, sign(-12.,-1.)
-           end program test_sign
- 
- _Specific names_:
-      Name          Arguments     Return type   Standard
-      `ISIGN(A,P)'  `INTEGER(4)'  `INTEGER(4)'  f95, gnu
-      `DSIGN(A,P)'  `REAL(8)'     `REAL(8)'     f95, gnu
- 
- 
- File: gfortran.info,  Node: SIGNAL,  Next: SIN,  Prev: SIGN,  Up: Intrinsic Procedures
- 
- 6.180 `SIGNAL' -- Signal handling subroutine (or function)
- ==========================================================
- 
- _Description_:
-      `SIGNAL(NUMBER, HANDLER [, STATUS])' causes external subroutine
-      HANDLER to be executed with a single integer argument when signal
-      NUMBER occurs.  If HANDLER is an integer, it can be used to turn
-      off handling of signal NUMBER or revert to its default action.
-      See `signal(2)'.
- 
-      If `SIGNAL' is called as a subroutine and the STATUS argument is
-      supplied, it is set to the value returned by `signal(2)'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL SIGNAL(NUMBER, HANDLER [, STATUS])'
-      `STATUS = SIGNAL(NUMBER, HANDLER)'
- 
- _Arguments_:
-      NUMBER     Shall be a scalar integer, with `INTENT(IN)'
-      HANDLER    Signal handler (`INTEGER FUNCTION' or
-                 `SUBROUTINE') or dummy/global `INTEGER' scalar.
-                 `INTEGER'. It is `INTENT(IN)'.
-      STATUS     (Optional) STATUS shall be a scalar integer.
-                 It has `INTENT(OUT)'.
- 
- _Return value_:
-      The `SIGNAL' function returns the value returned by `signal(2)'.
- 
- _Example_:
-           program test_signal
-             intrinsic signal
-             external handler_print
- 
-             call signal (12, handler_print)
-             call signal (10, 1)
- 
-             call sleep (30)
-           end program test_signal
- 
- 
- File: gfortran.info,  Node: SIN,  Next: SINH,  Prev: SIGNAL,  Up: Intrinsic Procedures
- 
- 6.181 `SIN' -- Sine function
- ============================
- 
- _Description_:
-      `SIN(X)' computes the sine of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SIN(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value has same type and kind as X.
- 
- _Example_:
-           program test_sin
-             real :: x = 0.0
-             x = sin(x)
-           end program test_sin
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DSIN(X)'     `REAL(8) X'   `REAL(8)'     f95, gnu
-      `CSIN(X)'     `COMPLEX(4)   `COMPLEX(4)'  f95, gnu
-                    X'                          
-      `ZSIN(X)'     `COMPLEX(8)   `COMPLEX(8)'  f95, gnu
-                    X'                          
-      `CDSIN(X)'    `COMPLEX(8)   `COMPLEX(8)'  f95, gnu
-                    X'                          
- 
- _See also_:
-      *Note ASIN::
- 
- 
- File: gfortran.info,  Node: SINH,  Next: SIZE,  Prev: SIN,  Up: Intrinsic Procedures
- 
- 6.182 `SINH' -- Hyperbolic sine function
- ========================================
- 
- _Description_:
-      `SINH(X)' computes the hyperbolic sine of X.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SINH(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)'.
- 
- _Example_:
-           program test_sinh
-             real(8) :: x = - 1.0_8
-             x = sinh(x)
-           end program test_sinh
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DSINH(X)'    `REAL(8) X'   `REAL(8)'     F95 and later
- 
- _See also_:
-      *Note ASINH::
- 
- 
- File: gfortran.info,  Node: SIZE,  Next: SLEEP,  Prev: SINH,  Up: Intrinsic Procedures
- 
- 6.183 `SIZE' -- Determine the size of an array
- ==============================================
- 
- _Description_:
-      Determine the extent of ARRAY along a specified dimension DIM, or
-      the total number of elements in ARRAY if DIM is absent.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = SIZE(ARRAY[, DIM])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of any type. If ARRAY is a
-                 pointer it must be associated and allocatable
-                 arrays must be allocated.
-      DIM        (Optional) shall be a scalar of type `INTEGER'
-                 and its value shall be in the range from 1 to
-                 n, where n equals the rank of ARRAY.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           PROGRAM test_size
-             WRITE(*,*) SIZE((/ 1, 2 /))    ! 2
-           END PROGRAM
- 
- _See also_:
-      *Note SHAPE::, *Note RESHAPE::
- 
- 
- File: gfortran.info,  Node: SLEEP,  Next: SNGL,  Prev: SIZE,  Up: Intrinsic Procedures
- 
- 6.184 `SLEEP' -- Sleep for the specified number of seconds
- ==========================================================
- 
- _Description_:
-      Calling this subroutine causes the process to pause for SECONDS
-      seconds.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL SLEEP(SECONDS)'
- 
- _Arguments_:
-      SECONDS    The type shall be of default `INTEGER'.
- 
- _Example_:
-           program test_sleep
-             call sleep(5)
-           end
- 
- 
- File: gfortran.info,  Node: SNGL,  Next: SPACING,  Prev: SLEEP,  Up: Intrinsic Procedures
- 
- 6.185 `SNGL' -- Convert double precision real to default real
- =============================================================
- 
- _Description_:
-      `SNGL(A)' converts the double precision real A to a default real
-      value. This is an archaic form of `REAL' that is specific to one
-      type for A.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SNGL(A)'
- 
- _Arguments_:
-      A          The type shall be a double precision `REAL'.
- 
- _Return value_:
-      The return value is of type default `REAL'.
- 
- _See also_:
-      *Note DBLE::
- 
- 
- File: gfortran.info,  Node: SPACING,  Next: SPREAD,  Prev: SNGL,  Up: Intrinsic Procedures
- 
- 6.186 `SPACING' -- Smallest distance between two numbers of a given type
- ========================================================================
- 
- _Description_:
-      Determines the distance between the argument X and the nearest
-      adjacent number of the same type.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SPACING(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL(*)'.
- 
- _Return value_:
-      The result is of the same type as the input argument X.
- 
- _Example_:
-           PROGRAM test_spacing
-             INTEGER, PARAMETER :: SGL = SELECTED_REAL_KIND(p=6, r=37)
-             INTEGER, PARAMETER :: DBL = SELECTED_REAL_KIND(p=13, r=200)
- 
-             WRITE(*,*) spacing(1.0_SGL)      ! "1.1920929E-07"          on i686
-             WRITE(*,*) spacing(1.0_DBL)      ! "2.220446049250313E-016" on i686
-           END PROGRAM
- 
- _See also_:
-      *Note RRSPACING::
- 
- 
- File: gfortran.info,  Node: SPREAD,  Next: SQRT,  Prev: SPACING,  Up: Intrinsic Procedures
- 
- 6.187 `SPREAD' -- Add a dimension to an array
- =============================================
- 
- _Description_:
-      Replicates a SOURCE array NCOPIES times along a specified
-      dimension DIM.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = SPREAD(SOURCE, DIM, NCOPIES)'
- 
- _Arguments_:
-      SOURCE     Shall be a scalar or an array of any type and
-                 a rank less than seven.
-      DIM        Shall be a scalar of type `INTEGER' with a
-                 value in the range from 1 to n+1, where n
-                 equals the rank of SOURCE.
-      NCOPIES    Shall be a scalar of type `INTEGER'.
- 
- _Return value_:
-      The result is an array of the same type as SOURCE and has rank n+1
-      where n equals the rank of SOURCE.
- 
- _Example_:
-           PROGRAM test_spread
-             INTEGER :: a = 1, b(2) = (/ 1, 2 /)
-             WRITE(*,*) SPREAD(A, 1, 2)            ! "1 1"
-             WRITE(*,*) SPREAD(B, 1, 2)            ! "1 1 2 2"
-           END PROGRAM
- 
- _See also_:
-      *Note UNPACK::
- 
- 
- File: gfortran.info,  Node: SQRT,  Next: SRAND,  Prev: SPREAD,  Up: Intrinsic Procedures
- 
- 6.188 `SQRT' -- Square-root function
- ====================================
- 
- _Description_:
-      `SQRT(X)' computes the square root of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = SQRT(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)' or `COMPLEX(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' or `COMPLEX(*)'.  The kind
-      type parameter is the same as X.
- 
- _Example_:
-           program test_sqrt
-             real(8) :: x = 2.0_8
-             complex :: z = (1.0, 2.0)
-             x = sqrt(x)
-             z = sqrt(z)
-           end program test_sqrt
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DSQRT(X)'    `REAL(8) X'   `REAL(8)'     F95 and later
-      `CSQRT(X)'    `COMPLEX(4)   `COMPLEX(4)'  F95 and later
-                    X'                          
-      `ZSQRT(X)'    `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    X'                          
-      `CDSQRT(X)'   `COMPLEX(8)   `COMPLEX(8)'  GNU extension
-                    X'                          
- 
- 
- File: gfortran.info,  Node: SRAND,  Next: STAT,  Prev: SQRT,  Up: Intrinsic Procedures
- 
- 6.189 `SRAND' -- Reinitialize the random number generator
- =========================================================
- 
- _Description_:
-      `SRAND' reinitializes the pseudo-random number generator called by
-      `RAND' and `IRAND'. The new seed used by the generator is
-      specified by the required argument SEED.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL SRAND(SEED)'
- 
- _Arguments_:
-      SEED       Shall be a scalar `INTEGER(kind=4)'.
- 
- _Return value_:
-      Does not return.
- 
- _Example_:
-      See `RAND' and `IRAND' for examples.
- 
- _Notes_:
-      The Fortran 2003 standard specifies the intrinsic `RANDOM_SEED' to
-      initialize the pseudo-random numbers generator and `RANDOM_NUMBER'
-      to generate pseudo-random numbers. Please note that in GNU
-      Fortran, these two sets of intrinsics (`RAND', `IRAND' and `SRAND'
-      on the one hand, `RANDOM_NUMBER' and `RANDOM_SEED' on the other
-      hand) access two independent pseudo-random number generators.
- 
- _See also_:
-      *Note RAND::, *Note RANDOM_SEED::, *Note RANDOM_NUMBER::
- 
- 
- 
- File: gfortran.info,  Node: STAT,  Next: SUM,  Prev: SRAND,  Up: Intrinsic Procedures
- 
- 6.190 `STAT' -- Get file status
- ===============================
- 
- _Description_:
-      This function returns information about a file. No permissions are
-      required on the file itself, but execute (search) permission is
-      required on all of the directories in path that lead to the file.
- 
-      The elements that are obtained and stored in the array `BUFF':
-      `buff(1)'  Device ID
-      `buff(2)'  Inode number
-      `buff(3)'  File mode
-      `buff(4)'  Number of links
-      `buff(5)'  Owner's uid
-      `buff(6)'  Owner's gid
-      `buff(7)'  ID of device containing directory entry for
-                 file (0 if not available)
-      `buff(8)'  File size (bytes)
-      `buff(9)'  Last access time
-      `buff(10)' Last modification time
-      `buff(11)' Last file status change time
-      `buff(12)' Preferred I/O block size (-1 if not available)
-      `buff(13)' Number of blocks allocated (-1 if not
-                 available)
- 
-      Not all these elements are relevant on all systems.  If an element
-      is not relevant, it is returned as 0.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL STAT(FILE,BUFF[,STATUS])'
- 
- _Arguments_:
-      FILE       The type shall be `CHARACTER(*)', a valid path
-                 within the file system.
-      BUFF       The type shall be `INTEGER(4), DIMENSION(13)'.
-      STATUS     (Optional) status flag of type `INTEGER(4)'.
-                 Returns 0                         on success
-                 and a system specific error code otherwise.
- 
- _Example_:
-           PROGRAM test_stat
-             INTEGER, DIMENSION(13) :: buff
-             INTEGER :: status
- 
-             CALL STAT("/etc/passwd", buff, status)
- 
-             IF (status == 0) THEN
-               WRITE (*, FMT="('Device ID:',               T30, I19)") buff(1)
-               WRITE (*, FMT="('Inode number:',            T30, I19)") buff(2)
-               WRITE (*, FMT="('File mode (octal):',       T30, O19)") buff(3)
-               WRITE (*, FMT="('Number of links:',         T30, I19)") buff(4)
-               WRITE (*, FMT="('Owner''s uid:',            T30, I19)") buff(5)
-               WRITE (*, FMT="('Owner''s gid:',            T30, I19)") buff(6)
-               WRITE (*, FMT="('Device where located:',    T30, I19)") buff(7)
-               WRITE (*, FMT="('File size:',               T30, I19)") buff(8)
-               WRITE (*, FMT="('Last access time:',        T30, A19)") CTIME(buff(9))
-               WRITE (*, FMT="('Last modification time',   T30, A19)") CTIME(buff(10))
-               WRITE (*, FMT="('Last status change time:', T30, A19)") CTIME(buff(11))
-               WRITE (*, FMT="('Preferred block size:',    T30, I19)") buff(12)
-               WRITE (*, FMT="('No. of blocks allocated:', T30, I19)") buff(13)
-             END IF
-           END PROGRAM
- 
- _See also_:
-      To stat an open file: *Note FSTAT::, to stat a link: *Note LSTAT::
- 
- 
- File: gfortran.info,  Node: SUM,  Next: SYMLNK,  Prev: STAT,  Up: Intrinsic Procedures
- 
- 6.191 `SUM' -- Sum of array elements
- ====================================
- 
- _Description_:
-      Adds the elements of ARRAY along dimension DIM if the
-      corresponding element in MASK is `TRUE'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = SUM(ARRAY[, MASK])' `RESULT = SUM(ARRAY, DIM[, MASK])'
- 
- _Arguments_:
-      ARRAY      Shall be an array of type `INTEGER(*)',
-                 `REAL(*)' or `COMPLEX(*)'.
-      DIM        (Optional) shall be a scalar of type `INTEGER'
-                 with a value in the range from 1 to n, where n
-                 equals the rank of ARRAY.
-      MASK       (Optional) shall be of type `LOGICAL' and
-                 either be a scalar or an array of the same
-                 shape as ARRAY.
- 
- _Return value_:
-      The result is of the same type as ARRAY.
- 
-      If DIM is absent, a scalar with the sum of all elements in ARRAY
-      is returned. Otherwise, an array of rank n-1, where n equals the
-      rank of ARRAY,and a shape similar to that of ARRAY with dimension
-      DIM dropped is returned.
- 
- _Example_:
-           PROGRAM test_sum
-             INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /)
-             print *, SUM(x)                        ! all elements, sum = 15
-             print *, SUM(x, MASK=MOD(x, 2)==1)     ! odd elements, sum = 9
-           END PROGRAM
- 
- _See also_:
-      *Note PRODUCT::
- 
- 
- File: gfortran.info,  Node: SYMLNK,  Next: SYSTEM,  Prev: SUM,  Up: Intrinsic Procedures
- 
- 6.192 `SYMLNK' -- Create a symbolic link
- ========================================
- 
- _Description_:
-      Makes a symbolic link from file PATH1 to PATH2. A null character
-      (`CHAR(0)') can be used to mark the end of the names in PATH1 and
-      PATH2; otherwise, trailing blanks in the file names are ignored.
-      If the STATUS argument is supplied, it contains 0 on success or a
-      nonzero error code upon return; see `symlink(2)'.  If the system
-      does not supply `symlink(2)', `ENOSYS' is returned.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL SYMLNK(PATH1, PATH2 [, STATUS])'
-      `STATUS = SYMLNK(PATH1, PATH2)'
- 
- _Arguments_:
-      PATH1      Shall be of default `CHARACTER' type.
-      PATH2      Shall be of default `CHARACTER' type.
-      STATUS     (Optional) Shall be of default `INTEGER' type.
- 
- _See also_:
-      *Note LINK::, *Note UNLINK::
- 
- 
- 
- File: gfortran.info,  Node: SYSTEM,  Next: SYSTEM_CLOCK,  Prev: SYMLNK,  Up: Intrinsic Procedures
- 
- 6.193 `SYSTEM' -- Execute a shell command
- =========================================
- 
- _Description_:
-      Passes the command COMMAND to a shell (see `system(3)'). If
-      argument STATUS is present, it contains the value returned by
-      `system(3)', which is presumably 0 if the shell command succeeded.
-      Note that which shell is used to invoke the command is
-      system-dependent and environment-dependent.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL SYSTEM(COMMAND [, STATUS])'
-      `STATUS = SYSTEM(COMMAND)'
- 
- _Arguments_:
-      COMMAND    Shall be of default `CHARACTER' type.
-      STATUS     (Optional) Shall be of default `INTEGER' type.
- 
- _See also_:
- 
- 
- File: gfortran.info,  Node: SYSTEM_CLOCK,  Next: TAN,  Prev: SYSTEM,  Up: Intrinsic Procedures
- 
- 6.194 `SYSTEM_CLOCK' -- Time function
- =====================================
- 
- _Description_:
-      Determines the COUNT of milliseconds of wall clock time since the
-      Epoch (00:00:00 UTC, January 1, 1970) modulo COUNT_MAX, COUNT_RATE
-      determines the number of clock ticks per second.  COUNT_RATE and
-      COUNT_MAX are constant and specific to `gfortran'.
- 
-      If there is no clock, COUNT is set to `-HUGE(COUNT)', and
-      COUNT_RATE and COUNT_MAX are set to zero
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX])'
- 
- _Arguments_:
- 
- _Arguments_:
-      COUNT      (Optional) shall be a scalar of type default
-                 `INTEGER' with `INTENT(OUT)'.
-      COUNT_RATE (Optional) shall be a scalar of type default
-                 `INTEGER' with `INTENT(OUT)'.
-      COUNT_MAX  (Optional) shall be a scalar of type default
-                 `INTEGER' with `INTENT(OUT)'.
- 
- _Example_:
-           PROGRAM test_system_clock
-             INTEGER :: count, count_rate, count_max
-             CALL SYSTEM_CLOCK(count, count_rate, count_max)
-             WRITE(*,*) count, count_rate, count_max
-           END PROGRAM
- 
- _See also_:
-      *Note DATE_AND_TIME::, *Note CPU_TIME::
- 
- 
- File: gfortran.info,  Node: TAN,  Next: TANH,  Prev: SYSTEM_CLOCK,  Up: Intrinsic Procedures
- 
- 6.195 `TAN' -- Tangent function
- ===============================
- 
- _Description_:
-      `TAN(X)' computes the tangent of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = TAN(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)'.  The kind type parameter is
-      the same as X.
- 
- _Example_:
-           program test_tan
-             real(8) :: x = 0.165_8
-             x = tan(x)
-           end program test_tan
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DTAN(X)'     `REAL(8) X'   `REAL(8)'     F95 and later
- 
- _See also_:
-      *Note ATAN::
- 
- 
- File: gfortran.info,  Node: TANH,  Next: TIME,  Prev: TAN,  Up: Intrinsic Procedures
- 
- 6.196 `TANH' -- Hyperbolic tangent function
- ===========================================
- 
- _Description_:
-      `TANH(X)' computes the hyperbolic tangent of X.
- 
- _Standard_:
-      F77 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `X = TANH(X)'
- 
- _Arguments_:
-      X          The type shall be `REAL(*)'.
- 
- _Return value_:
-      The return value is of type `REAL(*)' and lies in the range  - 1
-      \leq tanh(x) \leq 1 .
- 
- _Example_:
-           program test_tanh
-             real(8) :: x = 2.1_8
-             x = tanh(x)
-           end program test_tanh
- 
- _Specific names_:
-      Name          Argument      Return type   Standard
-      `DTANH(X)'    `REAL(8) X'   `REAL(8)'     F95 and later
- 
- _See also_:
-      *Note ATANH::
- 
- 
- File: gfortran.info,  Node: TIME,  Next: TIME8,  Prev: TANH,  Up: Intrinsic Procedures
- 
- 6.197 `TIME' -- Time function
- =============================
- 
- _Description_:
-      Returns the current time encoded as an integer (in the manner of
-      the UNIX function `time(3)'). This value is suitable for passing to
-      `CTIME()', `GMTIME()', and `LTIME()'.
- 
-      This intrinsic is not fully portable, such as to systems with
-      32-bit `INTEGER' types but supporting times wider than 32 bits.
-      Therefore, the values returned by this intrinsic might be, or
-      become, negative, or numerically less than previous values, during
-      a single run of the compiled program.
- 
-      See *Note TIME8::, for information on a similar intrinsic that
-      might be portable to more GNU Fortran implementations, though to
-      fewer Fortran compilers.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = TIME()'
- 
- _Return value_:
-      The return value is a scalar of type `INTEGER(4)'.
- 
- _See also_:
-      *Note CTIME::, *Note GMTIME::, *Note LTIME::, *Note MCLOCK::,
-      *Note TIME8::
- 
- 
- 
- File: gfortran.info,  Node: TIME8,  Next: TINY,  Prev: TIME,  Up: Intrinsic Procedures
- 
- 6.198 `TIME8' -- Time function (64-bit)
- =======================================
- 
- _Description_:
-      Returns the current time encoded as an integer (in the manner of
-      the UNIX function `time(3)'). This value is suitable for passing to
-      `CTIME()', `GMTIME()', and `LTIME()'.
- 
-      _Warning:_ this intrinsic does not increase the range of the timing
-      values over that returned by `time(3)'. On a system with a 32-bit
-      `time(3)', `TIME8()' will return a 32-bit value, even though it is
-      converted to a 64-bit `INTEGER(8)' value. That means overflows of
-      the 32-bit value can still occur. Therefore, the values returned
-      by this intrinsic might be or become negative or numerically less
-      than previous values during a single run of the compiled program.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = TIME8()'
- 
- _Return value_:
-      The return value is a scalar of type `INTEGER(8)'.
- 
- _See also_:
-      *Note CTIME::, *Note GMTIME::, *Note LTIME::, *Note MCLOCK8::,
-      *Note TIME::
- 
- 
- 
- File: gfortran.info,  Node: TINY,  Next: TRANSFER,  Prev: TIME8,  Up: Intrinsic Procedures
- 
- 6.199 `TINY' -- Smallest positive number of a real kind
- =======================================================
- 
- _Description_:
-      `TINY(X)' returns the smallest positive (non zero) number in the
-      model of the type of `X'.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = TINY(X)'
- 
- _Arguments_:
-      X          Shall be of type `REAL'.
- 
- _Return value_:
-      The return value is of the same type and kind as X
- 
- _Example_:
-      See `HUGE' for an example.
- 
- 
- File: gfortran.info,  Node: TRANSFER,  Next: TRANSPOSE,  Prev: TINY,  Up: Intrinsic Procedures
- 
- 6.200 `TRANSFER' -- Transfer bit patterns
- =========================================
- 
- _Description_:
-      Interprets the bitwise representation of SOURCE in memory as if it
-      is the representation of a variable or array of the same type and
-      type parameters as MOLD.
- 
-      This is approximately equivalent to the C concept of _casting_ one
-      type to another.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = TRANSFER(SOURCE, MOLD[, SIZE])'
- 
- _Arguments_:
-      SOURCE     Shall be a scalar or an array of any type.
-      MOLD       Shall be a scalar or an array of any type.
-      SIZE       (Optional) shall be a scalar of type `INTEGER'.
- 
- _Return value_:
-      The result has the same type as MOLD, with the bit level
-      representation of SOURCE.  If SIZE is present, the result is a
-      one-dimensional array of length SIZE.  If SIZE is absent but MOLD
-      is an array (of any size or shape), the result is a one-
-      dimensional array of the minimum length needed to contain the
-      entirety of the bitwise representation of SOURCE.   If SIZE is
-      absent and MOLD is a scalar, the result is a scalar.
- 
-      If the bitwise representation of the result is longer than that of
-      SOURCE, then the leading bits of the result correspond to those of
-      SOURCE and any trailing bits are filled arbitrarily.
- 
-      When the resulting bit representation does not correspond to a
-      valid representation of a variable of the same type as MOLD, the
-      results are undefined, and subsequent operations on the result
-      cannot be guaranteed to produce sensible behavior.  For example,
-      it is possible to create `LOGICAL' variables for which `VAR' and
-      `.NOT.VAR' both appear to be true.
- 
- _Example_:
-           PROGRAM test_transfer
-             integer :: x = 2143289344
-             print *, transfer(x, 1.0)    ! prints "NaN" on i686
-           END PROGRAM
- 
- 
- File: gfortran.info,  Node: TRANSPOSE,  Next: TRIM,  Prev: TRANSFER,  Up: Intrinsic Procedures
- 
- 6.201 `TRANSPOSE' -- Transpose an array of rank two
- ===================================================
- 
- _Description_:
-      Transpose an array of rank two. Element (i, j) of the result has
-      the value `MATRIX(j, i)', for all i, j.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = TRANSPOSE(MATRIX)'
- 
- _Arguments_:
-      MATRIX     Shall be an array of any type and have a rank
-                 of two.
- 
- _Return value_:
-      The result has the the same type as MATRIX, and has shape `(/ m, n
-      /)' if MATRIX has shape `(/ n, m /)'.
- 
- 
- File: gfortran.info,  Node: TRIM,  Next: TTYNAM,  Prev: TRANSPOSE,  Up: Intrinsic Procedures
- 
- 6.202 `TRIM' -- Remove trailing blank characters of a string
- ============================================================
- 
- _Description_:
-      Removes trailing blank characters of a string.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = TRIM(STRING)'
- 
- _Arguments_:
-      STRING     Shall be a scalar of type `CHARACTER(*)'.
- 
- _Return value_:
-      A scalar of type `CHARACTER(*)' which length is that of STRING
-      less the number of trailing blanks.
- 
- _Example_:
-           PROGRAM test_trim
-             CHARACTER(len=10), PARAMETER :: s = "GFORTRAN  "
-             WRITE(*,*) LEN(s), LEN(TRIM(s))  ! "10 8", with/without trailing blanks
-           END PROGRAM
- 
- _See also_:
-      *Note ADJUSTL::, *Note ADJUSTR::
- 
- 
- File: gfortran.info,  Node: TTYNAM,  Next: UBOUND,  Prev: TRIM,  Up: Intrinsic Procedures
- 
- 6.203 `TTYNAM' -- Get the name of a terminal device.
- ====================================================
- 
- _Description_:
-      Get the name of a terminal device. For more information, see
-      `ttyname(3)'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL TTYNAM(UNIT, NAME)'
-      `NAME = TTYNAM(UNIT)'
- 
- _Arguments_:
-      UNIT       Shall be a scalar `INTEGER(*)'.
-      NAME       Shall be of type `CHARACTER(*)'.
- 
- _Example_:
-           PROGRAM test_ttynam
-             INTEGER :: unit
-             DO unit = 1, 10
-               IF (isatty(unit=unit)) write(*,*) ttynam(unit)
-             END DO
-           END PROGRAM
- 
- _See also_:
-      *Note ISATTY::
- 
- 
- File: gfortran.info,  Node: UBOUND,  Next: UMASK,  Prev: TTYNAM,  Up: Intrinsic Procedures
- 
- 6.204 `UBOUND' -- Upper dimension bounds of an array
- ====================================================
- 
- _Description_:
-      Returns the upper bounds of an array, or a single upper bound
-      along the DIM dimension.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Inquiry function
- 
- _Syntax_:
-      `RESULT = UBOUND(ARRAY [, DIM])'
- 
- _Arguments_:
-      ARRAY      Shall be an array, of any type.
-      DIM        (Optional) Shall be a scalar `INTEGER(*)'.
- 
- _Return value_:
-      If DIM is absent, the result is an array of the upper bounds of
-      ARRAY.  If DIM is present, the result is a scalar corresponding to
-      the upper bound of the array along that dimension.  If ARRAY is an
-      expression rather than a whole array or array structure component,
-      or if it has a zero extent along the relevant dimension, the upper
-      bound is taken to be the number of elements along the relevant
-      dimension.
- 
- _See also_:
-      *Note LBOUND::
- 
- 
- File: gfortran.info,  Node: UMASK,  Next: UNLINK,  Prev: UBOUND,  Up: Intrinsic Procedures
- 
- 6.205 `UMASK' -- Set the file creation mask
- ===========================================
- 
- _Description_:
-      Sets the file creation mask to MASK and returns the old value in
-      argument OLD if it is supplied. See `umask(2)'.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine
- 
- _Syntax_:
-      `CALL UMASK(MASK [, OLD])'
- 
- _Arguments_:
-      MASK       Shall be a scalar of type `INTEGER(*)'.
-      MASK       (Optional) Shall be a scalar of type
-                            `INTEGER(*)'.
- 
- 
- 
- File: gfortran.info,  Node: UNLINK,  Next: UNPACK,  Prev: UMASK,  Up: Intrinsic Procedures
- 
- 6.206 `UNLINK' -- Remove a file from the file system
- ====================================================
- 
- _Description_:
-      Unlinks the file PATH. A null character (`CHAR(0)') can be used to
-      mark the end of the name in PATH; otherwise, trailing blanks in
-      the file name are ignored.  If the STATUS argument is supplied, it
-      contains 0 on success or a nonzero error code upon return; see
-      `unlink(2)'.
- 
-      This intrinsic is provided in both subroutine and function forms;
-      however, only one form can be used in any given program unit.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Subroutine, function
- 
- _Syntax_:
-      `CALL UNLINK(PATH [, STATUS])'
-      `STATUS = UNLINK(PATH)'
- 
- _Arguments_:
-      PATH       Shall be of default `CHARACTER' type.
-      STATUS     (Optional) Shall be of default `INTEGER' type.
- 
- _See also_:
-      *Note LINK::, *Note SYMLNK::
- 
- 
- File: gfortran.info,  Node: UNPACK,  Next: VERIFY,  Prev: UNLINK,  Up: Intrinsic Procedures
- 
- 6.207 `UNPACK' -- Unpack an array of rank one into an array
- ===========================================================
- 
- _Description_:
-      Store the elements of VECTOR in an array of higher rank.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Transformational function
- 
- _Syntax_:
-      `RESULT = UNPACK(VECTOR, MASK, FIELD)'
- 
- _Arguments_:
-      VECTOR     Shall be an array of any type and rank one. It
-                 shall have at least as many elements as MASK
-                 has `TRUE' values.
-      MASK       Shall be an array of type `LOGICAL'.
-      FIELD      Shall be of the sam type as VECTOR and have
-                 the same shape as MASK.
- 
- _Return value_:
-      The resulting array corresponds to FIELD with `TRUE' elements of
-      MASK replaced by values from VECTOR in array element order.
- 
- _Example_:
-           PROGRAM test_unpack
-             integer :: vector(2)  = (/1,1/)
-             logical :: mask(4)  = (/ .TRUE., .FALSE., .FALSE., .TRUE. /)
-             integer :: field(2,2) = 0, unity(2,2)
- 
-             ! result: unity matrix
-             unity = unpack(vector, reshape(mask, (/2,2/)), field)
-           END PROGRAM
- 
- _See also_:
-      *Note PACK::, *Note SPREAD::
- 
- 
- File: gfortran.info,  Node: VERIFY,  Next: XOR,  Prev: UNPACK,  Up: Intrinsic Procedures
- 
- 6.208 `VERIFY' -- Scan a string for the absence of a set of characters
- ======================================================================
- 
- _Description_:
-      Verifies that all the characters in a SET are present in a STRING.
- 
-      If BACK is either absent or equals `FALSE', this function returns
-      the position of the leftmost character of STRING that is not in
-      SET. If BACK equals `TRUE', the rightmost position is returned. If
-      all characters of SET are found in STRING, the result is zero.
- 
- _Standard_:
-      F95 and later
- 
- _Class_:
-      Elemental function
- 
- _Syntax_:
-      `RESULT = VERFIY(STRING, SET[, BACK])'
- 
- _Arguments_:
-      STRING     Shall be of type `CHARACTER(*)'.
-      SET        Shall be of type `CHARACTER(*)'.
-      BACK       (Optional) shall be of type `LOGICAL'.
- 
- _Return value_:
-      The return value is of type `INTEGER' and of the default integer
-      kind.
- 
- _Example_:
-           PROGRAM test_verify
-             WRITE(*,*) VERIFY("FORTRAN", "AO")           ! 1, found 'F'
-             WRITE(*,*) VERIFY("FORTRAN", "FOO")          ! 3, found 'R'
-             WRITE(*,*) VERIFY("FORTRAN", "C++")          ! 1, found 'F'
-             WRITE(*,*) VERIFY("FORTRAN", "C++", .TRUE.)  ! 7, found 'N'
-             WRITE(*,*) VERIFY("FORTRAN", "FORTRAN")      ! 0' found none
-           END PROGRAM
- 
- _See also_:
-      *Note SCAN::, *Note INDEX::
- 
- 
- File: gfortran.info,  Node: XOR,  Prev: VERIFY,  Up: Intrinsic Procedures
- 
- 6.209 `XOR' -- Bitwise logical exclusive OR
- ===========================================
- 
- _Description_:
-      Bitwise logical exclusive or.
- 
-      This intrinsic routine is provided for backwards compatibility with
-      GNU Fortran 77.  For integer arguments, programmers should consider
-      the use of the *Note IEOR:: intrinsic defined by the Fortran
-      standard.
- 
- _Standard_:
-      GNU extension
- 
- _Class_:
-      Function
- 
- _Syntax_:
-      `RESULT = XOR(X, Y)'
- 
- _Arguments_:
-      X          The type shall be either `INTEGER(*)' or
-                 `LOGICAL'.
-      Y          The type shall be either `INTEGER(*)' or
-                 `LOGICAL'.
- 
- _Return value_:
-      The return type is either `INTEGER(*)' or `LOGICAL' after
-      cross-promotion of the arguments.
- 
- _Example_:
-           PROGRAM test_xor
-             LOGICAL :: T = .TRUE., F = .FALSE.
-             INTEGER :: a, b
-             DATA a / Z'F' /, b / Z'3' /
- 
-             WRITE (*,*) XOR(T, T), XOR(T, F), XOR(F, T), XOR(F, F)
-             WRITE (*,*) XOR(a, b)
-           END PROGRAM
- 
- _See also_:
-      F95 elemental function: *Note IEOR::
- 
- 
- File: gfortran.info,  Node: Contributing,  Next: Copying,  Prev: Intrinsic Procedures,  Up: Top
- 
- Contributing
- ************
- 
- Free software is only possible if people contribute to efforts to
- create it.  We're always in need of more people helping out with ideas
- and comments, writing documentation and contributing code.
- 
-    If you want to contribute to GNU Fortran, have a look at the long
- lists of projects you can take on.  Some of these projects are small,
- some of them are large; some are completely orthogonal to the rest of
- what is happening on GNU Fortran, but others are "mainstream" projects
- in need of enthusiastic hackers.  All of these projects are important!
- We'll eventually get around to the things here, but they are also
- things doable by someone who is willing and able.
- 
- * Menu:
- 
- * Contributors::
- * Projects::
- * Proposed Extensions::
- 
- 
- File: gfortran.info,  Node: Contributors,  Next: Projects,  Up: Contributing
- 
- Contributors to GNU Fortran
- ===========================
- 
- Most of the parser was hand-crafted by _Andy Vaught_, who is also the
- initiator of the whole project.  Thanks Andy!  Most of the interface
- with GCC was written by _Paul Brook_.
- 
-    The following individuals have contributed code and/or ideas and
- significant help to the GNU Fortran project (in no particular order):
- 
-    - Andy Vaught
- 
-    - Katherine Holcomb
- 
-    - Tobias Schlu"ter
- 
-    - Steven Bosscher
- 
-    - Toon Moene
- 
-    - Tim Prince
- 
-    - Niels Kristian Bech Jensen
- 
-    - Steven Johnson
- 
-    - Paul Brook
- 
-    - Feng Wang
- 
-    - Bud Davis
- 
-    - Paul Thomas
- 
-    - Franc,ois-Xavier Coudert
- 
-    - Steven G. Kargl
- 
-    - Jerry Delisle
- 
-    - Janne Blomqvist
- 
-    - Erik Edelmann
- 
-    - Thomas Koenig
- 
-    - Asher Langton
- 
-    - Jakub Jelinek
- 
-    - Roger Sayle
- 
-    - H.J. Lu
- 
-    - Richard Henderson
- 
-    - Richard Sandiford
- 
-    - Richard Guenther
- 
-    - Bernhard Fischer
- 
-    The following people have contributed bug reports, smaller or larger
- patches, and much needed feedback and encouragement for the GNU Fortran
- project:
- 
-    - Erik Schnetter
- 
-    - Bill Clodius
- 
-    - Kate Hedstrom
- 
-    Many other individuals have helped debug, test and improve the GNU
- Fortran compiler over the past few years, and we welcome you to do the
- same!  If you already have done so, and you would like to see your name
- listed in the list above, please contact us.
- 
- 
- File: gfortran.info,  Node: Projects,  Next: Proposed Extensions,  Prev: Contributors,  Up: Contributing
- 
- Projects
- ========
- 
- _Help build the test suite_
-      Solicit more code for donation to the test suite.  We can keep
-      code private on request.
- 
- _Bug hunting/squishing_
-      Find bugs and write more test cases!  Test cases are especially
-      very welcome, because it allows us to concentrate on fixing bugs
-      instead of isolating them.
- 
- _Smaller projects ("bug" fixes):_
-         - Allow init exprs to be numbers raised to integer powers.
- 
-         - Implement correct rounding.
- 
-         - Implement F restrictions on Fortran 95 syntax.
- 
-         - See about making Emacs-parsable error messages.
- 
- If you wish to work on the runtime libraries, please contact a project
- maintainer.
- 
- 
- File: gfortran.info,  Node: Proposed Extensions,  Prev: Projects,  Up: Contributing
- 
- Proposed Extensions
- ===================
- 
- Here's a list of proposed extensions for the GNU Fortran compiler, in
- no particular order.  Most of these are necessary to be fully
- compatible with existing Fortran compilers, but they are not part of
- the official J3 Fortran 95 standard.
- 
- Compiler extensions:
- --------------------
- 
-    * User-specified alignment rules for structures.
- 
-    * Flag to generate `Makefile' info.
- 
-    * Automatically extend single precision constants to double.
- 
-    * Compile code that conserves memory by dynamically allocating
-      common and module storage either on stack or heap.
- 
-    * Compile flag to generate code for array conformance checking
-      (suggest -CC).
- 
-    * User control of symbol names (underscores, etc).
- 
-    * Compile setting for maximum size of stack frame size before
-      spilling parts to static or heap.
- 
-    * Flag to force local variables into static space.
- 
-    * Flag to force local variables onto stack.
- 
-    * Flag for maximum errors before ending compile.
- 
-    * Option to initialize otherwise uninitialized integer and floating
-      point variables.
- 
- Environment Options
- -------------------
- 
-    * Pluggable library modules for random numbers, linear algebra.  LA
-      should use BLAS calling conventions.
- 
-    * Environment variables controlling actions on arithmetic exceptions
-      like overflow, underflow, precision loss--Generate NaN, abort,
-      default.  action.
- 
-    * Set precision for fp units that support it (i387).
- 
-    * Variable for setting fp rounding mode.
- 
-    * Variable to fill uninitialized variables with a user-defined bit
-      pattern.
- 
-    * Environment variable controlling filename that is opened for that
-      unit number.
- 
-    * Environment variable to clear/trash memory being freed.
- 
-    * Environment variable to control tracing of allocations and frees.
- 
-    * Environment variable to display allocated memory at normal program
-      end.
- 
-    * Environment variable for filename for * IO-unit.
- 
-    * Environment variable for temporary file directory.
- 
-    * Environment variable forcing standard output to be line buffered
-      (unix).
- 
- 
- 
- File: gfortran.info,  Node: Copying,  Next: GNU Free Documentation License,  Prev: Contributing,  Up: Top
- 
- GNU GENERAL PUBLIC LICENSE
- **************************
- 
-                          Version 2, June 1991
- 
-      Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-      51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
- 
-      Everyone is permitted to copy and distribute verbatim copies
-      of this license document, but changing it is not allowed.
- 
- Preamble
- ========
- 
- The licenses for most software are designed to take away your freedom
- to share and change it.  By contrast, the GNU General Public License is
- intended to guarantee your freedom to share and change free
- software--to make sure the software is free for all its users.  This
- General Public License applies to most of the Free Software
- Foundation's software and to any other program whose authors commit to
- using it.  (Some other Free Software Foundation software is covered by
- the GNU Library General Public License instead.)  You can apply it to
- your programs, too.
- 
-    When we speak of free software, we are referring to freedom, not
- price.  Our General Public Licenses are designed to make sure that you
- have the freedom to distribute copies of free software (and charge for
- this service if you wish), that you receive source code or can get it
- if you want it, that you can change the software or use pieces of it in
- new free programs; and that you know you can do these things.
- 
-    To protect your rights, we need to make restrictions that forbid
- anyone to deny you these rights or to ask you to surrender the rights.
- These restrictions translate to certain responsibilities for you if you
- distribute copies of the software, or if you modify it.
- 
-    For example, if you distribute copies of such a program, whether
- gratis or for a fee, you must give the recipients all the rights that
- you have.  You must make sure that they, too, receive or can get the
- source code.  And you must show them these terms so they know their
- rights.
- 
-    We protect your rights with two steps: (1) copyright the software,
- and (2) offer you this license which gives you legal permission to copy,
- distribute and/or modify the software.
- 
-    Also, for each author's protection and ours, we want to make certain
- that everyone understands that there is no warranty for this free
- software.  If the software is modified by someone else and passed on, we
- want its recipients to know that what they have is not the original, so
- that any problems introduced by others will not reflect on the original
- authors' reputations.
- 
-    Finally, any free program is threatened constantly by software
- patents.  We wish to avoid the danger that redistributors of a free
- program will individually obtain patent licenses, in effect making the
- program proprietary.  To prevent this, we have made it clear that any
- patent must be licensed for everyone's free use or not licensed at all.
- 
-    The precise terms and conditions for copying, distribution and
- modification follow.
- 
-     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-   0. This License applies to any program or other work which contains a
-      notice placed by the copyright holder saying it may be distributed
-      under the terms of this General Public License.  The "Program",
-      below, refers to any such program or work, and a "work based on
-      the Program" means either the Program or any derivative work under
-      copyright law: that is to say, a work containing the Program or a
-      portion of it, either verbatim or with modifications and/or
-      translated into another language.  (Hereinafter, translation is
-      included without limitation in the term "modification".)  Each
-      licensee is addressed as "you".
- 
-      Activities other than copying, distribution and modification are
-      not covered by this License; they are outside its scope.  The act
-      of running the Program is not restricted, and the output from the
-      Program is covered only if its contents constitute a work based on
-      the Program (independent of having been made by running the
-      Program).  Whether that is true depends on what the Program does.
- 
-   1. You may copy and distribute verbatim copies of the Program's
-      source code as you receive it, in any medium, provided that you
-      conspicuously and appropriately publish on each copy an appropriate
-      copyright notice and disclaimer of warranty; keep intact all the
-      notices that refer to this License and to the absence of any
-      warranty; and give any other recipients of the Program a copy of
-      this License along with the Program.
- 
-      You may charge a fee for the physical act of transferring a copy,
-      and you may at your option offer warranty protection in exchange
-      for a fee.
- 
-   2. You may modify your copy or copies of the Program or any portion
-      of it, thus forming a work based on the Program, and copy and
-      distribute such modifications or work under the terms of Section 1
-      above, provided that you also meet all of these conditions:
- 
-        a. You must cause the modified files to carry prominent notices
-           stating that you changed the files and the date of any change.
- 
-        b. You must cause any work that you distribute or publish, that
-           in whole or in part contains or is derived from the Program
-           or any part thereof, to be licensed as a whole at no charge
-           to all third parties under the terms of this License.
- 
-        c. If the modified program normally reads commands interactively
-           when run, you must cause it, when started running for such
-           interactive use in the most ordinary way, to print or display
-           an announcement including an appropriate copyright notice and
-           a notice that there is no warranty (or else, saying that you
-           provide a warranty) and that users may redistribute the
-           program under these conditions, and telling the user how to
-           view a copy of this License.  (Exception: if the Program
-           itself is interactive but does not normally print such an
-           announcement, your work based on the Program is not required
-           to print an announcement.)
- 
-      These requirements apply to the modified work as a whole.  If
-      identifiable sections of that work are not derived from the
-      Program, and can be reasonably considered independent and separate
-      works in themselves, then this License, and its terms, do not
-      apply to those sections when you distribute them as separate
-      works.  But when you distribute the same sections as part of a
-      whole which is a work based on the Program, the distribution of
-      the whole must be on the terms of this License, whose permissions
-      for other licensees extend to the entire whole, and thus to each
-      and every part regardless of who wrote it.
- 
-      Thus, it is not the intent of this section to claim rights or
-      contest your rights to work written entirely by you; rather, the
-      intent is to exercise the right to control the distribution of
-      derivative or collective works based on the Program.
- 
-      In addition, mere aggregation of another work not based on the
-      Program with the Program (or with a work based on the Program) on
-      a volume of a storage or distribution medium does not bring the
-      other work under the scope of this License.
- 
-   3. You may copy and distribute the Program (or a work based on it,
-      under Section 2) in object code or executable form under the terms
-      of Sections 1 and 2 above provided that you also do one of the
-      following:
- 
-        a. Accompany it with the complete corresponding machine-readable
-           source code, which must be distributed under the terms of
-           Sections 1 and 2 above on a medium customarily used for
-           software interchange; or,
- 
-        b. Accompany it with a written offer, valid for at least three
-           years, to give any third party, for a charge no more than your
-           cost of physically performing source distribution, a complete
-           machine-readable copy of the corresponding source code, to be
-           distributed under the terms of Sections 1 and 2 above on a
-           medium customarily used for software interchange; or,
- 
-        c. Accompany it with the information you received as to the offer
-           to distribute corresponding source code.  (This alternative is
-           allowed only for noncommercial distribution and only if you
-           received the program in object code or executable form with
-           such an offer, in accord with Subsection b above.)
- 
-      The source code for a work means the preferred form of the work for
-      making modifications to it.  For an executable work, complete
-      source code means all the source code for all modules it contains,
-      plus any associated interface definition files, plus the scripts
-      used to control compilation and installation of the executable.
-      However, as a special exception, the source code distributed need
-      not include anything that is normally distributed (in either
-      source or binary form) with the major components (compiler,
-      kernel, and so on) of the operating system on which the executable
-      runs, unless that component itself accompanies the executable.
- 
-      If distribution of executable or object code is made by offering
-      access to copy from a designated place, then offering equivalent
-      access to copy the source code from the same place counts as
-      distribution of the source code, even though third parties are not
-      compelled to copy the source along with the object code.
- 
-   4. You may not copy, modify, sublicense, or distribute the Program
-      except as expressly provided under this License.  Any attempt
-      otherwise to copy, modify, sublicense or distribute the Program is
-      void, and will automatically terminate your rights under this
-      License.  However, parties who have received copies, or rights,
-      from you under this License will not have their licenses
-      terminated so long as such parties remain in full compliance.
- 
-   5. You are not required to accept this License, since you have not
-      signed it.  However, nothing else grants you permission to modify
-      or distribute the Program or its derivative works.  These actions
-      are prohibited by law if you do not accept this License.
-      Therefore, by modifying or distributing the Program (or any work
-      based on the Program), you indicate your acceptance of this
-      License to do so, and all its terms and conditions for copying,
-      distributing or modifying the Program or works based on it.
- 
-   6. Each time you redistribute the Program (or any work based on the
-      Program), the recipient automatically receives a license from the
-      original licensor to copy, distribute or modify the Program
-      subject to these terms and conditions.  You may not impose any
-      further restrictions on the recipients' exercise of the rights
-      granted herein.  You are not responsible for enforcing compliance
-      by third parties to this License.
- 
-   7. If, as a consequence of a court judgment or allegation of patent
-      infringement or for any other reason (not limited to patent
-      issues), conditions are imposed on you (whether by court order,
-      agreement or otherwise) that contradict the conditions of this
-      License, they do not excuse you from the conditions of this
-      License.  If you cannot distribute so as to satisfy simultaneously
-      your obligations under this License and any other pertinent
-      obligations, then as a consequence you may not distribute the
-      Program at all.  For example, if a patent license would not permit
-      royalty-free redistribution of the Program by all those who
-      receive copies directly or indirectly through you, then the only
-      way you could satisfy both it and this License would be to refrain
-      entirely from distribution of the Program.
- 
-      If any portion of this section is held invalid or unenforceable
-      under any particular circumstance, the balance of the section is
-      intended to apply and the section as a whole is intended to apply
-      in other circumstances.
- 
-      It is not the purpose of this section to induce you to infringe any
-      patents or other property right claims or to contest validity of
-      any such claims; this section has the sole purpose of protecting
-      the integrity of the free software distribution system, which is
-      implemented by public license practices.  Many people have made
-      generous contributions to the wide range of software distributed
-      through that system in reliance on consistent application of that
-      system; it is up to the author/donor to decide if he or she is
-      willing to distribute software through any other system and a
-      licensee cannot impose that choice.
- 
-      This section is intended to make thoroughly clear what is believed
-      to be a consequence of the rest of this License.
- 
-   8. If the distribution and/or use of the Program is restricted in
-      certain countries either by patents or by copyrighted interfaces,
-      the original copyright holder who places the Program under this
-      License may add an explicit geographical distribution limitation
-      excluding those countries, so that distribution is permitted only
-      in or among countries not thus excluded.  In such case, this
-      License incorporates the limitation as if written in the body of
-      this License.
- 
-   9. The Free Software Foundation may publish revised and/or new
-      versions of the General Public License from time to time.  Such
-      new versions will be similar in spirit to the present version, but
-      may differ in detail to address new problems or concerns.
- 
-      Each version is given a distinguishing version number.  If the
-      Program specifies a version number of this License which applies
-      to it and "any later version", you have the option of following
-      the terms and conditions either of that version or of any later
-      version published by the Free Software Foundation.  If the Program
-      does not specify a version number of this License, you may choose
-      any version ever published by the Free Software Foundation.
- 
-  10. If you wish to incorporate parts of the Program into other free
-      programs whose distribution conditions are different, write to the
-      author to ask for permission.  For software which is copyrighted
-      by the Free Software Foundation, write to the Free Software
-      Foundation; we sometimes make exceptions for this.  Our decision
-      will be guided by the two goals of preserving the free status of
-      all derivatives of our free software and of promoting the sharing
-      and reuse of software generally.
- 
-                                 NO WARRANTY
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
-      WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
-      LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-      HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
-      WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
-      NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-      FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE
-      QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-      PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
-      SERVICING, REPAIR OR CORRECTION.
- 
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-      WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
-      MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE
-      LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
-      INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
-      INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-      DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
-      OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY
-      OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
-      ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- 
-                       END OF TERMS AND CONDITIONS
- Appendix: How to Apply These Terms to Your New Programs
- =======================================================
- 
- If you develop a new program, and you want it to be of the greatest
- possible use to the public, the best way to achieve this is to make it
- free software which everyone can redistribute and change under these
- terms.
- 
-    To do so, attach the following notices to the program.  It is safest
- to attach them to the start of each source file to most effectively
- convey the exclusion of warranty; and each file should have at least
- the "copyright" line and a pointer to where the full notice is found.
- 
-      ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES.
-      Copyright (C) YEAR  NAME OF AUTHOR
- 
-      This program is free software; you can redistribute it and/or modify
-      it under the terms of the GNU General Public License as published by
-      the Free Software Foundation; either version 2 of the License, or
-      (at your option) any later version.
- 
-      This program is distributed in the hope that it will be useful,
-      but WITHOUT ANY WARRANTY; without even the implied warranty of
-      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-      GNU General Public License for more details.
- 
-      You should have received a copy of the GNU General Public License
-      along with this program; if not, write to the Free Software
-      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
- 
-    Also add information on how to contact you by electronic and paper
- mail.
- 
-    If the program is interactive, make it output a short notice like
- this when it starts in an interactive mode:
- 
-      Gnomovision version 69, Copyright (C) YEAR NAME OF AUTHOR
-      Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
-      type `show w'.
-      This is free software, and you are welcome to redistribute it
-      under certain conditions; type `show c' for details.
- 
-    The hypothetical commands `show w' and `show c' should show the
- appropriate parts of the General Public License.  Of course, the
- commands you use may be called something other than `show w' and `show
- c'; they could even be mouse-clicks or menu items--whatever suits your
- program.
- 
-    You should also get your employer (if you work as a programmer) or
- your school, if any, to sign a "copyright disclaimer" for the program,
- if necessary.  Here is a sample; alter the names:
- 
-      Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-      `Gnomovision' (which makes passes at compilers) written by James Hacker.
- 
-      SIGNATURE OF TY COON, 1 April 1989
-      Ty Coon, President of Vice
- 
-    This General Public License does not permit incorporating your
- program into proprietary programs.  If your program is a subroutine
- library, you may consider it more useful to permit linking proprietary
- applications with the library.  If this is what you want to do, use the
- GNU Library General Public License instead of this License.
- 
- 
- File: gfortran.info,  Node: GNU Free Documentation License,  Next: Funding,  Prev: Copying,  Up: Top
- 
- GNU Free Documentation License
- ******************************
- 
-                       Version 1.2, November 2002
- 
-      Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.
-      51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
- 
-      Everyone is permitted to copy and distribute verbatim copies
-      of this license document, but changing it is not allowed.
- 
-   0. PREAMBLE
- 
-      The purpose of this License is to make a manual, textbook, or other
-      functional and useful document "free" in the sense of freedom: to
-      assure everyone the effective freedom to copy and redistribute it,
-      with or without modifying it, either commercially or
-      noncommercially.  Secondarily, this License preserves for the
-      author and publisher a way to get credit for their work, while not
-      being considered responsible for modifications made by others.
- 
-      This License is a kind of "copyleft", which means that derivative
-      works of the document must themselves be free in the same sense.
-      It complements the GNU General Public License, which is a copyleft
-      license designed for free software.
- 
-      We have designed this License in order to use it for manuals for
-      free software, because free software needs free documentation: a
-      free program should come with manuals providing the same freedoms
-      that the software does.  But this License is not limited to
-      software manuals; it can be used for any textual work, regardless
-      of subject matter or whether it is published as a printed book.
-      We recommend this License principally for works whose purpose is
-      instruction or reference.
- 
-   1. APPLICABILITY AND DEFINITIONS
- 
-      This License applies to any manual or other work, in any medium,
-      that contains a notice placed by the copyright holder saying it
-      can be distributed under the terms of this License.  Such a notice
-      grants a world-wide, royalty-free license, unlimited in duration,
-      to use that work under the conditions stated herein.  The
-      "Document", below, refers to any such manual or work.  Any member
-      of the public is a licensee, and is addressed as "you".  You
-      accept the license if you copy, modify or distribute the work in a
-      way requiring permission under copyright law.
- 
-      A "Modified Version" of the Document means any work containing the
-      Document or a portion of it, either copied verbatim, or with
-      modifications and/or translated into another language.
- 
-      A "Secondary Section" is a named appendix or a front-matter section
-      of the Document that deals exclusively with the relationship of the
-      publishers or authors of the Document to the Document's overall
-      subject (or to related matters) and contains nothing that could
-      fall directly within that overall subject.  (Thus, if the Document
-      is in part a textbook of mathematics, a Secondary Section may not
-      explain any mathematics.)  The relationship could be a matter of
-      historical connection with the subject or with related matters, or
-      of legal, commercial, philosophical, ethical or political position
-      regarding them.
- 
-      The "Invariant Sections" are certain Secondary Sections whose
-      titles are designated, as being those of Invariant Sections, in
-      the notice that says that the Document is released under this
-      License.  If a section does not fit the above definition of
-      Secondary then it is not allowed to be designated as Invariant.
-      The Document may contain zero Invariant Sections.  If the Document
-      does not identify any Invariant Sections then there are none.
- 
-      The "Cover Texts" are certain short passages of text that are
-      listed, as Front-Cover Texts or Back-Cover Texts, in the notice
-      that says that the Document is released under this License.  A
-      Front-Cover Text may be at most 5 words, and a Back-Cover Text may
-      be at most 25 words.
- 
-      A "Transparent" copy of the Document means a machine-readable copy,
-      represented in a format whose specification is available to the
-      general public, that is suitable for revising the document
-      straightforwardly with generic text editors or (for images
-      composed of pixels) generic paint programs or (for drawings) some
-      widely available drawing editor, and that is suitable for input to
-      text formatters or for automatic translation to a variety of
-      formats suitable for input to text formatters.  A copy made in an
-      otherwise Transparent file format whose markup, or absence of
-      markup, has been arranged to thwart or discourage subsequent
-      modification by readers is not Transparent.  An image format is
-      not Transparent if used for any substantial amount of text.  A
-      copy that is not "Transparent" is called "Opaque".
- 
-      Examples of suitable formats for Transparent copies include plain
-      ASCII without markup, Texinfo input format, LaTeX input format,
-      SGML or XML using a publicly available DTD, and
-      standard-conforming simple HTML, PostScript or PDF designed for
-      human modification.  Examples of transparent image formats include
-      PNG, XCF and JPG.  Opaque formats include proprietary formats that
-      can be read and edited only by proprietary word processors, SGML or
-      XML for which the DTD and/or processing tools are not generally
-      available, and the machine-generated HTML, PostScript or PDF
-      produced by some word processors for output purposes only.
- 
-      The "Title Page" means, for a printed book, the title page itself,
-      plus such following pages as are needed to hold, legibly, the
-      material this License requires to appear in the title page.  For
-      works in formats which do not have any title page as such, "Title
-      Page" means the text near the most prominent appearance of the
-      work's title, preceding the beginning of the body of the text.
- 
-      A section "Entitled XYZ" means a named subunit of the Document
-      whose title either is precisely XYZ or contains XYZ in parentheses
-      following text that translates XYZ in another language.  (Here XYZ
-      stands for a specific section name mentioned below, such as
-      "Acknowledgements", "Dedications", "Endorsements", or "History".)
-      To "Preserve the Title" of such a section when you modify the
-      Document means that it remains a section "Entitled XYZ" according
-      to this definition.
- 
-      The Document may include Warranty Disclaimers next to the notice
-      which states that this License applies to the Document.  These
-      Warranty Disclaimers are considered to be included by reference in
-      this License, but only as regards disclaiming warranties: any other
-      implication that these Warranty Disclaimers may have is void and
-      has no effect on the meaning of this License.
- 
-   2. VERBATIM COPYING
- 
-      You may copy and distribute the Document in any medium, either
-      commercially or noncommercially, provided that this License, the
-      copyright notices, and the license notice saying this License
-      applies to the Document are reproduced in all copies, and that you
-      add no other conditions whatsoever to those of this License.  You
-      may not use technical measures to obstruct or control the reading
-      or further copying of the copies you make or distribute.  However,
-      you may accept compensation in exchange for copies.  If you
-      distribute a large enough number of copies you must also follow
-      the conditions in section 3.
- 
-      You may also lend copies, under the same conditions stated above,
-      and you may publicly display copies.
- 
-   3. COPYING IN QUANTITY
- 
-      If you publish printed copies (or copies in media that commonly
-      have printed covers) of the Document, numbering more than 100, and
-      the Document's license notice requires Cover Texts, you must
-      enclose the copies in covers that carry, clearly and legibly, all
-      these Cover Texts: Front-Cover Texts on the front cover, and
-      Back-Cover Texts on the back cover.  Both covers must also clearly
-      and legibly identify you as the publisher of these copies.  The
-      front cover must present the full title with all words of the
-      title equally prominent and visible.  You may add other material
-      on the covers in addition.  Copying with changes limited to the
-      covers, as long as they preserve the title of the Document and
-      satisfy these conditions, can be treated as verbatim copying in
-      other respects.
- 
-      If the required texts for either cover are too voluminous to fit
-      legibly, you should put the first ones listed (as many as fit
-      reasonably) on the actual cover, and continue the rest onto
-      adjacent pages.
- 
-      If you publish or distribute Opaque copies of the Document
-      numbering more than 100, you must either include a
-      machine-readable Transparent copy along with each Opaque copy, or
-      state in or with each Opaque copy a computer-network location from
-      which the general network-using public has access to download
-      using public-standard network protocols a complete Transparent
-      copy of the Document, free of added material.  If you use the
-      latter option, you must take reasonably prudent steps, when you
-      begin distribution of Opaque copies in quantity, to ensure that
-      this Transparent copy will remain thus accessible at the stated
-      location until at least one year after the last time you
-      distribute an Opaque copy (directly or through your agents or
-      retailers) of that edition to the public.
- 
-      It is requested, but not required, that you contact the authors of
-      the Document well before redistributing any large number of
-      copies, to give them a chance to provide you with an updated
-      version of the Document.
- 
-   4. MODIFICATIONS
- 
-      You may copy and distribute a Modified Version of the Document
-      under the conditions of sections 2 and 3 above, provided that you
-      release the Modified Version under precisely this License, with
-      the Modified Version filling the role of the Document, thus
-      licensing distribution and modification of the Modified Version to
-      whoever possesses a copy of it.  In addition, you must do these
-      things in the Modified Version:
- 
-        A. Use in the Title Page (and on the covers, if any) a title
-           distinct from that of the Document, and from those of
-           previous versions (which should, if there were any, be listed
-           in the History section of the Document).  You may use the
-           same title as a previous version if the original publisher of
-           that version gives permission.
- 
-        B. List on the Title Page, as authors, one or more persons or
-           entities responsible for authorship of the modifications in
-           the Modified Version, together with at least five of the
-           principal authors of the Document (all of its principal
-           authors, if it has fewer than five), unless they release you
-           from this requirement.
- 
-        C. State on the Title page the name of the publisher of the
-           Modified Version, as the publisher.
- 
-        D. Preserve all the copyright notices of the Document.
- 
-        E. Add an appropriate copyright notice for your modifications
-           adjacent to the other copyright notices.
- 
-        F. Include, immediately after the copyright notices, a license
-           notice giving the public permission to use the Modified
-           Version under the terms of this License, in the form shown in
-           the Addendum below.
- 
-        G. Preserve in that license notice the full lists of Invariant
-           Sections and required Cover Texts given in the Document's
-           license notice.
- 
-        H. Include an unaltered copy of this License.
- 
-        I. Preserve the section Entitled "History", Preserve its Title,
-           and add to it an item stating at least the title, year, new
-           authors, and publisher of the Modified Version as given on
-           the Title Page.  If there is no section Entitled "History" in
-           the Document, create one stating the title, year, authors,
-           and publisher of the Document as given on its Title Page,
-           then add an item describing the Modified Version as stated in
-           the previous sentence.
- 
-        J. Preserve the network location, if any, given in the Document
-           for public access to a Transparent copy of the Document, and
-           likewise the network locations given in the Document for
-           previous versions it was based on.  These may be placed in
-           the "History" section.  You may omit a network location for a
-           work that was published at least four years before the
-           Document itself, or if the original publisher of the version
-           it refers to gives permission.
- 
-        K. For any section Entitled "Acknowledgements" or "Dedications",
-           Preserve the Title of the section, and preserve in the
-           section all the substance and tone of each of the contributor
-           acknowledgements and/or dedications given therein.
- 
-        L. Preserve all the Invariant Sections of the Document,
-           unaltered in their text and in their titles.  Section numbers
-           or the equivalent are not considered part of the section
-           titles.
- 
-        M. Delete any section Entitled "Endorsements".  Such a section
-           may not be included in the Modified Version.
- 
-        N. Do not retitle any existing section to be Entitled
-           "Endorsements" or to conflict in title with any Invariant
-           Section.
- 
-        O. Preserve any Warranty Disclaimers.
- 
-      If the Modified Version includes new front-matter sections or
-      appendices that qualify as Secondary Sections and contain no
-      material copied from the Document, you may at your option
-      designate some or all of these sections as invariant.  To do this,
-      add their titles to the list of Invariant Sections in the Modified
-      Version's license notice.  These titles must be distinct from any
-      other section titles.
- 
-      You may add a section Entitled "Endorsements", provided it contains
-      nothing but endorsements of your Modified Version by various
-      parties--for example, statements of peer review or that the text
-      has been approved by an organization as the authoritative
-      definition of a standard.
- 
-      You may add a passage of up to five words as a Front-Cover Text,
-      and a passage of up to 25 words as a Back-Cover Text, to the end
-      of the list of Cover Texts in the Modified Version.  Only one
-      passage of Front-Cover Text and one of Back-Cover Text may be
-      added by (or through arrangements made by) any one entity.  If the
-      Document already includes a cover text for the same cover,
-      previously added by you or by arrangement made by the same entity
-      you are acting on behalf of, you may not add another; but you may
-      replace the old one, on explicit permission from the previous
-      publisher that added the old one.
- 
-      The author(s) and publisher(s) of the Document do not by this
-      License give permission to use their names for publicity for or to
-      assert or imply endorsement of any Modified Version.
- 
-   5. COMBINING DOCUMENTS
- 
-      You may combine the Document with other documents released under
-      this License, under the terms defined in section 4 above for
-      modified versions, provided that you include in the combination
-      all of the Invariant Sections of all of the original documents,
-      unmodified, and list them all as Invariant Sections of your
-      combined work in its license notice, and that you preserve all
-      their Warranty Disclaimers.
- 
-      The combined work need only contain one copy of this License, and
-      multiple identical Invariant Sections may be replaced with a single
-      copy.  If there are multiple Invariant Sections with the same name
-      but different contents, make the title of each such section unique
-      by adding at the end of it, in parentheses, the name of the
-      original author or publisher of that section if known, or else a
-      unique number.  Make the same adjustment to the section titles in
-      the list of Invariant Sections in the license notice of the
-      combined work.
- 
-      In the combination, you must combine any sections Entitled
-      "History" in the various original documents, forming one section
-      Entitled "History"; likewise combine any sections Entitled
-      "Acknowledgements", and any sections Entitled "Dedications".  You
-      must delete all sections Entitled "Endorsements."
- 
-   6. COLLECTIONS OF DOCUMENTS
- 
-      You may make a collection consisting of the Document and other
-      documents released under this License, and replace the individual
-      copies of this License in the various documents with a single copy
-      that is included in the collection, provided that you follow the
-      rules of this License for verbatim copying of each of the
-      documents in all other respects.
- 
-      You may extract a single document from such a collection, and
-      distribute it individually under this License, provided you insert
-      a copy of this License into the extracted document, and follow
-      this License in all other respects regarding verbatim copying of
-      that document.
- 
-   7. AGGREGATION WITH INDEPENDENT WORKS
- 
-      A compilation of the Document or its derivatives with other
-      separate and independent documents or works, in or on a volume of
-      a storage or distribution medium, is called an "aggregate" if the
-      copyright resulting from the compilation is not used to limit the
-      legal rights of the compilation's users beyond what the individual
-      works permit.  When the Document is included in an aggregate, this
-      License does not apply to the other works in the aggregate which
-      are not themselves derivative works of the Document.
- 
-      If the Cover Text requirement of section 3 is applicable to these
-      copies of the Document, then if the Document is less than one half
-      of the entire aggregate, the Document's Cover Texts may be placed
-      on covers that bracket the Document within the aggregate, or the
-      electronic equivalent of covers if the Document is in electronic
-      form.  Otherwise they must appear on printed covers that bracket
-      the whole aggregate.
- 
-   8. TRANSLATION
- 
-      Translation is considered a kind of modification, so you may
-      distribute translations of the Document under the terms of section
-      4.  Replacing Invariant Sections with translations requires special
-      permission from their copyright holders, but you may include
-      translations of some or all Invariant Sections in addition to the
-      original versions of these Invariant Sections.  You may include a
-      translation of this License, and all the license notices in the
-      Document, and any Warranty Disclaimers, provided that you also
-      include the original English version of this License and the
-      original versions of those notices and disclaimers.  In case of a
-      disagreement between the translation and the original version of
-      this License or a notice or disclaimer, the original version will
-      prevail.
- 
-      If a section in the Document is Entitled "Acknowledgements",
-      "Dedications", or "History", the requirement (section 4) to
-      Preserve its Title (section 1) will typically require changing the
-      actual title.
- 
-   9. TERMINATION
- 
-      You may not copy, modify, sublicense, or distribute the Document
-      except as expressly provided for under this License.  Any other
-      attempt to copy, modify, sublicense or distribute the Document is
-      void, and will automatically terminate your rights under this
-      License.  However, parties who have received copies, or rights,
-      from you under this License will not have their licenses
-      terminated so long as such parties remain in full compliance.
- 
-  10. FUTURE REVISIONS OF THIS LICENSE
- 
-      The Free Software Foundation may publish new, revised versions of
-      the GNU Free Documentation License from time to time.  Such new
-      versions will be similar in spirit to the present version, but may
-      differ in detail to address new problems or concerns.  See
-      `http://www.gnu.org/copyleft/'.
- 
-      Each version of the License is given a distinguishing version
-      number.  If the Document specifies that a particular numbered
-      version of this License "or any later version" applies to it, you
-      have the option of following the terms and conditions either of
-      that specified version or of any later version that has been
-      published (not as a draft) by the Free Software Foundation.  If
-      the Document does not specify a version number of this License,
-      you may choose any version ever published (not as a draft) by the
-      Free Software Foundation.
- 
- ADDENDUM: How to use this License for your documents
- ====================================================
- 
- To use this License in a document you have written, include a copy of
- the License in the document and put the following copyright and license
- notices just after the title page:
- 
-        Copyright (C)  YEAR  YOUR NAME.
-        Permission is granted to copy, distribute and/or modify this document
-        under the terms of the GNU Free Documentation License, Version 1.2
-        or any later version published by the Free Software Foundation;
-        with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
-        Texts.  A copy of the license is included in the section entitled ``GNU
-        Free Documentation License''.
- 
-    If you have Invariant Sections, Front-Cover Texts and Back-Cover
- Texts, replace the "with...Texts." line with this:
- 
-          with the Invariant Sections being LIST THEIR TITLES, with
-          the Front-Cover Texts being LIST, and with the Back-Cover Texts
-          being LIST.
- 
-    If you have Invariant Sections without Cover Texts, or some other
- combination of the three, merge those two alternatives to suit the
- situation.
- 
-    If your document contains nontrivial examples of program code, we
- recommend releasing these examples in parallel under your choice of
- free software license, such as the GNU General Public License, to
- permit their use in free software.
- 
- 
- File: gfortran.info,  Node: Funding,  Next: Option Index,  Prev: GNU Free Documentation License,  Up: Top
- 
- Funding Free Software
- *********************
- 
- If you want to have more free software a few years from now, it makes
- sense for you to help encourage people to contribute funds for its
- development.  The most effective approach known is to encourage
- commercial redistributors to donate.
- 
-    Users of free software systems can boost the pace of development by
- encouraging for-a-fee distributors to donate part of their selling price
- to free software developers--the Free Software Foundation, and others.
- 
-    The way to convince distributors to do this is to demand it and
- expect it from them.  So when you compare distributors, judge them
- partly by how much they give to free software development.  Show
- distributors they must compete to be the one who gives the most.
- 
-    To make this approach work, you must insist on numbers that you can
- compare, such as, "We will donate ten dollars to the Frobnitz project
- for each disk sold."  Don't be satisfied with a vague promise, such as
- "A portion of the profits are donated," since it doesn't give a basis
- for comparison.
- 
-    Even a precise fraction "of the profits from this disk" is not very
- meaningful, since creative accounting and unrelated business decisions
- can greatly alter what fraction of the sales price counts as profit.
- If the price you pay is $50, ten percent of the profit is probably less
- than a dollar; it might be a few cents, or nothing at all.
- 
-    Some redistributors do development work themselves.  This is useful
- too; but to keep everyone honest, you need to inquire how much they do,
- and what kind.  Some kinds of development make much more long-term
- difference than others.  For example, maintaining a separate version of
- a program contributes very little; maintaining the standard version of a
- program for the whole community contributes much.  Easy new ports
- contribute little, since someone else would surely do them; difficult
- ports such as adding a new CPU to the GNU Compiler Collection
- contribute more; major new features or packages contribute the most.
- 
-    By establishing the idea that supporting further development is "the
- proper thing to do" when distributing free software for a fee, we can
- assure a steady flow of resources into making more free software.
- 
-      Copyright (C) 1994 Free Software Foundation, Inc.
-      Verbatim copying and redistribution of this section is permitted
-      without royalty; alteration is not permitted.
- 
- 
- File: gfortran.info,  Node: Option Index,  Next: Keyword Index,  Prev: Funding,  Up: Top
- 
- Option Index
- ************
- 
- `gfortran''s command line options are indexed here without any initial
- `-' or `--'. Where an option has both positive and negative forms (such
- as -foption and -fno-option), relevant entries in the manual are
- indexed under the most appropriate form; it may sometimes be useful to
- look up both forms.
- 
- [index]
- * Menu:
- 
- * fall-intrinsics:                       Fortran Dialect Options.
-                                                               (line  18)
- * fbounds-check:                         Code Gen Options.    (line 126)
- * fconvert=CONVERSION:                   Runtime Options.     (line   9)
- * fcray-pointer:                         Fortran Dialect Options.
-                                                               (line  80)
- * fd-lines-as-code:                      Fortran Dialect Options.
-                                                               (line  26)
- * fd-lines-as-comments:                  Fortran Dialect Options.
-                                                               (line  26)
- * fdefault-double-8:                     Fortran Dialect Options.
-                                                               (line  33)
- * fdefault-integer-8:                    Fortran Dialect Options.
-                                                               (line  36)
- * fdefault-real-8:                       Fortran Dialect Options.
-                                                               (line  40)
- * fdollar-ok:                            Fortran Dialect Options.
-                                                               (line  44)
- * fdump-parse-tree:                      Debugging Options.   (line  10)
- * ff2c:                                  Code Gen Options.    (line  21)
- * ffixed-line-length-N:                  Fortran Dialect Options.
-                                                               (line  51)
- * ffpe-trap=LIST:                        Debugging Options.   (line  14)
- * ffree-form:                            Fortran Dialect Options.
-                                                               (line  12)
- * ffree-line-length-N:                   Fortran Dialect Options.
-                                                               (line  64)
- * fimplicit-none:                        Fortran Dialect Options.
-                                                               (line  75)
- * fmax-errors-N:                         Error and Warning Options.
-                                                               (line  27)
- * fmax-identifier-length=N:              Fortran Dialect Options.
-                                                               (line  71)
- * fmax-stack-var-size:                   Code Gen Options.    (line 135)
- * fmax-subrecord-length=LENGTH:          Runtime Options.     (line  28)
- * fno-automatic:                         Code Gen Options.    (line  15)
- * fno-backslash:                         Fortran Dialect Options.
-                                                               (line  47)
- * fno-fixed-form:                        Fortran Dialect Options.
-                                                               (line  12)
- * fno-underscoring:                      Code Gen Options.    (line  50)
- * fopenmp:                               Fortran Dialect Options.
-                                                               (line  84)
- * fpack-derived:                         Code Gen Options.    (line 145)
- * frange-check:                          Fortran Dialect Options.
-                                                               (line  92)
- * frecord-marker=LENGTH:                 Runtime Options.     (line  20)
- * frepack-arrays:                        Code Gen Options.    (line 151)
- * fsecond-underscore:                    Code Gen Options.    (line 109)
- * fshort-enums <1>:                      Fortran 2003 status. (line  20)
- * fshort-enums:                          Code Gen Options.    (line 161)
- * fsyntax-only:                          Error and Warning Options.
-                                                               (line  33)
- * IDIR:                                  Directory Options.   (line  14)
- * JDIR:                                  Directory Options.   (line  31)
- * MDIR:                                  Directory Options.   (line  31)
- * pedantic:                              Error and Warning Options.
-                                                               (line  37)
- * pedantic-errors:                       Error and Warning Options.
-                                                               (line  55)
- * std=STD option:                        Fortran Dialect Options.
-                                                               (line 102)
- * Waliasing:                             Error and Warning Options.
-                                                               (line  65)
- * Wall:                                  Error and Warning Options.
-                                                               (line  59)
- * Wampersand:                            Error and Warning Options.
-                                                               (line  82)
- * Wcharacter-truncation:                 Error and Warning Options.
-                                                               (line  90)
- * Wconversion:                           Error and Warning Options.
-                                                               (line  93)
- * Werror:                                Error and Warning Options.
-                                                               (line 129)
- * Wimplicit-interface:                   Error and Warning Options.
-                                                               (line  96)
- * Wnonstd-intrinsics:                    Error and Warning Options.
-                                                               (line 102)
- * Wsurprising:                           Error and Warning Options.
-                                                               (line 106)
- * Wtabs:                                 Error and Warning Options.
-                                                               (line 119)
- * Wunderflow:                            Error and Warning Options.
-                                                               (line 125)
- 
- 
- File: gfortran.info,  Node: Keyword Index,  Prev: Option Index,  Up: Top
- 
- Keyword Index
- *************
- 
- [index]
- * Menu:
- 
- * $:                                     Fortran Dialect Options.
-                                                               (line  44)
- * &:                                     Error and Warning Options.
-                                                               (line  82)
- * [...]:                                 Fortran 2003 status. (line  13)
- * ABORT:                                 ABORT.               (line   6)
- * ABS:                                   ABS.                 (line   6)
- * absolute value:                        ABS.                 (line   6)
- * ACCESS:                                ACCESS.              (line   6)
- * ACCESS='STREAM' I/O:                   Fortran 2003 status. (line  32)
- * ACHAR:                                 ACHAR.               (line   6)
- * ACOS:                                  ACOS.                (line   6)
- * ACOSH:                                 ACOSH.               (line   6)
- * adjust string <1>:                     ADJUSTR.             (line   6)
- * adjust string:                         ADJUSTL.             (line   6)
- * ADJUSTL:                               ADJUSTL.             (line   6)
- * ADJUSTR:                               ADJUSTR.             (line   6)
- * AIMAG:                                 AIMAG.               (line   6)
- * AINT:                                  AINT.                (line   6)
- * ALARM:                                 ALARM.               (line   6)
- * aliasing:                              Error and Warning Options.
-                                                               (line  65)
- * ALL:                                   ALL.                 (line   6)
- * all warnings:                          Error and Warning Options.
-                                                               (line  59)
- * ALLOCATABLE components of derived types: Fortran 2003 status.
-                                                               (line  30)
- * ALLOCATABLE dummy arguments:           Fortran 2003 status. (line  26)
- * ALLOCATABLE function results:          Fortran 2003 status. (line  28)
- * ALLOCATED:                             ALLOCATED.           (line   6)
- * allocation, moving:                    MOVE_ALLOC.          (line   6)
- * allocation, status:                    ALLOCATED.           (line   6)
- * ALOG:                                  LOG.                 (line   6)
- * ALOG10:                                LOG10.               (line   6)
- * AMAX0:                                 MAX.                 (line   6)
- * AMAX1:                                 MAX.                 (line   6)
- * AMIN0:                                 MIN.                 (line   6)
- * AMIN1:                                 MIN.                 (line   6)
- * AMOD:                                  MOD.                 (line   6)
- * AND:                                   AND.                 (line   6)
- * ANINT:                                 ANINT.               (line   6)
- * ANY:                                   ANY.                 (line   6)
- * area hyperbolic cosine:                ACOSH.               (line   6)
- * area hyperbolic sine:                  ASINH.               (line   6)
- * area hyperbolic tangent:               ATANH.               (line   6)
- * arguments, to program <1>:             IARGC.               (line   6)
- * arguments, to program <2>:             GET_COMMAND_ARGUMENT.
-                                                               (line   6)
- * arguments, to program <3>:             GET_COMMAND.         (line   6)
- * arguments, to program <4>:             GETARG.              (line   6)
- * arguments, to program:                 COMMAND_ARGUMENT_COUNT.
-                                                               (line   6)
- * array, add elements:                   SUM.                 (line   6)
- * array, apply condition <1>:            ANY.                 (line   6)
- * array, apply condition:                ALL.                 (line   6)
- * array, bounds checking:                Code Gen Options.    (line 126)
- * array, change dimensions:              RESHAPE.             (line   6)
- * array, combine arrays:                 MERGE.               (line   6)
- * array, condition testing <1>:          ANY.                 (line   6)
- * array, condition testing:              ALL.                 (line   6)
- * array, conditionally add elements:     SUM.                 (line   6)
- * array, conditionally count elements:   COUNT.               (line   6)
- * array, conditionally multiply elements: PRODUCT.            (line   6)
- * array, constructors:                   Fortran 2003 status. (line  13)
- * array, count elements:                 SIZE.                (line   6)
- * array, duplicate dimensions:           SPREAD.              (line   6)
- * array, duplicate elementes:            SPREAD.              (line   6)
- * array, element counting:               COUNT.               (line   6)
- * array, gather elements:                PACK.                (line   6)
- * array, increase dimension <1>:         UNPACK.              (line   6)
- * array, increase dimension:             SPREAD.              (line   6)
- * array, indices of type real:           Real array indices.  (line   6)
- * array, location of maximum element:    MAXLOC.              (line   6)
- * array, location of minimum element:    MINLOC.              (line   6)
- * array, lower bound:                    LBOUND.              (line   6)
- * array, maximum value:                  MAXVAL.              (line   6)
- * array, merge arrays:                   MERGE.               (line   6)
- * array, minmum value:                   MINVAL.              (line   6)
- * array, multiply elements:              PRODUCT.             (line   6)
- * array, number of elements <1>:         SIZE.                (line   6)
- * array, number of elements:             COUNT.               (line   6)
- * array, packing:                        PACK.                (line   6)
- * array, permutation:                    CSHIFT.              (line   6)
- * array, product:                        PRODUCT.             (line   6)
- * array, reduce dimension:               PACK.                (line   6)
- * array, rotate:                         CSHIFT.              (line   6)
- * array, scatter elements:               UNPACK.              (line   6)
- * array, shape:                          SHAPE.               (line   6)
- * array, shift:                          EOSHIFT.             (line   6)
- * array, shift circularly:               CSHIFT.              (line   6)
- * array, size:                           SIZE.                (line   6)
- * array, sum:                            SUM.                 (line   6)
- * array, transmogrify:                   RESHAPE.             (line   6)
- * array, transpose:                      TRANSPOSE.           (line   6)
- * array, unpacking:                      UNPACK.              (line   6)
- * array, upper bound:                    UBOUND.              (line   6)
- * ASCII collating sequence <1>:          IACHAR.              (line   6)
- * ASCII collating sequence:              ACHAR.               (line   6)
- * ASIN:                                  ASIN.                (line   6)
- * ASINH <1>:                             ATANH.               (line   6)
- * ASINH:                                 ASINH.               (line   6)
- * ASSOCIATED:                            ASSOCIATED.          (line   6)
- * association status:                    ASSOCIATED.          (line   6)
- * ATAN:                                  ATAN.                (line   6)
- * ATAN2:                                 ATAN2.               (line   6)
- * Authors:                               Contributors.        (line   6)
- * backslash:                             Fortran Dialect Options.
-                                                               (line  47)
- * BESJ0:                                 BESJ0.               (line   6)
- * BESJ1:                                 BESJ1.               (line   6)
- * BESJN:                                 BESJN.               (line   6)
- * Bessel function, first kind <1>:       BESJN.               (line   6)
- * Bessel function, first kind <2>:       BESJ1.               (line   6)
- * Bessel function, first kind:           BESJ0.               (line   6)
- * Bessel function, second kind <1>:      BESYN.               (line   6)
- * Bessel function, second kind <2>:      BESY1.               (line   6)
- * Bessel function, second kind:          BESY0.               (line   6)
- * BESY0:                                 BESY0.               (line   6)
- * BESY1:                                 BESY1.               (line   6)
- * BESYN:                                 BESYN.               (line   6)
- * BIT_SIZE:                              BIT_SIZE.            (line   6)
- * bits, clear:                           IBCLR.               (line   6)
- * bits, extract:                         IBITS.               (line   6)
- * bits, get:                             IBITS.               (line   6)
- * bits, move <1>:                        TRANSFER.            (line   6)
- * bits, move:                            MVBITS.              (line   6)
- * bits, negate:                          NOT.                 (line   6)
- * bits, number of:                       BIT_SIZE.            (line   6)
- * bits, set:                             IBSET.               (line   6)
- * bits, shift:                           ISHFT.               (line   6)
- * bits, shift circular:                  ISHFTC.              (line   6)
- * bits, shift left:                      LSHIFT.              (line   6)
- * bits, shift right:                     RSHIFT.              (line   6)
- * bits, testing:                         BTEST.               (line   6)
- * bits, unset:                           IBCLR.               (line   6)
- * bitwise logical and <1>:               IAND.                (line   6)
- * bitwise logical and:                   AND.                 (line   6)
- * bitwise logical exclusive or <1>:      XOR.                 (line   6)
- * bitwise logical exclusive or:          IEOR.                (line   6)
- * bitwise logical not:                   NOT.                 (line   6)
- * bitwise logical or <1>:                OR.                  (line   6)
- * bitwise logical or:                    IOR.                 (line   6)
- * bounds checking:                       Code Gen Options.    (line 126)
- * BOZ literal constants:                 BOZ literal constants.
-                                                               (line   6)
- * BTEST:                                 BTEST.               (line   6)
- * CABS:                                  ABS.                 (line   6)
- * calling convention:                    Code Gen Options.    (line  21)
- * CCOS:                                  COS.                 (line   6)
- * CDABS:                                 ABS.                 (line   6)
- * CDCOS:                                 COS.                 (line   6)
- * CDEXP:                                 EXP.                 (line   6)
- * CDLOG:                                 LOG.                 (line   6)
- * CDSIN:                                 SIN.                 (line   6)
- * CDSQRT:                                SQRT.                (line   6)
- * ceiling:                               CEILING.             (line   6)
- * CEILING:                               CEILING.             (line   6)
- * ceiling:                               ANINT.               (line   6)
- * CEXP:                                  EXP.                 (line   6)
- * CHAR:                                  CHAR.                (line   6)
- * character set:                         Fortran Dialect Options.
-                                                               (line  44)
- * CHDIR:                                 CHDIR.               (line   6)
- * checking subscripts:                   Code Gen Options.    (line 126)
- * CHMOD:                                 CHMOD.               (line   6)
- * clock ticks <1>:                       SYSTEM_CLOCK.        (line   6)
- * clock ticks <2>:                       MCLOCK8.             (line   6)
- * clock ticks:                           MCLOCK.              (line   6)
- * CLOG:                                  LOG.                 (line   6)
- * CMPLX:                                 CMPLX.               (line   6)
- * code generation, conventions:          Code Gen Options.    (line   6)
- * collating sequence, ASCII <1>:         IACHAR.              (line   6)
- * collating sequence, ASCII:             ACHAR.               (line   6)
- * command options:                       Invoking GNU Fortran.
-                                                               (line   6)
- * command-line arguments <1>:            IARGC.               (line   6)
- * command-line arguments <2>:            GET_COMMAND_ARGUMENT.
-                                                               (line   6)
- * command-line arguments <3>:            GET_COMMAND.         (line   6)
- * command-line arguments <4>:            GETARG.              (line   6)
- * command-line arguments:                COMMAND_ARGUMENT_COUNT.
-                                                               (line   6)
- * command-line arguments, number of <1>: IARGC.               (line   6)
- * command-line arguments, number of:     COMMAND_ARGUMENT_COUNT.
-                                                               (line   6)
- * COMMAND_ARGUMENT_COUNT:                COMMAND_ARGUMENT_COUNT.
-                                                               (line   6)
- * COMPLEX:                               COMPLEX.             (line   6)
- * complex conjugate:                     CONJG.               (line   6)
- * complex numbers, conversion to <1>:    DCMPLX.              (line   6)
- * complex numbers, conversion to <2>:    COMPLEX.             (line   6)
- * complex numbers, conversion to:        CMPLX.               (line   6)
- * complex numbers, imaginary part:       AIMAG.               (line   6)
- * complex numbers, real part <1>:        REAL.                (line   6)
- * complex numbers, real part:            DREAL.               (line   6)
- * CONJG:                                 CONJG.               (line   6)
- * Contributing:                          Contributing.        (line   6)
- * Contributors:                          Contributors.        (line   6)
- * conversion:                            Error and Warning Options.
-                                                               (line  93)
- * conversion, to character:              CHAR.                (line   6)
- * conversion, to complex <1>:            DCMPLX.              (line   6)
- * conversion, to complex <2>:            COMPLEX.             (line   6)
- * conversion, to complex:                CMPLX.               (line   6)
- * conversion, to integer <1>:            LONG.                (line   6)
- * conversion, to integer <2>:            INT8.                (line   6)
- * conversion, to integer <3>:            INT2.                (line   6)
- * conversion, to integer <4>:            INT.                 (line   6)
- * conversion, to integer <5>:            ICHAR.               (line   6)
- * conversion, to integer <6>:            IACHAR.              (line   6)
- * conversion, to integer:                Implicitly convert LOGICAL and INTEGER values.
-                                                               (line   6)
- * conversion, to logical <1>:            LOGICAL.             (line   6)
- * conversion, to logical:                Implicitly convert LOGICAL and INTEGER values.
-                                                               (line   6)
- * conversion, to real <1>:               SNGL.                (line   6)
- * conversion, to real <2>:               REAL.                (line   6)
- * conversion, to real <3>:               FLOAT.               (line   6)
- * conversion, to real <4>:               DFLOAT.              (line   6)
- * conversion, to real:                   DBLE.                (line   6)
- * conversion, to string:                 CTIME.               (line   6)
- * CONVERT specifier:                     CONVERT specifier.   (line   6)
- * core, dump:                            ABORT.               (line   6)
- * COS:                                   COS.                 (line   6)
- * COSH:                                  COSH.                (line   6)
- * cosine:                                COS.                 (line   6)
- * cosine, hyperbolic:                    COSH.                (line   6)
- * cosine, hyperbolic, inverse:           ACOSH.               (line   6)
- * cosine, inverse:                       ACOS.                (line   6)
- * COUNT:                                 COUNT.               (line   6)
- * CPU_TIME:                              CPU_TIME.            (line   6)
- * Credits:                               Contributors.        (line   6)
- * CSHIFT:                                CSHIFT.              (line   6)
- * CSIN:                                  SIN.                 (line   6)
- * CSQRT:                                 SQRT.                (line   6)
- * CTIME:                                 CTIME.               (line   6)
- * current date <1>:                      IDATE.               (line   6)
- * current date <2>:                      FDATE.               (line   6)
- * current date:                          DATE_AND_TIME.       (line   6)
- * current time <1>:                      TIME8.               (line   6)
- * current time <2>:                      TIME.                (line   6)
- * current time <3>:                      ITIME.               (line   6)
- * current time <4>:                      FDATE.               (line   6)
- * current time:                          DATE_AND_TIME.       (line   6)
- * DABS:                                  ABS.                 (line   6)
- * DACOS:                                 ACOS.                (line   6)
- * DACOSH:                                ACOSH.               (line   6)
- * DASIN:                                 ASIN.                (line   6)
- * DASINH <1>:                            ATANH.               (line   6)
- * DASINH:                                ASINH.               (line   6)
- * DATAN:                                 ATAN.                (line   6)
- * DATAN2:                                ATAN2.               (line   6)
- * date, current <1>:                     IDATE.               (line   6)
- * date, current <2>:                     FDATE.               (line   6)
- * date, current:                         DATE_AND_TIME.       (line   6)
- * DATE_AND_TIME:                         DATE_AND_TIME.       (line   6)
- * DBESJ0:                                BESJ0.               (line   6)
- * DBESJ1:                                BESJ1.               (line   6)
- * DBESJN:                                BESJN.               (line   6)
- * DBESY0:                                BESY0.               (line   6)
- * DBESY1:                                BESY1.               (line   6)
- * DBESYN:                                BESYN.               (line   6)
- * DBLE:                                  DBLE.                (line   6)
- * DCMPLX:                                DCMPLX.              (line   6)
- * DCONJG:                                CONJG.               (line   6)
- * DCOS:                                  COS.                 (line   6)
- * DCOSH:                                 COSH.                (line   6)
- * DDIM:                                  DIM.                 (line   6)
- * debugging information options:         Debugging Options.   (line   6)
- * delayed execution <1>:                 SLEEP.               (line   6)
- * delayed execution:                     ALARM.               (line   6)
- * DEXP:                                  EXP.                 (line   6)
- * DFLOAT:                                DFLOAT.              (line   6)
- * dialect options:                       Fortran Dialect Options.
-                                                               (line   6)
- * DIGITS:                                DIGITS.              (line   6)
- * DIM:                                   DIM.                 (line   6)
- * DIMAG:                                 AIMAG.               (line   6)
- * DINT:                                  AINT.                (line   6)
- * directive, INCLUDE:                    Directory Options.   (line   6)
- * directory, options:                    Directory Options.   (line   6)
- * directory, search paths for inclusion: Directory Options.   (line  14)
- * division, modulo:                      MODULO.              (line   6)
- * division, remainder:                   MOD.                 (line   6)
- * DLOG:                                  LOG.                 (line   6)
- * DLOG10:                                LOG10.               (line   6)
- * DMAX1:                                 MAX.                 (line   6)
- * DMIN1:                                 MIN.                 (line   6)
- * DMOD:                                  MOD.                 (line   6)
- * DNINT:                                 ANINT.               (line   6)
- * dot product:                           DOT_PRODUCT.         (line   6)
- * DOT_PRODUCT:                           DOT_PRODUCT.         (line   6)
- * DPROD:                                 DPROD.               (line   6)
- * DREAL:                                 DREAL.               (line   6)
- * DSIGN:                                 SIGN.                (line   6)
- * DSIN:                                  SIN.                 (line   6)
- * DSINH:                                 SINH.                (line   6)
- * DSQRT:                                 SQRT.                (line   6)
- * DTAN:                                  TAN.                 (line   6)
- * DTANH:                                 TANH.                (line   6)
- * DTIME:                                 DTIME.               (line   6)
- * elapsed time <1>:                      SECOND.              (line   6)
- * elapsed time <2>:                      SECNDS.              (line   6)
- * elapsed time:                          DTIME.               (line   6)
- * ENUM statement:                        Fortran 2003 status. (line  20)
- * ENUMERATOR statement:                  Fortran 2003 status. (line  20)
- * environment variable <1>:              GET_ENVIRONMENT_VARIABLE.
-                                                               (line   6)
- * environment variable <2>:              GETENV.              (line   6)
- * environment variable <3>:              Runtime.             (line   6)
- * environment variable:                  Environment Variables.
-                                                               (line   6)
- * EOSHIFT:                               EOSHIFT.             (line   6)
- * EPSILON:                               EPSILON.             (line   6)
- * ERF:                                   ERF.                 (line   6)
- * ERFC:                                  ERFC.                (line   6)
- * error function:                        ERF.                 (line   6)
- * error function, complementary:         ERFC.                (line   6)
- * errors, limiting:                      Error and Warning Options.
-                                                               (line  27)
- * escape characters:                     Fortran Dialect Options.
-                                                               (line  47)
- * ETIME:                                 ETIME.               (line   6)
- * EXIT:                                  EXIT.                (line   6)
- * EXP:                                   EXP.                 (line   6)
- * EXPONENT:                              EXPONENT.            (line   6)
- * exponential function:                  EXP.                 (line   6)
- * exponential function, inverse <1>:     LOG10.               (line   6)
- * exponential function, inverse:         LOG.                 (line   6)
- * Extension:                             Extensions.          (line   6)
- * f2c calling convention:                Code Gen Options.    (line  21)
- * FDATE:                                 FDATE.               (line   6)
- * FDL, GNU Free Documentation License:   GNU Free Documentation License.
-                                                               (line   6)
- * FGET:                                  FGET.                (line   6)
- * FGETC:                                 FGETC.               (line   6)
- * file format, fixed:                    Fortran Dialect Options.
-                                                               (line  12)
- * file format, free:                     Fortran Dialect Options.
-                                                               (line  12)
- * file operation, file number:           FNUM.                (line   6)
- * file operation, flush:                 FLUSH.               (line   6)
- * file operation, position <1>:          FTELL.               (line   6)
- * file operation, position:              FSEEK.               (line   6)
- * file operation, read character <1>:    FGETC.               (line   6)
- * file operation, read character:        FGET.                (line   6)
- * file operation, seek:                  FSEEK.               (line   6)
- * file operation, write character <1>:   FPUTC.               (line   6)
- * file operation, write character:       FPUT.                (line   6)
- * file system, access mode:              ACCESS.              (line   6)
- * file system, change access mode:       CHMOD.               (line   6)
- * file system, create link <1>:          SYMLNK.              (line   6)
- * file system, create link:              LINK.                (line   6)
- * file system, file creation mask:       UMASK.               (line   6)
- * file system, file status <1>:          STAT.                (line   6)
- * file system, file status <2>:          LSTAT.               (line   6)
- * file system, file status:              FSTAT.               (line   6)
- * file system, hard link:                LINK.                (line   6)
- * file system, remove file:              UNLINK.              (line   6)
- * file system, rename file:              RENAME.              (line   6)
- * file system, soft link:                SYMLNK.              (line   6)
- * FLOAT:                                 FLOAT.               (line   6)
- * floating point, exponent:              EXPONENT.            (line   6)
- * floating point, fraction:              FRACTION.            (line   6)
- * floating point, nearest different:     NEAREST.             (line   6)
- * floating point, relative spacing <1>:  SPACING.             (line   6)
- * floating point, relative spacing:      RRSPACING.           (line   6)
- * floating point, scale:                 SCALE.               (line   6)
- * floating point, set exponent:          SET_EXPONENT.        (line   6)
- * floor:                                 FLOOR.               (line   6)
- * FLOOR:                                 FLOOR.               (line   6)
- * floor:                                 AINT.                (line   6)
- * FLUSH:                                 FLUSH.               (line   6)
- * FLUSH statement:                       Fortran 2003 status. (line  16)
- * FNUM:                                  FNUM.                (line   6)
- * Fortran 77:                            GNU Fortran and G77. (line   6)
- * FPUT:                                  FPUT.                (line   6)
- * FPUTC:                                 FPUTC.               (line   6)
- * FRACTION:                              FRACTION.            (line   6)
- * FREE:                                  FREE.                (line   6)
- * FSEEK:                                 FSEEK.               (line   6)
- * FSTAT:                                 FSTAT.               (line   6)
- * FTELL:                                 FTELL.               (line   6)
- * g77:                                   GNU Fortran and G77. (line   6)
- * g77 calling convention:                Code Gen Options.    (line  21)
- * GCC:                                   GNU Fortran and GCC. (line   6)
- * GERROR:                                GERROR.              (line   6)
- * GET_COMMAND:                           GET_COMMAND.         (line   6)
- * GET_COMMAND_ARGUMENT:                  GET_COMMAND_ARGUMENT.
-                                                               (line   6)
- * GET_ENVIRONMENT_VARIABLE:              GET_ENVIRONMENT_VARIABLE.
-                                                               (line   6)
- * GETARG:                                GETARG.              (line   6)
- * GETCWD:                                GETCWD.              (line   6)
- * GETENV:                                GETENV.              (line   6)
- * GETGID:                                GETGID.              (line   6)
- * GETLOG:                                GETLOG.              (line   6)
- * GETPID:                                GETPID.              (line   6)
- * GETUID:                                GETUID.              (line   6)
- * GMTIME:                                GMTIME.              (line   6)
- * GNU Compiler Collection:               GNU Fortran and GCC. (line   6)
- * GNU Fortran command options:           Invoking GNU Fortran.
-                                                               (line   6)
- * Hollerith constants:                   Hollerith constants support.
-                                                               (line   6)
- * HOSTNM:                                HOSTNM.              (line   6)
- * HUGE:                                  HUGE.                (line   6)
- * hyperbolic arccosine:                  ACOSH.               (line   6)
- * hyperbolic arcsine:                    ASINH.               (line   6)
- * hyperbolic arctangent:                 ATANH.               (line   6)
- * hyperbolic cosine:                     COSH.                (line   6)
- * hyperbolic function, cosine:           COSH.                (line   6)
- * hyperbolic function, cosine, inverse:  ACOSH.               (line   6)
- * hyperbolic function, sine:             SINH.                (line   6)
- * hyperbolic function, sine, inverse:    ASINH.               (line   6)
- * hyperbolic function, tangent:          TANH.                (line   6)
- * hyperbolic function, tangent, inverse: ATANH.               (line   6)
- * hyperbolic sine:                       SINH.                (line   6)
- * hyperbolic tangent:                    TANH.                (line   6)
- * I/O item lists:                        I/O item lists.      (line   6)
- * IABS:                                  ABS.                 (line   6)
- * IACHAR:                                IACHAR.              (line   6)
- * IAND:                                  IAND.                (line   6)
- * IARGC:                                 IARGC.               (line   6)
- * IBCLR:                                 IBCLR.               (line   6)
- * IBITS:                                 IBITS.               (line   6)
- * IBSET:                                 IBSET.               (line   6)
- * ICHAR:                                 ICHAR.               (line   6)
- * IDATE:                                 IDATE.               (line   6)
- * IDIM:                                  DIM.                 (line   6)
- * IDINT:                                 INT.                 (line   6)
- * IDNINT:                                NINT.                (line   6)
- * IEOR:                                  IEOR.                (line   6)
- * IERRNO:                                IERRNO.              (line   6)
- * IFIX:                                  INT.                 (line   6)
- * IMAG:                                  AIMAG.               (line   6)
- * IMAGPART:                              AIMAG.               (line   6)
- * INCLUDE directive:                     Directory Options.   (line   6)
- * inclusion, directory search paths for: Directory Options.   (line  14)
- * INDEX:                                 INDEX.               (line   6)
- * INT:                                   INT.                 (line   6)
- * INT2:                                  INT2.                (line   6)
- * INT8:                                  INT8.                (line   6)
- * integer kind:                          SELECTED_INT_KIND.   (line   6)
- * intrinsic procedures:                  Intrinsic Procedures.
-                                                               (line   6)
- * Introduction:                          Top.                 (line   6)
- * IOMSG= specifier:                      Fortran 2003 status. (line  18)
- * IOR:                                   IOR.                 (line   6)
- * IRAND:                                 IRAND.               (line   6)
- * ISATTY:                                ISATTY.              (line   6)
- * ISHFT:                                 ISHFT.               (line   6)
- * ISHFTC:                                ISHFTC.              (line   6)
- * ISIGN:                                 SIGN.                (line   6)
- * ITIME:                                 ITIME.               (line   6)
- * KILL:                                  KILL.                (line   6)
- * kind:                                  KIND.                (line   6)
- * KIND:                                  KIND.                (line   6)
- * kind, integer:                         SELECTED_INT_KIND.   (line   6)
- * kind, old-style:                       Old-style kind specifications.
-                                                               (line   6)
- * kind, real:                            SELECTED_REAL_KIND.  (line   6)
- * language, dialect options:             Fortran Dialect Options.
-                                                               (line   6)
- * LBOUND:                                LBOUND.              (line   6)
- * LEN:                                   LEN.                 (line   6)
- * LEN_TRIM:                              LEN_TRIM.            (line   6)
- * lexical comparison of strings <1>:     LLT.                 (line   6)
- * lexical comparison of strings <2>:     LLE.                 (line   6)
- * lexical comparison of strings <3>:     LGT.                 (line   6)
- * lexical comparison of strings:         LGE.                 (line   6)
- * LGE:                                   LGE.                 (line   6)
- * LGT:                                   LGT.                 (line   6)
- * libf2c calling convention:             Code Gen Options.    (line  21)
- * limits, largest number:                HUGE.                (line   6)
- * limits, smallest number:               TINY.                (line   6)
- * LINK:                                  LINK.                (line   6)
- * LLE:                                   LLE.                 (line   6)
- * LLT:                                   LLT.                 (line   6)
- * LNBLNK:                                LNBLNK.              (line   6)
- * LOC:                                   LOC.                 (line   6)
- * location of a variable in memory:      LOC.                 (line   6)
- * LOG:                                   LOG.                 (line   6)
- * LOG10:                                 LOG10.               (line   6)
- * logarithmic function <1>:              LOG10.               (line   6)
- * logarithmic function:                  LOG.                 (line   6)
- * logarithmic function, inverse:         EXP.                 (line   6)
- * LOGICAL:                               LOGICAL.             (line   6)
- * logical and, bitwise <1>:              IAND.                (line   6)
- * logical and, bitwise:                  AND.                 (line   6)
- * logical exclusive or, bitwise <1>:     XOR.                 (line   6)
- * logical exclusive or, bitwise:         IEOR.                (line   6)
- * logical not, bitwise:                  NOT.                 (line   6)
- * logical or, bitwise <1>:               OR.                  (line   6)
- * logical or, bitwise:                   IOR.                 (line   6)
- * login name:                            GETLOG.              (line   6)
- * LONG:                                  LONG.                (line   6)
- * LSHIFT:                                LSHIFT.              (line   6)
- * LSTAT:                                 LSTAT.               (line   6)
- * LTIME:                                 LTIME.               (line   6)
- * MALLOC:                                MALLOC.              (line   6)
- * MATMUL:                                MATMUL.              (line   6)
- * matrix multiplication:                 MATMUL.              (line   6)
- * matrix, transpose:                     TRANSPOSE.           (line   6)
- * MAX:                                   MAX.                 (line   6)
- * MAX0:                                  MAX.                 (line   6)
- * MAX1:                                  MAX.                 (line   6)
- * MAXEXPONENT:                           MAXEXPONENT.         (line   6)
- * maximum value <1>:                     MAXVAL.              (line   6)
- * maximum value:                         MAX.                 (line   6)
- * MAXLOC:                                MAXLOC.              (line   6)
- * MAXVAL:                                MAXVAL.              (line   6)
- * MCLOCK:                                MCLOCK.              (line   6)
- * MCLOCK8:                               MCLOCK8.             (line   6)
- * MERGE:                                 MERGE.               (line   6)
- * messages, error:                       Error and Warning Options.
-                                                               (line   6)
- * messages, warning:                     Error and Warning Options.
-                                                               (line   6)
- * MIN:                                   MIN.                 (line   6)
- * MIN0:                                  MIN.                 (line   6)
- * MIN1:                                  MIN.                 (line   6)
- * MINEXPONENT:                           MINEXPONENT.         (line   6)
- * minimum value <1>:                     MINVAL.              (line   6)
- * minimum value:                         MIN.                 (line   6)
- * MINLOC:                                MINLOC.              (line   6)
- * MINVAL:                                MINVAL.              (line   6)
- * MOD:                                   MOD.                 (line   6)
- * model representation, base:            RADIX.               (line   6)
- * model representation, epsilon:         EPSILON.             (line   6)
- * model representation, largest number:  HUGE.                (line   6)
- * model representation, maximum exponent: MAXEXPONENT.        (line   6)
- * model representation, minimum exponent: MINEXPONENT.        (line   6)
- * model representation, precision:       PRECISION.           (line   6)
- * model representation, radix:           RADIX.               (line   6)
- * model representation, range:           RANGE.               (line   6)
- * model representation, significant digits: DIGITS.           (line   6)
- * model representation, smallest number: TINY.                (line   6)
- * module search path:                    Directory Options.   (line  14)
- * modulo:                                MODULO.              (line   6)
- * MODULO:                                MODULO.              (line   6)
- * MOVE_ALLOC:                            MOVE_ALLOC.          (line   6)
- * moving allocation:                     MOVE_ALLOC.          (line   6)
- * multiply array elements:               PRODUCT.             (line   6)
- * MVBITS:                                MVBITS.              (line   6)
- * Namelist:                              Extensions to namelist.
-                                                               (line   6)
- * NEAREST:                               NEAREST.             (line   6)
- * NEW_LINE:                              NEW_LINE.            (line   6)
- * newline:                               NEW_LINE.            (line   6)
- * NINT:                                  NINT.                (line   6)
- * NOT:                                   NOT.                 (line   6)
- * NULL:                                  NULL.                (line   6)
- * OpenMP <1>:                            OpenMP.              (line   6)
- * OpenMP:                                Fortran Dialect Options.
-                                                               (line  84)
- * operators, unary:                      Unary operators.     (line   6)
- * options, code generation:              Code Gen Options.    (line   6)
- * options, debugging:                    Debugging Options.   (line   6)
- * options, dialect:                      Fortran Dialect Options.
-                                                               (line   6)
- * options, directory search:             Directory Options.   (line   6)
- * options, errors:                       Error and Warning Options.
-                                                               (line   6)
- * options, fortran dialect:              Fortran Dialect Options.
-                                                               (line  12)
- * options, gfortran command:             Invoking GNU Fortran.
-                                                               (line   6)
- * options, negative forms:               Invoking GNU Fortran.
-                                                               (line  13)
- * options, run-time:                     Code Gen Options.    (line   6)
- * options, runtime:                      Runtime Options.     (line   6)
- * options, warnings:                     Error and Warning Options.
-                                                               (line   6)
- * OR:                                    OR.                  (line   6)
- * output, newline:                       NEW_LINE.            (line   6)
- * PACK:                                  PACK.                (line   6)
- * paths, search:                         Directory Options.   (line  14)
- * PERROR:                                PERROR.              (line   6)
- * pointer, cray <1>:                     MALLOC.              (line   6)
- * pointer, cray <2>:                     FREE.                (line   6)
- * pointer, cray:                         Cray pointers.       (line   6)
- * pointer, disassociated:                NULL.                (line   6)
- * pointer, status <1>:                   NULL.                (line   6)
- * pointer, status:                       ASSOCIATED.          (line   6)
- * positive difference:                   DIM.                 (line   6)
- * PRECISION:                             PRECISION.           (line   6)
- * PRESENT:                               PRESENT.             (line   6)
- * process id:                            GETPID.              (line   6)
- * PRODUCT:                               PRODUCT.             (line   6)
- * product, double-precision:             DPROD.               (line   6)
- * product, matrix:                       MATMUL.              (line   6)
- * product, vector:                       DOT_PRODUCT.         (line   6)
- * program termination:                   EXIT.                (line   6)
- * program termination, with core dump:   ABORT.               (line   6)
- * RADIX:                                 RADIX.               (line   6)
- * RAN:                                   RAN.                 (line   6)
- * RAND:                                  RAND.                (line   6)
- * random number generation <1>:          RANDOM_NUMBER.       (line   6)
- * random number generation <2>:          RAND.                (line   6)
- * random number generation <3>:          RAN.                 (line   6)
- * random number generation:              IRAND.               (line   6)
- * random number generation, seeding <1>: SRAND.               (line   6)
- * random number generation, seeding:     RANDOM_SEED.         (line   6)
- * RANDOM_NUMBER:                         RANDOM_NUMBER.       (line   6)
- * RANDOM_SEED:                           RANDOM_SEED.         (line   6)
- * RANGE:                                 RANGE.               (line   6)
- * range checking:                        Code Gen Options.    (line 126)
- * read character, stream mode <1>:       FGETC.               (line   6)
- * read character, stream mode:           FGET.                (line   6)
- * REAL:                                  REAL.                (line   6)
- * real kind:                             SELECTED_REAL_KIND.  (line   6)
- * real number, exponent:                 EXPONENT.            (line   6)
- * real number, fraction:                 FRACTION.            (line   6)
- * real number, nearest different:        NEAREST.             (line   6)
- * real number, relative spacing <1>:     SPACING.             (line   6)
- * real number, relative spacing:         RRSPACING.           (line   6)
- * real number, scale:                    SCALE.               (line   6)
- * real number, set exponent:             SET_EXPONENT.        (line   6)
- * REALPART:                              REAL.                (line   6)
- * remainder:                             MOD.                 (line   6)
- * RENAME:                                RENAME.              (line   6)
- * repacking arrays:                      Code Gen Options.    (line 151)
- * REPEAT:                                REPEAT.              (line   6)
- * RESHAPE:                               RESHAPE.             (line   6)
- * root:                                  SQRT.                (line   6)
- * rounding, ceiling <1>:                 CEILING.             (line   6)
- * rounding, ceiling:                     ANINT.               (line   6)
- * rounding, floor <1>:                   FLOOR.               (line   6)
- * rounding, floor:                       AINT.                (line   6)
- * rounding, nearest whole number:        NINT.                (line   6)
- * RRSPACING:                             RRSPACING.           (line   6)
- * RSHIFT:                                RSHIFT.              (line   6)
- * SAVE statement:                        Code Gen Options.    (line  15)
- * SCALE:                                 SCALE.               (line   6)
- * SCAN:                                  SCAN.                (line   6)
- * search path:                           Directory Options.   (line   6)
- * search paths, for included files:      Directory Options.   (line  14)
- * SECNDS:                                SECNDS.              (line   6)
- * SECOND:                                SECOND.              (line   6)
- * seeding a random number generator <1>: SRAND.               (line   6)
- * seeding a random number generator:     RANDOM_SEED.         (line   6)
- * SELECTED_INT_KIND:                     SELECTED_INT_KIND.   (line   6)
- * SELECTED_REAL_KIND:                    SELECTED_REAL_KIND.  (line   6)
- * SET_EXPONENT:                          SET_EXPONENT.        (line   6)
- * SHAPE:                                 SHAPE.               (line   6)
- * SHORT:                                 INT2.                (line   6)
- * SIGN:                                  SIGN.                (line   6)
- * sign copying:                          SIGN.                (line   6)
- * SIGNAL:                                SIGNAL.              (line   6)
- * SIN:                                   SIN.                 (line   6)
- * sine:                                  SIN.                 (line   6)
- * sine, hyperbolic:                      SINH.                (line   6)
- * sine, hyperbolic, inverse:             ASINH.               (line   6)
- * sine, inverse:                         ASIN.                (line   6)
- * SINH:                                  SINH.                (line   6)
- * SIZE:                                  SIZE.                (line   6)
- * size of a variable, in bits:           BIT_SIZE.            (line   6)
- * SLEEP:                                 SLEEP.               (line   6)
- * SNGL:                                  SNGL.                (line   6)
- * SPACING:                               SPACING.             (line   6)
- * SPREAD:                                SPREAD.              (line   6)
- * SQRT:                                  SQRT.                (line   6)
- * square-root:                           SQRT.                (line   6)
- * SRAND:                                 SRAND.               (line   6)
- * Standards:                             Standards.           (line   6)
- * STAT:                                  STAT.                (line   6)
- * statement, ENUM:                       Fortran 2003 status. (line  20)
- * statement, ENUMERATOR:                 Fortran 2003 status. (line  20)
- * statement, FLUSH:                      Fortran 2003 status. (line  16)
- * statement, SAVE:                       Code Gen Options.    (line  15)
- * STREAM I/O:                            Fortran 2003 status. (line  32)
- * stream mode, read character <1>:       FGETC.               (line   6)
- * stream mode, read character:           FGET.                (line   6)
- * stream mode, write character <1>:      FPUTC.               (line   6)
- * stream mode, write character:          FPUT.                (line   6)
- * string, adjust left:                   ADJUSTL.             (line   6)
- * string, adjust right:                  ADJUSTR.             (line   6)
- * string, comparison <1>:                LLT.                 (line   6)
- * string, comparison <2>:                LLE.                 (line   6)
- * string, comparison <3>:                LGT.                 (line   6)
- * string, comparison:                    LGE.                 (line   6)
- * string, concatenate:                   REPEAT.              (line   6)
- * string, find missing set:              VERIFY.              (line   6)
- * string, find non-blank character:      LNBLNK.              (line   6)
- * string, find subset:                   SCAN.                (line   6)
- * string, find substring:                INDEX.               (line   6)
- * string, length:                        LEN.                 (line   6)
- * string, length, without trailing whitespace: LEN_TRIM.      (line   6)
- * string, remove trailing whitespace:    TRIM.                (line   6)
- * string, repeat:                        REPEAT.              (line   6)
- * structure packing:                     Code Gen Options.    (line 145)
- * subscript checking:                    Code Gen Options.    (line 126)
- * substring position:                    INDEX.               (line   6)
- * SUM:                                   SUM.                 (line   6)
- * sum array elements:                    SUM.                 (line   6)
- * suppressing warnings:                  Error and Warning Options.
-                                                               (line   6)
- * symbol names:                          Fortran Dialect Options.
-                                                               (line  44)
- * symbol names, transforming:            Code Gen Options.    (line  50)
- * symbol names, underscores:             Code Gen Options.    (line  50)
- * SYMLNK:                                SYMLNK.              (line   6)
- * syntax checking:                       Error and Warning Options.
-                                                               (line  33)
- * SYSTEM:                                SYSTEM.              (line   6)
- * system, error handling <1>:            PERROR.              (line   6)
- * system, error handling <2>:            IERRNO.              (line   6)
- * system, error handling:                GERROR.              (line   6)
- * system, group id:                      GETGID.              (line   6)
- * system, host name:                     HOSTNM.              (line   6)
- * system, login name:                    GETLOG.              (line   6)
- * system, process id:                    GETPID.              (line   6)
- * system, signal handling:               SIGNAL.              (line   6)
- * system, system call:                   SYSTEM.              (line   6)
- * system, terminal <1>:                  TTYNAM.              (line   6)
- * system, terminal:                      ISATTY.              (line   6)
- * system, user id:                       GETUID.              (line   6)
- * system, working directory <1>:         GETCWD.              (line   6)
- * system, working directory:             CHDIR.               (line   6)
- * SYSTEM_CLOCK:                          SYSTEM_CLOCK.        (line   6)
- * tabulators:                            Error and Warning Options.
-                                                               (line 119)
- * TAN:                                   TAN.                 (line   6)
- * tangent:                               TAN.                 (line   6)
- * tangent, hyperbolic:                   TANH.                (line   6)
- * tangent, hyperbolic, inverse:          ATANH.               (line   6)
- * tangent, inverse <1>:                  ATAN2.               (line   6)
- * tangent, inverse:                      ATAN.                (line   6)
- * TANH:                                  TANH.                (line   6)
- * terminate program:                     EXIT.                (line   6)
- * terminate program, with core dump:     ABORT.               (line   6)
- * TIME:                                  TIME.                (line   6)
- * time, clock ticks <1>:                 SYSTEM_CLOCK.        (line   6)
- * time, clock ticks <2>:                 MCLOCK8.             (line   6)
- * time, clock ticks:                     MCLOCK.              (line   6)
- * time, conversion to GMT info:          GMTIME.              (line   6)
- * time, conversion to string:            CTIME.               (line   6)
- * time, converstion to local time info:  LTIME.               (line   6)
- * time, current <1>:                     TIME8.               (line   6)
- * time, current <2>:                     TIME.                (line   6)
- * time, current <3>:                     ITIME.               (line   6)
- * time, current <4>:                     FDATE.               (line   6)
- * time, current:                         DATE_AND_TIME.       (line   6)
- * time, elapsed <1>:                     SECOND.              (line   6)
- * time, elapsed <2>:                     SECNDS.              (line   6)
- * time, elapsed <3>:                     ETIME.               (line   6)
- * time, elapsed <4>:                     DTIME.               (line   6)
- * time, elapsed:                         CPU_TIME.            (line   6)
- * TIME8:                                 TIME8.               (line   6)
- * TINY:                                  TINY.                (line   6)
- * TR 15581:                              Fortran 2003 status. (line  25)
- * TRANSFER:                              TRANSFER.            (line   6)
- * transforming symbol names:             Code Gen Options.    (line  50)
- * transpose:                             TRANSPOSE.           (line   6)
- * TRANSPOSE:                             TRANSPOSE.           (line   6)
- * trigonometric function, cosine:        COS.                 (line   6)
- * trigonometric function, cosine, inverse: ACOS.              (line   6)
- * trigonometric function, sine:          SIN.                 (line   6)
- * trigonometric function, sine, inverse: ASIN.                (line   6)
- * trigonometric function, tangent:       TAN.                 (line   6)
- * trigonometric function, tangent, inverse <1>: ATAN2.        (line   6)
- * trigonometric function, tangent, inverse: ATAN.             (line   6)
- * TRIM:                                  TRIM.                (line   6)
- * TTYNAM:                                TTYNAM.              (line   6)
- * type cast:                             TRANSFER.            (line   6)
- * UBOUND:                                UBOUND.              (line   6)
- * UMASK:                                 UMASK.               (line   6)
- * underflow:                             Error and Warning Options.
-                                                               (line 125)
- * underscore:                            Code Gen Options.    (line  50)
- * UNLINK:                                UNLINK.              (line   6)
- * UNPACK:                                UNPACK.              (line   6)
- * user id:                               GETUID.              (line   6)
- * vector product:                        DOT_PRODUCT.         (line   6)
- * VERIFY:                                VERIFY.              (line   6)
- * warnings, aliasing:                    Error and Warning Options.
-                                                               (line  65)
- * warnings, all:                         Error and Warning Options.
-                                                               (line  59)
- * warnings, ampersand:                   Error and Warning Options.
-                                                               (line  82)
- * warnings, character truncation:        Error and Warning Options.
-                                                               (line  90)
- * warnings, conversion:                  Error and Warning Options.
-                                                               (line  93)
- * warnings, implicit interface:          Error and Warning Options.
-                                                               (line  96)
- * warnings, non-stdandard intrinsics:    Error and Warning Options.
-                                                               (line 102)
- * warnings, suppressing:                 Error and Warning Options.
-                                                               (line   6)
- * warnings, suspicious code:             Error and Warning Options.
-                                                               (line 106)
- * warnings, tabs:                        Error and Warning Options.
-                                                               (line 119)
- * warnings, to errors:                   Error and Warning Options.
-                                                               (line 129)
- * warnings, underflow:                   Error and Warning Options.
-                                                               (line 125)
- * write character, stream mode <1>:      FPUTC.               (line   6)
- * write character, stream mode:          FPUT.                (line   6)
- * XOR:                                   XOR.                 (line   6)
- * ZABS:                                  ABS.                 (line   6)
- * ZCOS:                                  COS.                 (line   6)
- * ZEXP:                                  EXP.                 (line   6)
- * ZLOG:                                  LOG.                 (line   6)
- * ZSIN:                                  SIN.                 (line   6)
- * ZSQRT:                                 SQRT.                (line   6)
- 
- 
- 
- Tag Table:
- Node: Top2086
- Node: Introduction3234
- Node: About GNU Fortran3908
- Node: GNU Fortran and GCC7966
- Node: GNU Fortran and G779631
- Node: Project Status10182
- Node: Standards12680
- Node: Invoking GNU Fortran13337
- Node: Option Summary14944
- Node: Fortran Dialect Options17364
- Node: Error and Warning Options22415
- Node: Debugging Options27997
- Node: Directory Options29333
- Node: Runtime Options30680
- Node: Code Gen Options32139
- Node: Environment Variables39956
- Node: Runtime40559
- Node: GFORTRAN_STDIN_UNIT41568
- Node: GFORTRAN_STDOUT_UNIT41935
- Node: GFORTRAN_STDERR_UNIT42336
- Node: GFORTRAN_USE_STDERR42734
- Node: GFORTRAN_TMPDIR43179
- Node: GFORTRAN_UNBUFFERED_ALL43620
- Node: GFORTRAN_SHOW_LOCUS44098
- Node: GFORTRAN_OPTIONAL_PLUS44583
- Node: GFORTRAN_DEFAULT_RECL45058
- Node: GFORTRAN_LIST_SEPARATOR45547
- Node: GFORTRAN_CONVERT_UNIT46156
- Node: Fortran 2003 status48999
- Node: Extensions50089
- Node: Old-style kind specifications51296
- Node: Old-style variable initialization52130
- Node: Extensions to namelist53411
- Node: X format descriptor without count field55376
- Node: Commas in FORMAT specifications55872
- Node: Missing period in FORMAT specifications56358
- Node: I/O item lists56889
- Node: BOZ literal constants57247
- Node: Real array indices58757
- Node: Unary operators59023
- Node: Implicitly convert LOGICAL and INTEGER values59406
- Node: Hollerith constants support60162
- Node: Cray pointers61903
- Node: CONVERT specifier67282
- Node: OpenMP69249
- Node: Intrinsic Procedures69899
- Node: Introduction to Intrinsics82499
- Node: ABORT84812
- Node: ABS85515
- Node: ACCESS87007
- Node: ACHAR88896
- Node: ACOS89836
- Node: ACOSH90766
- Node: ADJUSTL91739
- Node: ADJUSTR92633
- Node: AIMAG93533
- Node: AINT94943
- Node: ALARM96388
- Node: ALL98022
- Node: ALLOCATED99939
- Node: AND100808
- Node: ANINT101970
- Node: ANY103308
- Node: ASIN105237
- Node: ASINH106182
- Node: ASSOCIATED107135
- Node: ATAN109960
- Node: ATAN2110794
- Node: ATANH112073
- Node: BESJ0113055
- Node: BESJ1113969
- Node: BESJN114889
- Node: BESY0115914
- Node: BESY1116772
- Node: BESYN117630
- Node: BIT_SIZE118709
- Node: BTEST119458
- Node: CEILING120301
- Node: CHAR121262
- Node: CHDIR122349
- Node: CHMOD123570
- Node: CMPLX125335
- Node: COMMAND_ARGUMENT_COUNT126874
- Node: COMPLEX127764
- Node: CONJG128919
- Node: COS129928
- Node: COSH131141
- Node: COUNT131959
- Node: CPU_TIME133493
- Node: CSHIFT134417
- Node: CTIME136060
- Node: DATE_AND_TIME137283
- Node: DBLE139646
- Node: DCMPLX140486
- Node: DFLOAT141725
- Node: DIGITS142422
- Node: DIM143366
- Node: DOT_PRODUCT144502
- Node: DPROD145932
- Node: DREAL146651
- Node: DTIME147315
- Node: EOSHIFT149655
- Node: EPSILON151716
- Node: ERF152412
- Node: ERFC153209
- Node: ETIME154024
- Node: EXIT156248
- Node: EXP157107
- Node: EXPONENT158204
- Node: FDATE158950
- Node: FLOAT160170
- Node: FGET160880
- Node: FGETC162673
- Node: FLOOR164421
- Node: FLUSH165363
- Node: FNUM166001
- Node: FPUT166723
- Node: FPUTC168304
- Node: FRACTION170024
- Node: FREE170918
- Node: FSEEK171755
- Node: FSTAT172248
- Node: FTELL173312
- Node: GERROR174291
- Node: GETARG174999
- Node: GET_COMMAND176596
- Node: GET_COMMAND_ARGUMENT177476
- Node: GETCWD178872
- Node: GETENV179810
- Node: GET_ENVIRONMENT_VARIABLE180974
- Node: GETGID181908
- Node: GETLOG182443
- Node: GETPID183199
- Node: GETUID183927
- Node: GMTIME184441
- Node: HOSTNM185996
- Node: HUGE186934
- Node: IACHAR187647
- Node: IAND188573
- Node: IARGC189561
- Node: IBCLR190575
- Node: IBITS191236
- Node: IBSET192154
- Node: ICHAR192810
- Node: IDATE194539
- Node: IEOR195555
- Node: IERRNO196434
- Node: INDEX196979
- Node: INT198073
- Node: INT2199587
- Node: INT8200367
- Node: IOR201094
- Node: IRAND201939
- Node: ISATTY203287
- Node: ISHFT204066
- Node: ISHFTC205048
- Node: ITIME206269
- Node: KILL207286
- Node: KIND208201
- Node: LBOUND209039
- Node: LEN210019
- Node: LEN_TRIM210841
- Node: LGE211553
- Node: LGT212858
- Node: LINK214128
- Node: LLE215163
- Node: LLT216460
- Node: LNBLNK217723
- Node: LOC218492
- Node: LOG219223
- Node: LOG10220425
- Node: LOGICAL221291
- Node: LONG222118
- Node: LSHIFT222889
- Node: LSTAT223852
- Node: LTIME225013
- Node: MALLOC226492
- Node: MATMUL228156
- Node: MAX229345
- Node: MAXEXPONENT230850
- Node: MAXLOC231659
- Node: MAXVAL233792
- Node: MCLOCK235584
- Node: MCLOCK8236587
- Node: MERGE237801
- Node: MIN238562
- Node: MINEXPONENT240064
- Node: MINLOC240687
- Node: MINVAL242820
- Node: MOD244586
- Node: MODULO245963
- Node: MOVE_ALLOC247170
- Node: MVBITS248228
- Node: NEAREST249410
- Node: NEW_LINE250526
- Node: NINT251311
- Node: NOT252331
- Node: NULL252913
- Node: OR253797
- Node: PACK254940
- Node: PERROR256927
- Node: PRECISION257517
- Node: PRESENT258336
- Node: PRODUCT259435
- Node: RADIX260962
- Node: RAN261732
- Node: RAND262188
- Node: RANDOM_NUMBER263523
- Node: RANDOM_SEED265254
- Node: RANGE267130
- Node: REAL267750
- Node: RENAME269251
- Node: REPEAT270270
- Node: RESHAPE270995
- Node: RRSPACING272457
- Node: RSHIFT273143
- Node: SCALE274114
- Node: SCAN274881
- Node: SECNDS276176
- Node: SECOND277264
- Node: SELECTED_INT_KIND278139
- Node: SELECTED_REAL_KIND279295
- Node: SET_EXPONENT281234
- Node: SHAPE282223
- Node: SIGN283329
- Node: SIGNAL284405
- Node: SIN285902
- Node: SINH286943
- Node: SIZE287700
- Node: SLEEP288756
- Node: SNGL289311
- Node: SPACING289975
- Node: SPREAD290983
- Node: SQRT292121
- Node: SRAND293305
- Node: STAT294464
- Node: SUM297579
- Node: SYMLNK299050
- Node: SYSTEM300182
- Node: SYSTEM_CLOCK301130
- Node: TAN302467
- Node: TANH303248
- Node: TIME304060
- Node: TIME8305164
- Node: TINY306301
- Node: TRANSFER306896
- Node: TRANSPOSE308921
- Node: TRIM309605
- Node: TTYNAM310461
- Node: UBOUND311382
- Node: UMASK312421
- Node: UNLINK313009
- Node: UNPACK313986
- Node: VERIFY315266
- Node: XOR316727
- Node: Contributing317899
- Node: Contributors318754
- Node: Projects320224
- Node: Proposed Extensions321016
- Node: Copying323214
- Node: GNU Free Documentation License342423
- Node: Funding364835
- Node: Option Index367360
- Node: Keyword Index373732
- 
- End Tag Table
--- 0 ----
diff -Nrcpad gcc-4.2.2/gcc/fortran/trans-intrinsic.c gcc-4.2.3/gcc/fortran/trans-intrinsic.c
*** gcc-4.2.2/gcc/fortran/trans-intrinsic.c	Fri Aug 31 08:27:50 2007
--- gcc-4.2.3/gcc/fortran/trans-intrinsic.c	Mon Oct 15 18:23:39 2007
*************** gfc_conv_intrinsic_minmaxloc (gfc_se * s
*** 1878,1883 ****
--- 1878,1884 ----
    tree tmp;
    tree elsetmp;
    tree ifbody;
+   tree offset;
    gfc_loopinfo loop;
    gfc_actual_arglist *actual;
    gfc_ss *arrayss;
*************** gfc_conv_intrinsic_minmaxloc (gfc_se * s
*** 1897,1902 ****
--- 1898,1904 ----
  
    /* Initialize the result.  */
    pos = gfc_create_var (gfc_array_index_type, "pos");
+   offset = gfc_create_var (gfc_array_index_type, "offset");
    type = gfc_typenode_for_spec (&expr->ts);
  
    /* Walk the arguments.  */
*************** gfc_conv_intrinsic_minmaxloc (gfc_se * s
*** 1995,2009 ****
    /* Assign the value to the limit...  */
    gfc_add_modify_expr (&ifblock, limit, arrayse.expr);
  
!   /* Remember where we are.  */
!   gfc_add_modify_expr (&ifblock, pos, loop.loopvar[0]);
  
    ifbody = gfc_finish_block (&ifblock);
  
!   /* If it is a more extreme value or pos is still zero.  */
    tmp = build2 (TRUTH_OR_EXPR, boolean_type_node,
! 		  build2 (op, boolean_type_node, arrayse.expr, limit),
! 		  build2 (EQ_EXPR, boolean_type_node, pos, gfc_index_zero_node));
    tmp = build3_v (COND_EXPR, tmp, ifbody, build_empty_stmt ());
    gfc_add_expr_to_block (&block, tmp);
  
--- 1997,2024 ----
    /* Assign the value to the limit...  */
    gfc_add_modify_expr (&ifblock, limit, arrayse.expr);
  
!   /* Remember where we are.  An offset must be added to the loop
!      counter to obtain the required position.  */
!   if (loop.temp_dim)
!     tmp = build_int_cst (gfc_array_index_type, 1);
!   else
!     tmp =fold_build2 (MINUS_EXPR, gfc_array_index_type,
! 			 gfc_index_one_node, loop.from[0]);
!   gfc_add_modify_expr (&block, offset, tmp);
! 
!   tmp = build2 (PLUS_EXPR, TREE_TYPE (pos),
! 		loop.loopvar[0], offset);
!   gfc_add_modify_expr (&ifblock, pos, tmp);
  
    ifbody = gfc_finish_block (&ifblock);
  
!   /* If it is a more extreme value or pos is still zero and the value
!      equal to the limit.  */
!   tmp = build2 (TRUTH_AND_EXPR, boolean_type_node,
! 		build2 (EQ_EXPR, boolean_type_node, pos, gfc_index_zero_node),
! 		build2 (EQ_EXPR, boolean_type_node, arrayse.expr, limit));
    tmp = build2 (TRUTH_OR_EXPR, boolean_type_node,
! 		build2 (op, boolean_type_node, arrayse.expr, limit), tmp);
    tmp = build3_v (COND_EXPR, tmp, ifbody, build_empty_stmt ());
    gfc_add_expr_to_block (&block, tmp);
  
*************** gfc_conv_intrinsic_minmaxloc (gfc_se * s
*** 2048,2059 ****
      }
    gfc_cleanup_loop (&loop);
  
!   /* Return a value in the range 1..SIZE(array).  */
!   tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, loop.from[0],
! 		     gfc_index_one_node);
!   tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, pos, tmp);
!   /* And convert to the required type.  */
!   se->expr = convert (type, tmp);
  }
  
  static void
--- 2063,2069 ----
      }
    gfc_cleanup_loop (&loop);
  
!   se->expr = convert (type, pos);
  }
  
  static void
diff -Nrcpad gcc-4.2.2/libgfortran/ChangeLog gcc-4.2.3/libgfortran/ChangeLog
*** gcc-4.2.2/libgfortran/ChangeLog	Sun Oct  7 21:20:11 2007
--- gcc-4.2.3/libgfortran/ChangeLog	Fri Feb  1 16:53:53 2008
***************
*** 1,3 ****
--- 1,16 ----
+ 2008-02-01  Release Manager
+ 
+ 	* GCC 4.2.3 released.
+ 
+ 2008-01-21  John David Anglin  <dave.anglin@nrc-cnrc.gc.ca>
+ 
+ 	PR libfortran/34699
+ 	Backport:
+ 	2007-09-21  Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
+ 
+ 	PR libfortran/26253
+ 	* intrinsics/c99_functions.c (scalbn): Use ldexp if appopriate.
+ 
  2007-10-07  Release Manager
  
  	* GCC 4.2.2 released.
diff -Nrcpad gcc-4.2.2/libgfortran/intrinsics/c99_functions.c gcc-4.2.3/libgfortran/intrinsics/c99_functions.c
*** gcc-4.2.2/libgfortran/intrinsics/c99_functions.c	Wed Dec  6 21:17:35 2006
--- gcc-4.2.3/libgfortran/intrinsics/c99_functions.c	Mon Jan 21 17:24:30 2008
*************** log10f(float x)
*** 249,255 ****
--- 249,259 ----
  double
  scalbn(double x, int y)
  {
+ #if (FLT_RADIX == 2) && defined(HAVE_LDEXP)
+   return ldexp (x, y);
+ #else
    return x * pow(FLT_RADIX, y);
+ #endif
  }
  #endif
  
