fpp.1

变尺度法的源程序

           block_1
      \f3#elif \f2condition\f1
           block_2
      \f3#else\f1
          block_n
      \f3#endif\f1
.LP
else- and elif-part are optional.  There may be more than
one elif-part. Condition is an expression involving 
.B fpp
constants, macros  and  
intrinsic  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,
.B fpp 
will accept and evaluate Fortran logical operations .NOT. .AND.
\&.OR. .EQV. .NEQV. .GT. .LT. .LE. .GE. etc. and logical
constants .TRUE. .FALSE.
.SH Details
.SS 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. 
.LP
There are the following exceptions to the scope effected by
an fpp definition:
.LP
- files included by Fortran INCLUDE statements;
.LP
- fpp and Fortran comments;
.LP
- IMPLICIT single letter specifications;
.LP
- FORMAT specifications;
.LP
- numeric, typeless and character constants.
.LP
The scope of the macro effect can be limited by means
of the #undef directive.
.SS End of macro definition
Macro definition can be of any length and is limited
only by the 'newline' symbol. A Macro can be defined in
multiple lines. A Macro can be continued to the next line
with the insertion of '\e'. So, the occurrence of a 'newline'
without a macro-continuation signifies the end of the macro
definition.
.br
.sp
For example:
.br
#define long_macro_name(x,\e
.br
y) x*y
.SS 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.
.SS Cancelling macro definitions of both kinds
\f3#undef \f2name\f1
.LP
After this directive,  'name' would not interpreted by
.B 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
.SS Conditional source code selection
.LP
- Constant-expression
.LP
Subsequent lines up to the matching #else, #elif, or
#endif directive, appear in the output only if
their constant-expression yields a true value.
.LP
The lines following the #elif directive appear 
in the output only if all of the following conditions
hold:
.RS
.TP
-
The constant-expression  in the   preceding
#if directive evaluated to .FALSE.
.BI or
the name in the preceding #ifdef directive
is not defined
.BI or
the name in the preceding #ifndef directive
is defined.
.TP
-
The constant-expression in all intervening 
#elif  directives  evaluated to .FALSE.
.TP
-
The  current constant-expression   evaluates
to .TRUE.
.RE
.LP
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
directive.
.LP
The intrinsic function `defined' can be used in a
constant-expression also.
.LP
The following items are permitted:
.RS
.TP
-
C language operations: <, >, ==, !=, >=, <=, 
+, -, /, *, %, <<, >>,
&,  ~, |, &&, ||
They are interpreted by
.B fpp
in accordance to the C language
semantics (this facility is provided for compatibility with
"old" Fortran programs using cpp)
.TP
-
Fortran language 
operations: .AND., .OR., .NEQV., .XOR., .EQV., .NOT.
\&, .GT., .LT., .LE., .GE., .NE., .EQ., ** (power).
.TP
-
Fortran logical constants: .TRUE. , .FALSE.
.LP
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.
.RE
.TP
.BI #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.
.TP
.BI #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 definition has been removed
with an #undef directive. No additional tokens  are
permitted on the directive line after name.
.TP
.BI #elif " constant-expression ".
Any number of #elif directives may  appear   between
an #if,  #ifdef, or #ifndef directive and a matching
#else or #endif  directive.
.TP
.BI #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
output.
.BR
Conditional directives and corresponding #else directives 
can be nested.
.TP
.BI #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.
.SS Including External Files 
Is the same as it is for cpp.
Files are searched as follows:
.LP
for  #include "file_name":
.RS
.TP
-
in the directory, in which the processed file has been found;
.TP
-
in the directories specified by the -I option;
.TP
-
in the default directory.
.RE
.LP
for #include <file_name>:
.RS
.TP
-
in the directories specified by the -I option;
.TP
-
in the default directory.
.RE
.LP
.B 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 
.B fpp
directives
within a macro call divided on several lines by means
of continuation symbols.
.LP
.SS Comments
.LP
.B fpp 
permits comments of two kinds:
.LP
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). 
.LP
2) 
.B fpp 
comments enclosed in the '/*' and '*/' parasymbols.
They are excluded from the output and 
macro expansions are not performed within these symbols.        
.B fpp
comments can be nested and for each parasymbol '/*'
there must be a corresponding parasymbol '*/'.
.B fpp 
comments are suitable for excluding the compilation of
large portions of source instead of commenting every line
with Fortran comment symbols.
.LP
.SS Intrinsic functions
.LP
The intrinsic function
.LP
\f3defined(\f2name\f3)\f1   or \f3defined \f2name\f3 \f1
.LP
Returns:
.LP
  .TRUE. - if name is defined as a macro.
.LP
  .FALSE.- if the name is not defined.
.LP
.SS Macro expansion
.LP
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),
.B fpp 
inserts appropriate continuation
lines.
.LP
In the fixed form there is limitation on macro expansions
in label fields (positions 1-5):
.RS
.TP
-
a macro call (together with possible arguments) should not
extend more than the column 5 position;
.TP
-
a macro call whose name begins with one of the Fortran
comment symbols is considered as a part of a comment;
.TP
-
a macro expansion may produce a text extending beyond the
column 5 position. In such a case a warning will be issued.
.RE
.LP
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:
.LP
  #define callp(x)   call f(x)
          call p(0)     
.LP
.B 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:
.RS
.TP
-
the longer identifier is chosen (callp in this case);
.TP
-
from this identifier the longest macro name or keyword
is extracted;
.TP
-
if a macro name has been extracted a macro expansion is
performed. If the name begins with some keyword
.B fpp
outputs an appropriate warning;
.TP
-
the rest of the identifier is considered as a whole
identifier.
.RE
.LP
In the above example the macro expansion would be performed
and the following warning would be output:
.LP
warning: possibly incorrect substitution of macro callp
.LP
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 coincides
with a keyword beginning part, as in the following case:
.LP
     #define INT    INTEGER*8
             INTEGER k
.LP
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.    
.SH DIAGNOSTICS 
.LP
There are three kinds of diagnostic messages:
.RS
.TP
-
warnings.
preprocessing of source code is continued and
the return value remains to be 0.
.TP
-
errors.
.B fpp 
continues preprocessing but sets the return
code to a nonzero value, namely number of errors. 
.TP
-
fatal error.
.B fpp 
cancels preprocessing and returns a nonzero
return value.  
.RE
.LP         
The messages produced by
.B fpp 
are intended to be self-explanatory. 
The line number and filename where the error
occurred are printed along with the diagnostic.
.SH SEE ALSO
.LP
cpp(1), f77(1), f90(1)