home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Usenet 1994 October
/
usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso
/
unix
/
volume21
/
p2c
/
part32
< prev
next >
Wrap
Text File
|
1990-04-05
|
53KB
|
1,081 lines
Subject: v21i077: Pascal to C translator, Part32/32
Newsgroups: comp.sources.unix
Approved: rsalz@uunet.UU.NET
X-Checksum-Snefru: 41fb3543 d858cf7e 11271833 f9620960
Submitted-by: Dave Gillespie <daveg@csvax.caltech.edu>
Posting-number: Volume 21, Issue 77
Archive-name: p2c/part32
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 32 (of 32)."
# Contents: src/sys.p2crc.1
# Wrapped by rsalz@litchi.bbn.com on Mon Mar 26 14:29:55 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'src/sys.p2crc.1' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'src/sys.p2crc.1'\"
else
echo shar: Extracting \"'src/sys.p2crc.1'\" \(49793 characters\)
sed "s/^X//" >'src/sys.p2crc.1' <<'END_OF_FILE'
X# Standard configuration file for "p2c" 1.14, the Pascal to C translator
X# Copyright (C) 1989 David Gillespie.
X# Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125.
X
X# This program is free software; you can redistribute it and/or modify
X# it under the terms of the GNU General Public License as published by
X# the Free Software Foundation (any version).
X
X# This program is distributed in the hope that it will be useful,
X# but WITHOUT ANY WARRANTY; without even the implied warranty of
X# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
X# GNU General Public License for more details.
X
X# You should have received a copy of the GNU General Public License
X# along with this program; see the file COPYING. If not, write to
X# the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
X
X
X# Note that all options except "Naming Conventions" and certain library
X# functions may be left blank or omitted entirely; the defaults are intended
X# to encompass a wide variety of "reasonable" implementations of C.
X# Option names are case-insensitive.
X
X# The single-valued options can all be overridden by a later line in
X# this file, or in your own "p2crc" or ".p2crc" file, or in comments
X# in the input file. To override an explicit value with the original
X# default, use the word "def".
X
X# Some options define printf-like format strings. These support all the
X# usual formatting codes, with additional features for string formatting.
X# The following extra "flag" characters are defined for %s:
X# _ Convert to lower case
X# ^ Convert to upper case
X# _^ Convert to lower except capitalize first char and after non-letters
X# ~ Insert '_' between lower case and following upper case letters
X# ! Remove '_' and other non-alphanumeric characters
X# ? Negates _ and ^ flags if name contains mixed case
X# R Remove file name suffix (e.g., "foo.pas" => "foo")
X# / Remove path name (prefix ending in /, \, ], or :)
X# Also, where a format includes several "%" arguments, they may
X# appear in either order in the string. When two string args are
X# involved, "%s" will refer to one and "%S" to the other. The
X# notation %H expands to the p2c home directory name, as in "%H/p2crc".
X
X# Many options simply refine defaults controlled by the Language,
X# AnsiC, and Target options.
X
X
X
X
XDebug # Level of debugging output
X
XTokenTrace # Additional debugging output
X
X
XInclude # Additional p2crc files to be included
XInclude # %s=program name
X
XCopySource # 1=copy Pascal source code into output
X # file, #ifdef'd out.
X
X
X
X
X# INPUT LANGUAGE
X
XLanguage # Known languages:
X # HP (default; Pascal Workstation version)
X # MODCAL (HP's advanced Pascal)
X # HP-UX (almost same as HP)
X # TURBO (vers 5.0 for IBM PC)
X # OREGON (Oregon Software Pascal-2 V2.1)
X # VAX (VAX/VMS Pascal)
X # MODULA (Modula-2)
X # UCSD (almost same as TURBO)
X # MPW (MPW Pascal 2.0 for the Mac)
X # BERK (SUN Berkeley Pascal)
X
XModula2 # 1=Use modula-2 block structure (IF-END)
X # 0=Use Pascal block structure (IF-BEGIN-END)
X # default=1 if Language=MODULA, 0 for others
X
XInteger16 # 1=assume Pascal integers are 16 bits
X # 0=assume Pascal integers are 32 bits
X # 2=use native C "int" for Pascal "integer"
X # default=0 for HP/Oregon/VAX, 1 for Turbo/MPW
X
XDoubleReals # 1=convert Pascal real to C double
X # 0=convert Pascal real to C float
X # default=1 for Turbo and HP-UX, 0 for HP
X
XUnsignedChar # 1=Pascal char must be unsigned
X # 0=Pascal char must be signed
X # 2=doesn't matter; use native C "char"
X # default=unsigned, but use native "char"
X
XNeedSignedByte # 1=use "signed char" even if not available
X # 0 or default=use "short" if not sure
X
XPascalEnumSize # Size in BITS of a Pascal enum type.
X # Default=according to Language.
X
XNestedComments # 1=Pascal comments may be nested
X # 2=comments don't nest, but { must match }
X # 0=comments are unnested, unmatched
X # default=0 in HP/MODCAL, 2 in Turbo
X
XExternWords external # Words analogous to "forward" for declaring
XExternWords extern # procedures or functions external.
XExternWords fortran
X
XCExternWords nonpascal # Words like ExternWords but for which any
XCExternWords # leading and/or trailing "_" is removed
XCExternWords # from the Pascal function/variable names.
X
XImportAll # 1=read all of each imported file, in case
X # file contains several modules/units
X # 0=read only interface text of first module
X # default=1 in HP/MODCAL, 0 in others
X
XImplModules # 1=MODULE starts a block like PROGRAM.
X # 0=MODULEs have export/implement sections.
X
XPascalSignif # Number of significant characters in Pascal
X # identifiers; default=unlimited
X
XPascalCaseSens # 1=Pascal idents are case-sensitive,
X # keywords and predef words are u.c. or l.c.
X # 2=case-sens, keywords and predef words u.c.
X # 3=case-sens, keywords and predef words l.c.
X # 0=not case-sensitive
X # default=2 in Modula-2, otherwise 0
X
XDollarIdents # 1='$' is legal in Pascal and C identifiers
X # 2=convert '$' (and '%') in idents into C '_'
X # 0='$' is for HP directives/Turbo hex consts
X # default=1 for Oregon & VAX Pascal only
X
XIgnoreNonAlpha # 1=ignore _, $, % in Pascal identifiers
X # 0=retain them (subject to DollarIdents)
X # default=1 for UCSD, 0 otherwise
X
XInputTabSize # Number of characters per tab stop in input
X # file, for reading Pascal indentation.
X # Default=8.
X
X
X
X# TARGET LANGUAGE
X
XAnsiC # 1=use all Ansi C features and definitions
X # 2=use GNU C language extensions
X # 0=use only original K&R features
X # default=use "modern" Unix-like C
X
XC++ # 1=use C++ extensions,
X # 0=use straight C,
X # default=generate code that works on either
X
XVoid* # 1=use "void *" for anyptr's
X # 0=use "char *" for anyptr's
X # default=1 if AnsiC=1 or C++=1
X
XHasSignedChar # 1="signed char" and "signed int" are legal
X # 0="signed ..." is not supported
X # default=1 if AnsiC=1
X
XCastNull # 1=must type-cast NULL into specific types
X # 0 or default=don't cast NULL
X
XCopyStructs # 0=no implicit copying of structs allowed
X # 1=can assign but not pass to/from funcs
X # 2=struct assignment and parameters only
X # 3=can assign, pass, and return structs
X # default=3 unless AnsiC=0
X
XVariableArrays # 1=allows variable-length arrays
X # 0=array sizes must be constant
X # default=1 for Gnu C, 0 otherwise
X
XReUseFieldNames # 1=can use same field name in many structs
X # 0=field names must be globally unique
X # default=1
X
XUseVExtern # 1 or default=assume strict ANSI linkage
X # 0=UNIX-like "common" variable linkage
X
XUseAnyptrMacros # 1=use Anyptr, Signed, Static, etc. macros
X # 0=use true C constructs as specified above
X # 2=use Static, Local, Char only
X # default=2 if AnsiC=1, else 1
X
XUsePPMacros # 1=use PP and PV macros for prototypes
X # 0=do not use these macros for prototypes
X # 2=use them only for external/forward
X # default=0 if AnsiC=1, else 2
X
X
X
X# TARGET MACHINE
X
XTarget # machine name, if any. Specify this or answer
X # the following questions to tailor the output
X # program to a particular architecture.
X # Machines known:
X # HPUX-300, SUN-68K, BSD-VAX, BSD, SYSV
X
XSignedChar # 1=char is signed, 0=char is unsigned,
X # default=don't know
X
XSignedField # 1="int" bit-fields in structs are signed,
X # 0="int" bit-fields are unsigned,
X # default=don't know but probably signed
X # 2=don't know, be paranoid
X
XSignedShift # 1=">>" does arithmetic (signed) shift,
X # 0=">>" does logical shift even for ints,
X # default=don't know but probably signed
X # 2=don't know, be paranoid
X
XCharSize # size in bits of a char, default at least 8
XShortSize # size in bits of a short, default at least 16
XIntSize # size in bits of an int, default at least 16
XLongSize # size in bits of a long, default at least 32
XPtrSize # size in bits of a pointer. If not all
X # pointers have same size, must leave blank.
XFloatSize # size in bits of a float
XDoubleSize # size in bits of a double
XEnumSize # size in bits of an enum
X
XSize_T_Long # 1=Ansi "size_t" type is long
X # 0=Ansi "size_t" type is int
X # default=don't know, probably long
X
X
X
X# BRACES AND PLACEMENT OF STATEMENTS
X
XNullStmtLine # 1=put null statements on their own lines,
X # 0 or default=write "while (x) ;"
X
XBracesAlways # 1=use {braces} always,
X # 0=never unless needed,
X # default=use nice braces
X
XBraceLine # 1=always put open braces on a new line,
X # 0=never put open brace on new line if poss,
X # default=0 for sub-stmts, 1 for func bodies
X
XBraceCombine # 1=don't put newline after '{' if possible
X # 0 or default=open brace always ends a line
X
XBraceElse # 1=put { } on both "then" and "else" if would
X # put them on either, default=independent
X
XBraceElseLine # 0 or default=write "} else {"
X # 1=write "}\nelse {", 2=write "} else\n{"
X # 3=write "}\nelse\n{"
X
XElseIf # 1=always write "else if" on same line
X # 0=always write "else\nif"
X # default=use "else if" only when input used it
X
XNewLineFuncs # 1=write "static int\nfoo()" in function defs
X # 0 or default=write "static int foo()"
X
X
X
X# INDENTATION
X
XPhysTabSize # Spacing of tab-character tabs; default=8.
X # 0=do not use tabs in output file.
X
XIndent # Basic indentation delta; default=+2.
X # Indentation deltas specify an amount by which
X # to change indentation; +n or -n specifies a
X # relative adjustment, n specifies an absolute
X # amount of indentation where 0=far left.
X
XBlockIndent # Indentation delta for statements enclosed
X # in braces; applied after Indent. Default=+0.
X
XSwitchIndent # Indentation delta for switch statement body;
X # applied after Indent. Default=+0.
X
XCaseIndent # Indentation delta for case labels; applied
X # after Indent and SwitchIndent. Default=-2.
X
XLabelIndent # Indentation delta for statement labels.
X # Default is 0 (absolute).
X
XOpenBraceIndent # Indentation delta for the open brace that
X # begins a block. Used only if the brace is
X # on its own line. Default=+0.
X
XCloseBraceIndent # Indentation delta for the close brace that
X # ends a block. Default=+0.
X
XFuncArgIndent # Indentation delta for function arguments.
X # Default is 0.
X
XBodyIndent # Indentation delta for the body of a function;
X # applied after Indent. Default=+0.
X
XFuncOpenIndent # Indentation delta for the open brace that
X # begins a function body. Default=+0.
X
XFuncCloseIndent # Indentation delta for the close brace that
X # ends a function body. Default=+0.
X
XStructIndent # Indentation delta for "struct" declarations;
X # applied after Indent. Default=+0.
X
XStructInitIndent # Indentation delta for struct and array
X # initializers; applied after Indent.
X # Default=+0.
X
XExtraInitIndent # Indentation delta for nested struct/array
X # initializers; not combined with Indent.
X # Default=+2.
X
XExtraIndent # Extra indentation for broken lines if
X # indenting by nesting order is too much;
X # default=+2:
X # long_function_name(arguments,
X # more_arguments);
X # 1234
X
XBumpIndent # Extra indentation for subexpressions which
X # coincide with next statement's indentation
X # in a visually confusing way:
X # if (foo &&
X # bar) <- this gets BumpIndent
X # spam();
X # May be pos, neg or zero. Default=+1.
X
XConstIndent # Target column for #defines; default=24.
X # A positive relative value (e.g., +3) means
X # to use that many spaces always rather than
X # tabbing to a fixed column. A value of the
X # form, e.g., *5 means to tab to the next
X # multiple-of-5 column.
X
XCommentIndent # Target column (as in ConstIndent) for
X # comments trailing statements. Another
X # syntax is, e.g., "-80" which means to
X # right-justify comments on an 80-column line.
X # Default=+3.
X
XBraceCommentIndent # Indentation for trailing comments on
X # braces. Default=+2.
X
XDeclCommentIndent # Target column for comments trailing
X # declarations. Default=CommentIndent.
X
XCommentOverIndent # If line is too long to indent nicely by
X # CommentIndent or BraceCommentIndent, start
X # a new line and indent according to this
X # indentation, either n, +n, or -n. Zero means
X # never to start a new line. Default=+4.
X
XMinSpacing # Minimum spacing allowed for things like
X # absolute ConstIndent spacing. Default=2,
X # i.e., ConstIndent will always insert at
X # least two spaces, even on long lines.
X
XMinSpacingThresh # If specified, threshhold below which
X # MinSpacing is used. (Default=MinSpacing.)
X # For example, if MinSpacingThresh=1:
X # foo /*comment*/ (CommentIndent=5 used)
X # spam /*comment*/ (CommentIndent=5 used)
X # thing /*comment*/ (MinSpacing=2 used)
X
X
X
X# LINE BREAKING
X
XLineWidth # Target max output line width; default=78.
X
XMaxLineWidth # Absolute max output line width; default=90.
X
XOverWidePenalty # Penalty for line lengths > LineWidth.
X # Default=25. (Penalties are real numbers.)
X
XOverWideExtraPenalty # Additional penalty multiplied by
X # number-of-chars-too-long squared.
X # Default=1. Total over-wide penalty is
X # OW = max(OWP + N^2*OWEP, 0).
X
XEarlyBreakPenalty # Penalty for breaking at early break-points
X # among those at a given nesting level.
X # Default=1. If N=number of possible break
X # points before this one in this nesting,
X # EB = -N*EBP.
X
XCommaBreakPenalty # Penalty for breaking lines after a comma.
X # Default=10.
X
XCommaBreakExtraPenalty # Additional penalty multiplied by nesting
X # level of (number of parens enclosing) comma.
X # Default=5. Total comma-break penalty is
X # B = max(P + CBP + N*CBEP, 1.0)
X # where
X # P = OW + EB + SIP + IP (defined elsewhere)
X
XSpecialArgBreakPenalty # Penalty for breaking lines after a comma
X # which follows a "special" argument, such
X # as the format string of a printf. Default=5.
X
XOpBreakPenalty # Penalty for breaking at an operator (like +).
X # Analogous to CommaBreakPenalty; default=25.
X
XOpBreakExtraPenalty # Additional penalty multiplied by nesting
X # level of the operator. Default=20.
X
XExHyphenPenalty # Additional penalty for breaking a line just
X # after a minus sign. Default=10. :-)
X
XAssignBreakPenalty # Penalty for breaking at an assignment
X # operator. Default=50.
X
XAssignBreakExtraPenalty # Additional penalty multiplied by nesting
X # level of the assignment. Default=30.
X
XQMarkBreakPenalty # Penalty for breaking lines at the "?" of
X # a "?:" operator. Default=50. (Colons
X # get the regular OpBreakPenalty.)
X
XQMarkBreakExtraPenalty # Additional penalty multiplied by nesting
X # level of the "?:" operator. Default=30.
X
XParenBreakPenalty # Penalty for breaking after an open paren
X # in a function call:
X # long_function_name(
X # very_long_argument);
X # Default=25.
X
XParenBreakExtraPenalty # Additional penalty multiplied by nesting
X # level of the parentheses. Default=10.
X
XMoreBreakPenalty # Adjustment to CommaBreakPenalty, etc.,
X # if it is the second or later break in the
X # same nesting. (E.g., if two or more commas
X # of a function call are broken.) Default=-5.
X
XMoreBreakExtraPenalty # Adjustment to CommaBreakExtraPenalty, etc.,
X # as in MoreBreakPenalty. Default=-3.
X
XWrongSidePenalty # Extra penalty for breaking on the less
X # preferred side of an operator (see BreakArith
X # et al below). Default=10.
X
XExtraIndentPenalty # Penalty for indenting by ExtraIndent instead
X # of according to nesting order. If negative,
X # -EIP is penalty for *not* using ExtraIndent.
X # Default=30.
X
XBumpIndentPenalty # Penalty for using BumpIndent for identation.
X # Default=10.
X
XNoBumpIndentPenalty # Penalty for not using BumpIndent when it
X # ought to have been used. Default=25.
X
XIndentAmountPenalty # Penalty for indentation; for a line indented
X # N spaces (beyond the indentation of the
X # statement as a whole),
X # IP = N*IAP.
X # Default=0.5.
X
XSameIndentPenalty # Penalty for indenting two successive lines
X # the same even though they belong to different
X # nesting levels:
X # foo = x +
X # y *
X # z
X # Default=5.
X
XMaxLineBreakTries # Limit to the number of line breaking
X # alternatives to be tried. Default=5000.
X
XAllOrNoneBreak # List of functions for which arguments must
XAllOrNoneBreak # be written all on one line or all on separate
XAllOrNoneBreak # lines. (A given function may have only one
XAllOrNoneBreak # of this and the following break properties.)
X
XOneSpecialArg printf # List of functions like printf for which the
XOneSpecialArg # first argument is "special", remaining args
XOneSpecialArg # are uniform.
X
XTwoSpecialArgs sprintf # List of functions like fprintf for which the
XTwoSpecialArgs fprintf # first two arguments are "special".
X
XThreeSpecialArgs # List of functions for which the first three
XThreeSpecialArgs # arguments are "special".
X
XBreakArith # Options string for how to break lines at
X # arithmetic operators. One or more of:
X # L Break on left side of operator.
X # R Break on right side of operator.
X # H Same as L, but use "hanging" indent.
X # N No breaking.
X # L>R Break either way, L preferred (or R<L).
X # R>L Break either way, R preferred (or L<R).
X # L=R Break either way equally (or LR).
X # A (with above) Use all-or-none breaking.
X # Default is R.
X
XBreakRel # Same for relational ops (==, <, etc.)
X
XBreakLog # Same for logical operators && and ||
X
XBreakDot # Same for dot operators . and ->
X
XBreakAssign # Same for assignments.
X
XFor_AllOrNone # 1 or default=all-or-none breaking of the
X # three clauses of a "for" statement. 0=plain.
X
X
X
X# COMMENTS AND BLANK LINES
X
XEatComments # 1=don't copy any comments into C code
X # 2=don't copy comments inside procedures
X # 0 or default=keep all comments
X
XSpitComments # 1=spit out all comments between procedures
X # 0 or default=try to attach comments to code
X
XSpitOrphanComments # 1=spit out comments whose orig stmts are lost
X # 0 or default=attach orphans to nearby code
X
XCommentAfter # 1=assume comments follow statements
X # 0 or default=assume comments precede stmts
X # (in case statements are rearranged.)
X
XBlankAfter # 1 or default=assume blank lines follow stmts
X # 0=assume blanks precede statements
X
XMajorSpacing # Minimum number of blank lines between major
X # sections of code, default=2.
X
XMinorSpacing # Minimum number of blank lines between minor
X # sections, default=1.
X
XFuncSpacing # Minimum number of blank lines between global
X # functions, default=2.
X
XMinFuncSpacing # Minimum number of blank lines separating
X # sub-procedures, default=1.
X
XEatNotes # Suppress any notes whose text contains these
XEatNotes # words. Example: "EatNotes Spam [216]"
XEatNotes # suppresses notes with "Spam" or "[216]".
X
X
X
X# SPECIAL COMMENTS
X
XFixedComment FIXED # Comment for fixed upper limit of FOR loops:
X # for i:=1 to N do {FIXED}
X # will suppress use of a FORLIM for N.
X # Case-sensitive; no spaces allowed.
X
XPermanentComment PERMANENT # Comment for permanently imported modules,
X # such as "system".
X
XInterfaceComment INTF-ONLY # Comment for include files which are to be
X # treated as unit interface text, i.e., are
X # to be read without generating C code.
X
XEmbedComment EMBED # Comment for embedded C code in Pascal:
X # {EMBED
X # printf("stuff\n");
X # }
X # Use \[ \] for curly braces within embedded
X # code. May appear in any context where
X # comments are used.
X
XSkipComment SKIP # Comment for code to skip in p2c only:
X # {SKIP} writeln('Not in p2c'); {NOSKIP}
X
XNoSkipComment NOSKIP # Comment for code to skip except in p2c:
X # {NOSKIP writeln('Only in p2c'); }
X # Can be used in if-then-else fashion:
X # {SKIP} foo; {NOSKIP bar; }
X
XSignedComment SIGNED # Type annotation: var c : {SIGNED} char;
X
XUnsignedComment UNSIGNED # Type annotation: type uc = {UNSIGNED} char;
X
X
X
X
X# STYLISTIC OPTIONS
X
XExtraParens # 1=use many parentheses for readability,
X # 2=use even more parentheses,
X # 0=use minimal parens,
X # default=use nice parens
X
XBreakAddParens # 1=always add parens for operators broken
X # across lines. 0=never, default=nice parens
X
XReturnParens # 1=write "return (x)"
X # 0=write "return x"
X # default=omit parens for trivial expressions
X
XSpaceExprs # 1=use many spaces in expressions,
X # 0=use minimal spaces in expressions,
X # default=use nice spacing
X
XImplicitZero # 1=generate "if (x)" rather than "if (x!=0)"
X # 0=always generate explicit comparisons
X # default=only with strcmp and other idioms
X
XStarIndex # 1=always use "*a"
X # 0=always use "a[0]"
X # default=use "*a" only in common idioms
X
XAddIndex # 1=always use "a + n"
X # 0=always use "&a[n]"
X # default=use "a+n" only in common idioms
X
XStarArrays # 1 or default=write "f(int *a)" for array a
X # 0=write "f(int a[10])"
X # 2=write "f(int a[])"
X
XStarFunctions # 1=write "(*fp)(x,y)" to call thru func ptr
X # 0=write "fp(x,y)"
X # default=1 unless AnsiC=1
X
XPostIncrement # 1 or default=write i++ preferentially
X # 0=write ++i preferentially
X
XCaseSpacing # Number of blank lines between CASE sections,
X # default=0.
X
XCaseTabs # 0 or default=put each CASE on its own line.
X # Else this is an amount by which to space
X # cases on same line, either +n or *n in the
X # style of ConstIndent.
X
XCaseLimit # Maximum number of options in a CASE subrange
X # that will be expanded out in-line; more than
X # this moves to an "if" in the default clause.
X # Default=9.
X
XUseCommas # 1=use comma operator when convenient
X # 0=do not use comma operator
X # default=use comma operator when necessary
X
XUseReturns # 1 or default=introduce "return" statements
X # 0=do not rearrange to use "return"
X
XReturnLimit # Need at least this many statements in an
X # "if" block before "return" rearrangement;
X # default=3
X
XUseBreaks # 1 or default=introduce "break"/"continue"
X # 0=do not use "break" and "continue"
X
XBreakLimit # Need at least this many statements in an
X # "if" block before "break" rearrangement;
X # default=2
X
XContinueLimit # Need at least this many statements in an
X # "if" block before "continue" rearrangement;
X # default=5
X
XInfLoopStyle # 0 or default=follow the source file
X # 1=use "for (;;) ..." for all infinite loops
X # 2=use "while (1) ..."
X # 3=use "do ... while (1)"
X
XNullChar # 1 or default=write '\0' for null character
X # 0=write 0 for null character constant
X
XHighCharInt # 1 or default=write '\200' as 128 and above
X # 0=write all char consts as characters
X
XMixVars # 1=mix all vars of same base type: int a,b;
X # 0=never mix variables: int a; int b;
X # default=mix only adjacent variables
X
XMixTypes # 1=mix all var types: int a,*b,c[5];
X # 0=never mix variables with different types
X # default=pointers only: int a,*b; int c[5];
X
XMixFields # 1=mix bit-fields just like other vars
X # 0=only one bit-field per declaration
X # default=1
X
XMixInits # 1=always mix variables with initializers
X # 0=never mix variables with initializers
X # default=mix with-inits with other with-inits
X
XMainLocals # 1 or default=make globals local to main if poss
X # 0=globals are always made global
X
X
X
X# CODING OPTIONS
X
XInitialCalls # Initial function calls (or other brief C
XInitialCalls # statements) to put at front of main program.
XInitialCalls # E.g.: InitialCalls setup_buffer()
X
XExpandIncludes # 1 or default=expand include files into output
X # 0=convert Pascal include to #include
X
XCollectNest # 1 or default=collect sub-procs, emit at end.
X # 0=emit sub-procedures one by one; this will
X # produce bad code but is useful with
X # ExpandIncludes=0.
X
XShortCircuit # 1=use &&, 0=use & for boolean AND, also OR.
X # default=1 for Turbo/HP-UX, 0 for HP Pascal
X # may be overridden by {$B} / $partial_eval$
X
XShortOpt # 1 or default=optimize a&b to a&&b if equiv
X # 0=always use a&b, depending on ShortCircuit
X
XElimDeadCode # 1 or default=eliminate unreachable code
X # 0=leave unreachable code in place
X
XFoldConstants # 1=instantiate non-structure const's in-line
X # (applies to int, char, boolean, enum, real)
X # 0 or default=use #define's for constants
X # 0 causes constant to be completely symbolic;
X # default sometimes instantiates if convenient.
X # A constant is folded if FoldConstants=1
X # either when the const was defined, or when
X # it was referenced.
X
XFoldStrConstants # 1=instantiate string const's in-line, as above
X # 0 or default=use #define's for string const's
X
XUseConsts # 1=use "const" keyword in C
X # 2=use "Const" form even if UseAnyptrMacros=0
X # 0=do not use "const" declarations
X # default=1 if AnsiC=1 or C++=1
X
XUseUndef # 1=use "#undef" when #defines go out of scope
X # 0=do not use "#undef", default=1.
X
XStoreFileNames # 1=store file names associated with file vars
X # 0=let the system record the name
X # default=1 in Turbo Pascal, 0 otherwise.
X
XSqueezeSubr # 1 or default=squeeze subranges into char, etc.
X # 0=use only short's and int's (or long's).
X
XUseEnum # 1=use C "enum" types
X # 0=use integers for enumerations
X # default=1 unless AnsiC=0
X
XSqueezeEnum # 1=use bytes for small enums, when UseEnum=0
X # 0=use shorts always
X # default=0 for HP Pascal, 1 otherwise.
X
XCompEnums # 1=okay to compare enums directly
X # 0=cast enums to ints for comparisons
X # default=0 unless AnsiC=1.
X
XPacking # 1 or default=fully packed records and arrays
X # 0=ignore "packed" keyword
X # 2=pack to bytes, but not bits
X
XPackSigned # 1=implement packed arrays of signed values
X # 0=only pack unsigned arrays
X # default=1
X
XSkipIndices # Number of vacant array indices allowable,
X # default 0. If 1, then array [1..10] is
X # converted to array [11], but array [2..10]
X # would be converted as array [9] with offsets.
X
XOffsetForLoops # 1=adjust loops where index is always used
X # as, e.g., i-1 by offsetting the index.
X # 0=leave them alone. Default=1.
X
XForEvalOrder # 1=in for x:=y to z, force eval of y before z.
X # 0 or default=evaluation order unimportant.
X
XStringLeaders # Number of leading '>' placeholder characters
X # that can be prepended to a string literal.
X # Default is 3.
X
XStringCeiling # Maximum size for strings. Default is 255.
X # If > 255, allows some "slop" in strings.
X # If < 255, shortens large strings.
X
XStringDefault # Size of string declared without [ ] brackets.
X # Default is 255.
X
XStringTruncLimit # Minimum size of strings for which a warning
X # is generated when assigned possibly longer
X # strings. These are assignments to check if
X # Turbo-like truncation is necessary.
X # Default is 80 for Turbo, 0 otherwise.
X
XLongStringSize # Smallest string which can be considered
X # "arbitrarily long"; default=StringCeiling.
X
XKeepNulls # 1=try to preserve null (#0) chars in strings
X # 0 or default=ignore them (but warn)
X
XHighCharBits # 1=convert "ch >= 128" to "(ch & ~127) != 0"
X # 2=convert "ch >= 127" to "(ch & 128) != 0"
X # 0=do not use bit ops for high characters
X # default=1 only if ch's signed-ness is unknown
X
XStaticFunctions # 1 or default=use "static" for private funcs
X # 0=don't create static functions
X
XStaticVariables # 1 or default=use "static" for private vars
X # 0=don't create static global vars
X
XNeedStatic # Names of functions or variables which
X # need to be declared static despite
X # StaticFunctions=0 or StaticVariables=0.
X
XAlwaysCopyValues # 1=always make a local copy of a parameter
X # 0 or default=only if it appears to be changed
X
XVoidArgs # 1=write "f(void)" for funcs with no args
X # 0=write "f()" for funcs with no args
X # default=depends on AnsiC and C++
X
XPrototypes # 1=write "f(int a, int b)"
X # 2=write "f(int, int)" when possible
X # 0=write "f(a, b) \n int a, b;"
X # default=depends of AnsiC and C++
X
XFullPrototyping # 1 or default=use prototypes everywhere
X # 0=use prototypes only for forward/extern
X
XProcPtrPrototypes # 1 or default=use prototypes for C func ptrs
X # 0=always write, e.g., int (*fp)();
X
XCastArgs # 1=include argument casts if needed: (double)i
X # 0=do not include argument casts (dangerous!)
X # default=do not cast if func has a prototype
X
XCastLongArgs # 1=include int/long argument casts if needed
X # 0=do not cast between int and long
X # default=follow CastArgs
X
XPromoteArgs # 1=promote e.g. short to int in prototypes
X # 0=do not promote in prototypes
X # default=only when prototyping forwards only
X
XPromoteEnums # 1=promote enum to int when promoting args
X # 0=leave enums alone in prototypes
X # default=only when UseEnum=0
X
XStaticLinks # 1=use _PROCEDURE (ProcTypeName) for proc ptrs
X # 2=use _PROCEDURE but assume only global procs
X # 0=use C function pointers, no static links
X # default=1 in HP, 0 in Turbo Pascal
X
XVarStrings # 1=full support for "var s:string" params
X # and HP Pascal's strmax function
X # 0=assume all var s:string's are string[255]
X # default=0 always; may need 1 for some
X # HP Pascal programs
X
XVarFiles # 1 or default="var f : file" params use &
X # 0=pass FILE *'s by value; must not open or
X # close the file within the procedure
X
XAddrStdFiles # 1=okay to write "&stdout", etc.
X # 0 or default=not okay
X
XCopyStructFuncs # 1=write "temp = f(); temp.field"
X # 0=write "f().field"
X # default=1 unless AnsiC=1
X
XAtan2 # 1=convert arctan(a/b) to atan2(a,b)
X # 0 or default=convert it to atan(a/b)
X
XBitwiseMod # 1 or default=convert x mod 16 to x&15
X # 0=convert x mod 16 to x%16
X
XBitwiseDiv # 1=convert x div 16 to x>>4
X # 0 or default=convert x div 16 to x/16
X
XAssumeBits # 1=assume args of funcs like na_po2 are
X # within reasonable range; write 1<<x.
X # 0 or default=no assumptions; write na_po2
X
XAssumeSigns # 1 or default=for e.g. na_lsl, assume
X # "x" is positive, "-x" is negative.
X # 0=no assumptions (except for constants!)
X
XAllocZeroNil # 1=na_new(p,0) must set p to nil
X # 0 or default=not necessary
X # 2=not necessary, but print a warning
X
XPrintfOnly # 1=don't use puts, putc, etc., in WRITE
X # 0=use puts, etc., as well as printf
X # default=a pleasing compromise
X
XMixWritelns # 1 or default=writeln;writeln=>printf("\n\n")
X # 0=don't mix consecutive writeln stmts
X
XIntegerWidth # Default field width for writing integers.
X # Default is 1 for Turbo, 12 for HP.
X
XRealWidth # Default field width for writing reals.
X # Default is 12.
X
XFormatStrings # 1=full support for write(string:width)
X # 0 or default=':width' only stretches
X
XWhileFgets # 1 or default=while (fgets(...)) { ... }
X # 0=while (!eof(...)) { fgets(...); ... }
X
XUseGets # 1 or default=use gets to read string[255]
X # 0=always use fgets (with length checking)
X
XNewLineSpace # 1=convert \n to ' ' in read(ch)
X # 0=leave newlines alone reading characters
X # default=0 in Turbo Pascal, 1 otherwise
X
XBuildReads # 1=combine x:=f^;get(f) into read(f,x)
X # 2=only for text files and files of char
X # 0=leave it alone; default=1
X
XBuildWrites # 1=combine f^:=x;put(f) into write(f,x)
X # 2=only for text files and files of char
X # 0=leave it alone; default=1
X
XBinaryMode # 1 or default=fopen binary files as, say, "rb"
X # 0=fopen binary files as "r"
X # 2=fopen binary files as "r" with a warning
X
XReadWriteOpen # 1=RESET/REWRITE open binary files read/write
X # 0=RESET opens read-only, REWRITE write-only
X # 2=Open all files (text and binary) read/write
X # default=1 in Turbo, 0 otherwise.
X
XOpenMode # fopen mode string to use for Pascal open
X # statement. Use a+ if that mode allows
X # seeking. Default=build out of ANSI modes
X
XFileNameFilter # Name of a function to call which converts
X # a file name into a form usable by fopen;
X # if name must be changed this should return
X # a pointer to a static buffer.
X # Not used for constant names. "0"=no filter.
X # default=P_trimname for Oregon/Berk, else 0
X
XLiteralFiles # 0=nameless rewrite(f) generates a temp file
X # 1=nameless rewrite(f) uses "f" as file name
X # 2=like 1 only if f appeared in "program" stmt
X # default=2 for Berkeley, else 0.
X
XLiteralFile # A file variable which should be treated as
XLiteralFile # if LiteralFiles=1. If LiteralFiles=2, files
XLiteralFile # in program header are added to this list.
X
XFullStrWrite # 1=full implementation of strwrite(s,i,j,...)
X # 0=ignore "j" variable and other issues
X # default=assign "j", assume not mid-string
X # 2=like default, but issue a warning
X
XFullStrRead # 1 or default=full impl of strread using "%n"
X # 0=fake the value of "j"
X # 2=like default, but issue a warning
X
XSetBits # Number of bits to use in each "long" of a set
X # default=LongSize if defined, else 32
X
XDefaultSetSize # Default size of un-typed set constants;
X # default default=256 for VAX, else 8192
X
XSmallSetConst # 0=write small-set literals like "1<<2|1<<4"
X # 1=write them like "0x14"
X # 2=write them like "20"
X # -1=do not use small-sets at all
X # default=-1 if SetBitsName defined, else 1
X
XBigSetConst # (analogous to SmallSetConst for big sets)
X
XLeLeRange # 1=write "j in [1..10]" as "1<=j && j<=10"
X # 0 or default=write ... as "j>=1 && j<=10"
X
XUnsignedTrick # 1 or default=write "(unsigned)i <= 10"
X # 0=leave "i >= 0 && i <= 10" alone
X
XUseIsAlpha # 1 or default=use "isalpha", "isdigit", etc.
X # 0=use plain comparisons
X
XUseIsSpace # 1=convert "c==' '" to "isspace(c)"
X # 0 or default=leave it alone
X
XUseStrncmp # 1=use strncmp to compare packed array of char
X # 0=use memcmp, same as for all other arrays
X # default=1
X
X
X
X# NAMING CONVENTIONS
X
XCodeFileName %Rs.c # Name of .c output file for a program,
X # %s=input file name.
X
XModuleFileName %_S.c # Name of .c output file for a module,
X # %s=input file name, %S=module name.
X
XHeaderFileName %_S.h # Name of .h output file for a module,
X # %s=input file name, %S=module name.
X
XHeaderFileName2 # If defined, different format to use when
X # generating #include's, otherwise same.
X # May be quoted as in IncludeFrom.
X
XLogFileName %RS.log # Name of log file name for -V mode.
X # %s=input file name, %S=output file name.
X
XIncludeFileName # Format for translating Pascal include-file
X # names.
X
XSymCase # 1 or default=preserve case of Pascal idents,
X # 0=convert all Pascal idents to lower case
X
XSymbolFormat # Format for C identifiers derived from
X # Pascal ones; default=%s. The following
X # specific formats override this one.
X # %s=original Pascal identifier,
END_OF_FILE
if test 49793 -ne `wc -c <'src/sys.p2crc.1'`; then
echo shar: \"'src/sys.p2crc.1'\" unpacked with wrong size!
fi
# end of 'src/sys.p2crc.1'
fi
echo shar: End of archive 32 \(of 32\).
cp /dev/null ark32isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 32 archives.
echo "Now see PACKNOTES and the README"
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
