| /* "p2c", a Pascal to C translator, version 1.20. |
| Copyright (C) 1989, 1990, 1991 Free Software Foundation. |
| Author: Dave Gillespie. |
| Author's address: daveg@csvax.caltech.edu; 256-80 Caltech/Pasadena CA 91125. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation (any version). |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; see the file COPYING. If not, write to |
| the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| |
| |
| |
| |
| #ifdef __STDC__ |
| # define PP(x) x /* use true prototypes */ |
| # define PV() (void) |
| # define Anyptr void |
| # define __CAT__(a,b)a##b |
| #else |
| # define PP(x) () /* use old-style declarations */ |
| # define PV() () |
| # define Anyptr char |
| # define __ID__(a)a |
| # define __CAT__(a,b)__ID__(a)b |
| #endif |
| |
| #define Static /* For debugging purposes */ |
| |
| |
| |
| #include <stdio.h> |
| |
| |
| /* If the following heuristic fails, compile -DBSD=0 for non-BSD systems, |
| or -DBSD=1 for BSD systems. */ |
| |
| #ifdef M_XENIX |
| # define BSD 0 |
| #endif |
| |
| #ifdef FILE /* a #define in BSD, a typedef in SYSV (hp-ux, at least) */ |
| # ifndef BSD |
| # define BSD 1 |
| # endif |
| #endif |
| |
| #ifdef BSD |
| # if !BSD |
| # undef BSD |
| # endif |
| #endif |
| |
| |
| #ifdef __STDC__ |
| /* # include <stddef.h> */ |
| # include <stdlib.h> |
| # include <limits.h> |
| #else |
| # ifndef BSD |
| # include <malloc.h> |
| # include <memory.h> |
| # include <values.h> |
| # endif |
| # define EXIT_SUCCESS 0 |
| # define EXIT_FAILURE 1 |
| # define CHAR_BIT 8 |
| # define LONG_MAX (((unsigned long)~0L) >> 1) |
| # define LONG_MIN (- LONG_MAX - 1) |
| #endif |
| |
| |
| |
| #if defined(BSD) && !defined(__STDC__) |
| # include <strings.h> |
| # define memcpy(a,b,n) bcopy(b,a,n) |
| # define memcmp(a,b,n) bcmp(a,b,n) |
| char *malloc(), *realloc(); |
| #else |
| # include <string.h> |
| #endif |
| |
| #include <ctype.h> |
| |
| |
| #ifdef __GNUC__ /* Fast, in-line version of strcmp */ |
| # define strcmp(a,b) ({ char *_aa = (a), *_bb = (b); int _diff; \ |
| for (;;) { \ |
| if (!*_aa && !*_bb) { _diff = 0; break; } \ |
| if (*_aa++ != *_bb++) \ |
| { _diff = _aa[-1] - _bb[-1]; break; } \ |
| } _diff; }) |
| #endif |
| |
| |
| #if defined(HASDUMPS) && defined(define_globals) |
| # define DEFDUMPS |
| #endif |
| |
| |
| |
| /* Constants */ |
| |
| #undef MININT /* we want the Pascal definitions, not the local C definitions */ |
| #undef MAXINT |
| |
| #define MININT 0x80000000 |
| #define MAXINT 0x7fffffff |
| |
| |
| #ifndef EXIT_SUCCESS |
| # define EXIT_SUCCESS 0 |
| # define EXIT_FAILURE 1 |
| #endif |
| |
| |
| #ifndef P2C_HOME |
| # ifdef citPWS |
| # define P2C_HOME "/lib/p2c" |
| # else |
| # define P2C_HOME "/usr/local/p2c" /* sounds reasonable... */ |
| # endif |
| #endif |
| |
| #ifdef define_globals |
| char *p2c_home = P2C_HOME; |
| #else |
| extern char *p2c_home; |
| #endif |
| |
| #define P2C_VERSION "1.20" |
| |
| |
| |
| |
| /* Types */ |
| |
| #ifdef __STDC__ |
| typedef void *anyptr; |
| #else |
| typedef char *anyptr; |
| #endif |
| |
| typedef unsigned char uchar; |
| |
| |
| |
| /* Ought to rearrange token assignments at the next full re-compile */ |
| |
| typedef enum E_token { |
| TOK_NONE, |
| |
| /* reserved words */ |
| TOK_AND, TOK_ARRAY, TOK_BEGIN, TOK_CASE, TOK_CONST, |
| TOK_DIV, TOK_DO, TOK_DOWNTO, TOK_ELSE, TOK_END, |
| TOK_FILE, TOK_FOR, TOK_FUNCTION, TOK_GOTO, TOK_IF, |
| TOK_IN, TOK_LABEL, TOK_MOD, TOK_NIL, TOK_NOT, |
| TOK_OF, TOK_OR, TOK_PACKED, TOK_PROCEDURE, TOK_PROGRAM, |
| TOK_RECORD, TOK_REPEAT, TOK_SET, TOK_THEN, TOK_TO, |
| TOK_TYPE, TOK_UNTIL, TOK_VAR, TOK_WHILE, TOK_WITH, |
| |
| /* symbols */ |
| TOK_DOLLAR, TOK_STRLIT, TOK_LPAR, TOK_RPAR, TOK_STAR, |
| TOK_PLUS, TOK_COMMA, TOK_MINUS, TOK_DOT, TOK_DOTS, |
| TOK_SLASH, TOK_INTLIT, TOK_REALLIT, TOK_COLON, TOK_ASSIGN, |
| TOK_SEMI, TOK_NE, TOK_LT, TOK_GT, TOK_LE, TOK_GE, |
| TOK_EQ, TOK_LBR, TOK_RBR, TOK_HAT, |
| TOK_INCLUDE, TOK_ENDIF, |
| TOK_IDENT, TOK_MININT, TOK_EOF, |
| |
| /* C symbols */ |
| TOK_ARROW, TOK_AMP, TOK_VBAR, TOK_BANG, |
| TOK_TWIDDLE, TOK_PERC, TOK_QM, |
| TOK_LTLT, TOK_GTGT, TOK_EQEQ, TOK_BANGEQ, |
| TOK_PLPL, TOK_MIMI, TOK_ANDAND, TOK_OROR, |
| TOK_LBRACE, TOK_RBRACE, TOK_CHARLIT, |
| |
| /* HP Pascal tokens */ |
| TOK_ANYVAR, TOK_EXPORT, TOK_IMPLEMENT, TOK_IMPORT, TOK_MODULE, |
| TOK_OTHERWISE, TOK_RECOVER, TOK_TRY, |
| |
| /* Turbo Pascal tokens */ |
| TOK_SHL, TOK_SHR, TOK_XOR, TOK_INLINE, TOK_ABSOLUTE, |
| TOK_INTERRUPT, TOK_ADDR, TOK_HEXLIT, |
| |
| /* Oregon Software Pascal tokens */ |
| TOK_ORIGIN, TOK_INTFONLY, |
| |
| /* VAX Pascal tokens */ |
| TOK_REM, TOK_VALUE, TOK_VARYING, TOK_OCTLIT, TOK_COLONCOLON, |
| TOK_STARSTAR, |
| |
| /* Modula-2 tokens */ |
| TOK_BY, TOK_DEFINITION, TOK_ELSIF, TOK_FROM, TOK_LOOP, |
| TOK_POINTER, TOK_QUALIFIED, TOK_RETURN, |
| |
| /* UCSD Pascal tokens */ |
| TOK_SEGMENT, |
| |
| TOK_LAST |
| } Token; |
| |
| #ifdef define_globals |
| char *toknames[(int)TOK_LAST] = { "", |
| "AND", "ARRAY", "BEGIN", "CASE", "CONST", |
| "DIV", "DO", "DOWNTO", "ELSE", "END", |
| "FILE", "FOR", "FUNCTION", "GOTO", "IF", |
| "IN", "LABEL", "MOD", "NIL", "NOT", |
| "OF", "OR", "PACKED", "PROCEDURE", "PROGRAM", |
| "RECORD", "REPEAT", "SET", "THEN", "TO", |
| "TYPE", "UNTIL", "VAR", "WHILE", "WITH", |
| |
| "a '$'", "a string literal", "a '('", "a ')'", "a '*'", |
| "a '+'", "a comma", "a '-'", "a '.'", "'..'", |
| "a '/'", "an integer", "a real number", "a colon", "a ':='", |
| "a semicolon", "a '<>'", "a '<'", "a '>'", "a '<='", "a '>='", |
| "an '='", "a '['", "a ']'", "a '^'", |
| "an \"include\" file", "$end$", |
| "an identifier", "an integer", "end of file", |
| |
| "an '->'", "an '&'", "a '|'", "a '!'", |
| "a '~'", "a '%'", "a '?'", |
| "a '<<'", "a '>>'", "a '=='", "a '!='", |
| "a '++'", "a '--'", "a '&&'", "a '||'", |
| "a '{'", "a '}'", "a character literal", |
| |
| "ANYVAR", "EXPORT", "IMPLEMENT", "IMPORT", "MODULE", |
| "OTHERWISE", "RECOVER", "TRY", |
| |
| "SHL", "SHR", "XOR", "INLINE", "ABSOLUTE", |
| "INTERRUPT", "an '@'", "a hex integer", |
| |
| "ORIGIN", "INTF-ONLY", |
| |
| "REM", "VALUE", "VARYING", "an octal integer", "a '::'", |
| "a '**'", |
| |
| "BY", "DEFINITION", "ELSIF", "FROM", "LOOP", |
| "POINTER", "QUALIFIED", "RETURN", |
| |
| "SEGMENT" |
| } ; |
| #else |
| extern char *toknames[]; |
| #endif /*define_globals*/ |
| |
| typedef struct S_strlist { |
| struct S_strlist *next; |
| long value; |
| char s[1]; |
| } Strlist; |
| |
| |
| |
| typedef struct S_value { |
| struct S_type *type; |
| long i; |
| char *s; |
| } Value; |
| |
| |
| |
| /* "Symbol" notes: |
| * |
| * The symbol table is used for several things. Mainly it records all |
| * identifiers in the Pascal program (normally converted to upper case). |
| * Also used for recording certain properties about C and Pascal names. |
| * |
| * The symbol table is a hash table of binary trees. |
| */ |
| |
| #define AVOIDNAME 0x1 /* Avoid this name in C code */ |
| #define WARNNAME 0x2 /* Warn if using this name in C code */ |
| #define AVOIDGLOB 0x4 /* Avoid C name except private to module */ |
| #define NOSIDEEFF 0x8 /* Function by this name has no side effects */ |
| #define STRUCTF 0x10 /* Function by this name is a StructFunction */ |
| #define STRLAPF 0x20 /* Function by this name is a StrlapFunction */ |
| #define LEAVEALONE 0x40 /* Do not use custom handler for function */ |
| #define DETERMF 0x80 /* Function by this name is Deterministic */ |
| #define FMACREC 0x100 /* Used by FieldMacro stuff */ |
| #define AVOIDFIELD 0x200 /* Avoid this name as a struct field name */ |
| #define NEEDSTATIC 0x400 /* This name must be declared static */ |
| #define KWPOSS 0x800 /* This word may be a keyword */ |
| #define FUNCBREAK 0x7000 /* Line breaking flags (see sys.p2crc) */ |
| # define FALLBREAK 0x1000 /* Break at all commas if at any */ |
| # define FSPCARG1 0x2000 /* First argument is special */ |
| # define FSPCARG2 0x3000 /* First two arguments are special */ |
| # define FSPCARG3 0x4000 /* First three arguments are special */ |
| #define WARNLIBR 0x8000 /* Warn for all uses of this library function */ |
| #define FWDPARAM 0x10000 /* Was a param name for forward-declared func */ |
| #define SSYNONYM 0x20000 /* Symbol is a synonym for another */ |
| |
| typedef struct S_symbol { |
| struct S_symbol *left; /* Left pointer in binary tree */ |
| struct S_symbol *right; /* Right pointer in binary tree */ |
| struct S_meaning *mbase; /* First normal meaning for this symbol */ |
| struct S_meaning *fbase; /* First record-field meaning for this symbol */ |
| Strlist *symbolnames; /* List of NameOf's for this name */ |
| long flags; /* (above) */ |
| Token kwtok; /* Token, if symbol is a keyword */ |
| char name[1]; /* Pascal name (actually variable-sized) */ |
| } Symbol; |
| |
| |
| |
| /* "Meaning" notes: |
| * |
| * This represents one meaning of a symbol (see below). Meanings are |
| * organized in a tree of contexts (i.e., scopes), and also in linked |
| * lists of meanings per symbol. Fields described in the following are |
| * undefined for kinds where they are not listed. Other fields are |
| * defined in all kinds of meanings. |
| * |
| * MK_MODULE: Program, module, or unit. |
| * mp->anyvarflag = 1 if main program, 0 if module. |
| * mp->cbase => First meaning in module's context. |
| * |
| * MK_CONST: Pascal CONST. |
| * mp->type => Type of constant, same as mp->constdefn->type & mp->val.type. |
| * mp->anyvarflag = 1 if FoldConstants was true when defined. |
| * mp->constdefn => Expression for the value of the constant. |
| * mp->val = Value of the const, if can be evaluated, else val.type is NULL. |
| * mp->xnext => Next constant in enumeration, else NULL. |
| * mp->isreturn = 1 if constant was declared as a macro (with #define). |
| * |
| * MK_TYPE: Pascal type name. |
| * mp->type => Type which name represents. |
| * |
| * MK_VAR: Normal variable. |
| * mp->type => Type of variable. |
| * mp->constdefn => Initializer for variable, else NULL. |
| * mp->varstructflag = 1 if variable is in parent function's varstruct. |
| * mp->isforward = 1 if should be declared static. |
| * mp->isfunction = 1 if should be declared extern. |
| * mp->namedfile = 1 if this file variable has a shadow file-name variable. |
| * mp->bufferedfile = 1 if this file variable has a shadow buffer variable. |
| * mp->val.s => name format string if temporary var, else NULL. |
| * |
| * MK_VARREF: Variable always referenced through a pointer. |
| * mp->type => Type "pointer to T" where T is type of variable. |
| * mp->constdefn => Initializer for the pointer, else NULL. |
| * (Others same as for MK_VAR.) |
| * |
| * MK_VARMAC: Variable which has a VarMacro. |
| * mp->type => Type of variable. |
| * mp->constdefn => Expression for VarMacro definition. |
| * (Others same as for MK_VAR.) |
| * |
| * MK_SPVAR: Special variable. |
| * mp->handler => C function to parse and translate the special variable. |
| * |
| * MK_FIELD: Record/struct field name. |
| * mp->ctx, cbase = unused (unlike other meanings). |
| * mp->cnext => Next field in record or variant. |
| * mp->type => Type of field (base type if a bit-field). |
| * mp->rectype => Type of containing record. |
| * mp->constdefn => Expression for definition if FieldMacro, else NULL. |
| * mp->val.i = Number of bits if bit-field, or 0 if normal field. |
| * mp->val.type => True type of bit-field, else same as mp->type. |
| * mp->isforward = 1 if tag field for following variant, else 0. |
| * mp->namedfile = 1 if this file field has a shadow file-name field. |
| * mp->bufferedfile = 1 if this file field has a shadow buffer field. |
| * |
| * MK_VARIANT: Header for variant record case. |
| * mp->ctx => First field in variant (unlike other meanings). |
| * mp->cbase = unused (unlike other meanings). |
| * mp->cnext => Next variant in record (or next sub-variant in variant). |
| * mp->rectype => Type of containing record. |
| * mp->val = Tag value of variant. |
| * |
| * MK_LABEL: Statement label. |
| * mp->val.i => Case number if used by non-local gotos, else -1. |
| * mp->xnext => MK_VAR representing associated jmp_buf variable. |
| * (All optional fields are unused.) |
| * |
| * MK_FUNCTION: Procedure or function. |
| * mp->type => TK_FUNCTION type. |
| * mp->cbase => First meaning in procedure's context (when isfunction is 1, |
| * this will always be the return-value meaning.) |
| * mp->val.i => Body of the function (cast to Stmt *). |
| * mp->constdefn => Expression for definition if FuncMacro, else NULL. |
| * mp->handler => C function to adjust parse tree if predefined, else NULL. |
| * mp->isfunction = 1 if function, 0 if procedure. |
| * mp->isforward = 1 if function has been declared forward. |
| * mp->varstructflag = 1 if function has a varstruct. |
| * mp->needvarstruct = 1 if no varstruct yet but may need one. |
| * mp->namedfile = 1 if function should be declared "inline". |
| * |
| * MK_SPECIAL: Special, irregular built-in function. |
| * mp->handler => C function to parse and translate the special function. |
| * mp->constdefn => Expression for definition if FuncMacro, else NULL. |
| * mp->isfunction = 1 if function, 0 if procedure. |
| * |
| * MK_PARAM: Procedure or function parameter, or function return value. |
| * mp->type => Type of parameter. |
| * mp->isreturn = 1 if a function return value (not on parameter list). |
| * mp->xnext => Next parameter of function. |
| * mp->fakeparam = 1 if a fake parameter (e.g., conformant array size). |
| * mp->othername => Name of true param if this one is a local copy. |
| * mp->rectype => Type of true param if this one is a local copy. |
| * If a normal copy param, will be "pointer to" mp->type. |
| * If copied for varstruct reasons, will be same as mp->type. |
| * mp->varstructflag = 1 if variable is in parent function's varstruct. |
| * |
| * MK_VARPARAM: VAR parameter, or StructFunction return value. |
| * mp->type => Type "pointer to T" where T is type of parameter. |
| * mp->anyvarflag = 1 if no type checking is to be applied to parameter. |
| * mp->isreturn = 1 if a StructFunction return value (will be first param). |
| * (Others same as for MK_PARAM.) |
| * |
| * MK_VARPARAM with mp->type == tp_anyptr: Turbo "typeless var" parameter. |
| * mp->type = tp_anyptr. |
| * mp->anyvarflag = 1. |
| * (Others same as for MK_PARAM.) |
| * |
| * MK_VARPARAM with mp->type == tp_strptr: HP Pascal "var s:string" parameter. |
| * mp->type = tp_strptr. |
| * mp->anyvarflag = 1 if a separate "strmax" parameter is passed. |
| * (Others same as for MK_PARAM.) |
| * |
| * MK_SYNONYM: Meaning which should be treated as identical to another. |
| * mp->xnext => Actual meaning to be used. |
| * |
| */ |
| |
| enum meaningkind { |
| MK_NONE, MK_SPECIAL, |
| MK_MODULE, MK_FUNCTION, MK_CONST, MK_VAR, MK_TYPE, |
| MK_FIELD, MK_LABEL, MK_VARIANT, |
| MK_PARAM, MK_VARPARAM, MK_VARREF, MK_VARMAC, |
| MK_SPVAR, MK_SYNONYM, |
| MK_LAST |
| } ; |
| |
| #ifdef DEFDUMPS |
| char *meaningkindnames[(int)MK_LAST] = { |
| "MK_NONE", "MK_SPECIAL", |
| "MK_MODULE", "MK_FUNCTION", "MK_CONST", "MK_VAR", "MK_TYPE", |
| "MK_FIELD", "MK_LABEL", "MK_VARIANT", |
| "MK_PARAM", "MK_VARPARAM", "MK_VARREF", "MK_VARMAC", |
| "MK_SPVAR", "MK_SYNONYM" |
| } ; |
| #endif /*DEFDUMPS*/ |
| |
| typedef struct S_meaning { |
| struct S_meaning *snext; /* Next meaning for this symbol */ |
| struct S_meaning *cnext; /* Next meaning in this meaning's context */ |
| struct S_meaning *cbase; /* First meaning in this context */ |
| struct S_meaning *ctx; /* Context of this meaning */ |
| struct S_meaning *xnext; /* (above) */ |
| struct S_meaning *dtype; /* Declared type name, if any */ |
| struct S_symbol *sym; /* Symbol of which this is a meaning */ |
| struct S_type *type; /* (above) */ |
| struct S_type *rectype; /* (above) */ |
| struct S_expr *constdefn; /* (above) */ |
| enum meaningkind kind; /* Kind of meaning */ |
| unsigned needvarstruct:1, /* (above) */ |
| varstructflag:1, /* (above) */ |
| wasdeclared:1, /* Declaration has been written for meaning */ |
| istemporary:1, /* Is a temporary variable */ |
| isforward:1, /* (above) */ |
| isfunction:1, /* (above) */ |
| anyvarflag:1, /* (above) */ |
| isactive:1, /* Meaning is currently in scope */ |
| exported:1, /* Meaning is visible outside this module */ |
| warnifused:1, /* WarnNames was 1 when meaning was declared */ |
| dumped:1, /* Has been dumped (for debugging) */ |
| isreturn:1, /* (above) */ |
| fakeparam:1, /* (above) */ |
| namedfile:1, /* (above) */ |
| bufferedfile:1, /* (above) */ |
| volatilequal:1, /* Object has C "volatile" qualifier */ |
| constqual:1, /* Object has C "const" qualifier */ |
| dummy17:1, dummy18:1, dummy19:1, |
| dummy20:1, dummy21:1, dummy22:1, dummy23:1, dummy24:1, dummy25:1, |
| dummy26:1, dummy27:1, dummy28:1, dummy29:1, dummy30:1, dummy31:1; |
| Value val; /* (above) */ |
| int refcount; /* Number of references to meaning in program */ |
| char *name; /* Print name (i.e., C name) of the meaning */ |
| char *othername; /* (above) */ |
| struct S_expr *(*handler)(); /* Custom translator for procedure */ |
| Strlist *comments; /* Comments associated with meaning */ |
| } Meaning; |
| |
| |
| |
| /* "Type" notes: |
| * |
| * This struct represents a data type. Types are stored in a strange |
| * cross between Pascal and C semantics. (This usually works out okay.) |
| * |
| * TK_INTEGER: Base integer type. |
| * The following types are TK_INTEGER: |
| * tp_integer, tp_unsigned, tp_int, tp_uint, tp_sint. |
| * All other integer types are represented by subranges. |
| * tp->smin => Minimum value for integer. |
| * tp->smax => Maximum value for integer. |
| * |
| * TK_CHAR: Base character type. |
| * The following types are TK_CHAR: tp_char, tp_schar, tp_uchar. |
| * All other character types are represented by subranges. |
| * tp->smin => Minimum value for character. |
| * tp->smax => Maximum value for character. |
| * |
| * TK_BOOLEAN: Boolean type. |
| * The only TK_BOOLEAN type is tp_boolean. |
| * tp->smin => "False" expression. |
| * tp->smax => "True" expression. |
| * |
| * TK_REAL: Real types. |
| * The only TK_REAL types are tp_real, tp_longreal, and/or the SINGLE type. |
| * |
| * TK_VOID: C "void" type. |
| * The only TK_VOID type is tp_void. |
| * |
| * TK_SUBR: Subrange of ordinal type. |
| * tp->basetype => a TK_INTEGER, TK_CHAR, TK_BOOLEAN, or TK_ENUM type. |
| * tp->smin => Minimum ordinal value for subrange. |
| * tp->smax => Maximum ordinal value for subrange. |
| * |
| * TK_ENUM: Enumerated type. |
| * tp->fbase => First enumeration constant. |
| * tp->smin => Minimum value (zero). |
| * tp->smax => Maximum value (number of choices minus 1). |
| * |
| * TK_POINTER: Pointer type. |
| * tp->basetype => Base type of pointer. |
| * tp->smin => EK_NAME for type if not-yet-resolved forward; else NULL. |
| * tp->fbase => Actual type name for tp->basetype, or NULL. |
| * Only one pointer type is ever generated for a given other type; |
| * each tp->pointertype points back to that type if it has been generated. |
| * |
| * TK_STRING: Pascal string or VARYING OF CHAR type. |
| * tp->basetype => tp_char. |
| * tp->indextype => TK_SUBR from 0 to maximum string length. |
| * tp->structdefd = 1 if type is for a conformant VARYING OF CHAR parameter. |
| * |
| * TK_RECORD: Pascal record/C struct type. |
| * tp->fbase => First field in record. |
| * tp->structdefd = 1 if struct type has been declared in output. |
| * |
| * TK_ARRAY with smax == NULL: Normal array type. |
| * tp->basetype => Element type of array. |
| * tp->indextype => Index type (usually a TK_SUBR). |
| * tp->smin => Integer constant if SkipIndices was used, else NULL. |
| * tp->smax = NULL. |
| * tp->structdefd = 1 if type is for a conformant array parameter. |
| * tp->fbase => Actual type name for tp->basetype, or NULL. |
| * |
| * TK_ARRAY with smax != NULL: Large packed array type. |
| * tp->basetype => Element type of C array (tp_ubyte/tp_sbyte/tp_sshort). |
| * tp->indextype => Index type (usually a TK_SUBR). |
| * tp->smin => Integer constant if SkipIndices was used, else NULL. |
| * tp->smax => EK_TYPENAME for element type of Pascal array. |
| * tp->escale = log-base-two of number of bits per packed element, else 0. |
| * tp->issigned = 1 if packed array elements are signed, 0 if unsigned. |
| * tp->structdefd = 1 if type is for a conformant array parameter. |
| * tp->fbase => Actual type name for tp->basetype, or NULL. |
| * |
| * TK_SMALLARRAY: Packed array fitting within a single integer. |
| * (Same as for packed TK_ARRAY.) |
| * |
| * TK_SET: Normal set type. |
| * tp->basetype => tp_integer. |
| * tp->indextype => Element type of the set. |
| * |
| * TK_SMALLSET: Set fitting within a single integer. |
| * (Same as for TK_SET.) |
| * |
| * TK_FILE: File type (corresponds to C "FILE" type). |
| * tp->basetype => Type of file elements, or tp_abyte if UCSD untyped file. |
| * A Pascal "file" variable is represented as a TK_POINTER to a TK_FILE. |
| * |
| * TK_BIGFILE: File type with attached buffers and name. |
| * tp->basetype => Type of file elements, or tp_abyte if UCSD untyped file. |
| * A Pascal "file" variable is represented directly as a TK_BIGFILE. |
| * |
| * TK_FUNCTION: Procedure or procedure-pointer type. |
| * tp->basetype => Return type of function, or tp_void if procedure. |
| * tp->issigned = 1 if type has a generic static link. |
| * tp->fbase => First argument (or StructFunction return buffer pointer). |
| * |
| * TK_PROCPTR: Procedure pointer with static link. |
| * tp->basetype => TK_FUNCTION type. |
| * tp->fbase => Internal Meaning struct associated with basetype. |
| * tp->escale = Value of StaticLinks when type was declared. |
| * |
| * TK_CPROCPTR: Procedure pointer without static link. |
| * tp->basetype => TK_FUNCTION type. |
| * tp->fbase => Internal Meaning struct associated with basetype. |
| * tp->escale = Value of StaticLinks = 0. |
| * |
| * TK_SPECIAL: Special strange data type. |
| * Only TK_SPECIAL type at present is tp_jmp_buf. |
| * |
| */ |
| |
| enum typekind { |
| TK_NONE, |
| TK_INTEGER, TK_CHAR, TK_BOOLEAN, TK_REAL, TK_VOID, |
| TK_SUBR, TK_ENUM, TK_POINTER, TK_STRING, |
| TK_RECORD, TK_ARRAY, TK_SET, TK_FILE, TK_FUNCTION, |
| TK_PROCPTR, TK_SMALLSET, TK_SMALLARRAY, TK_CPROCPTR, |
| TK_SPECIAL, TK_BIGFILE, |
| TK_LAST |
| } ; |
| |
| #ifdef DEFDUMPS |
| char *typekindnames[(int)TK_LAST] = { |
| "TK_NONE", |
| "TK_INTEGER", "TK_CHAR", "TK_BOOLEAN", "TK_REAL", "TK_VOID", |
| "TK_SUBR", "TK_ENUM", "TK_POINTER", "TK_STRING", |
| "TK_RECORD", "TK_ARRAY", "TK_SET", "TK_FILE", "TK_FUNCTION", |
| "TK_PROCPTR", "TK_SMALLSET", "TK_SMALLARRAY", "TK_CPROCPTR", |
| "TK_SPECIAL", "TK_BIGFILE" |
| } ; |
| #endif /*DEFDUMPS*/ |
| |
| typedef struct S_type { |
| enum typekind kind; /* Kind of type */ |
| struct S_type *basetype; /* (above) */ |
| struct S_type *indextype; /* (above) */ |
| struct S_type *pointertype; /* Pointer to this type */ |
| struct S_meaning *meaning; /* Name of this type, if any */ |
| struct S_meaning *fbase; /* (above) */ |
| struct S_expr *smin; /* (above) */ |
| struct S_expr *smax; /* (above) */ |
| unsigned issigned:1, /* (above) */ |
| dumped:1, /* Has been dumped (for debugging) */ |
| structdefd:1, /* (above) */ |
| preserved:1; /* Declared with preservetypes = 1 */ |
| short escale; /* (above) */ |
| } Type; |
| |
| |
| /* "Expr" notes: |
| * |
| * Expression trees generally reflect C notation and semantics. For example, |
| * EK_ASSIGN is not generated for string arguments; these would get an |
| * EK_BICALL to strcpy instead. |
| * |
| * The data type of each expression node is stored in its "val.type" field. |
| * The rest of the "val" field is used only when shown below. |
| * The "nargs" field always contains the number of arguments; the "args" |
| * array is allocated to that size and will contain non-NULL Expr pointers. |
| * |
| * EK_EQ, EK_NE, EK_LT, EK_GT, EK_LE, EK_GE: Relational operators. |
| * ep->nargs = 2. |
| * |
| * EK_PLUS: Addition. |
| * ep->nargs >= 2. |
| * |
| * EK_NEG: Negation. |
| * ep->nargs = 1. |
| * |
| * EK_TIMES: Multiplication. |
| * ep->nargs >= 2. |
| * |
| * EK_DIVIDE: Real division. |
| * ep->nargs = 2. |
| * |
| * EK_DIV: Integer division. |
| * ep->nargs = 2. |
| * |
| * EK_MOD: Integer modulo (C "%" operator). |
| * ep->nargs = 2. |
| * |
| * EK_OR, EK_AND: Logical operators (C "&&" and "||"). |
| * ep->nargs = 2. |
| * |
| * EK_NOT: Logical NOT (C "!" operator). |
| * ep->nargs = 1. |
| * |
| * EK_BAND, EK_BOR, EK_BXOR: Bitwise operators (C "&", "|", "^"). |
| * ep->nargs = 2. |
| * |
| * EK_BNOT: Bitwise NOT (C "~" operator). |
| * ep->nargs = 1. |
| * |
| * EK_LSH, EK_RSH: Shift operators. |
| * ep->nargs = 2. |
| * |
| * EK_HAT: Pointer dereference. |
| * ep->nargs = 1. |
| * |
| * EK_INDEX: Array indexing. |
| * ep->nargs = 2. |
| * |
| * EK_CAST: "Soft" type cast, change data type retaining value. |
| * ep->type => New data type. |
| * ep->nargs = 1. |
| * |
| * EK_ACTCAST: "Active" type cast, performs a computation as result of cast. |
| * ep->type => New data type. |
| * ep->nargs = 1. |
| * |
| * EK_LITCAST: Literal type cast. |
| * ep->nargs = 2. |
| * ep->args[0] => EK_TYPENAME expression for name of new data type. |
| * ep->args[1] => Argument of cast. |
| * |
| * EK_DOT: Struct field extraction. |
| * ep->nargs = 1. (Only one of the following will be nonzero:) |
| * ep->val.i => MK_FIELD being extracted (cast to Meaning *), else 0. |
| * ep->val.s => Literal name of field being extracted, else NULL. |
| * |
| * EK_COND: C conditional expression. |
| * ep->nargs = 3. |
| * ep->args[0] => Condition expression. |
| * ep->args[1] => "Then" expression. |
| * ep->args[2] => "Else" expression. |
| * |
| * EK_ADDR: Address-of operator. |
| * ep->nargs = 1. |
| * |
| * EK_SIZEOF: Size-of operator. |
| * ep->nargs = 1. |
| * ep->args[0] => Argument expression, may be EK_TYPENAME. |
| * |
| * EK_CONST: Literal constant. |
| * ep->nargs = 0 or 1. |
| * ep->val = Value of constant. |
| * ep->args[0] => EK_NAME of printf format string for constant, if any. |
| * |
| * EK_LONGCONST: Literal constant, type "long int". |
| * (Same as for EK_CONST.) |
| * |
| * EK_VAR: Variable name. |
| * ep->nargs = 0. |
| * ep->val.i => Variable being referenced (cast to Meaning *). |
| * |
| * EK_ASSIGN: Assignment operator. |
| * ep->nargs = 2. |
| * ep->args[0] => Destination l-value expression. |
| * ep->args[1] => Source expression. |
| * |
| * EK_POSTINC, EK_POSTDEC: Post-increment/post-decrement operators. |
| * ep->nargs = 1. |
| * |
| * EK_MACARG: Placeholder for argument in expression for FuncMacro, etc. |
| * ep->nargs = 0. |
| * ep->val.i = Code selecting which argument. |
| * |
| * EK_CHECKNIL: Null-pointer check. |
| * ep->nargs = 1. |
| * |
| * EK_BICALL: Call to literal function name. |
| * ep->val.s => Name of function. |
| * |
| * EK_STRUCTCONST: Structured constant. |
| * ep->nargs = Number of elements in constant. |
| * (Note: constdefn points to an EK_CONST whose val.i points to this.) |
| * |
| * EK_STRUCTOF: Repeated element in structured constant. |
| * ep->nargs = 1. |
| * ep->val.i = Number of repetitions. |
| * |
| * EK_COMMA: C comma operator. |
| * ep->nargs >= 2. |
| * |
| * EK_NAME: Literal variable name. |
| * ep->nargs = 0. |
| * ep->val.s => Name of variable. |
| * |
| * EK_CTX: Name of a context, with static links. |
| * ep->nargs = 0. |
| * ep->val.i => MK_FUNCTION or MK_MODULE to name (cast to Meaning *). |
| * |
| * EK_SPCALL: Special function call. |
| * ep->nargs = 1 + number of arguments to function. |
| * ep->args[0] => Expression which is the function to call. |
| * |
| * EK_TYPENAME: Type name. |
| * ep->nargs = 0. |
| * ep->val.type => Type whose name should be printed. |
| * |
| * EK_FUNCTION: Normal function call. |
| * ep->val.i => MK_FUNCTION being called (cast to Meaning *). |
| * |
| */ |
| |
| enum exprkind { |
| EK_EQ, EK_NE, EK_LT, EK_GT, EK_LE, EK_GE, |
| EK_PLUS, EK_NEG, EK_TIMES, EK_DIVIDE, |
| EK_DIV, EK_MOD, |
| EK_OR, EK_AND, EK_NOT, |
| EK_BAND, EK_BOR, EK_BXOR, EK_BNOT, EK_LSH, EK_RSH, |
| EK_HAT, EK_INDEX, EK_CAST, EK_DOT, EK_COND, |
| EK_ADDR, EK_SIZEOF, EK_ACTCAST, |
| EK_CONST, EK_VAR, EK_FUNCTION, |
| EK_ASSIGN, EK_POSTINC, EK_POSTDEC, EK_CHECKNIL, |
| EK_MACARG, EK_BICALL, EK_STRUCTCONST, EK_STRUCTOF, |
| EK_COMMA, EK_LONGCONST, EK_NAME, EK_CTX, EK_SPCALL, |
| EK_LITCAST, EK_TYPENAME, |
| EK_LAST |
| } ; |
| |
| #ifdef DEFDUMPS |
| char *exprkindnames[(int)EK_LAST] = { |
| "EK_EQ", "EK_NE", "EK_LT", "EK_GT", "EK_LE", "EK_GE", |
| "EK_PLUS", "EK_NEG", "EK_TIMES", "EK_DIVIDE", |
| "EK_DIV", "EK_MOD", |
| "EK_OR", "EK_AND", "EK_NOT", |
| "EK_BAND", "EK_BOR", "EK_BXOR", "EK_BNOT", "EK_LSH", "EK_RSH", |
| "EK_HAT", "EK_INDEX", "EK_CAST", "EK_DOT", "EK_COND", |
| "EK_ADDR", "EK_SIZEOF", "EK_ACTCAST", |
| "EK_CONST", "EK_VAR", "EK_FUNCTION", |
| "EK_ASSIGN", "EK_POSTINC", "EK_POSTDEC", "EK_CHECKNIL", |
| "EK_MACARG", "EK_BICALL", "EK_STRUCTCONST", "EK_STRUCTOF", |
| "EK_COMMA", "EK_LONGCONST", "EK_NAME", "EK_CTX", "EK_SPCALL", |
| "EK_LITCAST", "EK_TYPENAME" |
| } ; |
| #endif /*DEFDUMPS*/ |
| |
| typedef struct S_expr { |
| enum exprkind kind; |
| short nargs; |
| Value val; |
| struct S_expr *args[1]; /* (Actually, variable-sized) */ |
| } Expr; |
| |
| |
| |
| /* "Stmt" notes. |
| * |
| * Statements form linked lists along the "next" pointers. |
| * All other pointers are NULL and unused unless shown below. |
| * |
| * SK_ASSIGN: Assignment or function call (C expression statement). |
| * sp->exp1 => Expression to be evaluated. |
| * |
| * SK_RETURN: C "return" statement. |
| * sp->exp1 => Value to return, else NULL. |
| * |
| * SK_CASE: C "switch" statement. |
| * sp->exp1 => Switch selector expression. |
| * sp->stm1 => List of SK_CASELABEL statements, followed by list of |
| * statements that make up the "default:" clause. |
| * |
| * SK_CASELABEL: C "case" label. |
| * sp->exp1 => Case value. |
| * sp->stm1 => List of SK_CASELABELs labelling the same clause, followed |
| * by list of statements in that clause. |
| * |
| * SK_CASECHECK: Case-value-range-error, occurs in "default:" clause. |
| * |
| * SK_IF: C "if" statement. |
| * sp->exp1 => Conditional expression. |
| * sp->exp2 => Constant expression, "1" if this "if" should be else-if'd |
| * on to parent "if". NULL => follow ElseIf parameter. |
| * sp->stm1 => "Then" clause. |
| * sp->stm2 => "Else" clause. |
| * |
| * SK_FOR: C "for" statement. |
| * sp->exp1 => Initialization expression (may be NULL). |
| * sp->exp2 => Conditional expression (may be NULL). |
| * sp->exp3 => Iteration expression (may be NULL). |
| * sp->stm1 => Loop body. |
| * |
| * SK_REPEAT: C "do-while" statement. |
| * sp->exp1 => Conditional expression (True = continue loop). |
| * sp->stm1 => Loop body. |
| * |
| * SK_WHILE: C "while" statement. |
| * sp->exp1 => Conditional expression. |
| * sp->stm1 => Loop body. |
| * |
| * SK_BREAK: C "break" statement. |
| * |
| * SK_CONTINUE: C "continue" statement. |
| * |
| * SK_TRY: HP Pascal TRY-RECOVER statement. |
| * sp->exp1->val.i = Global serial number of the TRY statement. |
| * sp->exp2 = Non-NULL if must generate a label for RECOVER block. |
| * sp->stm1 => TRY block. |
| * sp->stm2 => RECOVER block. |
| * |
| * SK_GOTO: C "goto" statement. |
| * sp->exp1 => EK_NAME for the label number or name. |
| * |
| * SK_LABEL: C statement label. |
| * sp->exp1 => EK_NAME for the label number of name. |
| * |
| * SK_HEADER: Function/module header. |
| * sp->exp1 => EK_VAR pointing to MK_FUNCTION or MK_MODULE. |
| * (This always comes first in a context's statement list.) |
| * |
| * SK_BODY: Body of function/module. |
| * sp->stm1 => SK_HEADER that begins the body. |
| * (This exists only during fixblock.) |
| * |
| */ |
| |
| enum stmtkind { |
| SK_ASSIGN, SK_RETURN, |
| SK_CASE, SK_CASELABEL, SK_IF, |
| SK_FOR, SK_REPEAT, SK_WHILE, SK_BREAK, SK_CONTINUE, |
| SK_TRY, SK_GOTO, SK_LABEL, |
| SK_HEADER, SK_CASECHECK, SK_BODY, |
| SK_LAST |
| } ; |
| |
| #ifdef DEFDUMPS |
| char *stmtkindnames[(int)SK_LAST] = { |
| "SK_ASSIGN", "SK_RETURN", |
| "SK_CASE", "SK_CASELABEL", "SK_IF", |
| "SK_FOR", "SK_REPEAT", "SK_WHILE", "SK_BREAK", "SK_CONTINUE", |
| "SK_TRY", "SK_GOTO", "SK_LABEL", |
| "SK_HEADER", "SK_CASECHECK", "SK_BODY" |
| } ; |
| #endif /*DEFDUMPS*/ |
| |
| typedef struct S_stmt { |
| enum stmtkind kind; |
| struct S_stmt *next, *stm1, *stm2; |
| struct S_expr *exp1, *exp2, *exp3; |
| long serial; |
| } Stmt; |
| |
| |
| |
| /* Flags for out_declarator(): */ |
| |
| #define ODECL_CHARSTAR 0x1 |
| #define ODECL_FREEARRAY 0x2 |
| #define ODECL_FUNCTION 0x4 |
| #define ODECL_HEADER 0x8 |
| #define ODECL_FORWARD 0x10 |
| #define ODECL_DECL 0x20 |
| #define ODECL_NOPRES 0x40 |
| |
| |
| /* Flags for fixexpr(): */ |
| |
| #define ENV_EXPR 0 /* return value needed */ |
| #define ENV_STMT 1 /* return value ignored */ |
| #define ENV_BOOL 2 /* boolean return value needed */ |
| |
| |
| /* Flags for defmacro(): */ |
| #define MAC_VAR 0 /* VarMacro */ |
| #define MAC_CONST 1 /* ConstMacro */ |
| #define MAC_FIELD 2 /* FieldMacro */ |
| #define MAC_FUNC 3 /* FuncMacro */ |
| |
| #define FMACRECname "<rec>" |
| |
| |
| /* Kinds of comment lines: */ |
| #define CMT_SHIFT 24 |
| #define CMT_MASK ((1L<<CMT_SHIFT)-1) |
| #define CMT_KMASK ((1<<(32-CMT_SHIFT))-1) |
| #define CMT_DONE 0 /* comment that has already been printed */ |
| #define CMT_PRE 1 /* comment line preceding subject */ |
| #define CMT_POST 2 /* comment line following subject */ |
| #define CMT_TRAIL 4 /* comment at end of line of code */ |
| #define CMT_ONBEGIN 6 /* comment on "begin" of procedure */ |
| #define CMT_ONEND 7 /* comment on "end" of procedure */ |
| #define CMT_ONELSE 8 /* comment on "else" keyword */ |
| #define CMT_NOT 256 /* negation of above, for searches */ |
| |
| #ifdef define_globals |
| char *CMT_NAMES[] = { "DONE", "PRE", "POST", "3", "TRAIL", "5", |
| "BEGIN", "END", "ELSE" }; |
| #else |
| extern char *CMT_NAMES[]; |
| #endif |
| |
| #define getcommentkind(cmt) (((cmt)->value >> CMT_SHIFT) & CMT_KMASK) |
| |
| |
| /* Kinds of operator line-breaking: */ |
| #define BRK_LEFT 0x1 |
| #define BRK_RIGHT 0x2 |
| #define BRK_LPREF 0x4 |
| #define BRK_RPREF 0x8 |
| #define BRK_ALLNONE 0x10 |
| #define BRK_HANG 0x20 |
| |
| |
| |
| |
| /* Translation parameters: */ |
| |
| #ifdef define_parameters |
| # define extern |
| #endif /* define_parameters */ |
| |
| extern enum { |
| UNIX_ANY, UNIX_BSD, UNIX_SYSV |
| } which_unix; |
| |
| extern enum { |
| LANG_HP, LANG_UCSD, LANG_TURBO, LANG_OREGON, LANG_VAX, |
| LANG_MODULA, LANG_MPW, LANG_BERK |
| } which_lang; |
| |
| extern short debug, tokentrace, quietmode, cmtdebug, copysource; |
| extern int nobanner, showprogress, maxerrors; |
| extern short hpux_lang, integer16, doublereals, pascalenumsize; |
| extern short needsignedbyte, unsignedchar, importall; |
| extern short nestedcomments, pascalsignif, pascalcasesens; |
| extern short dollar_idents, ignorenonalpha, modula2; |
| extern short ansiC, cplus, signedchars, signedfield, signedshift; |
| extern short hassignedchar, voidstar, symcase, ucconsts, csignif; |
| extern short copystructs, usevextern, implementationmodules; |
| extern short useAnyptrMacros, usePPMacros; |
| extern short sprintf_value; |
| extern char codefnfmt[40], modulefnfmt[40], logfnfmt[40]; |
| extern char headerfnfmt[40], headerfnfmt2[40], includefnfmt[40]; |
| extern char selfincludefmt[40]; |
| extern char constformat[40], moduleformat[40], functionformat[40]; |
| extern char varformat[40], fieldformat[40], typeformat[40]; |
| extern char enumformat[40], symbolformat[40]; |
| extern char p2c_h_name[40], exportsymbol[40], export_symbol[40]; |
| extern char externalias[40]; |
| extern char memcpyname[40], sprintfname[40]; |
| extern char roundname[40], divname[40], modname[40], remname[40]; |
| extern char strposname[40], strcicmpname[40]; |
| extern char strsubname[40], strdeletename[40], strinsertname[40]; |
| extern char strmovename[40], strpadname[40]; |
| extern char strltrimname[40], strrtrimname[40], strrptname[40]; |
| extern char absname[40], oddname[40], evenname[40], swapname[40]; |
| extern char mallocname[40], freename[40], freervaluename[40]; |
| extern char randrealname[40], randintname[40], randomizename[40]; |
| extern char skipspacename[40], readlnname[40], freopenname[40]; |
| extern char eofname[40], eolnname[40], fileposname[40], maxposname[40]; |
| extern char setunionname[40], setintname[40], setdiffname[40]; |
| extern char setinname[40], setaddname[40], setaddrangename[40]; |
| extern char setremname[40]; |
| extern char setequalname[40], subsetname[40], setxorname[40]; |
| extern char setcopyname[40], setexpandname[40], setpackname[40]; |
| extern char getbitsname[40], clrbitsname[40], putbitsname[40]; |
| extern char declbufname[40], declbufncname[40]; |
| extern char resetbufname[40], setupbufname[40]; |
| extern char getfbufname[40], chargetfbufname[40], arraygetfbufname[40]; |
| extern char putfbufname[40], charputfbufname[40], arrayputfbufname[40]; |
| extern char getname[40], chargetname[40], arraygetname[40]; |
| extern char putname[40], charputname[40], arrayputname[40]; |
| extern char eofbufname[40], fileposbufname[40]; |
| extern char storebitsname[40], signextname[40]; |
| extern char filenotfoundname[40], filenotopenname[40]; |
| extern char filewriteerrorname[40], badinputformatname[40], endoffilename[40]; |
| extern short strcpyleft; |
| extern char language[40], target[40]; |
| extern int sizeof_char, sizeof_short, sizeof_integer, sizeof_pointer, |
| sizeof_double, sizeof_float, sizeof_enum, sizeof_int, sizeof_long; |
| extern short size_t_long; |
| extern int setbits, defaultsetsize, seek_base, integerwidth, realwidth; |
| extern short quoteincludes, expandincludes, collectnest; |
| extern int phystabsize, intabsize, linewidth, maxlinewidth; |
| extern int majorspace, minorspace, functionspace, minfuncspace; |
| extern int casespacing, caselimit; |
| extern int returnlimit, breaklimit, continuelimit; |
| extern short nullstmtline, shortcircuit, shortopt, usecommas, elseif; |
| extern short usereturns, usebreaks, infloopstyle, reusefieldnames; |
| extern short bracesalways, braceline, bracecombine, braceelse, braceelseline; |
| extern short newlinefunctions; |
| extern short eatcomments, spitcomments, spitorphancomments; |
| extern short commentafter, blankafter; |
| extern int tabsize, blockindent, bodyindent, argindent; |
| extern int switchindent, caseindent, labelindent; |
| extern int openbraceindent, closebraceindent; |
| extern int funcopenindent, funccloseindent; |
| extern int structindent, structinitindent, extrainitindent; |
| extern int constindent, commentindent, bracecommentindent, commentoverindent; |
| extern int declcommentindent; |
| extern int minspacing, minspacingthresh; |
| extern int extraindent, bumpindent; |
| extern double overwidepenalty, overwideextrapenalty; |
| extern double commabreakpenalty, commabreakextrapenalty; |
| extern double assignbreakpenalty, assignbreakextrapenalty; |
| extern double specialargbreakpenalty; |
| extern double opbreakpenalty, opbreakextrapenalty, exhyphenpenalty; |
| extern double logbreakpenalty, logbreakextrapenalty; |
| extern double relbreakpenalty, relbreakextrapenalty; |
| extern double morebreakpenalty, morebreakextrapenalty; |
| extern double parenbreakpenalty, parenbreakextrapenalty; |
| extern double qmarkbreakpenalty, qmarkbreakextrapenalty; |
| extern double wrongsidepenalty, earlybreakpenalty, extraindentpenalty; |
| extern double bumpindentpenalty, nobumpindentpenalty; |
| extern double indentamountpenalty, sameindentpenalty; |
| extern double showbadlimit; |
| extern long maxalts; |
| extern short breakbeforearith, breakbeforerel, breakbeforelog; |
| extern short breakbeforedot, breakbeforeassign; |
| extern short for_allornone; |
| extern short extraparens, breakparens, returnparens; |
| extern short variablearrays, initpacstrings, stararrays; |
| extern short spaceexprs, spacefuncs, spacecommas, implicitzero, starindex; |
| extern int casetabs; |
| extern short starfunctions, mixfields, alloczeronil, postincrement; |
| extern short mixvars, mixtypes, mixinits, nullcharconst, castnull, addindex; |
| extern short highcharints, highcharbits, hasstaticlinks; |
| extern short mainlocals, storefilenames, addrstdfiles, readwriteopen; |
| extern short charfiletext, messagestderr, literalfilesflag, structfilesflag; |
| extern short printfonly, mixwritelns, usegets, newlinespace, binarymode; |
| extern char openmode[40], filenamefilter[40]; |
| extern short atan2flag, div_po2, mod_po2, assumebits, assumesigns; |
| extern short fullstrwrite, fullstrread, whilefgets, buildreads, buildwrites; |
| extern short foldconsts, foldstrconsts, charconsts, useconsts, useundef; |
| extern short elimdeadcode, offsetforloops, forevalorder; |
| extern short smallsetconst, bigsetconst, lelerange, unsignedtrick; |
| extern short useisalpha, useisspace, usestrncmp; |
| extern short casecheck, arraycheck, rangecheck, nilcheck, malloccheck; |
| extern short checkfileopen, checkfileisopen, checkfilewrite; |
| extern short checkreadformat, checkfileeof, checkstdineof, checkfileseek; |
| extern short squeezesubr, useenum, enumbyte, packing, packsigned, keepnulls; |
| extern short compenums, formatstrings, alwayscopyvalues; |
| extern short use_static, var_static, void_args, prototypes, fullprototyping; |
| extern short procptrprototypes, promote_enums; |
| extern short preservetypes, preservepointers, preservestrings; |
| extern short castargs, castlongargs, promoteargs, fixpromotedargs; |
| extern short varstrings, varfiles, copystructfuncs; |
| extern long skipindices; |
| extern short stringleaders; |
| extern int stringceiling, stringdefault, stringtrunclimit, longstringsize; |
| extern short warnnames, warnmacros; |
| extern Strlist *importfrom, *importdirs, *includedirs, *includefrom; |
| extern Strlist *librfiles, *bufferedfiles, *unbufferedfiles; |
| extern Strlist *externwords, *cexternwords; |
| extern Strlist *varmacros, *constmacros, *fieldmacros; |
| extern Strlist *funcmacros, *funcmacroargs, *nameoflist; |
| extern Strlist *specialmallocs, *specialfrees, *specialsizeofs; |
| extern Strlist *initialcalls, *eatnotes, *literalfiles, *structfiles; |
| |
| extern char fixedcomment[40], permanentcomment[40], interfacecomment[40]; |
| extern char embedcomment[40], skipcomment[40], noskipcomment[40]; |
| extern char signedcomment[40], unsignedcomment[40]; |
| |
| extern char name_RETV[40], name_STRMAX[40], name_LINK[40]; |
| extern char name_COPYPAR[40], name_TEMP[40], name_DUMMY[40]; |
| extern char name_LOC[40], name_VARS[40], name_STRUCT[40]; |
| extern char name_FAKESTRUCT[40], name_AHIGH[40], name_ALOW[40]; |
| extern char name_UNION[40], name_VARIANT[40], name_LABEL[40], name_LABVAR[40]; |
| extern char name_WITH[40], name_FOR[40], name_ENUM[40]; |
| extern char name_PTR[40], name_STRING[40], name_SET[40]; |
| extern char name_PROCEDURE[40], name_MAIN[40], name_UNITINIT[40]; |
| extern char name_HSYMBOL[40], name_GSYMBOL[40]; |
| extern char name_SETBITS[40], name_UCHAR[40], name_SCHAR[40]; |
| extern char name_BOOLEAN[40], name_TRUE[40], name_FALSE[40], name_NULL[40]; |
| extern char name_ESCAPECODE[40], name_IORESULT[40]; |
| extern char name_ARGC[40], name_ARGV[40]; |
| extern char name_ESCAPE[40], name_ESCIO[40], name_CHKIO[40], name_SETIO[40]; |
| extern char name_OUTMEM[40], name_CASECHECK[40], name_NILCHECK[40]; |
| extern char name_FNSIZE[40], name_FNVAR[40]; |
| extern char alternatename1[40], alternatename2[40], alternatename[40]; |
| |
| |
| #ifndef define_parameters |
| extern |
| #endif |
| struct rcstruct { |
| char kind; |
| char chgmode; |
| char *name; |
| anyptr ptr; |
| long def; |
| } rctable[] |
| #ifdef define_parameters |
| = { |
| 'S', 'R', "DEBUG", (anyptr) &debug, 0, |
| 'I', 'R', "SHOWPROGRESS", (anyptr) &showprogress, 0, |
| 'S', 'V', "TOKENTRACE", (anyptr) &tokentrace, 0, |
| 'S', 'V', "QUIET", (anyptr) &quietmode, 0, |
| 'S', 'V', "COPYSOURCE", (anyptr) ©source, 0, |
| 'I', 'R', "MAXERRORS", (anyptr) &maxerrors, 0, |
| 'X', ' ', "INCLUDE", (anyptr) NULL, 2, |
| |
| /* INPUT LANGUAGE */ |
| 'U', 'T', "LANGUAGE", (anyptr) language, 40, |
| 'S', 'V', "MODULA2", (anyptr) &modula2, -1, |
| 'S', 'T', "INTEGER16", (anyptr) &integer16, -1, |
| 'S', 'T', "DOUBLEREALS", (anyptr) &doublereals, -1, |
| 'S', 'V', "UNSIGNEDCHAR", (anyptr) &unsignedchar, -1, |
| 'S', 'V', "NEEDSIGNEDBYTE", (anyptr) &needsignedbyte, 0, |
| 'S', 'V', "PASCALENUMSIZE", (anyptr) &pascalenumsize, -1, |
| 'S', 'V', "NESTEDCOMMENTS", (anyptr) &nestedcomments, -1, |
| 'S', 'V', "IMPORTALL", (anyptr) &importall, -1, |
| 'S', 'V', "IMPLMODULES", (anyptr) &implementationmodules, -1, |
| 'A', 'V', "EXTERNWORDS", (anyptr) &externwords, 0, |
| 'A', 'V', "CEXTERNWORDS", (anyptr) &cexternwords, 0, |
| 'S', 'V', "PASCALSIGNIF", (anyptr) &pascalsignif, -1, |
| 'S', 'V', "PASCALCASESENS", (anyptr) &pascalcasesens, -1, |
| 'S', 'V', "DOLLARIDENTS", (anyptr) &dollar_idents, -1, |
| 'S', 'V', "IGNORENONALPHA", (anyptr) &ignorenonalpha, -1, |
| 'I', 'V', "SEEKBASE", (anyptr) &seek_base, -1, |
| 'I', 'R', "INPUTTABSIZE", (anyptr) &intabsize, 8, |
| |
| /* TARGET LANGUAGE */ |
| 'S', 'T', "ANSIC", (anyptr) &ansiC, -1, |
| 'S', 'T', "C++", (anyptr) &cplus, -1, |
| 'S', 'T', "VOID*", (anyptr) &voidstar, -1, |
| 'S', 'T', "HASSIGNEDCHAR", (anyptr) &hassignedchar, -1, |
| 'S', 'V', "CASTNULL", (anyptr) &castnull, -1, |
| 'S', 'V', "COPYSTRUCTS", (anyptr) ©structs, -1, |
| 'S', 'V', "VARIABLEARRAYS", (anyptr) &variablearrays, -1, |
| 'S', 'V', "INITPACSTRINGS", (anyptr) &initpacstrings, -1, |
| 'S', 'V', "REUSEFIELDNAMES", (anyptr) &reusefieldnames, 1, |
| 'S', 'V', "USEVEXTERN", (anyptr) &usevextern, 1, |
| 'S', 'V', "CSIGNIF", (anyptr) &csignif, -1, |
| 'S', 'V', "USEANYPTRMACROS", (anyptr) &useAnyptrMacros, -1, |
| 'S', 'V', "USEPPMACROS", (anyptr) &usePPMacros, -1, |
| |
| /* TARGET MACHINE */ |
| 'U', 'T', "TARGET", (anyptr) target, 40, |
| 'S', 'T', "SIGNEDCHAR", (anyptr) &signedchars, -1, |
| 'S', 'T', "SIGNEDFIELD", (anyptr) &signedfield, -1, |
| 'S', 'T', "SIGNEDSHIFT", (anyptr) &signedshift, -1, |
| 'I', 'T', "CHARSIZE", (anyptr) &sizeof_char, 0, |
| 'I', 'T', "SHORTSIZE", (anyptr) &sizeof_short, 0, |
| 'I', 'T', "INTSIZE", (anyptr) &sizeof_int, 0, |
| 'I', 'T', "LONGSIZE", (anyptr) &sizeof_long, 0, |
| 'I', 'T', "PTRSIZE", (anyptr) &sizeof_pointer, 0, |
| 'I', 'T', "DOUBLESIZE", (anyptr) &sizeof_double, 0, |
| 'I', 'T', "FLOATSIZE", (anyptr) &sizeof_float, 0, |
| 'I', 'T', "ENUMSIZE", (anyptr) &sizeof_enum, 0, |
| 'S', 'T', "SIZE_T_LONG", (anyptr) &size_t_long, -1, |
| |
| /* BRACES */ |
| 'S', 'V', "NULLSTMTLINE", (anyptr) &nullstmtline, 0, |
| 'S', 'V', "BRACESALWAYS", (anyptr) &bracesalways, -1, |
| 'S', 'V', "BRACELINE", (anyptr) &braceline, -1, |
| 'S', 'V', "BRACECOMBINE", (anyptr) &bracecombine, 0, |
| 'S', 'V', "BRACEELSE", (anyptr) &braceelse, 0, |
| 'S', 'V', "BRACEELSELINE", (anyptr) &braceelseline, 0, |
| 'S', 'V', "ELSEIF", (anyptr) &elseif, -1, |
| 'S', 'V', "NEWLINEFUNCS", (anyptr) &newlinefunctions, 0, |
| |
| /* INDENTATION */ |
| 'I', 'R', "PHYSTABSIZE", (anyptr) &phystabsize, 8, |
| 'D', 'R', "INDENT", (anyptr) &tabsize, 2, |
| 'D', 'R', "BLOCKINDENT", (anyptr) &blockindent, 0, |
| 'D', 'R', "BODYINDENT", (anyptr) &bodyindent, 0, |
| 'D', 'R', "FUNCARGINDENT", (anyptr) &argindent, 1000, |
| 'D', 'R', "OPENBRACEINDENT", (anyptr) &openbraceindent, 0, |
| 'D', 'R', "CLOSEBRACEINDENT",(anyptr) &closebraceindent, 0, |
| 'D', 'R', "FUNCOPENINDENT", (anyptr) &funcopenindent, 0, |
| 'D', 'R', "FUNCCLOSEINDENT", (anyptr) &funccloseindent, 0, |
| 'D', 'R', "SWITCHINDENT", (anyptr) &switchindent, 0, |
| 'D', 'R', "CASEINDENT", (anyptr) &caseindent, -2, |
| 'D', 'R', "LABELINDENT", (anyptr) &labelindent, 1000, |
| 'D', 'R', "STRUCTINDENT", (anyptr) &structindent, 0, |
| 'D', 'R', "STRUCTINITINDENT",(anyptr) &structinitindent, 0, |
| 'D', 'R', "EXTRAINITINDENT", (anyptr) &extrainitindent, 2, |
| 'I', 'R', "EXTRAINDENT", (anyptr) &extraindent, 2, |
| 'I', 'R', "BUMPINDENT", (anyptr) &bumpindent, 1, |
| 'D', 'R', "CONSTINDENT", (anyptr) &constindent, 1024, |
| 'D', 'R', "COMMENTINDENT", (anyptr) &commentindent, 3, |
| 'D', 'R', "BRACECOMMENTINDENT",(anyptr)&bracecommentindent, 2, |
| 'D', 'R', "DECLCOMMENTINDENT",(anyptr)&declcommentindent, -999, |
| 'D', 'R', "COMMENTOVERINDENT",(anyptr)&commentoverindent, 4, /*1000*/ |
| 'I', 'R', "MINSPACING", (anyptr) &minspacing, 2, |
| 'I', 'R', "MINSPACINGTHRESH",(anyptr) &minspacingthresh, -1, |
| |
| /* LINE BREAKING */ |
| 'I', 'R', "LINEWIDTH", (anyptr) &linewidth, 78, |
| 'I', 'R', "MAXLINEWIDTH", (anyptr) &maxlinewidth, 90, |
| 'R', 'V', "OVERWIDEPENALTY", (anyptr) &overwidepenalty, 2500, |
| 'R', 'V', "OVERWIDEEXTRAPENALTY", (anyptr) &overwideextrapenalty, 100, |
| 'R', 'V', "COMMABREAKPENALTY", (anyptr) &commabreakpenalty, 1000, |
| 'R', 'V', "COMMABREAKEXTRAPENALTY",(anyptr) &commabreakextrapenalty, 500, |
| 'R', 'V', "ASSIGNBREAKPENALTY", (anyptr) &assignbreakpenalty, 5000, |
| 'R', 'V', "ASSIGNBREAKEXTRAPENALTY",(anyptr)&assignbreakextrapenalty, 3000, |
| 'R', 'V', "SPECIALARGBREAKPENALTY",(anyptr) &specialargbreakpenalty, 500, |
| 'R', 'V', "OPBREAKPENALTY", (anyptr) &opbreakpenalty, 2500, |
| 'R', 'V', "OPBREAKEXTRAPENALTY", (anyptr) &opbreakextrapenalty, 2000, |
| 'R', 'V', "LOGBREAKPENALTY", (anyptr) &logbreakpenalty, 500, |
| 'R', 'V', "LOGBREAKEXTRAPENALTY", (anyptr) &logbreakextrapenalty, 100, |
| 'R', 'V', "RELBREAKPENALTY", (anyptr) &relbreakpenalty, 2000, |
| 'R', 'V', "RELBREAKEXTRAPENALTY", (anyptr) &relbreakextrapenalty, 1000, |
| 'R', 'V', "EXHYPHENPENALTY", (anyptr) &exhyphenpenalty, 1000, |
| 'R', 'V', "MOREBREAKPENALTY", (anyptr) &morebreakpenalty, -500, |
| 'R', 'V', "MOREBREAKEXTRAPENALTY", (anyptr) &morebreakextrapenalty, -300, |
| 'R', 'V', "QMARKBREAKPENALTY", (anyptr) &qmarkbreakpenalty, 5000, |
| 'R', 'V', "QMARKBREAKEXTRAPENALTY",(anyptr) &qmarkbreakextrapenalty, 3000, |
| 'R', 'V', "PARENBREAKPENALTY", (anyptr) &parenbreakpenalty, 2500, |
| 'R', 'V', "PARENBREAKEXTRAPENALTY",(anyptr) &parenbreakextrapenalty, 1000, |
| 'R', 'V', "WRONGSIDEPENALTY", (anyptr) &wrongsidepenalty, 1000, |
| 'R', 'V', "EARLYBREAKPENALTY", (anyptr) &earlybreakpenalty, 100, |
| 'R', 'V', "EXTRAINDENTPENALTY", (anyptr) &extraindentpenalty, 3000, |
| 'R', 'V', "BUMPINDENTPENALTY", (anyptr) &bumpindentpenalty, 1000, |
| 'R', 'V', "NOBUMPINDENTPENALTY", (anyptr) &nobumpindentpenalty, 2500, |
| 'R', 'V', "INDENTAMOUNTPENALTY", (anyptr) &indentamountpenalty, 50, |
| 'R', 'V', "SAMEINDENTPENALTY", (anyptr) &sameindentpenalty, 500, |
| 'R', 'V', "SHOWBADLIMIT", (anyptr) &showbadlimit, -120, |
| 'L', 'R', "MAXLINEBREAKTRIES", (anyptr) &maxalts, 5000, |
| 'G', 'V', "ALLORNONEBREAK", (anyptr) NULL, FALLBREAK, |
| 'G', 'V', "ONESPECIALARG", (anyptr) NULL, FSPCARG1, |
| 'G', 'V', "TWOSPECIALARGS", (anyptr) NULL, FSPCARG2, |
| 'G', 'V', "THREESPECIALARGS",(anyptr) NULL, FSPCARG3, |
| 'B', 'V', "BREAKARITH", (anyptr) &breakbeforearith, BRK_RIGHT, |
| 'B', 'V', "BREAKREL", (anyptr) &breakbeforerel, BRK_RIGHT, |
| 'B', 'V', "BREAKLOG", (anyptr) &breakbeforelog, BRK_RIGHT, |
| 'B', 'V', "BREAKDOT", (anyptr) &breakbeforedot, BRK_RIGHT, |
| 'B', 'V', "BREAKASSIGN", (anyptr) &breakbeforeassign, BRK_RIGHT, |
| 'S', 'V', "FOR_ALLORNONE", (anyptr) &for_allornone, 1, |
| |
| /* COMMENTS AND BLANK LINES */ |
| 'S', 'V', "NOBANNER", (anyptr) &nobanner, 0, |
| 'S', 'V', "EATCOMMENTS", (anyptr) &eatcomments, 0, |
| 'S', 'V', "SPITCOMMENTS", (anyptr) &spitcomments, 0, |
| 'S', 'V', "SPITORPHANCOMMENTS",(anyptr)&spitorphancomments, 0, |
| 'S', 'V', "COMMENTAFTER", (anyptr) &commentafter, -1, |
| 'S', 'V', "BLANKAFTER", (anyptr) &blankafter, 1, |
| 'A', 'V', "EATNOTES", (anyptr) &eatnotes, 0, |
| |
| /* SPECIAL COMMENTS */ |
| 'C', 'V', "FIXEDCOMMENT", (anyptr) fixedcomment, 40, |
| 'C', 'V', "PERMANENTCOMMENT",(anyptr) permanentcomment, 40, |
| 'C', 'V', "INTERFACECOMMENT",(anyptr) interfacecomment, 40, |
| 'C', 'V', "EMBEDCOMMENT", (anyptr) embedcomment, 40, |
| 'C', 'V', "SKIPCOMMENT", (anyptr) skipcomment, 40, |
| 'C', 'V', "NOSKIPCOMMENT", (anyptr) noskipcomment, 40, |
| 'C', 'V', "SIGNEDCOMMENT", (anyptr) signedcomment, 40, |
| 'C', 'V', "UNSIGNEDCOMMENT", (anyptr) unsignedcomment, 40, |
| |
| /* STYLISTIC OPTIONS */ |
| 'I', 'V', "MAJORSPACING", (anyptr) &majorspace, 2, |
| 'I', 'V', "MINORSPACING", (anyptr) &minorspace, 1, |
| 'I', 'V', "FUNCSPACING", (anyptr) &functionspace, 2, |
| 'I', 'V', "MINFUNCSPACING", (anyptr) &minfuncspace, 1, |
| 'S', 'V', "EXTRAPARENS", (anyptr) &extraparens, -1, |
| 'S', 'V', "BREAKADDPARENS", (anyptr) &breakparens, -1, |
| 'S', 'V', "RETURNPARENS", (anyptr) &returnparens, -1, |
| 'S', 'V', "SPACEEXPRS", (anyptr) &spaceexprs, -1, |
| 'S', 'V', "SPACEFUNCS", (anyptr) &spacefuncs, 0, |
| 'S', 'V', "SPACECOMMAS", (anyptr) &spacecommas, 1, |
| 'S', 'V', "IMPLICITZERO", (anyptr) &implicitzero, -1, |
| 'S', 'V', "STARINDEX", (anyptr) &starindex, -1, |
| 'S', 'V', "ADDINDEX", (anyptr) &addindex, -1, |
| 'S', 'V', "STARARRAYS", (anyptr) &stararrays, 1, |
| 'S', 'V', "STARFUNCTIONS", (anyptr) &starfunctions, -1, |
| 'S', 'V', "POSTINCREMENT", (anyptr) &postincrement, 1, |
| 'S', 'V', "MIXVARS", (anyptr) &mixvars, -1, |
| 'S', 'V', "MIXTYPES", (anyptr) &mixtypes, -1, |
| 'S', 'V', "MIXFIELDS", (anyptr) &mixfields, -1, |
| 'S', 'V', "MIXINITS", (anyptr) &mixinits, -1, |
| 'S', 'V', "MAINLOCALS", (anyptr) &mainlocals, 1, |
| 'S', 'V', "NULLCHAR", (anyptr) &nullcharconst, 1, |
| 'S', 'V', "HIGHCHARINT", (anyptr) &highcharints, 1, |
| 'I', 'V', "CASESPACING", (anyptr) &casespacing, 1, |
| 'D', 'V', "CASETABS", (anyptr) &casetabs, 1000, |
| 'I', 'V', "CASELIMIT", (anyptr) &caselimit, 9, |
| 'S', 'V', "USECOMMAS", (anyptr) &usecommas, -1, |
| 'S', 'V', "USERETURNS", (anyptr) &usereturns, 1, |
| 'I', 'V', "RETURNLIMIT", (anyptr) &returnlimit, 3, |
| 'S', 'V', "USEBREAKS", (anyptr) &usebreaks, 1, |
| 'I', 'V', "BREAKLIMIT", (anyptr) &breaklimit, 2, |
| 'I', 'V', "CONTINUELIMIT", (anyptr) &continuelimit, 5, |
| 'S', 'V', "INFLOOPSTYLE", (anyptr) &infloopstyle, 0, |
| |
| /* NAMING CONVENTIONS */ |
| 'C', 'V', "CODEFILENAME", (anyptr) codefnfmt, 40, |
| 'C', 'V', "MODULEFILENAME", (anyptr) modulefnfmt, 40, |
| 'C', 'V', "HEADERFILENAME", (anyptr) headerfnfmt, 40, |
| 'C', 'V', "HEADERFILENAME2", (anyptr) headerfnfmt2, 40, |
| 'C', 'V', "SELFINCLUDENAME", (anyptr) selfincludefmt, 40, |
| 'C', 'V', "LOGFILENAME", (anyptr) logfnfmt, 40, |
| 'C', 'V', "INCLUDEFILENAME", (anyptr) includefnfmt, 40, |
| 'S', 'V', "SYMCASE", (anyptr) &symcase, -1, |
| 'C', 'V', "SYMBOLFORMAT", (anyptr) symbolformat, 40, |
| 'C', 'V', "CONSTFORMAT", (anyptr) constformat, 40, |
| 'C', 'V', "MODULEFORMAT", (anyptr) moduleformat, 40, |
| 'C', 'V', "FUNCTIONFORMAT", (anyptr) functionformat, 40, |
| 'C', 'V', "VARFORMAT", (anyptr) varformat, 40, |
| 'C', 'V', "FIELDFORMAT", (anyptr) fieldformat, 40, |
| 'C', 'V', "TYPEFORMAT", (anyptr) typeformat, 40, |
| 'C', 'V', "ENUMFORMAT", (anyptr) enumformat, 40, |
| 'C', 'V', "RETURNVALUENAME", (anyptr) name_RETV, 40, |
| 'C', 'V', "UNITINITNAME", (anyptr) name_UNITINIT, 40, |
| 'C', 'V', "HSYMBOLNAME", (anyptr) name_HSYMBOL, 40, |
| 'C', 'V', "GSYMBOLNAME", (anyptr) name_GSYMBOL, 40, |
| 'C', 'V', "STRINGMAXNAME", (anyptr) name_STRMAX, 40, |
| 'C', 'V', "ARRAYMINNAME", (anyptr) name_ALOW, 40, |
| 'C', 'V', "ARRAYMAXNAME", (anyptr) name_AHIGH, 40, |
| 'C', 'V', "COPYPARNAME", (anyptr) name_COPYPAR, 40, |
| 'C', 'V', "STATICLINKNAME", (anyptr) name_LINK, 40, |
| 'C', 'V', "LOCALVARSSTRUCT", (anyptr) name_LOC, 40, |
| 'C', 'V', "LOCALVARSNAME", (anyptr) name_VARS, 40, |
| 'C', 'V', "FWDSTRUCTNAME", (anyptr) name_STRUCT, 40, |
| 'C', 'V', "ENUMLISTNAME", (anyptr) name_ENUM, 40, |
| 'C', 'V', "UNIONNAME", (anyptr) name_UNION, 40, |
| 'C', 'V', "UNIONPARTNAME", (anyptr) name_VARIANT, 40, |
| 'C', 'V', "FAKESTRUCTNAME", (anyptr) name_FAKESTRUCT, 40, |
| 'C', 'V', "LABELNAME", (anyptr) name_LABEL, 40, |
| 'C', 'V', "LABELVARNAME", (anyptr) name_LABVAR, 40, |
| 'C', 'V', "TEMPNAME", (anyptr) name_TEMP, 40, |
| 'C', 'V', "DUMMYNAME", (anyptr) name_DUMMY, 40, |
| 'C', 'V', "FORNAME", (anyptr) name_FOR, 40, |
| 'C', 'V', "WITHNAME", (anyptr) name_WITH, 40, |
| 'C', 'V', "PTRNAME", (anyptr) name_PTR, 40, |
| 'C', 'V', "STRINGNAME", (anyptr) name_STRING, 40, |
| 'C', 'V', "SETNAME", (anyptr) name_SET, 40, |
| 'C', 'V', "FNVARNAME", (anyptr) name_FNVAR, 40, |
| 'C', 'V', "FNSIZENAME", (anyptr) name_FNSIZE, 40, |
| 'C', 'V', "ALTERNATENAME1", (anyptr) alternatename1, 40, |
| 'C', 'V', "ALTERNATENAME2", (anyptr) alternatename2, 40, |
| 'C', 'V', "ALTERNATENAME", (anyptr) alternatename, 40, |
| 'C', 'V', "EXPORTSYMBOL", (anyptr) exportsymbol, 40, |
| 'C', 'V', "EXPORT_SYMBOL", (anyptr) export_symbol, 40, |
| 'C', 'V', "ALIAS", (anyptr) externalias, 40, |
| 'X', 'V', "SYNONYM", (anyptr) NULL, 3, |
| 'X', 'V', "NAMEOF", (anyptr) &nameoflist, 1, |
| 'G', 'V', "AVOIDNAME", (anyptr) NULL, AVOIDNAME, |
| 'G', 'V', "AVOIDGLOBALNAME", (anyptr) NULL, AVOIDGLOB, |
| 'G', 'V', "WARNNAME", (anyptr) NULL, WARNNAME, |
| 'G', 'V', "NOSIDEEFFECTS", (anyptr) NULL, NOSIDEEFF, |
| 'G', 'V', "STRUCTFUNCTION", (anyptr) NULL, STRUCTF, |
| 'G', 'V', "STRLAPFUNCTION", (anyptr) NULL, STRLAPF, |
| 'F', 'V', "LEAVEALONE", (anyptr) NULL, LEAVEALONE, |
| 'G', 'V', "DETERMINISTIC", (anyptr) NULL, DETERMF, |
| 'G', 'V', "NEEDSTATIC", (anyptr) NULL, NEEDSTATIC, |
| 'S', 'V', "WARNNAMES", (anyptr) &warnnames, 0, |
| 'M', 'V', "VARMACRO", (anyptr) NULL, MAC_VAR, |
| 'M', 'V', "CONSTMACRO", (anyptr) NULL, MAC_CONST, |
| 'M', 'V', "FIELDMACRO", (anyptr) NULL, MAC_FIELD, |
| 'M', 'V', "FUNCMACRO", (anyptr) NULL, MAC_FUNC, |
| 'S', 'V', "WARNMACROS", (anyptr) &warnmacros, 0, |
| |
| /* CODING OPTIONS */ |
| 'A', 'V', "INITIALCALLS", (anyptr) &initialcalls, 0, |
| 'S', 'V', "EXPANDINCLUDES", (anyptr) &expandincludes, -1, |
| 'S', 'V', "COLLECTNEST", (anyptr) &collectnest, 1, |
| 'S', 'V', "SHORTCIRCUIT", (anyptr) &shortcircuit, -1, |
| 'S', 'V', "SHORTOPT", (anyptr) &shortopt, 1, |
| 'S', 'V', "ELIMDEADCODE", (anyptr) &elimdeadcode, 1, |
| 'S', 'V', "FOLDCONSTANTS", (anyptr) &foldconsts, -1, |
| 'S', 'V', "FOLDSTRCONSTANTS",(anyptr) &foldstrconsts, -1, |
| 'S', 'V', "CHARCONSTS", (anyptr) &charconsts, 1, |
| 'S', 'V', "USECONSTS", (anyptr) &useconsts, -1, |
| 'S', 'V', "USEUNDEF", (anyptr) &useundef, 1, |
| 'L', 'V', "SKIPINDICES", (anyptr) &skipindices, 0, |
| 'S', 'V', "OFFSETFORLOOPS", (anyptr) &offsetforloops, 1, |
| 'S', 'V', "FOREVALORDER", (anyptr) &forevalorder, 0, |
| 'S', 'V', "STRINGLEADERS", (anyptr) &stringleaders, 2, |
| 'S', 'V', "STOREFILENAMES", (anyptr) &storefilenames, -1, |
| 'S', 'V', "CHARFILETEXT", (anyptr) &charfiletext, -1, |
| 'S', 'V', "SQUEEZESUBR", (anyptr) &squeezesubr, 1, |
| 'S', 'T', "USEENUM", (anyptr) &useenum, -1, |
| 'S', 'V', "SQUEEZEENUM", (anyptr) &enumbyte, -1, |
| 'S', 'V', "COMPENUMS", (anyptr) &compenums, -1, |
| 'S', 'V', "PRESERVETYPES", (anyptr) &preservetypes, 1, |
| 'S', 'V', "PRESERVEPOINTERS",(anyptr) &preservepointers, 0, |
| 'S', 'V', "PRESERVESTRINGS", (anyptr) &preservestrings, -1, |
| 'S', 'V', "PACKING", (anyptr) &packing, 1, |
| 'S', 'V', "PACKSIGNED", (anyptr) &packsigned, 1, |
| 'I', 'V', "STRINGCEILING", (anyptr) &stringceiling, 255, |
| 'I', 'V', "STRINGDEFAULT", (anyptr) &stringdefault, 255, |
| 'I', 'V', "STRINGTRUNCLIMIT",(anyptr) &stringtrunclimit, -1, |
| 'I', 'V', "LONGSTRINGSIZE", (anyptr) &longstringsize, -1, |
| 'S', 'V', "KEEPNULLS", (anyptr) &keepnulls, 0, |
| 'S', 'V', "HIGHCHARBITS", (anyptr) &highcharbits, -1, |
| 'S', 'V', "ALWAYSCOPYVALUES",(anyptr) &alwayscopyvalues, 0, |
| 'S', 'V', "STATICFUNCTIONS", (anyptr) &use_static, 1, |
| 'S', 'V', "STATICVARIABLES", (anyptr) &var_static, 1, |
| 'S', 'V', "VOIDARGS", (anyptr) &void_args, -1, |
| 'S', 'V', "PROTOTYPES", (anyptr) &prototypes, -1, |
| 'S', 'V', "FULLPROTOTYPING", (anyptr) &fullprototyping, -1, |
| 'S', 'V', "PROCPTRPROTOTYPES",(anyptr)&procptrprototypes, 1, |
| 'S', 'V', "CASTARGS", (anyptr) &castargs, -1, |
| 'S', 'V', "CASTLONGARGS", (anyptr) &castlongargs, -1, |
| 'S', 'V', "PROMOTEARGS", (anyptr) &promoteargs, -1, |
| 'S', 'V', "FIXPROMOTEDARGS", (anyptr) &fixpromotedargs, 1, |
| 'S', 'V', "PROMOTEENUMS", (anyptr) &promote_enums, -1, |
| 'S', 'V', "STATICLINKS", (anyptr) &hasstaticlinks, -1, |
| 'S', 'V', "VARSTRINGS", (anyptr) &varstrings, 0, |
| 'S', 'V', "VARFILES", (anyptr) &varfiles, 1, |
| 'S', 'V', "ADDRSTDFILES", (anyptr) &addrstdfiles, 0, |
| 'S', 'V', "COPYSTRUCTFUNCS", (anyptr) ©structfuncs, -1, |
| 'S', 'V', "ATAN2", (anyptr) &atan2flag, 0, |
| 'S', 'V', "BITWISEMOD", (anyptr) &mod_po2, -1, |
| 'S', 'V', "BITWISEDIV", (anyptr) &div_po2, -1, |
| 'S', 'V', "ASSUMEBITS", (anyptr) &assumebits, 0, |
| 'S', 'V', "ASSUMESIGNS", (anyptr) &assumesigns, 1, |
| 'S', 'V', "ALLOCZERONIL", (anyptr) &alloczeronil, 0, |
| 'S', 'V', "PRINTFONLY", (anyptr) &printfonly, -1, |
| 'S', 'V', "MIXWRITELNS", (anyptr) &mixwritelns, 1, |
| 'S', 'V', "MESSAGESTDERR", (anyptr) &messagestderr, 1, |
| 'I', 'V', "INTEGERWIDTH", (anyptr) &integerwidth, -1, |
| 'I', 'V', "REALWIDTH", (anyptr) &realwidth, 12, |
| 'S', 'V', "FORMATSTRINGS", (anyptr) &formatstrings, 0, |
| 'S', 'V', "WHILEFGETS", (anyptr) &whilefgets, 1, |
| 'S', 'V', "USEGETS", (anyptr) &usegets, 1, |
| 'S', 'V', "NEWLINESPACE", (anyptr) &newlinespace, -1, |
| 'S', 'V', "BUILDREADS", (anyptr) &buildreads, 1, |
| 'S', 'V', "BUILDWRITES", (anyptr) &buildwrites, 1, |
| 'S', 'V', "BINARYMODE", (anyptr) &binarymode, 1, |
| 'S', 'V', "READWRITEOPEN", (anyptr) &readwriteopen, -1, |
| 'C', 'V', "OPENMODE", (anyptr) openmode, 40, |
| 'S', 'V', "LITERALFILES", (anyptr) &literalfilesflag, -1, |
| 'A', 'V', "LITERALFILE", (anyptr) &literalfiles, 0, |
| 'S', 'V', "STRUCTFILES", (anyptr) &structfilesflag, 0, |
| 'A', 'V', "STRUCTFILE", (anyptr) &structfiles, 0, |
| 'C', 'V', "FILENAMEFILTER", (anyptr) filenamefilter, 40, |
| 'S', 'V', "FULLSTRWRITE", (anyptr) &fullstrwrite, -1, |
| 'S', 'V', "FULLSTRREAD", (anyptr) &fullstrread, 1, |
| 'I', 'R', "SETBITS", (anyptr) &setbits, -1, |
| 'I', 'V', "DEFAULTSETSIZE", (anyptr) &defaultsetsize, -1, |
| 'S', 'V', "SMALLSETCONST", (anyptr) &smallsetconst, -2, |
| 'S', 'V', "BIGSETCONST", (anyptr) &bigsetconst, 1, |
| 'S', 'V', "LELERANGE", (anyptr) &lelerange, 0, |
| 'S', 'V', "UNSIGNEDTRICK", (anyptr) &unsignedtrick, 1, |
| 'S', 'V', "USEISALPHA", (anyptr) &useisalpha, 1, |
| 'S', 'V', "USEISSPACE", (anyptr) &useisspace, 0, |
| 'S', 'V', "USESTRNCMP", (anyptr) &usestrncmp, 1, |
| |
| /* TARGET LIBRARY */ |
| 'G', 'V', "WARNLIBRARY", (anyptr) NULL, WARNLIBR, |
| 'S', 'V', "QUOTEINCLUDES", (anyptr) "eincludes, 1, |
| 'X', 'V', "IMPORTFROM", (anyptr) &importfrom, 1, |
| 'A', 'V', "IMPORTDIR", (anyptr) &importdirs, 0, |
| 'A', 'V', "INCLUDEDIR", (anyptr) &includedirs, 0, |
| 'X', 'V', "INCLUDEFROM", (anyptr) &includefrom, 1, |
| 'A', 'V', "LIBRARYFILE", (anyptr) &librfiles, 0, |
| 'C', 'V', "HEADERNAME", (anyptr) p2c_h_name, 40, |
| 'C', 'V', "PROCTYPENAME", (anyptr) name_PROCEDURE, 40, |
| 'C', 'V', "UCHARNAME", (anyptr) name_UCHAR, 40, |
| 'C', 'V', "SCHARNAME", (anyptr) name_SCHAR, 40, |
| 'C', 'V', "BOOLEANNAME", (anyptr) name_BOOLEAN, 40, |
| 'C', 'V', "TRUENAME", (anyptr) name_TRUE, 40, |
| 'C', 'V', "FALSENAME", (anyptr) name_FALSE, 40, |
| 'C', 'V', "NULLNAME", (anyptr) name_NULL, 40, |
| 'C', 'V', "ESCAPECODENAME", (anyptr) name_ESCAPECODE, 40, |
| 'C', 'V', "IORESULTNAME", (anyptr) name_IORESULT, 40, |
| 'C', 'V', "ARGCNAME", (anyptr) name_ARGC, 40, |
| 'C', 'V', "ARGVNAME", (anyptr) name_ARGV, 40, |
| 'C', 'V', "MAINNAME", (anyptr) name_MAIN, 40, |
| 'C', 'V', "ESCAPENAME", (anyptr) name_ESCAPE, 40, |
| 'C', 'V', "ESCIONAME", (anyptr) name_ESCIO, 40, |
| 'C', 'V', "CHECKIONAME", (anyptr) name_CHKIO, 40, |
| 'C', 'V', "SETIONAME", (anyptr) name_SETIO, 40, |
| 'C', 'V', "FILENOTFOUNDNAME",(anyptr) filenotfoundname, 40, |
| 'C', 'V', "FILENOTOPENNAME", (anyptr) filenotopenname, 40, |
| 'C', 'V', "FILEWRITEERRORNAME",(anyptr)filewriteerrorname,40, |
| 'C', 'V', "BADINPUTFORMATNAME",(anyptr)badinputformatname,40, |
| 'C', 'V', "ENDOFFILENAME", (anyptr) endoffilename, 40, |
| 'C', 'V', "OUTMEMNAME", (anyptr) name_OUTMEM, 40, |
| 'C', 'V', "CASECHECKNAME", (anyptr) name_CASECHECK, 40, |
| 'C', 'V', "NILCHECKNAME", (anyptr) name_NILCHECK, 40, |
| 'C', 'V', "SETBITSNAME", (anyptr) name_SETBITS, 40, |
| 'S', 'V', "SPRINTFVALUE", (anyptr) &sprintf_value, -1, |
| 'C', 'V', "SPRINTFNAME", (anyptr) sprintfname, 40, |
| 'C', 'V', "MEMCPYNAME", (anyptr) memcpyname, 40, |
| 'C', 'V', "ROUNDNAME", (anyptr) roundname, 40, |
| 'C', 'V', "DIVNAME", (anyptr) divname, 40, |
| 'C', 'V', "MODNAME", (anyptr) modname, 40, |
| 'C', 'V', "REMNAME", (anyptr) remname, 40, |
| 'C', 'V', "STRCICMPNAME", (anyptr) strcicmpname, 40, |
| 'C', 'V', "STRSUBNAME", (anyptr) strsubname, 40, |
| 'C', 'V', "STRPOSNAME", (anyptr) strposname, 40, |
| 'S', 'V', "STRCPYLEFT", (anyptr) &strcpyleft, 1, |
| 'C', 'V', "STRDELETENAME", (anyptr) strdeletename, 40, |
| 'C', 'V', "STRINSERTNAME", (anyptr) strinsertname, 40, |
| 'C', 'V', "STRMOVENAME", (anyptr) strmovename, 40, |
| 'C', 'V', "STRLTRIMNAME", (anyptr) strltrimname, 40, |
| 'C', 'V', "STRRTRIMNAME", (anyptr) strrtrimname, 40, |
| 'C', 'V', "STRRPTNAME", (anyptr) strrptname, 40, |
| 'C', 'V', "STRPADNAME", (anyptr) strpadname, 40, |
| 'C', 'V', "ABSNAME", (anyptr) absname, 40, |
| 'C', 'V', "ODDNAME", (anyptr) oddname, 40, |
| 'C', 'V', "EVENNAME", (anyptr) evenname, 40, |
| 'C', 'V', "SWAPNAME", (anyptr) swapname, 40, |
| 'C', 'V', "MALLOCNAME", (anyptr) mallocname, 40, |
| 'C', 'V', "FREENAME", (anyptr) freename, 40, |
| 'C', 'V', "FREERVALUENAME", (anyptr) freervaluename, 40, |
| 'X', 'V', "SPECIALMALLOC", (anyptr) &specialmallocs, 1, |
| 'X', 'V', "SPECIALFREE", (anyptr) &specialfrees, 1, |
| 'X', 'V', "SPECIALSIZEOF", (anyptr) &specialsizeofs, 1, |
| 'C', 'V', "RANDREALNAME", (anyptr) randrealname, 40, |
| 'C', 'V', "RANDINTNAME", (anyptr) randintname, 40, |
| 'C', 'V', "RANDOMIZENAME", (anyptr) randomizename, 40, |
| 'C', 'V', "SKIPSPACENAME", (anyptr) skipspacename, 40, |
| 'C', 'V', "READLNNAME", (anyptr) readlnname, 40, |
| 'C', 'V', "FREOPENNAME", (anyptr) freopenname, 40, |
| 'C', 'V', "EOFNAME", (anyptr) eofname, 40, |
| 'C', 'V', "EOLNNAME", (anyptr) eolnname, 40, |
| 'C', 'V', "FILEPOSNAME", (anyptr) fileposname, 40, |
| 'C', 'V', "MAXPOSNAME", (anyptr) maxposname, 40, |
| 'C', 'V', "SETUNIONNAME", (anyptr) setunionname, 40, |
| 'C', 'V', "SETINTNAME", (anyptr) setintname, 40, |
| 'C', 'V', "SETDIFFNAME", (anyptr) setdiffname, 40, |
| 'C', 'V', "SETXORNAME", (anyptr) setxorname, 40, |
| 'C', 'V', "SETINNAME", (anyptr) setinname, 40, |
| 'C', 'V', "SETADDNAME", (anyptr) setaddname, 40, |
| 'C', 'V', "SETADDRANGENAME", (anyptr) setaddrangename, 40, |
| 'C', 'V', "SETREMNAME", (anyptr) setremname, 40, |
| 'C', 'V', "SETEQUALNAME", (anyptr) setequalname, 40, |
| 'C', 'V', "SUBSETNAME", (anyptr) subsetname, 40, |
| 'C', 'V', "SETCOPYNAME", (anyptr) setcopyname, 40, |
| 'C', 'V', "SETEXPANDNAME", (anyptr) setexpandname, 40, |
| 'C', 'V', "SETPACKNAME", (anyptr) setpackname, 40, |
| 'C', 'V', "SIGNEXTENDNAME", (anyptr) signextname, 40, |
| 'C', 'V', "GETBITSNAME", (anyptr) getbitsname, 40, |
| 'C', 'V', "CLRBITSNAME", (anyptr) clrbitsname, 40, |
| 'C', 'V', "PUTBITSNAME", (anyptr) putbitsname, 40, |
| 'C', 'V', "STOREBITSNAME", (anyptr) storebitsname, 40, |
| 'C', 'V', "DECLBUFNAME", (anyptr) declbufname, 40, |
| 'C', 'V', "DECLBUFNCNAME", (anyptr) declbufncname, 40, |
| 'A', 'V', "BUFFEREDFILE", (anyptr) &bufferedfiles, 0, |
| 'A', 'V', "UNBUFFEREDFILE", (anyptr) &unbufferedfiles, 0, |
| 'C', 'V', "RESETBUFNAME", (anyptr) resetbufname, 40, |
| 'C', 'V', "SETUPBUFNAME", (anyptr) setupbufname, 40, |
| 'C', 'V', "GETFBUFNAME", (anyptr) getfbufname, 40, |
| 'C', 'V', "CHARGETFBUFNAME", (anyptr) chargetfbufname, 40, |
| 'C', 'V', "ARRAYGETFBUFNAME",(anyptr) arraygetfbufname, 40, |
| 'C', 'V', "PUTFBUFNAME", (anyptr) putfbufname, 40, |
| 'C', 'V', "CHARPUTFBUFNAME", (anyptr) charputfbufname, 40, |
| 'C', 'V', "ARRAYPUTFBUFNAME",(anyptr) arrayputfbufname, 40, |
| 'C', 'V', "GETNAME", (anyptr) getname, 40, |
| 'C', 'V', "CHARGETNAME", (anyptr) chargetname, 40, |
| 'C', 'V', "ARRAYGETNAME", (anyptr) arraygetname, 40, |
| 'C', 'V', "PUTNAME", (anyptr) putname, 40, |
| 'C', 'V', "CHARPUTNAME", (anyptr) charputname, 40, |
| 'C', 'V', "ARRAYPUTNAME", (anyptr) arrayputname, 40, |
| 'C', 'V', "EOFBUFNAME", (anyptr) eofbufname, 40, |
| 'C', 'V', "FILEPOSBUFNAME", (anyptr) fileposbufname, 40, |
| |
| /* RANGE CHECKING */ |
| 'S', 'V', "CASECHECK", (anyptr) &casecheck, 0, |
| 'S', 'V', "ARRAYCHECK", (anyptr) &arraycheck, 0, |
| 'S', 'V', "RANGECHECK", (anyptr) &rangecheck, 0, |
| 'S', 'V', "NILCHECK", (anyptr) &nilcheck, 0, |
| 'S', 'V', "MALLOCCHECK", (anyptr) &malloccheck, 0, |
| 'S', 'V', "CHECKFILEOPEN", (anyptr) &checkfileopen, 1, |
| 'S', 'V', "CHECKFILEISOPEN", (anyptr) &checkfileisopen, 0, |
| 'S', 'V', "CHECKFILEWRITE", (anyptr) &checkfilewrite, 2, |
| 'S', 'V', "CHECKREADFORMAT", (anyptr) &checkreadformat, 2, |
| 'S', 'V', "CHECKFILEEOF", (anyptr) &checkfileeof, 2, |
| 'S', 'V', "CHECKSTDINEOF", (anyptr) &checkstdineof, 2, |
| 'S', 'V', "CHECKFILESEEK", (anyptr) &checkfileseek, 2, |
| } |
| #endif /* define_parameters */ |
| ; |
| |
| |
| #undef extern |
| |
| |
| #ifdef define_parameters |
| int numparams = sizeof(rctable) / sizeof(struct rcstruct); |
| Strlist *rcprevvalues[sizeof(rctable) / sizeof(struct rcstruct)]; |
| #else |
| extern int numparams; |
| extern Strlist *rcprevvalues[]; |
| #endif /* define_parameters */ |
| |
| |
| |
| /* Global variables: */ |
| |
| #ifdef define_globals |
| # define extern |
| #endif /* define_globals */ |
| |
| |
| extern char *charname, *ucharname, *scharname, *integername; |
| extern long min_schar, max_schar, max_uchar; |
| extern long min_sshort, max_sshort, max_ushort; |
| |
| extern char *alloctemp; |
| extern short error_crash; |
| extern int total_bytes, total_exprs, total_meanings, total_strings; |
| extern int total_symbols, total_types, total_stmts, total_strlists; |
| extern int total_literals, total_ctxstacks, total_tempvars, total_inprecs; |
| extern int total_parens, total_ptrdescs, total_misc; |
| extern int final_bytes, final_exprs, final_meanings, final_strings; |
| extern int final_symbols, final_types, final_stmts, final_strlists; |
| extern int final_literals, final_ctxstacks, final_tempvars, final_inprecs; |
| extern int final_parens, final_ptrdescs, final_misc; |
| |
| extern char *infname, *outfname, *codefname, *hdrfname; |
| extern char *requested_module; |
| extern FILE *inf, *outf, *codef, *hdrf, *logf; |
| extern short setup_complete, found_module; |
| extern short regression, verbose, conserve_mem; |
| extern int inf_lnum, inf_ltotal; |
| |
| extern int outindent, outputmode; |
| extern int outf_lnum; |
| extern short dontbreaklines; |
| |
| extern Token curtok; |
| extern char curtokbuf[256], curtokcase[256]; |
| extern char *inbufptr; |
| extern int inbufindent; |
| extern long curtokint; |
| extern Symbol *curtoksym; |
| extern Meaning *curtokmeaning; |
| extern Strlist *curcomments; |
| extern Strlist **keepingstrlist; |
| extern short ignore_directives, skipping_module; |
| extern short C_lex; |
| extern char sysprog_flag, partial_eval_flag, iocheck_flag; |
| extern char range_flag, ovflcheck_flag, stackcheck_flag; |
| extern short switch_strpos; |
| extern int fixedflag; |
| extern int numimports; |
| extern Strlist *tempoptionlist; |
| extern long curserial, serialcount; |
| extern int notephase; |
| extern Strlist *permimports; |
| extern int permflag; |
| |
| #define SYMHASHSIZE 293 |
| extern Symbol *(symtab[SYMHASHSIZE]); |
| extern short partialdump; |
| |
| #define MAXWITHS 100 |
| extern int withlevel; |
| extern Type *withlist[MAXWITHS]; |
| extern Expr *withexprs[MAXWITHS]; |
| |
| extern Token blockkind; |
| extern Meaning *curctx, *curctxlast, *nullctx; |
| |
| extern int fixexpr_tryblock; |
| extern short fixexpr_tryflag; |
| |
| extern Type *tp_integer, *tp_char, *tp_boolean, *tp_real, *tp_longreal; |
| extern Type *tp_anyptr, *tp_jmp_buf, *tp_schar, *tp_uchar, *tp_charptr; |
| extern Type *tp_int, *tp_sshort, *tp_ushort, *tp_abyte, *tp_sbyte, *tp_ubyte; |
| extern Type *tp_void, *tp_str255, *tp_strptr, *tp_text, *tp_bigtext; |
| extern Type *tp_unsigned, *tp_uint, *tp_sint, *tp_smallset, *tp_proc; |
| extern Meaning *mp_string, *mp_true, *mp_false; |
| extern Meaning *mp_input, *mp_output, *mp_stderr; |
| extern Meaning *mp_maxint, *mp_minint, *mp_escapecode, *mp_ioresult; |
| extern Meaning *mp_uchar, *mp_schar, *mp_unsigned, *mp_uint; |
| extern Meaning *mp_str_hp, *mp_str_turbo; |
| extern Meaning *mp_val_modula, *mp_val_turbo; |
| extern Meaning *mp_blockread_ucsd, *mp_blockread_turbo; |
| extern Meaning *mp_blockwrite_ucsd, *mp_blockwrite_turbo; |
| extern Meaning *mp_dec_dec, *mp_dec_turbo; |
| extern Expr *ex_input, *ex_output; |
| extern Strlist *attrlist; |
| |
| |
| #ifndef define_globals |
| # undef extern |
| #endif |
| |
| |
| |
| |
| /* Function declarations are created automatically by "makeproto" */ |
| |
| #include "p2c.hdrs" |
| |
| #include "p2c.proto" |
| |
| |
| |
| /* Our library omits declarations for these functions! */ |
| |
| int link PP( (char *, char *) ); |
| int unlink PP( (char *) ); |
| |
| |
| |
| #define minspcthresh ((minspacingthresh >= 0) ? minspacingthresh : minspacing) |
| |
| #define delfreearg(ex, n) freeexpr((*(ex))->args[n]), deletearg(ex, n) |
| #define delsimpfreearg(ex, n) freeexpr((*(ex))->args[n]), delsimparg(ex, n) |
| |
| #define swapexprs(a,b) do {register Expr *t=(a);(a)=(b);(b)=(t);} while (0) |
| #define swapstmts(a,b) do {register Stmt *t=(a);(a)=(b);(b)=(t);} while (0) |
| |
| #define CHECKORDEXPR(ex,v) ((ex)->kind==EK_CONST ? (ex)->val.i - (v) : -2) |
| |
| #define FCheck(flag) ((flag) == 1 || (!iocheck_flag && (flag))) |
| #define checkeof(fex) (isvar(fex, mp_input) ? FCheck(checkstdineof) \ |
| : FCheck(checkfileeof)) |
| |
| |
| #ifdef TEST_MALLOC /* Memory testing */ |
| |
| #define ALLOC(N,TYPE,NAME) \ |
| (TYPE *) test_malloc((unsigned)((N)*sizeof(TYPE)), \ |
| &__CAT__(total_,NAME), &__CAT__(final_,NAME)) |
| |
| #define ALLOCV(N,TYPE,NAME) \ |
| (TYPE *) test_malloc((unsigned)(N), \ |
| &__CAT__(total_,NAME), &__CAT__(final_,NAME)) |
| |
| #define REALLOC(P,N,TYPE) \ |
| (TYPE *) test_realloc((char *)(P), (unsigned)((N)*sizeof(TYPE))) |
| |
| #define FREE(P) test_free((char*)(P)) |
| |
| #else /* not TEST_MALLOC */ |
| |
| /* If p2c always halts immediately with an out-of-memory error, try |
| recompiling all modules with BROKEN_OR defined. */ |
| #ifdef BROKEN_OR |
| |
| #define ALLOC(N,TYPE,NAME) \ |
| ((alloctemp = malloc((unsigned)((N)*sizeof(TYPE)))), \ |
| (alloctemp ? (TYPE *) alloctemp : (TYPE *) outmem())) |
| |
| #define ALLOCV(N,TYPE,NAME) \ |
| ((alloctemp = malloc((unsigned)(N))), \ |
| (alloctemp ? (TYPE *) alloctemp : (TYPE *) outmem())) |
| |
| #define REALLOC(P,N,TYPE) \ |
| ((alloctemp = realloc((char*)(P), (unsigned)((N)*sizeof(TYPE)))), \ |
| (alloctemp ? (TYPE *) alloctemp : (TYPE *) outmem())) |
| |
| #define FREE(P) free((char*)(P)) |
| |
| #else /* not BROKEN_OR */ |
| |
| #define ALLOC(N,TYPE,NAME) \ |
| ((alloctemp = malloc((unsigned)((N)*sizeof(TYPE)))) || outmem(), \ |
| (TYPE *) alloctemp) |
| |
| #define ALLOCV(N,TYPE,NAME) \ |
| ((alloctemp = malloc((unsigned)(N))) || outmem(), \ |
| (TYPE *) alloctemp) |
| |
| #define REALLOC(P,N,TYPE) \ |
| ((alloctemp = realloc((char*)(P), (unsigned)((N)*sizeof(TYPE)))) || outmem(), \ |
| (TYPE *) alloctemp) |
| |
| #define FREE(P) free((char*)(P)) |
| |
| #endif /* BROKEN_OR */ |
| #endif /* TEST_MALLOC */ |
| |
| |
| #define MIN(a,b) ((a) < (b) ? (a) : (b)) |
| #define MAX(a,b) ((a) > (b) ? (a) : (b)) |
| |
| |
| |
| #ifdef toupper |
| # undef toupper |
| # undef tolower |
| # define toupper(c) my_toupper(c) |
| # define tolower(c) my_tolower(c) |
| #endif |
| |
| #ifndef _toupper |
| # if 'A' == 65 && 'a' == 97 |
| # define _toupper(c) ((c)-'a'+'A') |
| # define _tolower(c) ((c)-'A'+'a') |
| # else |
| # ifdef toupper |
| # undef toupper /* hope these are shadowing real functions, */ |
| # undef tolower /* because my_toupper calls _toupper! */ |
| # endif |
| # define _toupper(c) toupper(c) |
| # define _tolower(c) tolower(c) |
| # endif |
| #endif |
| |
| |
| |
| |
| /* End. */ |
| |
