p2c.man

把pascal程序转成C语言程序 把pascal程序转成C语言程序

code.  This may be turned on or off around specific constant declarations.
Set this to 0 to force
.I p2c
to make absolutely no assumptions about the constant's value in generated
code, so that you can change the constant later in the C code without
invalidating the translation.  The default is to allow
.I p2c
to take advantage of its knowledge of a constant's value, such as by
generating code that assumes the constant is positive.
.TP
.B CharConsts
This governs whether single-character string literals in Pascal
.B const
declarations should be interpreted as characters or strings.  In other words,
.I const a='x';
will translate to
.I #define a 'x'
if
.BR CharConsts =1
(the default), or to
.I #define a "x"
if
.BR CharConsts =0.
Note that if
.I p2c
guesses wrong, the generated code will not be wrong, just uglier.  For
example, if
.I a
is written as a character constant but it turns out to be used as a
string,
.I p2c
will have to write char-to-string conversion code each time the constant
is used.
.TP
.B PreserveTypes
.I P2c
makes an attempt to retain the original names used for data types.
For example,
.IP
\ \ \ \ \ type foo = integer; bar = integer;
.IP
establishes two synonyms for the standard integer type;
.I p2c
does its best to preserve the particular synonym that was used to
declare each integer variable.  Because the Pascal language treats
these types as indistinguishable, there will be cases in the
translation where
.I p2c
must fall back on the "true" type,
.BR int .
.B PreserveTypes
and a few related options control whether various kinds of type
names are preserved.  The default settings preserve all type names
except for pointer types, which use "*" notation throught the
program.  This reflects the fact that Pascal forces pointer types
to be named when traditionally they are not separately named in C.
.TP
.B VarStrings
In HP Pascal, a parameter of the form "var s : string" will match a
string variable of any size; a hidden size parameter is passed which
may be accessed by the Pascal
.I strmax
function.  You can prevent
.I p2c
from creating a hidden size parameter by setting
.BR VarStrings =0.
(Note that each function uses the value of
.B VarStrings
as of the
.I first
declaration of the function that is parsed, which is often in the interface
section of a module.)
.TP
.B Prototypes
Control whether ANSI C function prototypes are used.  Default is according to
.B AnsiC
or
.BR C++ .
This also controls whether to include parameter names or just their types
in situations where names are optional.  The
.B FullPrototyping
parameter allows prototypes to be generated for declarations but not
for definitions (older versions of Lightspeed C required this).  If you
use a mixture of prototypes and old-style definitions, types like short
and float will be promoted to int and double as required by the ANSI
standard, unless
.B PromoteArgs
is used to override this.  The
.B CastArgs
parameter controls whether type-casts are used in function arguments;
by default they are used only if prototypes are not available.
.TP
.B StaticLinks
HP Pascal and Turbo Pascal each include the concept of procedure or
function pointers, though with somewhat different syntaxes.
.I P2c
recognizes both notational styles.  Another difference is that HP's
procedure pointers can point to nested procedures, while Turbo's can
point only to global procedures.  In HP Pascal a procedure pointer must
be stored as a
.B struct
containing both a pure C function pointer and a "static link," a pointer
to the parent procedure's locals.  (The static link is NULL for global
procedures.)  This notation can be forced by setting
.BR StaticLinks =1.
In Turbo, the default
.RB ( StaticLinks =0)
is to use plain C function pointers with no static links.  A third option
.RB ( StaticLinks =2)
uses structures with static links, but assumes the links are always NULL
when calling through a pointer (if you need compatibility with the HP
format but know your procedures are global).
.TP
.B SmallSetConst
Pascal sets are translated into one of two formats, depending on the size
of the set.  If all elements have ordinal values in the range 0..31, the
set is translated as a single integer variable using bit operations.
(The
.B SetBits
parameter may be used to change the upper limit of 31.)
The
.B SmallSetConst
parameter controls whether these small-sets are used, and, if so, how
constant sets should be represented in C.
.IR
For larger sets, an array of
.B long
is used.  The
.IR s [0]
element contains the number of succeeding array elements
which are in use.  Set elements in the range 0..31 are stored in the
.IR s [1]
array element, and so on.  Sets are normalized so that
.IR s [ s [0]]
is nonzero for any nonempty set.  The standard run-time library
includes all the necessary procedures for operating on sets.
.TP
.B ReturnValueName
This is one of many "naming conventions" parameters.  Most of these
take the form of a
.IR printf -like
string containing a
.I %s
where the relevant information should go.  In the case of
.BR ReturnValueName ,
the
.I %s
refers to a function name and the resulting string gives the name of
the variable to use to hold the function's return value.  Such a variable
will be made if a function contains assignments to its return value
buried within the body, so that
.I return
statements cannot conveniently be used.  Some parameters
.RB ( ReturnValueName
included) do not require the
.I %s
to be present in the format string; for example, the standard
.I p2crc
file stores every function's return value in a variable called
.I Result.
.TP
.B AlternateName
.I P2c
normally translates Pascal names into C names verbatim, but occasionally
this is not possible.  A Pascal name may be a C reserved word or
traditional C name like
.I putc,
or there may be several like-named things that are hidden from each other by
Pascal's scoping rules but must be global in C.  In these situations
.I p2c
uses the parameter
.B AlternateName1
to generate an alternative name for the symbol.  The default is to add
an underscore to the name.  There is also an
.B AlternateName2
parameter for a second alternate name, and an
.B AlternateName
parameter for the
.IR n th
alternate name.  (The value for this parameter should include both a
.I %s
and a
.I %d,
in either order.)  If these latter parameters are not defined,
.I p2c
applies
.B AlternateName1
many times over.
.TP
.B ExportSymbol
Symbols in the interface section for a Pascal module are formatted
according to the value of
.BR ExportSymbol ,
if any.  It is not uncommon to use
.I modulename_%s
for this symbol; the default is
.I %s,
i.e., no special treatment for exported symbols.  If you also define the
.B Export_Symbol
parameter, that format is used instead for exported symbols which
contain an underscore character.  If
.I %S
(with a capital "S") appears in the format string it stands for the
current module name.
.TP
.B Alias
If the value of this parameter contains a
.I %s,
it is a format string applied to the names of external functions or
variables.  If the value does not contain a
.I %s,
it becomes the name of the next external symbol which is declared (after
which the parameter is cleared).
.TP
.B Synonym
This creates a synonym for another Pascal symbol or keyword.  The format is
.IP
.B "\ \ \ \ \ Synonym"
.I old-name = new-name
.IP
All occurrences of 
.I old-name
in the input text are treated as if they were
.I new-name
by the parser.  If
.I new-name
is a keyword,
.I old-name
will be an equivalent keyword.  If
.I new-name
is the name of a predefined function,
.I old-name
will behave in the same way as that function, and so on.  If
.I new-name
is omitted, then occurrences of
.I old-name
are entirely ignored in the input file.  Synonyms allow you to skip over
a keyword in your dialect of Pascal that is not understood by
.I p2c,
or to simulate a keyword or predefined identifier of your dialect with a
similar one that
.I p2c
recognizes.  Note that all predefined functions are available at all times;
if you have a library routine that behaves like, e.g., Turbo Pascal's
.I getmem
procedure, you can make your routine a synonym for
.I getmem
even if you are not translating in Turbo mode.
.TP
.B NameOf
This defines the name to use in C for a specific symbol.  It must appear
before the symbol is declared in the Pascal code; it is usually placed
in the local
.I p2crc
file for the project.  The format is
.IP
.B "\ \ \ \ \ NameOf"
.I pascal-name = C-name
.IP
By default, Pascal names map directly onto C names with no change
(except for the various kinds of formatting outlined above).  If the
.I pascal-name
is of the form
.I module.name
or
.I procedure.name
then the command applies only to the instance of the Pascal name that is
global to that module, or local to that procedure.  Otherwise, it applies
to all usages of the name.
.TP
.B VarMacro
This is analogous to
.BR NameOf ,
but specifically for use with Pascal variables.  The righthand side can
be most any C expression; all references to the variable are expanded
into that C expression.  Names used in the C expression are taken
verbatim.  There is also a
.B ConstMacro
parameter for translating constants as arbitrary expressions.
Note that the variable on the lefthand side must actually be declared
in the program or in a module that it uses.
The declaration for the variable will be omitted from the generated code
unless the Pascal-name appears in the expression:  If you ask to
replace
.I i
with
.I i+1,
the variable
.I i
will still be declared but its value will be shifted accordingly.
Note that if
.I i
appears on the lefthand side of an assignment,
.I p2c
will use algebra to "solve" for
.I i.
.IP
In all cases where
.I p2c
parses C expressions, all C operators are recognized except compound
assignments like `+='.  (Increment and decrement operators are allowed.)
All variable and function names are assumed to have integer type, even
if they are names that occur in the actual program.  A type-specification
operator `::' has been introduced; it has the same precedence as `.' or `->'
but the righthand side must be a Pascal type identifier (built-in or defined
by your program previously to when the macro definition was parsed),
or an arbitrary Pascal type expression in parentheses.
The lefthand argument is then
considered to have the specified type.  This may be necessary if your
macro is used in situations where the exact type of the expression
must be known (say, as the argument to a
.IR writeln ).
.TP
.B FieldMacro
Here the lefthand side must have the form
.I record.field,
where
.I record
is the Pascal type or variable name for a record, and
.I field
is a field in that record.  The righthand side must be a C expression
generally including the name
.I record.
All instances of that name are replaced by the actual record being "dotted."
For example,
.IP
\ \ \ \ \ FieldMacro Rect.topLeft = topLeft(Rect)
.IP
translates
.I a[i].topLeft
into
.I topLeft(a[i]),
where
.I a
is an array of
.I Rect.
.TP
.B FuncMacro
The lefthand side must be any Pascal function or procedure name plus a
parameter list.  The number of parameters must match the number in the
function's uses and declaration.  Calls to the function are replaced by the
C expression on the righthand side.  For example,
.IP
\ \ \ \ \ FuncMacro PtInRect(p,r) = PtInRect(p,&r)
.IP
causes the second argument of
.I PtInRect
to be passed by reference, even though the declaration says it's not.
If the function in question is actually defined in the program or module
being translated, the
.B FuncMacro
will not affect the definition but it will affect all calls to the function
elsewhere in the module.
.B FuncMacros
can also be applied to predefined or never-defined functions.
.TP
.B ReplaceBefore
This option specifies a string replacement to be done on every Pascal
source line.  For example:
.IP
\ \ \ \ \ ReplaceBefore "{$ifdef" "{EMBED #ifdef"
\ \ \ \ \ ReplaceBefore "{$endif}" "{EMBED #endif}"
.IP
These lines rewrite Turbo Pascal compile-time conditionals into
comments beginning with the special word EMBED.  This word instructs
p2c to format the rest of the comment without "/* */" delimiters,
i.e., the rest of the comment is embedded directly in the output
C program.  There is also a
.B ReplaceAfter
option, which specifies replacements to be done on the output of
.I p2c.
.IP
Currently, this feature makes only literal string replacements,
not pattern-based matches.  Some users of
.I p2c
have found it useful to feed their Pascal programs through a more
powerful editor like
.I sed
or
.I perl
before giving them to
.I p2c.
Quite often this is all that is necessary to get an acceptable
translation in the face of unrecognized Pascal dialects or
language features.
.TP
.B IncludeFrom
This specifies that a given module's header should be included from a
given place.  The second argument may be surrounded by "\ " or <\ > as
necessary; if the second argument is omitted, no include directive will
be generated for the module.
.TP
.B ImportFrom
This specifies that a given module's Pascal interface text can be found
in the given file.  The named file should be either the source file for
the module, or a specially prepared file with the implementation section
removed for speed.  If no
.B ImportFrom
entry is found for a module, the path defined by the
.B ImportDir
list is searched.  Each entry in the path may contain a
.I %s,
which expands to the name of the module.  The default path looks for
.I %s.pas
and
.I %s.text
in the current directory, then for
.I --HOMEDIR--/%s.imp.
(where --HOMEDIR-- is the
.I p2c
home directory.)
.TP
.B StructFunction
This parameter is a list of functions which follow the
.I p2c
semantics for structure-valued functions (functions returning arrays,
sets, and strings, and structs in primitive C dialects).  For these
functions, a pointer to a return-value area is passed to the function
as a special first parameter.  The function stores the result in this
area, then returns a copy of the pointer.  (The standard C function
.I strcpy
is an example of this concept.
.I Sprintf
also behaves this way in some dialects; it always appears on the
.B StructFunction
list regardless of the type of implementation.)  The system configuration
file includes a list of common structured functions so that
.IR p2c 's
optimizer will know how to manipulate them.