Usenet 1994 January

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume21 / p2c / part32 < prev next >

Wrap

Internet Message Format | 1990-04-05 | 51.3 KB

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