svcadm(1M)을 검색하려면 섹션에서 1M 을 선택하고, 맨 페이지 이름에 svcadm을 입력하고 검색을 누른다.
fpp(1)
fpp(1) User Commands fpp(1)
NAME
fpp - the Fortran language preprocessor for FORTRAN 77 and Fortran 95
SYNOPSIS
fpp [ options ] [ input-file [ output-file ] ]
DESCRIPTION
fpp is the preprocessor for FORTRAN 77 and Fortran 95. fpp optionally
accepts two filenames as arguments. input-file and output-file are,
respectively, the input file read and the output file written by the
preprocessor. By default standard input and output are used. fpp can be
used instead of the cpp preprocessor with the Oracle Developer Studio
Fortran compiler.
OPTIONS
-c_com={yes|no}
By default, C style comments are recognized. Turn this off by spec‐
ifying -c_com=no
-Dname
Define the preprocessor variable name as 1 (one). This is the same
as if a -Dname=1 option appeared on the fpp command line, or as if
a
#define name 1
line appeared in the source file, which is processed by fpp.
-Dname=def
Define name as if by a #define directive. This is the same as if a
#define name def
line appeared in the source file that fpp is processing. The -D
option has lower precedence than the -U option. That is, if the
same name is used in both a -U option and a -D option, the name
will be undefined regardless of the order of the options.
-fixed
Assumes fixed format input source.
-free
Assumes free format input source.
-Idirectory
Insert directory into the search path for #include files with names
not beginning with `/'. directory is inserted ahead of the standard
list of ``include'' directories. Thus, #include files with names
enclosed in double-quotes (") are searched for first in the direc‐
tory of the file with the #include line, then in directories named
with -I options, and lastly, in directories from the standard list.
For #include files with names enclosed in angle-brackets (<>), the
directory of the file with the #include line is not searched.
-M
Generate a list of makefile dependencies and write them to the
standard output. This list indicates that the object file which
would be generated from the input file depends on the input file as
well as the include files referenced.
-macro={yes|no_com|no}
By default, macros are expanded everywhere. Turn off macro expan‐
sion in comments by specifying -macro=no_com and turn off macro
expansion all together by specifying -macro=no.
-P
Do not put line numbering directives to the output file. This
directive appears as
#line-number file-name
-Uname
Remove any initial definition of name, where name is a fpp variable
that is predefined by a particular preprocessor. Here is a partial
list of symbols that may be predefined, depending upon the archi‐
tecture of the system:
Operating System: unix, __unix, and__SVR4
Hardware: sun, __sun, sparc, and__sparc
-undef
Remove initial definitions for all predefined symbols.
-w0
Do not output warnings from fpp to stderr.
-Xu
Convert upper-case letters to lower-case, except within character-
string constants. The default is to not convert upper-case letters
to lower-case.
-Xw
For fixed form source files (See below) fpp assumes that the symbol
' ' (space) is insignificant. By default for this form the 'space'
symbol is the delimiter of tokens.
-Ydirectory
Use the specified directory in place of the standard list of direc‐
tories when searching for files.
fpp also understands some f95 compiler options (See f95(1)):
-e Accept extended source lines, up to 132 characters long.
-w Do not output warnings to stderr.
USAGE
Source files
fpp operates on both fixed and free form source files. Files with '.F'
extension are assumed to be in fixed form, and files with '.F90' and
'.F95' extensions (and all others) are assumed to be in free form by
default. There is the '-fixed' option for using fixed form in Fortran
95. fpp recognizes the tab format of a source line when in fixed mode.
A source file may contain fpp tokens. fpp tokens are close to those of
Fortran. They are:
o fpp directive names.
o symbolic names including Fortran keywords. fpp permits all
symbols in names that Fortran does.
o constants. Integer, real, double and quadruple precision,
binary, octal, hexadecimal including alternate notation,
character and hollerith.
o comments. There are Fortran comments and fpp comments.
o others. Special characters, space, tab, newline, etc.
Output
Output consists of a modified copy of the input, plus lines of the
form:
#line_number file_name
inserted to indicate the original source line number and filename of
the output line that follows. There is the '-P' option (See above)
which disables the generation of these lines.
Directives
Syntax and semantics of fpp directives are the same as cpp directives
(See cpp(1)).
All fpp directives start with the hash symbol (#) as the first charac‐
ter on a line. White space (SPACE or TAB characters) can appear after
the initial '#' for proper indentation. The directives can be divided
into the following groups:
o macro definitions
o conditional source code selection
o inclusion of external files
o line control
Macro definition
The #define directive is used to define both simple string variables
and more complicated macros:
#define name token-string
This is the definition of a fpp variable. Wherever 'name' appears in
the source lines following the definition, 'token-string' will be sub‐
stituted for 'name'.
#define name(argument [, argument] ... ) token-string
This is the definition of a function-like macro. Occurrences of the
macro 'name' followed by the comma-separated list of arguments within
parentheses are substituted by the token string produced from the macro
definition. Every occurrence of an argument identifier from the macro
definition's arguments list is substituted by the token sequence repre‐
senting the corresponding macro actual argument.
Macro arguments other than those that are operands of the macro substi‐
tution operators # and ## are expanded recursively prior to their sub‐
stitution in the replacement token list.
To allow argument substitution in string literals, use the # macro sub‐
stitution operator:
#define a(x) #x
...
a(actual argument)
produces:
´actual argument'
To combine two tokens in a macro definition, one or both of which is an
argument, use the ## macro substitution operator:
#define cat(x,y) x##y x##b a##y
#define ab ok
...
cat(a,b)
produces:
ok ok ok
In these definitions, spaces between the macro name and the '(' symbol
are prohibited to prevent the directive being interpreted as a fpp
variable definition with the rest of the line beginning with the '('
symbol being interpreted as a token-string.
#undef name
Remove any definition for 'name' (produced by 'D' options, #define
directives or by default). No additional tokens are permitted on the
directive line after the name.
Including External Files
There are two forms of file inclusion:
#include "filename"
#include <filename>
Read in the contents of filename at this location. The lines read in
from the file are processed by fpp as if it were a part of the current
file.
When the <filename> notation is used, filename is only searched for in
the standard ``include'' directories. See the 'I' and 'Y' options above
for more detail. No additional tokens are permitted in the directive
line after the final `"' or `>'.
Line control
#line-number "filename" or #line line-number "filename"
Generate line control information for the next pass of the compiler.
The integer-constant is interpreted as the line number of the next line
and the filename is interpreted as the name of the file from where it
comes. If "filename" is not given, the current filename is unchanged.
Conditional selection of source text.
There are two forms of conditional selection of source text
1) #if condition_1
block_1
#elif condition_2
block_2
#else
block_n
#endif
2) #ifdef name
block_1
#elif condition
block_2
#else
block_n
#endif
or #ifndef name
block_1
#elif condition
block_2
#else
block_n
#endif
else- and elif-part are optional. There may be more than one elif-part.
Condition is an expression involving fpp constants, macros and intrin‐
sic functions. Condition expressions are similar to cpp expressions,
and may contain any cpp operations and operands with the exception of c
long, octal and hexadecimal constants. Additionally, fpp will accept
and evaluate Fortran logical operations .NOT. .AND. .OR. .EQV. .NEQV.
.GT. .LT. .LE. .GE. etc. and logical constants .TRUE. .FALSE.
DETAILS
Scope of macro or variable definitions.
The scope of a definition begins from the place of its definition and
encloses all the source lines (and source lines from included files)
from that definition line to the end of the current file.
There are the following exceptions to the scope effected by an fpp def‐
inition:
o files included by Fortran INCLUDE statements
o fpp and Fortran comments
o IMPLICIT single letter specifications
o FORMAT specifications
o numeric, typeless and character constants
The scope of the macro effect can be limited by means of the #undef
directive.
End of macro definition
Macro definition can be of any length and is limited only by the 'new‐
line' symbol. A Macro can be defined in multiple lines. A Macro can be
continued to the next line with the insertion of '\'. So, the occur‐
rence of a 'newline' without a macro-continuation signifies the end of
the macro definition.
For example: #define long_macro_name(x, y) x*y
With Fortran 77 fixed form source files, there may be a need to produce
more than one line or statement as the expansion of a macro. Use the
';' to separate statements that are to be produced on separate lines:
#define init_i_j(x,y) i=x; j=y
...
init_i_j(1,2)
produces:
i=1
#2
j=2
Function-like macro definition
The number of macro call arguments should be the same as the number of
arguments in the corresponding macro definition. An error is flagged if
they don't.
Cancelling macro definitions of both kinds
#undef name
After this directive, 'name' would not interpreted by fpp as a macro or
variable name. If this name has not been defined earlier as a macro
name, then the given directive has no effect
Conditional source code selection
Constant-expression
Subsequent lines up to the matching #else, #elif, or #endif directive,
appear in the output only if their constant-expression yields a true
value.
The lines following the #elif directive appear in the output only if
all of the following conditions hold:
o The constant-expression in the preceding #if directive eval‐
uated to .FALSE. or the name in the preceding #ifdef direc‐
tive is not defined or the name in the preceding #ifndef
directive is defined.
o The constant-expression in all intervening #elif directives
evaluated to .FALSE.
o The current constant-expression evaluates to .TRUE.
If the constant-expression evaluates to .TRUE., subsequent #elif and
#else directives are ignored up to the matching #endif. Any constant-
expression allowed in an #if directive is allowed in an #elif direc‐
tive.
The intrinsic function `defined' can be used in a constant-expression
also.
The following items are permitted:
o C language operations: <, >, ==, !=, >=, <=, +, -, /, *, %,
<<, >>, &, ~, |, &&, || They are interpreted by fpp in
accordance to the C language semantics (this facility is
provided for compatibility with "old" Fortran programs using
cpp)
o Fortran language operations: .AND., .OR., .NEQV., .XOR.,
.EQV., .NOT. , .GT., .LT., .LE., .GE., .NE., .EQ., **
(power).
o Fortran logical constants: .TRUE. , .FALSE.
Only these items, integer constants, and names can be used within a
constant-expression. Names which have not been defined with the help of
the 'D' option, a #define directive or by default, get 0 as the value.
The C operation '!=' (not equal) can be used in #if or #elif directive,
but NOT in #define directive, where the symbol '!' is considered as the
Fortran comment symbol.
#ifdef name
Subsequent lines up to the matching #else, #elif, or #endif appear
in the output only if the name has been defined, either by a
#define directive or by the 'D' option, and in the absence of an
intervening #undef directive. No additional tokens are permitted on
the directive line after name.
#ifndef name
Subsequent lines up to the matching #else, #elif, or #endif appear
in the output only if name has not been defined, or if its defini‐
tion has been removed with an #undef directive. No additional
tokens are permitted on the directive line after name.
#elif constant-expression .
Any number of #elif directives may appear between an #if, #ifdef,
or #ifndef directive and a matching #else or #endif directive.
#else
This inverts the sense of the conditional directive otherwise in
effect. If the preceding conditional would indicate that lines are
to be included, then lines between the #else and the matching
#endif are ignored. If the preceding conditional indicates that
lines would be ignored, subsequent lines are included in the out‐
put. Conditional directives and corresponding #else directives can
be nested.
#endif
End a section of lines begun by one of the conditional directives
#if, #ifdef, or #ifndef. Each such directive must have a matching
#endif.
Including External Files
Is the same as it is for cpp. Files are searched as follows:
For #include "file_name":
o in the directory, in which the processed file has been
found;
o in the directories specified by the -I option;
o in the default directory.
For #include <file_name>:
o in the directories specified by the -I option;
o in the default directory.
fpp directives (beginning with the # symbol in the first position of
lines) can be placed anywhere in a source code, in particular before a
Fortran continuation line. The only exception is the prohibition of fpp
directives within a macro call divided on several lines by means of
continuation symbols.
Comments
fpp permits comments of two kinds:
1. Fortran language comments. A source line containing one of
the symbols 'C', 'c', '*', 'd' or 'D' in the first position,
is considered as a comment line. Within such lines macro
expansions are not performed. The '!' symbol is interpreted
as the beginning of a comment extending to the end of the
line. The only exception is the case when this symbol occurs
within a constant-expression in #if and #elif directives
(See above).
2. fpp comments enclosed in the '/*' and '*/' parasymbols. They
are excluded from the output and macro expansions are not
performed within these symbols. fpp comments can be nested
and for each parasymbol '/*' there must be a corresponding
parasymbol '*/'. fpp comments are suitable for excluding the
compilation of large portions of source instead of comment‐
ing every line with Fortran comment symbols.
Intrinsic functions
The intrinsic function
defined(name) or defined name
Returns:
.TRUE. - if name is defined as a macro.
.FALSE.- if the name is not defined.
Macro expansion
If, during expansion of a macro, the column width of a line exceeds
column 72 (for the fixed format) or column 132 (for the free format),
fpp inserts appropriate continuation lines.
In the fixed form there is limitation on macro expansions in label
fields (positions 1-5):
o a macro call (together with possible arguments) should not
extend more than the column 5 position;
o a macro call whose name begins with one of the Fortran com‐
ment symbols is considered as a part of a comment;
o a macro expansion may produce a text extending beyond the
column 5 position. In such a case a warning will be issued.
In the fixed form when the '-Xw' option has been specified an ambiguity
may appear if a macro call occurs in a statement position and a macro
name begins or coincides with a Fortran keyword. For example, in the
following text:
#define callp(x) call f(x)
call p(0)
fpp can not determine with certainty how to interpret the 'call p'
token sequence. It could be considered as a macro name. The current
implementation does the following:
o the longer identifier is chosen (callp in this case);
o from this identifier the longest macro name or keyword is
extracted;
o if a macro name has been extracted a macro expansion is per‐
formed. If the name begins with some keyword fpp outputs an
appropriate warning;
o the rest of the identifier is considered as a whole identi‐
fier.
In the above example the macro expansion would be performed and the
following warning would be output:
warning: possibly incorrect substitution of macro callp
It should be noted that this situation appears only when preprocessing
a fixed format source code and when the space symbol is not interpreted
as a token delimiter. It should be said also that if a macro name coin‐
cides with a keyword beginning part, as in the following case:
#define INT INTEGER*8
INTEGER k
then in accordance with the described algorithm, the INTEGER keyword
will be found earlier than the INT macro name. Thus, there will be no
warning when preprocessing such a macro definition.
DIAGNOSTICS
There are three kinds of diagnostic messages:
o warnings. preprocessing of source code is continued and the
return value remains to be 0.
o errors. fpp continues preprocessing but sets the return code
to a nonzero value, namely number of errors.
o fatal error. fpp cancels preprocessing and returns a nonzero
return value.
The messages produced by fpp are intended to be self-explanatory. The
line number and filename where the error occurred are printed along
with the diagnostic.
SEE ALSO
cpp(1), f95(1)
The source code for fpp is downloadable from NetLib.
http://www.netlib.org/fortran/
Studio 12.6 March 2016 fpp(1)