sys.p2crc

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

ThreeSpecialArgs                # arguments are "special".

BreakArith                      # Options string for how to break lines at
                                # arithmetic operators.  One or more of:
                                #   L  Break on left side of operator.
                                #   R  Break on right side of operator.
                                #   H  Same as L, but use "hanging" indent.
                                #   N  No breaking.
                                #  L>R Break either way, L preferred (or R<L).
                                #  R>L Break either way, R preferred (or L<R).
                                #  L=R Break either way equally (or LR).
                                #   A  (with above) Use all-or-none breaking.
                                # Default is R.

BreakRel                        # Same for relational ops (==, <, etc.)

BreakLog                        # Same for logical operators && and ||

BreakDot                        # Same for dot operators . and ->

BreakAssign                     # Same for assignments.

For_AllOrNone                   # 1 or default=all-or-none breaking of the
                                # three clauses of a "for" statement.  0=plain.



# COMMENTS AND BLANK LINES

NoBanner	     		# 1=omit "From input file..." comment
				# 0 or default=put this command at top of file

SlashSlash			# 1=use C++ // for all comments except #define
				# 2=use C++ // even on #define lines
				# 0=use C /* */ for all comments
				# default=1 if C++=1, else 0

EatComments                     # 1=don't copy any comments into C code
                                # 2=don't copy comments inside procedures
                                # 0 or default=keep all comments

SpitComments                    # 1=spit out all comments between procedures
                                # 0 or default=try to attach comments to code

SpitOrphanComments              # 1=spit out comments whose orig stmts are lost
                                # 0 or default=attach orphans to nearby code

CommentAfter                    # 1=assume comments follow statements
                                # 0 or default=assume comments precede stmts
                                # (in case statements are rearranged.)

BlankAfter                      # 1 or default=assume blank lines follow stmts
                                # 0=assume blanks precede statements

MajorSpacing                    # Minimum number of blank lines between major
                                # sections of code, default=2.

MinorSpacing                    # Minimum number of blank lines between minor
                                # sections, default=1.

DeclSpacing                     # Minimum number of blank lines between decls
                                # and function body, default=0 for C++, else 1.

FuncSpacing                     # Minimum number of blank lines between global
                                # functions, default=2.

MinFuncSpacing                  # Minimum number of blank lines separating
                                # sub-procedures, default=1.

EatNotes			# Suppress any notes whose text contains these
EatNotes			# words.  Example: "EatNotes Spam [216]"
EatNotes			# suppresses notes with "Spam" or "[216]".



# SPECIAL COMMENTS

FixedComment      FIXED		# Comment for fixed upper limit of FOR loops:
				#   for i:=1 to N do {FIXED}
				# will suppress use of a FORLIM for N.
				# Case-sensitive; no spaces allowed.

PermanentComment  PERMANENT	# Comment for permanently imported modules,
				# such as "system".

InterfaceComment  INTF-ONLY	# Comment for include files which are to be
				# treated as unit interface text, i.e., are
				# to be read without generating C code.

EmbedComment      EMBED		# Comment for embedded C code in Pascal:
				#   {EMBED
                                #   printf("stuff\n");
                                #   }
				# Use \[ \] for curly braces within embedded
				# code.  May appear in any context where
				# comments are used.

SkipComment       SKIP		# Comment for code to skip in p2c only:
				#   {SKIP} writeln('Not in p2c'); {NOSKIP}
				# {SKIP} ... {NOSKIP} sections can be nested.

NoSkipComment     NOSKIP        # Comment for code to skip except in p2c:
                                #   {NOSKIP writeln('Only in p2c'); }
				# Can be used in if-then-else fashion:
				#   {SKIP} foo; {NOSKIP bar; }
				# {NOSKIP ... } sections can not be nested.

SignedComment     SIGNED        # Type annotation: var c : {SIGNED} char;

UnsignedComment   UNSIGNED      # Type annotation: type uc = {UNSIGNED} char;

TagComment        TAGGED        # Comment for records that need struct tags:
				# var x : record {TAGGED} ... end;



# STYLISTIC OPTIONS

ExtraParens                     # 1=use many parentheses for readability,
                                # 2=use even more parentheses,
                                # 0=use minimal parens,
                                # default=use nice parens

BreakAddParens                  # 1=always add parens for operators broken
                                # across lines.  0=never, default=nice parens

ReturnParens                    # 1=write "return (x)"
                                # 0=write "return x"
                                # default=omit parens for trivial expressions

SpaceExprs                      # 1=use many spaces in expressions,
                                # 0=use minimal spaces in expressions,
                                # default=use nice spacing

SpaceFuncs			# 1=write a space after function name in call
				# 0 or default=no space: f(x)

SpaceCommas			# 1 or default=one space after commas: f(x, y)
				# 0=no space after commas: f(x,y)

ImplicitZero                    # 1=generate "if (x)" rather than "if (x!=0)"
                                # 0=always generate explicit comparisons
                                # default=only with strcmp and other idioms

StarIndex                       # 1=always use "*a"
                                # 0=always use "a[0]"
                                # default=use "*a" only in common idioms

AddIndex                        # 1=always use "a + n"
                                # 0=always use "&a[n]"
                                # default=use "a+n" only in common idioms

StarArrays			# 1 or default=write "f(int *a)" for array a
				# 0=write "f(int a[10])"
				# 2=write "f(int a[])"

StarFunctions                   # 1=write "(*fp)(x,y)" to call thru func ptr
                                # 0=write "fp(x,y)"
                                # default=1 unless AnsiC=1

SpaceStars                      # 1=write "int* x", "int& x".
                                # 2=write "int *x" but "int& x".
                                # 3=write "int* x" but "int &x".
                                # 0 or default=write "int *x", "int &x".

CallCasts			# 1=write "int(x)" type casts.
				# 0=write "(int)x" type casts.
				# default=1 if C++=1, 0 otherwise.

PostIncrement                   # 1 or default=write i++ preferentially
                                # 0=write ++i preferentially

CaseSpacing                     # Number of blank lines between CASE sections,
                                # default=1.

CaseTabs                        # 0 or default=put each CASE on its own line.
                                # Else this is an amount by which to space
                                # cases on same line, either +n or *n in the
                                # style of ConstIndent.

CaseLimit                       # Maximum number of options in a CASE subrange
                                # that will be expanded out in-line; more than
                                # this moves to an "if" in the default clause.
                                # Default=9.

UseCommas                       # 1=use comma operator when convenient
                                # 0=do not use comma operator
                                # default=use comma operator when necessary

UseReturns                      # 1 or default=introduce "return" statements
                                # 0=do not rearrange to use "return"

ReturnLimit                     # Need at least this many statements in an
                                # "if" block before "return" rearrangement;
                                # default=3

UseBreaks                       # 1 or default=introduce "break"/"continue"
                                # 0=do not use "break" and "continue"

BreakLimit                      # Need at least this many statements in an
                                # "if" block before "break" rearrangement;
                                # default=2

ContinueLimit                   # Need at least this many statements in an
                                # "if" block before "continue" rearrangement;
                                # default=5

InfLoopStyle                    # 0 or default=follow the source file
                                # 1=use "for (;;) ..." for all infinite loops
                                # 2=use "while (1) ..."
                                # 3=use "do ... while (1)"

NullChar                        # 1 or default=write '\0' for null character
                                # 0=write 0 for null character constant

HighCharInt                     # 1 or default=write '\200' as 128 and above
                                # 0=write all char consts as characters

AnonymousUnions                 # 1=use C++ anonymous unions for variant recs
                                # 0=use regular C named unions
                                # default=1 if C++=1, 0 otherwise

MixVars                         # 1=mix all vars of same base type: int a,b;
                                # 0=never mix variables: int a; int b;
                                # default=mix only adjacent variables

MixTypes                        # 1=mix all var types: int a,*b,c[5];
                                # 0=never mix variables with different types
                                # default=pointers only: int a,*b; int c[5];

MixFields                       # 1=mix bit-fields just like other vars
                                # 0=only one bit-field per declaration
                                # default=1

MixInits                        # 1=always mix variables with initializers
                                # 0=never mix variables with initializers
                                # default=mix only in pleasing cases

MainLocals                      # 1 or default=make globals local to main if poss
                                # 0=globals are always made global



# CODING OPTIONS

InitialCalls			# Initial function calls (or other brief C
InitialCalls			# statements) to put at front of main program.
InitialCalls			# E.g.: InitialCalls setup_buffer()

ExpandIncludes                  # 1 or default=expand include files into output
                                # 0=convert Pascal include to #include

CollectNest			# 1 or default=collect sub-procs, emit at end.
				# 0=emit sub-procedures one by one; this will
				#   produce bad code but is useful with
				#   ExpandIncludes=0.

ShortCircuit                    # 1=use &&, 0=use & for boolean AND, also OR.
                                # default=1 for Turbo/HP-UX, 0 for HP Pascal
				#   may be overridden by {$B} / $partial_eval$

ShortOpt                        # 1 or default=optimize a&b to a&&b if equiv
                                # 0=always use a&b, depending on ShortCircuit

ElimDeadCode                    # 1 or default=eliminate unreachable code
				# 2=even eliminate "if (false)" statements
                                # 0=leave unreachable code in place

AnalyzeFlow			# 1 or default=perform data flow analysis
				# 0=make no assumptions based on data flow