--- /dev/null
+# This is a shell archive. Save it in a file, remove anything before
+# this line, and then unpack it by entering "sh file". Note, it may
+# create directories; files and directories will be owned by you and
+# have default permissions.
+#
+# This archive contains:
+#
+# cpp1.c
+# cpp3.c
+# cpp4.c
+#
+echo x - cpp1.c
+sed 's/^X//' >cpp1.c << 'END-of-cpp1.c'
+X/*
+X * CPP main program.
+X *
+X * Edit history
+X * 21-May-84 MM "Field test" release
+X * 23-May-84 MM Some minor hacks.
+X * 30-May-84 ARF Didn't get enough memory for __DATE__
+X * Added code to read stdin if no input
+X * files are provided.
+X * 29-Jun-84 MM Added ARF's suggestions, Unixifying cpp.
+X * 11-Jul-84 MM "Official" first release (that's what I thought!)
+X * 22-Jul-84 MM/ARF/SCK Fixed line number bugs, added cpp recognition
+X * of #line, fixed problems with #include.
+X * 23-Jul-84 MM More (minor) include hacking, some documentation.
+X * Also, redid cpp's #include files
+X * 25-Jul-84 MM #line filename isn't used for #include searchlist
+X * #line format is <number> <optional name>
+X * 25-Jul-84 ARF/MM Various bugs, mostly serious. Removed homemade doprint
+X * 01-Aug-84 MM Fixed recursion bug, remove extra newlines and
+X * leading whitespace from cpp output.
+X * 02-Aug-84 MM Hacked (i.e. optimized) out blank lines and unneeded
+X * whitespace in general. Cleaned up unget()'s.
+X * 03-Aug-84 Keie Several bug fixes from Ed Keizer, Vrije Universitet.
+X * -- corrected arg. count in -D and pre-defined
+X * macros. Also, allow \n inside macro actual parameter
+X * lists.
+X * 06-Aug-84 MM If debugging, dump the preset vector at startup.
+X * 12-Aug-84 MM/SCK Some small changes from Sam Kendall
+X * 15-Aug-84 Keie/MM cerror, cwarn, etc. take a single string arg.
+X * cierror, etc. take a single int. arg.
+X * changed LINE_PREFIX slightly so it can be
+X * changed in the makefile.
+X * 31-Aug-84 MM USENET net.sources release.
+X * 7-Sep-84 SCH/ado Lint complaints
+X * 10-Sep-84 Keie Char's can't be signed in some implementations
+X * 11-Sep-84 ado Added -C flag, pathological line number fix
+X * 13-Sep-84 ado Added -E flag (does nothing) and "-" file for stdin.
+X * 14-Sep-84 MM Allow # 123 as a synonym for #line 123
+X * 19-Sep-84 MM scanid always reads to token, make sure #line is
+X * written to a new line, even if -C switch given.
+X * Also, cpp - - reads stdin, writes stdout.
+X * 03-Oct-84 ado/MM Several changes to line counting and keepcomments
+X * stuff. Also a rewritten control() hasher -- much
+X * simpler and no less "perfect". Note also changes
+X * in cpp3.c to fix numeric scanning.
+X * 04-Oct-84 MM Added recognition of macro formal parameters if
+X * they are the only thing in a string, per the
+X * draft standard.
+X * 08-Oct-84 MM One more attack on scannumber
+X * 15-Oct-84 MM/ado Added -N to disable predefined symbols. Fixed
+X * linecount if COMMENT_INVISIBLE enabled.
+X * 22-Oct-84 MM Don't evaluate the #if/#ifdef argument if
+X * compilation is supressed. This prevents
+X * unnecessary error messages in sequences such as
+X * #ifdef FOO -- undefined
+X * #if FOO == 10 -- shouldn't print warning
+X * 25-Oct-84 MM Fixed bug in false ifdef supression. On vms,
+X * #include <foo> should open foo.h -- this duplicates
+X * the behavior of Vax-C
+X * 31-Oct-84 ado/MM Parametized $ in indentifiers. Added a better
+X * token concatenator and took out the trial
+X * concatenation code. Also improved #ifdef code
+X * and cleaned up the macro recursion tester.
+X * 2-Nov-84 MM/ado Some bug fixes in token concatenation, also
+X * a variety of minor (uninteresting) hacks.
+X * 6-Nov-84 MM Happy Birthday. Broke into 4 files and added
+X * #if sizeof (basic_types)
+X * 9-Nov-84 MM Added -S* for pointer type sizes
+X * 13-Nov-84 MM Split cpp1.c, added vms defaulting
+X * 23-Nov-84 MM/ado -E supresses error exit, added CPP_INCLUDE,
+X * fixed strncpy bug.
+X * 3-Dec-84 ado/MM Added OLD_PREPROCESSOR
+X * 7-Dec-84 MM Stuff in Nov 12 Draft Standard
+X * 17-Dec-84 george Fixed problems with recursive macros
+X * 17-Dec-84 MM Yet another attack on #if's (f/t)level removed.
+X * 07-Jan-85 ado Init defines before doing command line options
+X * so -Uunix works.
+X */
+X
+X/*)BUILD
+X $(PROGRAM) = cpp
+X $(FILES) = { cpp1 cpp2 cpp3 cpp4 cpp5 cpp6 }
+X $(INCLUDE) = { cppdef.h cpp.h }
+X $(STACK) = 2000
+X $(TKBOPTIONS) = {
+X STACK = 2000
+X }
+X*/
+X
+X#ifdef DOCUMENTATION
+X
+Xtitle cpp C Pre-Processor
+Xindex C pre-processor
+X
+Xsynopsis
+X .s.nf
+X cpp [-options] [infile [outfile]]
+X .s.f
+Xdescription
+X
+X CPP reads a C source file, expands macros and include
+X files, and writes an input file for the C compiler.
+X If no file arguments are given, CPP reads from stdin
+X and writes to stdout. If one file argument is given,
+X it will define the input file, while two file arguments
+X define both input and output files. The file name "-"
+X is a synonym for stdin or stdout as appropriate.
+X
+X The following options are supported. Options may
+X be given in either case.
+X .lm +16
+X .p -16
+X -C If set, source-file comments are written
+X to the output file. This allows the output of CPP to be
+X used as the input to a program, such as lint, that expects
+X commands embedded in specially-formatted comments.
+X .p -16
+X -Dname=value Define the name as if the programmer wrote
+X
+X #define name value
+X
+X at the start of the first file. If "=value" is not
+X given, a value of "1" will be used.
+X
+X On non-unix systems, all alphabetic text will be forced
+X to upper-case.
+X .p -16
+X -E Always return "success" to the operating
+X system, even if errors were detected. Note that some fatal
+X errors, such as a missing #include file, will terminate
+X CPP, returning "failure" even if the -E option is given.
+X .p -16
+X -Idirectory Add this directory to the list of
+X directories searched for #include "..." and #include <...>
+X commands. Note that there is no space between the
+X "-I" and the directory string. More than one -I command
+X is permitted. On non-Unix systems "directory" is forced
+X to upper-case.
+X .p -16
+X -N CPP normally predefines some symbols defining
+X the target computer and operating system. If -N is specified,
+X no symbols will be predefined. If -N -N is specified, the
+X "always present" symbols, __LINE__, __FILE__, and __DATE__
+X are not defined.
+X .p -16
+X -Stext CPP normally assumes that the size of
+X the target computer's basic variable types is the same as the size
+X of these types of the host computer. (This can be overridden
+X when CPP is compiled, however.) The -S option allows dynamic
+X respecification of these values. "text" is a string of
+X numbers, separated by commas, that specifies correct sizes.
+X The sizes must be specified in the exact order:
+X
+X char short int long float double
+X
+X If you specify the option as "-S*text", pointers to these
+X types will be specified. -S* takes one additional argument
+X for pointer to function (e.g. int (*)())
+X
+X For example, to specify sizes appropriate for a PDP-11,
+X you would write:
+X
+X c s i l f d func
+X -S1,2,2,2,4,8,
+X -S*2,2,2,2,2,2,2
+X
+X Note that all values must be specified.
+X .p -16
+X -Uname Undefine the name as if
+X
+X #undef name
+X
+X were given. On non-Unix systems, "name" will be forced to
+X upper-case.
+X .p -16
+X -Xnumber Enable debugging code. If no value is
+X given, a value of 1 will be used. (For maintenence of
+X CPP only.)
+X .s.lm -16
+X
+XPre-Defined Variables
+X
+X When CPP begins processing, the following variables will
+X have been defined (unless the -N option is specified):
+X .s
+X Target computer (as appropriate):
+X .s
+X pdp11, vax, M68000 m68000 m68k
+X .s
+X Target operating system (as appropriate):
+X .s
+X rsx, rt11, vms, unix
+X .s
+X Target compiler (as appropriate):
+X .s
+X decus, vax11c
+X .s
+X The implementor may add definitions to this list.
+X The default definitions match the definition of the
+X host computer, operating system, and C compiler.
+X .s
+X The following are always available unless undefined (or
+X -N was specified twice):
+X .lm +16
+X .p -12
+X __FILE__ The input (or #include) file being compiled
+X (as a quoted string).
+X .p -12
+X __LINE__ The line number being compiled.
+X .p -12
+X __DATE__ The date and time of compilation as
+X a Unix ctime quoted string (the trailing newline is removed).
+X Thus,
+X .s
+X printf("Bug at line %s,", __LINE__);
+X printf(" source file %s", __FILE__);
+X printf(" compiled on %s", __DATE__);
+X .s.lm -16
+X
+XDraft Proposed Ansi Standard Considerations
+X
+X The current version of the Draft Proposed Standard
+X explicitly states that "readers are requested not to specify
+X or claim conformance to this draft." Readers and users
+X of Decus CPP should not assume that Decus CPP conforms
+X to the standard, or that it will conform to the actual
+X C Language Standard.
+X
+X When CPP is itself compiled, many features of the Draft
+X Proposed Standard that are incompatible with existing
+X preprocessors may be disabled. See the comments in CPP's
+X source for details.
+X
+X The latest version of the Draft Proposed Standard (as reflected
+X in Decus CPP) is dated November 12, 1984.
+X
+X Comments are removed from the input text. The comment
+X is replaced by a single space character. The -C option
+X preserves comments, writing them to the output file.
+X
+X The '$' character is considered to be a letter. This is
+X a permitted extension.
+X
+X The following new features of C are processed by CPP:
+X .s.comment Note: significant spaces, not tabs, .br quotes #if, #elif
+X .br;####_#elif expression (_#else _#if)
+X .br;####'_\xNNN' (Hexadecimal constant)
+X .br;####'_\a' (Ascii BELL)
+X .br;####'_\v' (Ascii Vertical Tab)
+X .br;####_#if defined NAME 1 if defined, 0 if not
+X .br;####_#if defined (NAME) 1 if defined, 0 if not
+X .br;####_#if sizeof (basic type)
+X .br;####unary +
+X .br;####123U, 123LU Unsigned ints and longs.
+X .br;####12.3L Long double numbers
+X .br;####token_#token Token concatenation
+X .br;####_#include token Expands to filename
+X
+X The Draft Proposed Standard has extended C, adding a constant
+X string concatenation operator, where
+X
+X "foo" "bar"
+X
+X is regarded as the single string "foobar". (This does not
+X affect CPP's processing but does permit a limited form of
+X macro argument substitution into strings as will be discussed.)
+X
+X The Standard Committee plans to add token concatenation
+X to #define command lines. One suggested implementation
+X is as follows: the sequence "Token1#Token2" is treated
+X as if the programmer wrote "Token1Token2". This could
+X be used as follows:
+X
+X #line 123
+X #define ATLINE foo#__LINE__
+X
+X ATLINE would be defined as foo123.
+X
+X Note that "Token2" must either have the format of an
+X identifier or be a string of digits. Thus, the string
+X
+X #define ATLINE foo#1x3
+X
+X generates two tokens: "foo1" and "x3".
+X
+X If the tokens T1 and T2 are concatenated into T3,
+X this implementation operates as follows:
+X
+X 1. Expand T1 if it is a macro.
+X 2. Expand T2 if it is a macro.
+X 3. Join the tokens, forming T3.
+X 4. Expand T3 if it is a macro.
+X
+X A macro formal parameter will be substituted into a string
+X or character constant if it is the only component of that
+X constant:
+X
+X #define VECSIZE 123
+X #define vprint(name, size) \
+X printf("name" "[" "size" "] = {\n")
+X ... vprint(vector, VECSIZE);
+X
+X expands (effectively) to
+X
+X vprint("vector[123] = {\n");
+X
+X Note that this will be useful if your C compiler supports
+X the new string concatenation operation noted above.
+X As implemented here, if you write
+X
+X #define string(arg) "arg"
+X ... string("foo") ...
+X
+X This implementation generates "foo", rather than the strictly
+X correct ""foo"" (which will probably generate an error message).
+X This is, strictly speaking, an error in CPP and may be removed
+X from future releases.
+X
+Xerror messages
+X
+X Many. CPP prints warning or error messages if you try to
+X use multiple-byte character constants (non-transportable)
+X if you #undef a symbol that was not defined, or if your
+X program has potentially nested comments.
+X
+Xauthor
+X
+X Martin Minow
+X
+Xbugs
+X
+X The #if expression processor uses signed integers only.
+X I.e, #if 0xFFFFu < 0 may be TRUE.
+X
+X#endif
+X\f
+X#include <stdio.h>
+X#include <ctype.h>
+X#include "cppdef.h"
+X#include "cpp.h"
+X
+X/*
+X * Commonly used global variables:
+X * line is the current input line number.
+X * wrongline is set in many places when the actual output
+X * line is out of sync with the numbering, e.g,
+X * when expanding a macro with an embedded newline.
+X *
+X * token holds the last identifier scanned (which might
+X * be a candidate for macro expansion).
+X * errors is the running cpp error counter.
+X * infile is the head of a linked list of input files (extended by
+X * #include and macros being expanded). infile always points
+X * to the current file/macro. infile->parent to the includer,
+X * etc. infile->fd is NULL if this input stream is a macro.
+X */
+Xint line; /* Current line number */
+Xint wrongline; /* Force #line to compiler */
+Xchar token[IDMAX + 1]; /* Current input token */
+Xint errors; /* cpp error counter */
+XFILEINFO *infile = NULL; /* Current input file */
+X#if DEBUG
+Xint debug; /* TRUE if debugging now */
+X#endif
+X/*
+X * This counter is incremented when a macro expansion is initiated.
+X * If it exceeds a built-in value, the expansion stops -- this tests
+X * for a runaway condition:
+X * #define X Y
+X * #define Y X
+X * X
+X * This can be disabled by falsifying rec_recover. (Nothing does this
+X * currently: it is a hook for an eventual invocation flag.)
+X */
+Xint recursion; /* Infinite recursion counter */
+Xint rec_recover = TRUE; /* Unwind recursive macros */
+X
+X/*
+X * instring is set TRUE when a string is scanned. It modifies the
+X * behavior of the "get next character" routine, causing all characters
+X * to be passed to the caller (except <DEF_MAGIC>). Note especially that
+X * comments and \<newline> are not removed from the source. (This
+X * prevents cpp output lines from being arbitrarily long).
+X *
+X * inmacro is set by #define -- it absorbs comments and converts
+X * form-feed and vertical-tab to space, but returns \<newline>
+X * to the caller. Strictly speaking, this is a bug as \<newline>
+X * shouldn't delimit tokens, but we'll worry about that some other
+X * time -- it is more important to prevent infinitly long output lines.
+X *
+X * instring and inmarcor are parameters to the get() routine which
+X * were made global for speed.
+X */
+Xint instring = FALSE; /* TRUE if scanning string */
+Xint inmacro = FALSE; /* TRUE if #defining a macro */
+X
+X/*
+X * work[] and workp are used to store one piece of text in a temporay
+X * buffer. To initialize storage, set workp = work. To store one
+X * character, call save(c); (This will fatally exit if there isn't
+X * room.) To terminate the string, call save(EOS). Note that
+X * the work buffer is used by several subroutines -- be sure your
+X * data won't be overwritten. The extra byte in the allocation is
+X * needed for string formal replacement.
+X */
+Xchar work[NWORK + 1]; /* Work buffer */
+Xchar *workp; /* Work buffer pointer */
+X
+X/*
+X * keepcomments is set TRUE by the -C option. If TRUE, comments
+X * are written directly to the output stream. This is needed if
+X * the output from cpp is to be passed to lint (which uses commands
+X * embedded in comments). cflag contains the permanent state of the
+X * -C flag. keepcomments is always falsified when processing #control
+X * commands and when compilation is supressed by a false #if
+X *
+X * If eflag is set, CPP returns "success" even if non-fatal errors
+X * were detected.
+X *
+X * If nflag is non-zero, no symbols are predefined except __LINE__.
+X * __FILE__, and __DATE__. If nflag > 1, absolutely no symbols
+X * are predefined.
+X */
+Xint keepcomments = FALSE; /* Write out comments flag */
+Xint cflag = FALSE; /* -C option (keep comments) */
+Xint eflag = FALSE; /* -E option (never fail) */
+Xint nflag = 0; /* -N option (no predefines) */
+X
+X/*
+X * ifstack[] holds information about nested #if's. It is always
+X * accessed via *ifptr. The information is as follows:
+X * WAS_COMPILING state of compiling flag at outer level.
+X * ELSE_SEEN set TRUE when #else seen to prevent 2nd #else.
+X * TRUE_SEEN set TRUE when #if or #elif succeeds
+X * ifstack[0] holds the compiling flag. It is TRUE if compilation
+X * is currently enabled. Note that this must be initialized TRUE.
+X */
+Xchar ifstack[BLK_NEST] = { TRUE }; /* #if information */
+Xchar *ifptr = ifstack; /* -> current ifstack[] */
+X
+X/*
+X * incdir[] stores the -i directories (and the system-specific
+X * #include <...> directories.
+X */
+Xchar *incdir[NINCLUDE]; /* -i directories */
+Xchar **incend = incdir; /* -> free space in incdir[] */
+X
+X/*
+X * This is the table used to predefine target machine and operating
+X * system designators. It may need hacking for specific circumstances.
+X * Note: it is not clear that this is part of the Ansi Standard.
+X * The -N option supresses preset definitions.
+X */
+Xchar *preset[] = { /* names defined at cpp start */
+X#ifdef MACHINE
+X MACHINE,
+X#endif
+X#ifdef SYSTEM
+X SYSTEM,
+X#endif
+X#ifdef COMPILER
+X COMPILER,
+X#endif
+X#if DEBUG
+X "decus_cpp", /* Ourselves! */
+X#endif
+X NULL /* Must be last */
+X};
+X
+X/*
+X * The value of these predefined symbols must be recomputed whenever
+X * they are evaluated. The order must not be changed.
+X */
+Xchar *magic[] = { /* Note: order is important */
+X "__LINE__",
+X "__FILE__",
+X NULL /* Must be last */
+X};
+X\f
+Xmain(argc, argv)
+Xint argc;
+Xchar *argv[];
+X{
+X register int i;
+X
+X#if HOST == SYS_VMS
+X argc = getredirection(argc, argv); /* vms >file and <file */
+X#endif
+X initdefines(); /* O.S. specific def's */
+X i = dooptions(argc, argv); /* Command line -flags */
+X switch (i) {
+X case 3:
+X /*
+X * Get output file, "-" means use stdout.
+X */
+X if (!streq(argv[2], "-")) {
+X#if HOST == SYS_VMS
+X /*
+X * On vms, reopen stdout with "vanilla rms" attributes.
+X */
+X if ((i = creat(argv[2], 0, "rat=cr", "rfm=var")) == -1
+X || dup2(i, fileno(stdout)) == -1) {
+X#else
+X if (freopen(argv[2], "w", stdout) == NULL) {
+X#endif
+X perror(argv[2]);
+X cerror("Can't open output file \"%s\"", argv[2]);
+X exit(IO_ERROR);
+X }
+X } /* Continue by opening input */
+X case 2: /* One file -> stdin */
+X /*
+X * Open input file, "-" means use stdin.
+X */
+X if (!streq(argv[1], "-")) {
+X if (freopen(argv[1], "r", stdin) == NULL) {
+X perror(argv[1]);
+X cerror("Can't open input file \"%s\"", argv[1]);
+X exit(IO_ERROR);
+X }
+X strcpy(work, argv[1]); /* Remember input filename */
+X break;
+X } /* Else, just get stdin */
+X case 0: /* No args? */
+X case 1: /* No files, stdin -> stdout */
+X#if HOST == SYS_UNIX
+X work[0] = EOS; /* Unix can't find stdin name */
+X#else
+X fgetname(stdin, work); /* Vax-11C, Decus C know name */
+X#endif
+X break;
+X
+X default:
+X exit(IO_ERROR); /* Can't happen */
+X }
+X setincdirs(); /* Setup -I include directories */
+X addfile(stdin, work); /* "open" main input file */
+X#if DEBUG
+X if (debug > 0)
+X dumpdef("preset #define symbols");
+X#endif
+X cppmain(); /* Process main file */
+X if ((i = (ifptr - &ifstack[0])) != 0) {
+X#if OLD_PREPROCESSOR
+X ciwarn("Inside #ifdef block at end of input, depth = %d", i);
+X#else
+X cierror("Inside #ifdef block at end of input, depth = %d", i);
+X#endif
+X }
+X fclose(stdout);
+X if (errors > 0) {
+X fprintf(stderr, (errors == 1)
+X ? "%d error in preprocessor\n"
+X : "%d errors in preprocessor\n", errors);
+X if (!eflag)
+X exit(IO_ERROR);
+X }
+X exit(IO_NORMAL); /* No errors or -E option set */
+X}
+X\f
+XFILE_LOCAL
+Xcppmain()
+X/*
+X * Main process for cpp -- copies tokens from the current input
+X * stream (main file, include file, or a macro) to the output
+X * file.
+X */
+X{
+X register int c; /* Current character */
+X register int counter; /* newlines and spaces */
+X extern int output(); /* Output one character */
+X
+X /*
+X * Explicitly output a #line at the start of cpp output so
+X * that lint (etc.) knows the name of the original source
+X * file. If we don't do this explicitly, we may get
+X * the name of the first #include file instead.
+X */
+X sharp();
+X /*
+X * This loop is started "from the top" at the beginning of each line
+X * wrongline is set TRUE in many places if it is necessary to write
+X * a #line record. (But we don't write them when expanding macros.)
+X *
+X * The counter variable has two different uses: at
+X * the start of a line, it counts the number of blank lines that
+X * have been skipped over. These are then either output via
+X * #line records or by outputting explicit blank lines.
+X * When expanding tokens within a line, the counter remembers
+X * whether a blank/tab has been output. These are dropped
+X * at the end of the line, and replaced by a single blank
+X * within lines.
+X */
+X for (;;) {
+X counter = 0; /* Count empty lines */
+X for (;;) { /* For each line, ... */
+X while (type[(c = get())] == SPA) /* Skip leading blanks */
+X ; /* in this line. */
+X if (c == '\n') /* If line's all blank, */
+X ++counter; /* Do nothing now */
+X else if (c == '#') { /* Is 1st non-space '#' */
+X keepcomments = FALSE; /* Don't pass comments */
+X counter = control(counter); /* Yes, do a #command */
+X keepcomments = (cflag && compiling);
+X }
+X else if (c == EOF_CHAR) /* At end of file? */
+X break;
+X else if (!compiling) { /* #ifdef false? */
+X skipnl(); /* Skip to newline */
+X counter++; /* Count it, too. */
+X }
+X else {
+X break; /* Actual token */
+X }
+X }
+X if (c == EOF_CHAR) /* Exit process at */
+X break; /* End of file */
+X /*
+X * If the loop didn't terminate because of end of file, we
+X * know there is a token to compile. First, clean up after
+X * absorbing newlines. counter has the number we skipped.
+X */
+X if ((wrongline && infile->fp != NULL) || counter > 4)
+X sharp(); /* Output # line number */
+X else { /* If just a few, stuff */
+X while (--counter >= 0) /* them out ourselves */
+X putchar('\n');
+X }
+X /*
+X * Process each token on this line.
+X */
+X unget(); /* Reread the char. */
+X for (;;) { /* For the whole line, */
+X do { /* Token concat. loop */
+X for (counter = 0; (type[(c = get())] == SPA);) {
+X#if COMMENT_INVISIBLE
+X if (c != COM_SEP)
+X counter++;
+X#else
+X counter++; /* Skip over blanks */
+X#endif
+X }
+X if (c == EOF_CHAR || c == '\n')
+X goto end_line; /* Exit line loop */
+X else if (counter > 0) /* If we got any spaces */
+X putchar(' '); /* Output one space */
+X c = macroid(c); /* Grab the token */
+X } while (type[c] == LET && catenate());
+X if (c == EOF_CHAR || c == '\n') /* From macro exp error */
+X goto end_line; /* Exit line loop */
+X switch (type[c]) {
+X case LET:
+X fputs(token, stdout); /* Quite ordinary token */
+X break;
+X
+X
+X case DIG: /* Output a number */
+X case DOT: /* Dot may begin floats */
+X scannumber(c, output);
+X break;
+X
+X case QUO: /* char or string const */
+X scanstring(c, output); /* Copy it to output */
+X break;
+X
+X default: /* Some other character */
+X cput(c); /* Just output it */
+X break;
+X } /* Switch ends */
+X } /* Line for loop */
+Xend_line: if (c == '\n') { /* Compiling at EOL? */
+X putchar('\n'); /* Output newline, if */
+X if (infile->fp == NULL) /* Expanding a macro, */
+X wrongline = TRUE; /* Output # line later */
+X }
+X } /* Continue until EOF */
+X}
+X\f
+Xoutput(c)
+Xint c;
+X/*
+X * Output one character to stdout -- output() is passed as an
+X * argument to scanstring()
+X */
+X{
+X#if COMMENT_INVISIBLE
+X if (c != TOK_SEP && c != COM_SEP)
+X#else
+X if (c != TOK_SEP)
+X#endif
+X putchar(c);
+X}
+X
+Xstatic char *sharpfilename = NULL;
+X
+XFILE_LOCAL
+Xsharp()
+X/*
+X * Output a line number line.
+X */
+X{
+X register char *name;
+X
+X if (keepcomments) /* Make sure # comes on */
+X putchar('\n'); /* a fresh, new line. */
+X printf("#%s %d", LINE_PREFIX, line);
+X if (infile->fp != NULL) {
+X name = (infile->progname != NULL)
+X ? infile->progname : infile->filename;
+X if (sharpfilename == NULL
+X || sharpfilename != NULL && !streq(name, sharpfilename)) {
+X if (sharpfilename != NULL)
+X free(sharpfilename);
+X sharpfilename = savestring(name);
+X printf(" \"%s\"", name);
+X }
+X }
+X putchar('\n');
+X wrongline = FALSE;
+X}
+END-of-cpp1.c
+echo x - cpp3.c
+sed 's/^X//' >cpp3.c << 'END-of-cpp3.c'
+X/*
+X * C P P 3 . C
+X *
+X * File open and command line options
+X *
+X * Edit history
+X * 13-Nov-84 MM Split from cpp1.c
+X */
+X
+X#include <stdio.h>
+X#include <ctype.h>
+X#include "cppdef.h"
+X#include "cpp.h"
+X#if DEBUG && (HOST == SYS_VMS || HOST == SYS_UNIX)
+X#include <signal.h>
+Xextern int abort(); /* For debugging */
+X#endif
+X
+Xint
+Xopenfile(filename)
+Xchar *filename;
+X/*
+X * Open a file, add it to the linked list of open files.
+X * This is called only from openfile() above.
+X */
+X{
+X register FILE *fp;
+X
+X if ((fp = fopen(filename, "r")) == NULL) {
+X#if DEBUG
+X perror(filename);
+X#endif
+X return (FALSE);
+X }
+X#if DEBUG
+X if (debug)
+X fprintf(stderr, "Reading from \"%s\"\n", filename);
+X#endif
+X addfile(fp, filename);
+X return (TRUE);
+X}
+X
+Xaddfile(fp, filename)
+XFILE *fp; /* Open file pointer */
+Xchar *filename; /* Name of the file */
+X/*
+X * Initialize tables for this open file. This is called from openfile()
+X * above (for #include files), and from the entry to cpp to open the main
+X * input file. It calls a common routine, getfile() to build the FILEINFO
+X * structure which is used to read characters. (getfile() is also called
+X * to setup a macro replacement.)
+X */
+X{
+X register FILEINFO *file;
+X extern FILEINFO *getfile();
+X
+X file = getfile(NBUFF, filename);
+X file->fp = fp; /* Better remember FILE * */
+X file->buffer[0] = EOS; /* Initialize for first read */
+X line = 1; /* Working on line 1 now */
+X wrongline = TRUE; /* Force out initial #line */
+X}
+X\f
+Xsetincdirs()
+X/*
+X * Append system-specific directories to the include directory list.
+X * Called only when cpp is started.
+X */
+X{
+X
+X#ifdef CPP_INCLUDE
+X *incend++ = CPP_INCLUDE;
+X#define IS_INCLUDE 1
+X#else
+X#define IS_INCLUDE 0
+X#endif
+X
+X#if HOST == SYS_UNIX
+X *incend++ = "/usr/include";
+X#define MAXINCLUDE (NINCLUDE - 1 - IS_INCLUDE)
+X#endif
+X
+X#if HOST == SYS_VMS
+X extern char *getenv();
+X
+X if (getenv("C$LIBRARY") != NULL)
+X *incend++ = "C$LIBRARY:";
+X *incend++ = "SYS$LIBRARY:";
+X#define MAXINCLUDE (NINCLUDE - 2 - IS_INCLUDE)
+X#endif
+X
+X#if HOST == SYS_RSX
+X extern int $$rsts; /* TRUE on RSTS/E */
+X extern int $$pos; /* TRUE on PRO-350 P/OS */
+X extern int $$vms; /* TRUE on VMS compat. */
+X
+X if ($$pos) { /* P/OS? */
+X *incend++ = "SY:[ZZDECUSC]"; /* C #includes */
+X *incend++ = "LB:[1,5]"; /* RSX library */
+X }
+X else if ($$rsts) { /* RSTS/E? */
+X *incend++ = "SY:@"; /* User-defined account */
+X *incend++ = "C:"; /* Decus-C library */
+X *incend++ = "LB:[1,1]"; /* RSX library */
+X }
+X else if ($$vms) { /* VMS compatibility? */
+X *incend++ = "C:";
+X }
+X else { /* Plain old RSX/IAS */
+X *incend++ = "LB:[1,1]";
+X }
+X#define MAXINCLUDE (NINCLUDE - 3 - IS_INCLUDE)
+X#endif
+X
+X#if HOST == SYS_RT11
+X extern int $$rsts; /* RSTS/E emulation? */
+X
+X if ($$rsts)
+X *incend++ = "SY:@"; /* User-defined account */
+X *incend++ = "C:"; /* Decus-C library disk */
+X *incend++ = "SY:"; /* System (boot) disk */
+X#define MAXINCLUDE (NINCLUDE - 3 - IS_INCLUDE)
+X#endif
+X}
+X\f
+Xint
+Xdooptions(argc, argv)
+Xint argc;
+Xchar *argv[];
+X/*
+X * dooptions is called to process command line arguments (-Detc).
+X * It is called only at cpp startup.
+X */
+X{
+X register char *ap;
+X register DEFBUF *dp;
+X register int c;
+X int i, j;
+X char *arg;
+X SIZES *sizp; /* For -S */
+X int size; /* For -S */
+X int isdatum; /* FALSE for -S* */
+X int endtest; /* For -S */
+X
+X for (i = j = 1; i < argc; i++) {
+X arg = ap = argv[i];
+X if (*ap++ != '-' || *ap == EOS)
+X argv[j++] = argv[i];
+X else {
+X c = *ap++; /* Option byte */
+X if (islower(c)) /* Normalize case */
+X c = toupper(c);
+X switch (c) { /* Command character */
+X case 'C': /* Keep comments */
+X cflag = TRUE;
+X keepcomments = TRUE;
+X break;
+X
+X case 'D': /* Define symbol */
+X#if HOST != SYS_UNIX
+X zap_uc(ap); /* Force define to U.C. */
+X#endif
+X /*
+X * If the option is just "-Dfoo", make it -Dfoo=1
+X */
+X while (*ap != EOS && *ap != '=')
+X ap++;
+X if (*ap == EOS)
+X ap = "1";
+X else
+X *ap++ = EOS;
+X /*
+X * Now, save the word and its definition.
+X */
+X dp = defendel(argv[i] + 2, FALSE);
+X dp->repl = savestring(ap);
+X dp->nargs = DEF_NOARGS;
+X break;
+X
+X case 'E': /* Ignore non-fatal */
+X eflag = TRUE; /* errors. */
+X break;
+X
+X case 'I': /* Include directory */
+X if (incend >= &incdir[MAXINCLUDE])
+X cfatal("Too many include directories", NULLST);
+X *incend++ = ap;
+X break;
+X
+X case 'N': /* No predefineds */
+X nflag++; /* Repeat to undefine */
+X break; /* __LINE__, etc. */
+X
+X case 'S':
+X sizp = size_table;
+X if (isdatum = (*ap != '*')) /* If it's just -S, */
+X endtest = T_FPTR; /* Stop here */
+X else { /* But if it's -S* */
+X ap++; /* Step over '*' */
+X endtest = 0; /* Stop at end marker */
+X }
+X while (sizp->bits != endtest && *ap != EOS) {
+X if (!isdigit(*ap)) { /* Skip to next digit */
+X ap++;
+X continue;
+X }
+X size = 0; /* Compile the value */
+X while (isdigit(*ap)) {
+X size *= 10;
+X size += (*ap++ - '0');
+X }
+X if (isdatum)
+X sizp->size = size; /* Datum size */
+X else
+X sizp->psize = size; /* Pointer size */
+X sizp++;
+X }
+X if (sizp->bits != endtest)
+X cwarn("-S, too few values specified in %s", argv[i]);
+X else if (*ap != EOS)
+X cwarn("-S, too many values, \"%s\" unused", ap);
+X break;
+X
+X case 'U': /* Undefine symbol */
+X#if HOST != SYS_UNIX
+X zap_uc(ap);
+X#endif
+X if (defendel(ap, TRUE) == NULL)
+X cwarn("\"%s\" wasn't defined", ap);
+X break;
+X
+X#if DEBUG
+X case 'X': /* Debug */
+X debug = (isdigit(*ap)) ? atoi(ap) : 1;
+X#if (HOST == SYS_VMS || HOST == SYS_UNIX)
+X signal(SIGINT, abort); /* Trap "interrupt" */
+X#endif
+X fprintf(stderr, "Debug set to %d\n", debug);
+X break;
+X#endif
+X
+X default: /* What is this one? */
+X cwarn("Unknown option \"%s\"", arg);
+X fprintf(stderr, "The following options are valid:\n\
+X -C\t\t\tWrite source file comments to output\n\
+X -Dsymbol=value\tDefine a symbol with the given (optional) value\n\
+X -Idirectory\t\tAdd a directory to the #include search list\n\
+X -N\t\t\tDon't predefine target-specific names\n\
+X -Stext\t\tSpecify sizes for #if sizeof\n\
+X -Usymbol\t\tUndefine symbol\n");
+X#if DEBUG
+X fprintf(stderr, " -Xvalue\t\tSet internal debug flag\n");
+X#endif
+X break;
+X } /* Switch on all options */
+X } /* If it's a -option */
+X } /* For all arguments */
+X if (j > 3) {
+X cerror(
+X "Too many file arguments. Usage: cpp [input [output]]",
+X NULLST);
+X }
+X return (j); /* Return new argc */
+X}
+X\f
+X#if HOST != SYS_UNIX
+XFILE_LOCAL
+Xzap_uc(ap)
+Xregister char *ap;
+X/*
+X * Dec operating systems mangle upper-lower case in command lines.
+X * This routine forces the -D and -U arguments to uppercase.
+X * It is called only on cpp startup by dooptions().
+X */
+X{
+X while (*ap != EOS) {
+X /*
+X * Don't use islower() here so it works with Multinational
+X */
+X if (*ap >= 'a' && *ap <= 'z')
+X *ap = toupper(*ap);
+X ap++;
+X }
+X}
+X#endif
+X
+Xinitdefines()
+X/*
+X * Initialize the built-in #define's. There are two flavors:
+X * #define decus 1 (static definitions)
+X * #define __FILE__ ?? (dynamic, evaluated by magic)
+X * Called only on cpp startup.
+X *
+X * Note: the built-in static definitions are supressed by the -N option.
+X * __LINE__, __FILE__, and __DATE__ are always present.
+X */
+X{
+X register char **pp;
+X register char *tp;
+X register DEFBUF *dp;
+X int i;
+X long tvec;
+X extern char *ctime();
+X
+X /*
+X * Predefine the built-in symbols. Allow the
+X * implementor to pre-define a symbol as "" to
+X * eliminate it.
+X */
+X if (nflag == 0) {
+X for (pp = preset; *pp != NULL; pp++) {
+X if (*pp[0] != EOS) {
+X dp = defendel(*pp, FALSE);
+X dp->repl = savestring("1");
+X dp->nargs = DEF_NOARGS;
+X }
+X }
+X }
+X /*
+X * The magic pre-defines (__FILE__ and __LINE__ are
+X * initialized with negative argument counts. expand()
+X * notices this and calls the appropriate routine.
+X * DEF_NOARGS is one greater than the first "magic" definition.
+X */
+X if (nflag < 2) {
+X for (pp = magic, i = DEF_NOARGS; *pp != NULL; pp++) {
+X dp = defendel(*pp, FALSE);
+X dp->nargs = --i;
+X }
+X#if OK_DATE
+X /*
+X * Define __DATE__ as today's date.
+X */
+X dp = defendel("__DATE__", FALSE);
+X dp->repl = tp = getmem(27);
+X dp->nargs = DEF_NOARGS;
+X time(&tvec);
+X *tp++ = '"';
+X strcpy(tp, ctime(&tvec));
+X tp[24] = '"'; /* Overwrite newline */
+X#endif
+X }
+X}
+X\f
+X#if HOST == SYS_VMS
+X/*
+X * getredirection() is intended to aid in porting C programs
+X * to VMS (Vax-11 C) which does not support '>' and '<'
+X * I/O redirection. With suitable modification, it may
+X * useful for other portability problems as well.
+X */
+X
+Xint
+Xgetredirection(argc, argv)
+Xint argc;
+Xchar **argv;
+X/*
+X * Process vms redirection arg's. Exit if any error is seen.
+X * If getredirection() processes an argument, it is erased
+X * from the vector. getredirection() returns a new argc value.
+X *
+X * Warning: do not try to simplify the code for vms. The code
+X * presupposes that getredirection() is called before any data is
+X * read from stdin or written to stdout.
+X *
+X * Normal usage is as follows:
+X *
+X * main(argc, argv)
+X * int argc;
+X * char *argv[];
+X * {
+X * argc = getredirection(argc, argv);
+X * }
+X */
+X{
+X register char *ap; /* Argument pointer */
+X int i; /* argv[] index */
+X int j; /* Output index */
+X int file; /* File_descriptor */
+X extern int errno; /* Last vms i/o error */
+X
+X for (j = i = 1; i < argc; i++) { /* Do all arguments */
+X switch (*(ap = argv[i])) {
+X case '<': /* <file */
+X if (freopen(++ap, "r", stdin) == NULL) {
+X perror(ap); /* Can't find file */
+X exit(errno); /* Is a fatal error */
+X }
+X break;
+X
+X case '>': /* >file or >>file */
+X if (*++ap == '>') { /* >>file */
+X /*
+X * If the file exists, and is writable by us,
+X * call freopen to append to the file (using the
+X * file's current attributes). Otherwise, create
+X * a new file with "vanilla" attributes as if the
+X * argument was given as ">filename".
+X * access(name, 2) returns zero if we can write on
+X * the specified file.
+X */
+X if (access(++ap, 2) == 0) {
+X if (freopen(ap, "a", stdout) != NULL)
+X break; /* Exit case statement */
+X perror(ap); /* Error, can't append */
+X exit(errno); /* After access test */
+X } /* If file accessable */
+X }
+X /*
+X * On vms, we want to create the file using "standard"
+X * record attributes. creat(...) creates the file
+X * using the caller's default protection mask and
+X * "variable length, implied carriage return"
+X * attributes. dup2() associates the file with stdout.
+X */
+X if ((file = creat(ap, 0, "rat=cr", "rfm=var")) == -1
+X || dup2(file, fileno(stdout)) == -1) {
+X perror(ap); /* Can't create file */
+X exit(errno); /* is a fatal error */
+X } /* If '>' creation */
+X break; /* Exit case test */
+X
+X default:
+X argv[j++] = ap; /* Not a redirector */
+X break; /* Exit case test */
+X }
+X } /* For all arguments */
+X argv[j] = NULL; /* Terminate argv[] */
+X return (j); /* Return new argc */
+X}
+X#endif
+X
+X
+X
+END-of-cpp3.c
+echo x - cpp4.c
+sed 's/^X//' >cpp4.c << 'END-of-cpp4.c'
+X/*
+X * C P P 4 . C
+X * M a c r o D e f i n i t i o n s
+X *
+X * Edit History
+X * 31-Aug-84 MM USENET net.sources release
+X * 04-Oct-84 MM __LINE__ and __FILE__ must call ungetstring()
+X * so they work correctly with token concatenation.
+X * Added string formal recognition.
+X * 25-Oct-84 MM "Short-circuit" evaluate #if's so that we
+X * don't print unnecessary error messages for
+X * #if !defined(FOO) && FOO != 0 && 10 / FOO ...
+X * 31-Oct-84 ado/MM Added token concatenation
+X * 6-Nov-84 MM Split off eval stuff
+X */
+X
+X#include <stdio.h>
+X#include <ctype.h>
+X#include "cppdef.h"
+X#include "cpp.h"
+X/*
+X * parm[], parmp, and parlist[] are used to store #define() argument
+X * lists. nargs contains the actual number of parameters stored.
+X */
+Xstatic char parm[NPARMWORK + 1]; /* define param work buffer */
+Xstatic char *parmp; /* Free space in parm */
+Xstatic char *parlist[LASTPARM]; /* -> start of each parameter */
+Xstatic int nargs; /* Parameters for this macro */
+X
+Xdodefine()
+X/*
+X * Called from control when a #define is scanned. This module
+X * parses formal parameters and the replacement string. When
+X * the formal parameter name is encountered in the replacement
+X * string, it is replaced by a character in the range 128 to
+X * 128+NPARAM (this allows up to 32 parameters within the
+X * Dec Multinational range). If cpp is ported to an EBCDIC
+X * machine, you will have to make other arrangements.
+X *
+X * There is some special case code to distinguish
+X * #define foo bar
+X * from #define foo() bar
+X *
+X * Also, we make sure that
+X * #define foo foo
+X * expands to "foo" but doesn't put cpp into an infinite loop.
+X *
+X * A warning message is printed if you redefine a symbol to a
+X * different text. I.e,
+X * #define foo 123
+X * #define foo 123
+X * is ok, but
+X * #define foo 123
+X * #define foo +123
+X * is not.
+X *
+X * The following subroutines are called from define():
+X * checkparm called when a token is scanned. It checks through the
+X * array of formal parameters. If a match is found, the
+X * token is replaced by a control byte which will be used
+X * to locate the parameter when the macro is expanded.
+X * textput puts a string in the macro work area (parm[]), updating
+X * parmp to point to the first free byte in parm[].
+X * textput() tests for work buffer overflow.
+X * charput puts a single character in the macro work area (parm[])
+X * in a manner analogous to textput().
+X */
+X{
+X register int c;
+X register DEFBUF *dp; /* -> new definition */
+X int isredefine; /* TRUE if redefined */
+X char *old; /* Remember redefined */
+X extern int save(); /* Save char in work[] */
+X
+X if (type[(c = skipws())] != LET)
+X goto bad_define;
+X isredefine = FALSE; /* Set if redefining */
+X if ((dp = lookid(c)) == NULL) /* If not known now */
+X dp = defendel(token, FALSE); /* Save the name */
+X else { /* It's known: */
+X isredefine = TRUE; /* Remember this fact */
+X old = dp->repl; /* Remember replacement */
+X dp->repl = NULL; /* No replacement now */
+X }
+X parlist[0] = parmp = parm; /* Setup parm buffer */
+X if ((c = get()) == '(') { /* With arguments? */
+X nargs = 0; /* Init formals counter */
+X do { /* Collect formal parms */
+X if (nargs >= LASTPARM)
+X cfatal("Too many arguments for macro", NULLST);
+X else if ((c = skipws()) == ')')
+X break; /* Got them all */
+X else if (type[c] != LET) /* Bad formal syntax */
+X goto bad_define;
+X scanid(c); /* Get the formal param */
+X parlist[nargs++] = parmp; /* Save its start */
+X textput(token); /* Save text in parm[] */
+X } while ((c = skipws()) == ','); /* Get another argument */
+X if (c != ')') /* Must end at ) */
+X goto bad_define;
+X c = ' '; /* Will skip to body */
+X }
+X else {
+X /*
+X * DEF_NOARGS is needed to distinguish between
+X * "#define foo" and "#define foo()".
+X */
+X nargs = DEF_NOARGS; /* No () parameters */
+X }
+X if (type[c] == SPA) /* At whitespace? */
+X c = skipws(); /* Not any more. */
+X workp = work; /* Replacement put here */
+X inmacro = TRUE; /* Keep \<newline> now */
+X while (c != EOF_CHAR && c != '\n') { /* Compile macro body */
+X#if OK_CONCAT
+X if (c == '#') { /* Token concatenation? */
+X while (workp > work && type[workp[-1]] == SPA)
+X --workp; /* Erase leading spaces */
+X save(TOK_SEP); /* Stuff a delimiter */
+X c = skipws(); /* Eat whitespace */
+X if (type[c] == LET) /* Another token here? */
+X ; /* Stuff it normally */
+X else if (type[c] == DIG) { /* Digit string after? */
+X while (type[c] == DIG) { /* Stuff the digits */
+X save(c);
+X c = get();
+X }
+X save(TOK_SEP); /* Delimit 2nd token */
+X }
+X else {
+X ciwarn("Strange character after # (%d.)", c);
+X }
+X continue;
+X }
+X#endif
+X switch (type[c]) {
+X case LET:
+X checkparm(c, dp); /* Might be a formal */
+X break;
+X
+X case DIG: /* Number in mac. body */
+X case DOT: /* Maybe a float number */
+X scannumber(c, save); /* Scan it off */
+X break;
+X
+X case QUO: /* String in mac. body */
+X#if STRING_FORMAL
+X stparmscan(c, dp); /* Do string magic */
+X#else
+X stparmscan(c);
+X#endif
+X break;
+X
+X case BSH: /* Backslash */
+X save('\\');
+X if ((c = get()) == '\n')
+X wrongline = TRUE;
+X save(c);
+X break;
+X
+X case SPA: /* Absorb whitespace */
+X /*
+X * Note: the "end of comment" marker is passed on
+X * to allow comments to separate tokens.
+X */
+X if (workp[-1] == ' ') /* Absorb multiple */
+X break; /* spaces */
+X else if (c == '\t')
+X c = ' '; /* Normalize tabs */
+X /* Fall through to store character */
+X default: /* Other character */
+X save(c);
+X break;
+X }
+X c = get();
+X }
+X inmacro = FALSE; /* Stop newline hack */
+X unget(); /* For control check */
+X if (workp > work && workp[-1] == ' ') /* Drop trailing blank */
+X workp--;
+X *workp = EOS; /* Terminate work */
+X dp->repl = savestring(work); /* Save the string */
+X dp->nargs = nargs; /* Save arg count */
+X#if DEBUG
+X if (debug)
+X dumpadef("macro definition", dp);
+X#endif
+X if (isredefine) { /* Error if redefined */
+X if ((old != NULL && dp->repl != NULL && !streq(old, dp->repl))
+X || (old == NULL && dp->repl != NULL)
+X || (old != NULL && dp->repl == NULL)) {
+X cerror("Redefining defined variable \"%s\"", dp->name);
+X }
+X if (old != NULL) /* We don't need the */
+X free(old); /* old definition now. */
+X }
+X return;
+X
+Xbad_define:
+X cerror("#define syntax error", NULLST);
+X inmacro = FALSE; /* Stop <newline> hack */
+X}
+X\f
+Xcheckparm(c, dp)
+Xregister int c;
+XDEFBUF *dp;
+X/*
+X * Replace this param if it's defined. Note that the macro name is a
+X * possible replacement token. We stuff DEF_MAGIC in front of the token
+X * which is treated as a LETTER by the token scanner and eaten by
+X * the output routine. This prevents the macro expander from
+X * looping if someone writes "#define foo foo".
+X */
+X{
+X register int i;
+X register char *cp;
+X
+X scanid(c); /* Get parm to token[] */
+X for (i = 0; i < nargs; i++) { /* For each argument */
+X if (streq(parlist[i], token)) { /* If it's known */
+X save(i + MAC_PARM); /* Save a magic cookie */
+X return; /* And exit the search */
+X }
+X }
+X if (streq(dp->name, token)) /* Macro name in body? */
+X save(DEF_MAGIC); /* Save magic marker */
+X for (cp = token; *cp != EOS;) /* And save */
+X save(*cp++); /* The token itself */
+X}
+X\f
+X#if STRING_FORMAL
+Xstparmscan(delim, dp)
+Xint delim;
+Xregister DEFBUF *dp;
+X/*
+X * Scan the string (starting with the given delimiter).
+X * The token is replaced if it is the only text in this string or
+X * character constant. The algorithm follows checkparm() above.
+X * Note that scanstring() has approved of the string.
+X */
+X{
+X register int c;
+X
+X /*
+X * Warning -- this code hasn't been tested for a while.
+X * It exists only to preserve compatibility with earlier
+X * implementations of cpp. It is not part of the Draft
+X * ANSI Standard C language.
+X */
+X save(delim);
+X instring = TRUE;
+X while ((c = get()) != delim
+X && c != '\n'
+X && c != EOF_CHAR) {
+X if (type[c] == LET) /* Maybe formal parm */
+X checkparm(c, dp);
+X else {
+X save(c);
+X if (c == '\\')
+X save(get());
+X }
+X }
+X instring = FALSE;
+X if (c != delim)
+X cerror("Unterminated string in macro body", NULLST);
+X save(c);
+X}
+X#else
+Xstparmscan(delim)
+Xint delim;
+X/*
+X * Normal string parameter scan.
+X */
+X{
+X register char *wp;
+X register int i;
+X extern int save();
+X
+X wp = workp; /* Here's where it starts */
+X if (!scanstring(delim, save))
+X return; /* Exit on scanstring error */
+X workp[-1] = EOS; /* Erase trailing quote */
+X wp++; /* -> first string content byte */
+X for (i = 0; i < nargs; i++) {
+X if (streq(parlist[i], wp)) {
+X *wp++ = MAC_PARM + PAR_MAC; /* Stuff a magic marker */
+X *wp++ = (i + MAC_PARM); /* Make a formal marker */
+X *wp = wp[-3]; /* Add on closing quote */
+X workp = wp + 1; /* Reset string end */
+X return;
+X }
+X }
+X workp[-1] = wp[-1]; /* Nope, reset end quote. */
+X}
+X#endif
+X\f
+Xdoundef()
+X/*
+X * Remove the symbol from the defined list.
+X * Called from the #control processor.
+X */
+X{
+X register int c;
+X
+X if (type[(c = skipws())] != LET)
+X cerror("Illegal #undef argument", NULLST);
+X else {
+X scanid(c); /* Get name to token[] */
+X if (defendel(token, TRUE) == NULL) {
+X cwarn("Symbol \"%s\" not defined in #undef", token);
+X }
+X }
+X}
+X
+Xtextput(text)
+Xchar *text;
+X/*
+X * Put the string in the parm[] buffer.
+X */
+X{
+X register int size;
+X
+X size = strlen(text) + 1;
+X if ((parmp + size) >= &parm[NPARMWORK])
+X cfatal("Macro work area overflow", NULLST);
+X else {
+X strcpy(parmp, text);
+X parmp += size;
+X }
+X}
+X
+Xcharput(c)
+Xregister int c;
+X/*
+X * Put the byte in the parm[] buffer.
+X */
+X{
+X if (parmp >= &parm[NPARMWORK])
+X cfatal("Macro work area overflow", NULLST);
+X else {
+X *parmp++ = c;
+X }
+X}
+X\f
+X/*
+X * M a c r o E x p a n s i o n
+X */
+X
+Xstatic DEFBUF *macro; /* Catches start of infinite macro */
+X
+Xexpand(tokenp)
+Xregister DEFBUF *tokenp;
+X/*
+X * Expand a macro. Called from the cpp mainline routine (via subroutine
+X * macroid()) when a token is found in the symbol table. It calls
+X * expcollect() to parse actual parameters, checking for the correct number.
+X * It then creates a "file" containing a single line containing the
+X * macro with actual parameters inserted appropriately. This is
+X * "pushed back" onto the input stream. (When the get() routine runs
+X * off the end of the macro line, it will dismiss the macro itself.)
+X */
+X{
+X register int c;
+X register FILEINFO *file;
+X extern FILEINFO *getfile();
+X
+X#if DEBUG
+X if (debug)
+X dumpadef("expand entry", tokenp);
+X#endif
+X /*
+X * If no macro is pending, save the name of this macro
+X * for an eventual error message.
+X */
+X if (recursion++ == 0)
+X macro = tokenp;
+X else if (recursion == RECURSION_LIMIT) {
+X cerror("Recursive macro definition of \"%s\"", tokenp->name);
+X fprintf(stderr, "(Defined by \"%s\")\n", macro->name);
+X if (rec_recover) {
+X do {
+X c = get();
+X } while (infile != NULL && infile->fp == NULL);
+X unget();
+X recursion = 0;
+X return;
+X }
+X }
+X /*
+X * Here's a macro to expand.
+X */
+X nargs = 0; /* Formals counter */
+X parmp = parm; /* Setup parm buffer */
+X switch (tokenp->nargs) {
+X case (-2): /* __LINE__ */
+X sprintf(work, "%d", line);
+X ungetstring(work);
+X break;
+X
+X case (-3): /* __FILE__ */
+X for (file = infile; file != NULL; file = file->parent) {
+X if (file->fp != NULL) {
+X sprintf(work, "\"%s\"", (file->progname != NULL)
+X ? file->progname : file->filename);
+X ungetstring(work);
+X break;
+X }
+X }
+X break;
+X
+X default:
+X /*
+X * Nothing funny about this macro.
+X */
+X if (tokenp->nargs < 0)
+X cfatal("Bug: Illegal __ macro \"%s\"", tokenp->name);
+X while ((c = skipws()) == '\n') /* Look for (, skipping */
+X wrongline = TRUE; /* spaces and newlines */
+X if (c != '(') {
+X /*
+X * If the programmer writes
+X * #define foo() ...
+X * ...
+X * foo [no ()]
+X * just write foo to the output stream.
+X */
+X unget();
+X cwarn("Macro \"%s\" needs arguments", tokenp->name);
+X fputs(tokenp->name, stdout);
+X return;
+X }
+X else if (expcollect()) { /* Collect arguments */
+X if (tokenp->nargs != nargs) { /* Should be an error? */
+X cwarn("Wrong number of macro arguments for \"%s\"",
+X tokenp->name);
+X }
+X#if DEBUG
+X if (debug)
+X dumpparm("expand");
+X#endif
+X } /* Collect arguments */
+X case DEF_NOARGS: /* No parameters just stuffs */
+X expstuff(tokenp); /* Do actual parameters */
+X } /* nargs switch */
+X}
+X\f
+XFILE_LOCAL int
+Xexpcollect()
+X/*
+X * Collect the actual parameters for this macro. TRUE if ok.
+X */
+X{
+X register int c;
+X register int paren; /* For embedded ()'s */
+X extern int charput();
+X
+X for (;;) {
+X paren = 0; /* Collect next arg. */
+X while ((c = skipws()) == '\n') /* Skip over whitespace */
+X wrongline = TRUE; /* and newlines. */
+X if (c == ')') { /* At end of all args? */
+X /*
+X * Note that there is a guard byte in parm[]
+X * so we don't have to check for overflow here.
+X */
+X *parmp = EOS; /* Make sure terminated */
+X break; /* Exit collection loop */
+X }
+X else if (nargs >= LASTPARM)
+X cfatal("Too many arguments in macro expansion", NULLST);
+X parlist[nargs++] = parmp; /* At start of new arg */
+X for (;; c = cget()) { /* Collect arg's bytes */
+X if (c == EOF_CHAR) {
+X cerror("end of file within macro argument", NULLST);
+X return (FALSE); /* Sorry. */
+X }
+X else if (c == '\\') { /* Quote next character */
+X charput(c); /* Save the \ for later */
+X charput(cget()); /* Save the next char. */
+X continue; /* And go get another */
+X }
+X else if (type[c] == QUO) { /* Start of string? */
+X scanstring(c, charput); /* Scan it off */
+X continue; /* Go get next char */
+X }
+X else if (c == '(') /* Worry about balance */
+X paren++; /* To know about commas */
+X else if (c == ')') { /* Other side too */
+X if (paren == 0) { /* At the end? */
+X unget(); /* Look at it later */
+X break; /* Exit arg getter. */
+X }
+X paren--; /* More to come. */
+X }
+X else if (c == ',' && paren == 0) /* Comma delimits args */
+X break;
+X else if (c == '\n') /* Newline inside arg? */
+X wrongline = TRUE; /* We'll need a #line */
+X charput(c); /* Store this one */
+X } /* Collect an argument */
+X charput(EOS); /* Terminate argument */
+X#if DEBUG
+X if (debug)
+X printf("parm[%d] = \"%s\"\n", nargs, parlist[nargs - 1]);
+X#endif
+X } /* Collect all args. */
+X return (TRUE); /* Normal return */
+X}
+X\f
+XFILE_LOCAL
+Xexpstuff(tokenp)
+XDEFBUF *tokenp; /* Current macro being expanded */
+X/*
+X * Stuff the macro body, replacing formal parameters by actual parameters.
+X */
+X{
+X register int c; /* Current character */
+X register char *inp; /* -> repl string */
+X register char *defp; /* -> macro output buff */
+X int size; /* Actual parm. size */
+X char *defend; /* -> output buff end */
+X int string_magic; /* String formal hack */
+X FILEINFO *file; /* Funny #include */
+X extern FILEINFO *getfile();
+X
+X file = getfile(NBUFF, tokenp->name);
+X inp = tokenp->repl; /* -> macro replacement */
+X defp = file->buffer; /* -> output buffer */
+X defend = defp + (NBUFF - 1); /* Note its end */
+X if (inp != NULL) {
+X while ((c = (*inp++ & 0xFF)) != EOS) {
+X if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC)) {
+X string_magic = (c == (MAC_PARM + PAR_MAC));
+X if (string_magic)
+X c = (*inp++ & 0xFF);
+X /*
+X * Replace formal parameter by actual parameter string.
+X */
+X if ((c -= MAC_PARM) < nargs) {
+X size = strlen(parlist[c]);
+X if ((defp + size) >= defend)
+X goto nospace;
+X /*
+X * Erase the extra set of quotes.
+X */
+X if (string_magic && defp[-1] == parlist[c][0]) {
+X strcpy(defp-1, parlist[c]);
+X defp += (size - 2);
+X }
+X else {
+X strcpy(defp, parlist[c]);
+X defp += size;
+X }
+X }
+X }
+X else if (defp >= defend) {
+Xnospace: cfatal("Out of space in macro \"%s\" arg expansion",
+X tokenp->name);
+X }
+X else {
+X *defp++ = c;
+X }
+X }
+X }
+X *defp = EOS;
+X#if DEBUG
+X if (debug > 1)
+X printf("macroline: \"%s\"\n", file->buffer);
+X#endif
+X}
+X\f
+X#if DEBUG
+Xdumpparm(why)
+Xchar *why;
+X/*
+X * Dump parameter list.
+X */
+X{
+X register int i;
+X
+X printf("dump of %d parameters (%d bytes total) %s\n",
+X nargs, parmp - parm, why);
+X for (i = 0; i < nargs; i++) {
+X printf("parm[%d] (%d) = \"%s\"\n",
+X i + 1, strlen(parlist[i]), parlist[i]);
+X }
+X}
+X#endif
+END-of-cpp4.c
+exit
projects / nethack / commitdiff