summaryrefslogtreecommitdiff
path: root/rsc/source/rscpp/cpp6.c
diff options
context:
space:
mode:
Diffstat (limited to 'rsc/source/rscpp/cpp6.c')
-rw-r--r--rsc/source/rscpp/cpp6.c1191
1 files changed, 1191 insertions, 0 deletions
diff --git a/rsc/source/rscpp/cpp6.c b/rsc/source/rscpp/cpp6.c
new file mode 100644
index 000000000000..3ae77a2816a1
--- /dev/null
+++ b/rsc/source/rscpp/cpp6.c
@@ -0,0 +1,1191 @@
+/*************************************************************************
+ *
+ * $RCSfile: cpp6.c,v $
+ *
+ * $Revision: 1.1 $
+ *
+ * last change: $Author: nf $ $Date: 2001-04-18 10:31:56 $
+ *
+ * The Contents of this file are made available subject to the terms of
+ * either of the following licenses
+ *
+ * - GNU Lesser General Public License Version 2.1
+ * - Sun Industry Standards Source License Version 1.1
+ *
+ * Sun Microsystems Inc., October, 2000
+ *
+ * GNU Lesser General Public License Version 2.1
+ * =============================================
+ * Copyright 2000 by Sun Microsystems, Inc.
+ * 901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ *
+ * Sun Industry Standards Source License Version 1.1
+ * =================================================
+ * The contents of this file are subject to the Sun Industry Standards
+ * Source License Version 1.1 (the "License"); You may not use this file
+ * except in compliance with the License. You may obtain a copy of the
+ * License at http://www.openoffice.org/license.html.
+ *
+ * Software provided under this License is provided on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ * See the License for the specific provisions governing your rights and
+ * obligations concerning the Software.
+ *
+ * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ * Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ * All Rights Reserved.
+ *
+ * Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+#include "cppdef.h"
+#include "cpp.h"
+
+/*ER evaluate macros to pDefOut */
+
+/*
+ * skipnl() skips over input text to the end of the line.
+ * skipws() skips over "whitespace" (spaces or tabs), but
+ * not skip over the end of the line. It skips over
+ * TOK_SEP, however (though that shouldn't happen).
+ * scanid() reads the next token (C identifier) into token[].
+ * The caller has already read the first character of
+ * the identifier. Unlike macroid(), the token is
+ * never expanded.
+ * macroid() reads the next token (C identifier) into token[].
+ * If it is a #defined macro, it is expanded, and
+ * macroid() returns TRUE, otherwise, FALSE.
+ * catenate() Does the dirty work of token concatenation, TRUE if it did.
+ * scanstring() Reads a string from the input stream, calling
+ * a user-supplied function for each character.
+ * This function may be output() to write the
+ * string to the output file, or save() to save
+ * the string in the work buffer.
+ * scannumber() Reads a C numeric constant from the input stream,
+ * calling the user-supplied function for each
+ * character. (output() or save() as noted above.)
+ * save() Save one character in the work[] buffer.
+ * savestring() Saves a string in malloc() memory.
+ * getfile() Initialize a new FILEINFO structure, called when
+ * #include opens a new file, or a macro is to be
+ * expanded.
+ * getmem() Get a specified number of bytes from malloc memory.
+ * output() Write one character to stdout (calling PUTCHAR) --
+ * implemented as a function so its address may be
+ * passed to scanstring() and scannumber().
+ * lookid() Scans the next token (identifier) from the input
+ * stream. Looks for it in the #defined symbol table.
+ * Returns a pointer to the definition, if found, or NULL
+ * if not present. The identifier is stored in token[].
+ * defnedel() Define enter/delete subroutine. Updates the
+ * symbol table.
+ * get() Read the next byte from the current input stream,
+ * handling end of (macro/file) input and embedded
+ * comments appropriately. Note that the global
+ * instring is -- essentially -- a parameter to get().
+ * cget() Like get(), but skip over TOK_SEP.
+ * unget() Push last gotten character back on the input stream.
+ * cerror(), cwarn(), cfatal(), cierror(), ciwarn()
+ * These routines format an print messages to the user.
+ * cerror & cwarn take a format and a single string argument.
+ * cierror & ciwarn take a format and a single int (char) argument.
+ * cfatal takes a format and a single string argument.
+ */
+
+/*
+ * This table must be rewritten for a non-Ascii machine.
+ *
+ * Note that several "non-visible" characters have special meaning:
+ * Hex 1D DEF_MAGIC -- a flag to prevent #define recursion.
+ * Hex 1E TOK_SEP -- a delimiter for token concatenation
+ * Hex 1F COM_SEP -- a zero-width whitespace for comment concatenation
+ */
+#if TOK_SEP != 0x1E || COM_SEP != 0x1F || DEF_MAGIC != 0x1D
+ << error type table is not correct >>
+#endif
+
+#if OK_DOLLAR
+#define DOL LET
+#else
+#define DOL 000
+#endif
+
+#ifdef EBCDIC
+
+char type[256] = { /* Character type codes Hex */
+ END, 000, 000, 000, 000, SPA, 000, 000, /* 00 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 08 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 10 */
+ 000, 000, 000, 000, 000, LET, 000, SPA, /* 18 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 20 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 28 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 30 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 38 */
+ SPA, 000, 000, 000, 000, 000, 000, 000, /* 40 */
+ 000, 000, 000, DOT, OP_LT,OP_LPA,OP_ADD, OP_OR, /* 48 .<(+| */
+OP_AND, 000, 000, 000, 000, 000, 000, 000, /* 50 & */
+ 000, 000,OP_NOT, DOL,OP_MUL,OP_RPA, 000,OP_XOR, /* 58 !$*);^ */
+OP_SUB,OP_DIV, 000, 000, 000, 000, 000, 000, /* 60 -/ */
+ 000, 000, 000, 000,OP_MOD, LET, OP_GT,OP_QUE, /* 68 ,%_>? */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 70 */
+ 000, 000,OP_COL, 000, 000, QUO, OP_EQ, QUO, /* 78 `:#@'=" */
+ 000, LET, LET, LET, LET, LET, LET, LET, /* 80 abcdefg */
+ LET, LET, 000, 000, 000, 000, 000, 000, /* 88 hi */
+ 000, LET, LET, LET, LET, LET, LET, LET, /* 90 jklmnop */
+ LET, LET, 000, 000, 000, 000, 000, 000, /* 98 qr */
+ 000,OP_NOT, LET, LET, LET, LET, LET, LET, /* A0 ~stuvwx */
+ LET, LET, 000, 000, 000, 000, 000, 000, /* A8 yz [ */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* B0 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* B8 ] */
+ 000, LET, LET, LET, LET, LET, LET, LET, /* C0 {ABCDEFG */
+ LET, LET, 000, 000, 000, 000, 000, 000, /* C8 HI */
+ 000, LET, LET, LET, LET, LET, LET, LET, /* D0 }JKLMNOP */
+ LET, LET, 000, 000, 000, 000, 000, 000, /* D8 QR */
+ BSH, 000, LET, LET, LET, LET, LET, LET, /* E0 \ STUVWX */
+ LET, LET, 000, 000, 000, 000, 000, 000, /* E8 YZ */
+ DIG, DIG, DIG, DIG, DIG, DIG, DIG, DIG, /* F0 01234567 */
+ DIG, DIG, 000, 000, 000, 000, 000, 000, /* F8 89 */
+};
+
+#else
+
+char type[256] = { /* Character type codes Hex */
+ END, 000, 000, 000, 000, 000, 000, 000, /* 00 */
+ 000, SPA, 000, 000, 000, 000, 000, 000, /* 08 */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 10 */
+ 000, 000, 000, 000, 000, LET, 000, SPA, /* 18 */
+ SPA,OP_NOT, QUO, 000, DOL,OP_MOD,OP_AND, QUO, /* 20 !"#$%&' */
+OP_LPA,OP_RPA,OP_MUL,OP_ADD, 000,OP_SUB, DOT,OP_DIV, /* 28 ()*+,-./ */
+ DIG, DIG, DIG, DIG, DIG, DIG, DIG, DIG, /* 30 01234567 */
+ DIG, DIG,OP_COL, 000, OP_LT, OP_EQ, OP_GT,OP_QUE, /* 38 89:;<=>? */
+ 000, LET, LET, LET, LET, LET, LET, LET, /* 40 @ABCDEFG */
+ LET, LET, LET, LET, LET, LET, LET, LET, /* 48 HIJKLMNO */
+ LET, LET, LET, LET, LET, LET, LET, LET, /* 50 PQRSTUVW */
+ LET, LET, LET, 000, BSH, 000,OP_XOR, LET, /* 58 XYZ[\]^_ */
+ 000, LET, LET, LET, LET, LET, LET, LET, /* 60 `abcdefg */
+ LET, LET, LET, LET, LET, LET, LET, LET, /* 68 hijklmno */
+ LET, LET, LET, LET, LET, LET, LET, LET, /* 70 pqrstuvw */
+ LET, LET, LET, 000, OP_OR, 000,OP_NOT, 000, /* 78 xyz{|}~ */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+ 000, 000, 000, 000, 000, 000, 000, 000, /* 80 .. FF */
+};
+
+#endif
+
+
+/*
+ * C P P S y m b o l T a b l e s
+ */
+
+/*
+ * SBSIZE defines the number of hash-table slots for the symbol table.
+ * It must be a power of 2.
+ */
+#ifndef SBSIZE
+#define SBSIZE 64
+#endif
+#define SBMASK (SBSIZE - 1)
+#if (SBSIZE ^ SBMASK) != ((SBSIZE * 2) - 1)
+ << error, SBSIZE must be a power of 2 >>
+#endif
+
+
+static DEFBUF *symtab[SBSIZE]; /* Symbol table queue headers */
+
+void InitCpp6()
+{
+ int i;
+ for( i = 0; i < SBSIZE; i++ )
+ symtab[ i ] = NULL;
+}
+
+
+
+skipnl()
+/*
+ * Skip to the end of the current input line.
+ */
+{
+ register int c;
+
+ do { /* Skip to newline */
+ c = get();
+ } while (c != '\n' && c != EOF_CHAR);
+}
+
+int
+skipws()
+/*
+ * Skip over whitespace
+ */
+{
+ register int c;
+
+ do { /* Skip whitespace */
+ c = get();
+#if COMMENT_INVISIBLE
+ } while (type[c] == SPA || c == COM_SEP);
+#else
+ } while (type[c] == SPA);
+#endif
+ return (c);
+}
+
+scanid(c)
+register int c; /* First char of id */
+/*
+ * Get the next token (an id) into the token buffer.
+ * Note: this code is duplicated in lookid().
+ * Change one, change both.
+ */
+{
+ register char *bp;
+
+ if (c == DEF_MAGIC) /* Eat the magic token */
+ c = get(); /* undefiner. */
+ bp = token;
+ do {
+ if (bp < &token[IDMAX]) /* token dim is IDMAX+1 */
+ *bp++ = c;
+ c = get();
+ } while (type[c] == LET || type[c] == DIG);
+ unget();
+ *bp = EOS;
+}
+
+int
+macroid(c)
+register int c;
+/*
+ * If c is a letter, scan the id. if it's #defined, expand it and scan
+ * the next character and try again.
+ *
+ * Else, return the character. If type[c] is a LET, the token is in token.
+ */
+{
+ register DEFBUF *dp;
+
+ if (infile != NULL && infile->fp != NULL)
+ recursion = 0;
+ while (type[c] == LET && (dp = lookid(c)) != NULL) {
+ expand(dp);
+ c = get();
+ }
+ return (c);
+}
+
+int
+catenate()
+/*
+ * A token was just read (via macroid).
+ * If the next character is TOK_SEP, concatenate the next token
+ * return TRUE -- which should recall macroid after refreshing
+ * macroid's argument. If it is not TOK_SEP, unget() the character
+ * and return FALSE.
+ */
+{
+ register int c;
+ register char *token1;
+
+#if OK_CONCAT
+ if (get() != TOK_SEP) { /* Token concatenation */
+ unget();
+ return (FALSE);
+ }
+ else {
+ token1 = savestring(token); /* Save first token */
+ c = macroid(get()); /* Scan next token */
+ switch(type[c]) { /* What was it? */
+ case LET: /* An identifier, ... */
+ if (strlen(token1) + strlen(token) >= NWORK)
+ cfatal("work buffer overflow doing %s #", token1);
+ sprintf(work, "%s%s", token1, token);
+ break;
+
+ case DIG: /* A digit string */
+ strcpy(work, token1);
+ workp = work + strlen(work);
+ do {
+ save(c);
+ } while ((c = get()) != TOK_SEP);
+ /*
+ * The trailing TOK_SEP is no longer needed.
+ */
+ save(EOS);
+ break;
+
+ default: /* An error, ... */
+#if ! COMMENT_INVISIBLE
+ if (isprint(c))
+ cierror("Strange character '%c' after #", c);
+ else
+ cierror("Strange character (%d.) after #", c);
+#endif
+ strcpy(work, token1);
+ unget();
+ break;
+ }
+ /*
+ * work has the concatenated token and token1 has
+ * the first token (no longer needed). Unget the
+ * new (concatenated) token after freeing token1.
+ * Finally, setup to read the new token.
+ */
+ free(token1); /* Free up memory */
+ ungetstring(work); /* Unget the new thing, */
+ return (TRUE);
+ }
+#else
+ return (FALSE); /* Not supported */
+#endif
+}
+
+int
+scanstring(delim, outfun)
+register int delim; /* ' or " */
+#ifndef _NO_PROTO
+int (*outfun)( int ); /* BP */ /* Output function */
+#else
+int (*outfun)(); /* BP */
+#endif
+
+/*
+ * Scan off a string. Warning if terminated by newline or EOF.
+ * outfun() outputs the character -- to a buffer if in a macro.
+ * TRUE if ok, FALSE if error.
+ */
+{
+ register int c;
+
+ instring = TRUE; /* Don't strip comments */
+ (*outfun)(delim);
+ while ((c = get()) != delim
+ && c != '\n'
+ && c != EOF_CHAR) {
+
+ if (c != DEF_MAGIC)
+ (*outfun)(c);
+ if (c == '\\')
+ (*outfun)(get());
+ }
+ instring = FALSE;
+ if (c == delim) {
+ (*outfun)(c);
+ return (TRUE);
+ }
+ else {
+ cerror("Unterminated string", NULLST);
+ unget();
+ return (FALSE);
+ }
+}
+
+scannumber(c, outfun)
+register int c; /* First char of number */
+#ifndef _NO_PROTO
+register int (*outfun)( int ); /* BP */ /* Output/store func */
+#else
+register int (*outfun)(); /* BP */
+#endif
+
+/*
+ * Process a number. We know that c is from 0 to 9 or dot.
+ * Algorithm from Dave Conroy's Decus C.
+ */
+{
+ register int radix; /* 8, 10, or 16 */
+ int expseen; /* 'e' seen in floater */
+ int signseen; /* '+' or '-' seen */
+ int octal89; /* For bad octal test */
+ int dotflag; /* TRUE if '.' was seen */
+
+ expseen = FALSE; /* No exponent seen yet */
+ signseen = TRUE; /* No +/- allowed yet */
+ octal89 = FALSE; /* No bad octal yet */
+ radix = 10; /* Assume decimal */
+ if ((dotflag = (c == '.')) != FALSE) { /* . something? */
+ (*outfun)('.'); /* Always out the dot */
+ if (type[(c = get())] != DIG) { /* If not a float numb, */
+ unget(); /* Rescan strange char */
+ return; /* All done for now */
+ }
+ } /* End of float test */
+ else if (c == '0') { /* Octal or hex? */
+ (*outfun)(c); /* Stuff initial zero */
+ radix = 8; /* Assume it's octal */
+ c = get(); /* Look for an 'x' */
+ if (c == 'x' || c == 'X') { /* Did we get one? */
+ radix = 16; /* Remember new radix */
+ (*outfun)(c); /* Stuff the 'x' */
+ c = get(); /* Get next character */
+ }
+ }
+ for (;;) { /* Process curr. char. */
+ /*
+ * Note that this algorithm accepts "012e4" and "03.4"
+ * as legitimate floating-point numbers.
+ */
+ if (radix != 16 && (c == 'e' || c == 'E')) {
+ if (expseen) /* Already saw 'E'? */
+ break; /* Exit loop, bad nbr. */
+ expseen = TRUE; /* Set exponent seen */
+ signseen = FALSE; /* We can read '+' now */
+ radix = 10; /* Decimal exponent */
+ }
+ else if (radix != 16 && c == '.') {
+ if (dotflag) /* Saw dot already? */
+ break; /* Exit loop, two dots */
+ dotflag = TRUE; /* Remember the dot */
+ radix = 10; /* Decimal fraction */
+ }
+ else if (c == '+' || c == '-') { /* 1.0e+10 */
+ if (signseen) /* Sign in wrong place? */
+ break; /* Exit loop, not nbr. */
+ /* signseen = TRUE; */ /* Remember we saw it */
+ }
+ else { /* Check the digit */
+ switch (c) {
+ case '8': case '9': /* Sometimes wrong */
+ octal89 = TRUE; /* Do check later */
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ break; /* Always ok */
+
+ case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+ case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+ if (radix == 16) /* Alpha's are ok only */
+ break; /* if reading hex. */
+ default: /* At number end */
+ goto done; /* Break from for loop */
+ } /* End of switch */
+ } /* End general case */
+ (*outfun)(c); /* Accept the character */
+ signseen = TRUE; /* Don't read sign now */
+ c = get(); /* Read another char */
+ } /* End of scan loop */
+ /*
+ * When we break out of the scan loop, c contains the first
+ * character (maybe) not in the number. If the number is an
+ * integer, allow a trailing 'L' for long and/or a trailing 'U'
+ * for unsigned. If not those, push the trailing character back
+ * on the input stream. Floating point numbers accept a trailing
+ * 'L' for "long double".
+ */
+done: if (dotflag || expseen) { /* Floating point? */
+ if (c == 'l' || c == 'L') {
+ (*outfun)(c);
+ c = get(); /* Ungotten later */
+ }
+ }
+ else { /* Else it's an integer */
+ /*
+ * We know that dotflag and expseen are both zero, now:
+ * dotflag signals "saw 'L'", and
+ * expseen signals "saw 'U'".
+ */
+ for (;;) {
+ switch (c) {
+ case 'l':
+ case 'L':
+ if (dotflag)
+ goto nomore;
+ dotflag = TRUE;
+ break;
+
+ case 'u':
+ case 'U':
+ if (expseen)
+ goto nomore;
+ expseen = TRUE;
+ break;
+
+ default:
+ goto nomore;
+ }
+ (*outfun)(c); /* Got 'L' or 'U'. */
+ c = get(); /* Look at next, too. */
+ }
+ }
+nomore: unget(); /* Not part of a number */
+ if (octal89 && radix == 8)
+ cwarn("Illegal digit in octal number", NULLST);
+}
+
+save(c)
+register int c;
+{
+ if (workp >= &work[NWORK]) {
+ work[NWORK-1] = '\0';
+ cfatal("Work buffer overflow: %s", work);
+ }
+ else *workp++ = c;
+}
+
+char *
+savestring(text)
+char *text;
+/*
+ * Store a string into free memory.
+ */
+{
+ register char *result;
+
+ result = getmem(strlen(text) + 1);
+ strcpy(result, text);
+ return (result);
+}
+
+FILEINFO *
+getfile(bufsize, name)
+int bufsize; /* Line or define buffer size */
+char *name; /* File or macro name string */
+/*
+ * Common FILEINFO buffer initialization for a new file or macro.
+ */
+{
+ register FILEINFO *file;
+ register int size;
+
+ size = strlen(name); /* File/macro name */
+ file = (FILEINFO *) getmem(sizeof (FILEINFO) + bufsize + size);
+ file->parent = infile; /* Chain files together */
+ file->fp = NULL; /* No file yet */
+ file->filename = savestring(name); /* Save file/macro name */
+ file->progname = NULL; /* No #line seen yet */
+ file->unrecur = 0; /* No macro fixup */
+ file->bptr = file->buffer; /* Initialize line ptr */
+ file->buffer[0] = EOS; /* Force first read */
+ file->line = 0; /* (Not used just yet) */
+ if (infile != NULL) /* If #include file */
+ infile->line = line; /* Save current line */
+ infile = file; /* New current file */
+ line = 1; /* Note first line */
+ return (file); /* All done. */
+}
+
+char *
+getmem(size)
+int size;
+/*
+ * Get a block of free memory.
+ */
+{
+ register char *result;
+
+#if !defined( ZTC ) && !defined( WNT ) /* BP */ && !defined(BLC) /* ER */
+ extern char *malloc();
+#endif
+ if ((result = malloc((unsigned) size)) == NULL)
+ cfatal("Out of memory", NULLST);
+ return (result);
+}
+
+
+DEFBUF *
+lookid(c)
+int c; /* First character of token */
+/*
+ * Look for the next token in the symbol table. Returns token in "token".
+ * If found, returns the table pointer; Else returns NULL.
+ */
+{
+ register int nhash;
+ register DEFBUF *dp;
+ register char *np;
+ int temp;
+ int isrecurse; /* For #define foo foo */
+
+ np = token;
+ nhash = 0;
+ if ((isrecurse = (c == DEF_MAGIC))) /* If recursive macro */
+ c = get(); /* hack, skip DEF_MAGIC */
+ do {
+ if (np < &token[IDMAX]) { /* token dim is IDMAX+1 */
+ *np++ = c; /* Store token byte */
+ nhash += c; /* Update hash value */
+ }
+ c = get(); /* And get another byte */
+ } while (type[c] == LET || type[c] == DIG);
+ unget(); /* Rescan terminator */
+ *np = EOS; /* Terminate token */
+ if (isrecurse) /* Recursive definition */
+ return (NULL); /* undefined just now */
+ nhash += (np - token); /* Fix hash value */
+ dp = symtab[nhash & SBMASK]; /* Starting bucket */
+ while (dp != (DEFBUF *) NULL) { /* Search symbol table */
+ if (dp->hash == nhash /* Fast precheck */
+ && (temp = strcmp(dp->name, token)) >= 0)
+ break;
+ dp = dp->link; /* Nope, try next one */
+ }
+ return ((temp == 0) ? dp : NULL);
+}
+
+DEFBUF *
+defendel(name, delete)
+char *name;
+int delete; /* TRUE to delete a symbol */
+/*
+ * Enter this name in the lookup table (delete = FALSE)
+ * or delete this name (delete = TRUE).
+ * Returns a pointer to the define block (delete = FALSE)
+ * Returns NULL if the symbol wasn't defined (delete = TRUE).
+ */
+{
+ register DEFBUF *dp;
+ register DEFBUF **prevp;
+ register char *np;
+ int nhash;
+ int temp;
+ int size;
+
+ for (nhash = 0, np = name; *np != EOS;)
+ nhash += *np++;
+ size = (np - name);
+ nhash += size;
+ prevp = &symtab[nhash & SBMASK];
+ while ((dp = *prevp) != (DEFBUF *) NULL) {
+ if (dp->hash == nhash
+ && (temp = strcmp(dp->name, name)) >= 0) {
+ if (temp > 0)
+ dp = NULL; /* Not found */
+ else {
+ *prevp = dp->link; /* Found, unlink and */
+ if (dp->repl != NULL) /* Free the replacement */
+ free(dp->repl); /* if any, and then */
+ free((char *) dp); /* Free the symbol */
+ }
+ break;
+ }
+ prevp = &dp->link;
+ }
+ if (!delete) {
+ dp = (DEFBUF *) getmem(sizeof (DEFBUF) + size);
+ dp->link = *prevp;
+ *prevp = dp;
+ dp->hash = nhash;
+ dp->repl = NULL;
+ dp->nargs = 0;
+ strcpy(dp->name, name);
+ }
+ return (dp);
+}
+
+#ifdef DEBUG
+
+dumpdef(why)
+char *why;
+{
+ register DEFBUF *dp;
+ register DEFBUF **syp;
+ FILE *pRememberOut;
+
+ if ( bDumpDefs ) /*ER */
+ {
+ pRememberOut = pCppOut;
+ pCppOut = pDefOut;
+ }
+ fprintf( pCppOut, "CPP symbol table dump %s\n", why);
+ for (syp = symtab; syp < &symtab[SBSIZE]; syp++) {
+ if ((dp = *syp) != (DEFBUF *) NULL) {
+ fprintf( pCppOut, "symtab[%d]\n", (syp - symtab));
+ do {
+ dumpadef((char *) NULL, dp);
+ } while ((dp = dp->link) != (DEFBUF *) NULL);
+ }
+ }
+ if ( bDumpDefs )
+ {
+ fprintf( pCppOut, "\n");
+ pCppOut = pRememberOut;
+ }
+}
+
+dumpadef(why, dp)
+char *why; /* Notation */
+register DEFBUF *dp;
+{
+ register char *cp;
+ register int c;
+ FILE *pRememberOut;
+
+/*ER dump #define's to pDefOut */
+ if ( bDumpDefs )
+ {
+ pRememberOut = pCppOut;
+ pCppOut = pDefOut;
+ }
+ fprintf( pCppOut, " \"%s\" [%d]", dp->name, dp->nargs);
+ if (why != NULL)
+ fprintf( pCppOut, " (%s)", why);
+ if (dp->repl != NULL) {
+ fprintf( pCppOut, " => ");
+ for (cp = dp->repl; (c = *cp++ & 0xFF) != EOS;) {
+#ifdef SOLAR
+ if (c == DEL) {
+ c = *cp++ & 0xFF;
+ if( c == EOS ) break;
+ fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
+ }
+#else
+ if (c >= MAC_PARM && c <= (MAC_PARM + PAR_MAC))
+ fprintf( pCppOut, "<%%%d>", c - MAC_PARM);
+#endif
+ else if (isprint(c) || c == '\n' || c == '\t')
+ PUTCHAR(c);
+ else if (c < ' ')
+ fprintf( pCppOut, "<^%c>", c + '@');
+ else
+ fprintf( pCppOut, "<\\0%o>", c);
+ }
+/*ER evaluate macros to pDefOut */
+#ifdef EVALDEFS
+ if ( bDumpDefs && !bIsInEval && dp->nargs <= 0 )
+ {
+ FILEINFO *infileSave = infile;
+ char *tokenSave = savestring( token );
+ char *workSave = savestring( work );
+ int lineSave = line;
+ int wronglineSave = wrongline;
+ int recursionSave = recursion;
+ FILEINFO *file;
+ EVALTYPE valEval;
+
+ bIsInEval = 1;
+ infile = NULL; /* start from scrap */
+ line = 0;
+ wrongline = 0;
+ *token = EOS;
+ *work = EOS;
+ recursion = 0;
+ file = getfile( strlen( dp->repl ), dp->name );
+ strcpy( file->buffer, dp->repl );
+ fprintf( pCppOut, " ===> ");
+ nEvalOff = 0;
+ cppmain(); /* get() frees also *file */
+ valEval = 0;
+ if ( 0 == evaluate( EvalBuf, &valEval ) )
+ {
+#ifdef EVALFLOATS
+ if ( valEval != (EVALTYPE)((long)valEval ) )
+ fprintf( pCppOut, " ==eval=> %f", valEval );
+ else
+#endif
+ fprintf( pCppOut, " ==eval=> %ld", (long)valEval );
+ }
+ recursion = recursionSave;
+ wrongline = wronglineSave;
+ line = lineSave;
+ strcpy( work, workSave );
+ free( workSave );
+ strcpy( token, tokenSave );
+ free( tokenSave );
+ infile = infileSave;
+ bIsInEval = 0;
+ }
+#endif
+ }
+ else {
+ fprintf( pCppOut, ", no replacement.");
+ }
+ PUTCHAR('\n');
+ if ( bDumpDefs )
+ pCppOut = pRememberOut;
+}
+#endif
+
+/*
+ * G E T
+ */
+
+int
+get()
+/*
+ * Return the next character from a macro or the current file.
+ * Handle end of file from #include files.
+ */
+{
+ register int c;
+ register FILEINFO *file;
+ register int popped; /* Recursion fixup */
+
+ popped = 0;
+get_from_file:
+ if ((file = infile) == NULL)
+ return (EOF_CHAR);
+newline:
+#if 0
+ fprintf( pCppOut, "get(%s), recursion %d, line %d, bptr = %d, buffer \"%s\"\n",
+ file->filename, recursion, line,
+ file->bptr - file->buffer, file->buffer);
+#endif
+ /*
+ * Read a character from the current input line or macro.
+ * At EOS, either finish the current macro (freeing temp.
+ * storage) or read another line from the current input file.
+ * At EOF, exit the current file (#include) or, at EOF from
+ * the cpp input file, return EOF_CHAR to finish processing.
+ */
+ if ((c = *file->bptr++ & 0xFF) == EOS) {
+ /*
+ * Nothing in current line or macro. Get next line (if
+ * input from a file), or do end of file/macro processing.
+ * In the latter case, jump back to restart from the top.
+ */
+ if (file->fp == NULL) { /* NULL if macro */
+ popped++;
+ recursion -= file->unrecur;
+ if (recursion < 0)
+ recursion = 0;
+ infile = file->parent; /* Unwind file chain */
+ }
+ else { /* Else get from a file */
+ if ((file->bptr = fgets(file->buffer, NBUFF, file->fp))
+ != NULL) {
+#ifdef DEBUG
+ if (debug > 1) { /* Dump it to stdout */
+ fprintf( pCppOut, "\n#line %d (%s), %s",
+ line, file->filename, file->buffer);
+ }
+#endif
+ goto newline; /* process the line */
+ }
+ else {
+ fclose(file->fp); /* Close finished file */
+ if ((infile = file->parent) != NULL) {
+ /*
+ * There is an "ungotten" newline in the current
+ * infile buffer (set there by doinclude() in
+ * cpp1.c). Thus, we know that the mainline code
+ * is skipping over blank lines and will do a
+ * #line at its convenience.
+ */
+ wrongline = TRUE; /* Need a #line now */
+ }
+ }
+ }
+ /*
+ * Free up space used by the (finished) file or macro and
+ * restart input from the parent file/macro, if any.
+ */
+ free(file->filename); /* Free name and */
+ if (file->progname != NULL) /* if a #line was seen, */
+ free(file->progname); /* free it, too. */
+ free((char *) file); /* Free file space */
+ if (infile == NULL) /* If at end of file */
+ return (EOF_CHAR); /* Return end of file */
+ line = infile->line; /* Reset line number */
+ goto get_from_file; /* Get from the top. */
+ }
+ /*
+ * Common processing for the new character.
+ */
+ if (c == DEF_MAGIC && file->fp != NULL) /* Don't allow delete */
+ goto newline; /* from a file */
+ if (file->parent != NULL) { /* Macro or #include */
+ if (popped != 0)
+ file->parent->unrecur += popped;
+ else {
+ recursion -= file->parent->unrecur;
+ if (recursion < 0)
+ recursion = 0;
+ file->parent->unrecur = 0;
+ }
+ }
+#if (HOST == SYS_UNIX)
+/*ER*/ if (c == '\r')
+/*ER*/ return get(); /* DOS fuck */
+#endif
+ if (c == '\n') /* Maintain current */
+ ++line; /* line counter */
+ if (instring) /* Strings just return */
+ return (c); /* the character. */
+ else if (c == '/') { /* Comment? */
+ instring = TRUE; /* So get() won't loop */
+/*MM c++ comments */
+/*MM*/ c = get();
+/*MM*/ if ((c != '*') && (c != '/')) { /* Next byte '*'? */
+ instring = FALSE; /* Nope, no comment */
+ unget(); /* Push the char. back */
+ return ('/'); /* Return the slash */
+ }
+ if (keepcomments) { /* If writing comments */
+ PUTCHAR('/'); /* Write out the */
+ /* initializer */
+/*MM*/ if( '*' == c )
+ PUTCHAR('*');
+/*MM*/ else
+/*MM*/ PUTCHAR('/');
+
+ }
+/*MM*/ if( '*' == c ){
+ for (;;) { /* Eat a comment */
+ c = get();
+ test: if (keepcomments && c != EOF_CHAR)
+ cput(c);
+ switch (c) {
+ case EOF_CHAR:
+ cerror("EOF in comment", NULLST);
+ return (EOF_CHAR);
+
+ case '/':
+ if ((c = get()) != '*') /* Don't let comments */
+ goto test; /* Nest. */
+#ifdef STRICT_COMMENTS
+ cwarn("Nested comments", NULLST);
+#endif
+ /* Fall into * stuff */
+ case '*':
+ if ((c = get()) != '/') /* If comment doesn't */
+ goto test; /* end, look at next */
+ instring = FALSE; /* End of comment, */
+ if (keepcomments) { /* Put out the comment */
+ cput(c); /* terminator, too */
+ }
+ /*
+ * A comment is syntactically "whitespace" --
+ * however, there are certain strange sequences
+ * such as
+ * #define foo(x) (something)
+ * foo|* comment *|(123)
+ * these are '/' ^ ^
+ * where just returning space (or COM_SEP) will cause
+ * problems. This can be "fixed" by overwriting the
+ * '/' in the input line buffer with ' ' (or COM_SEP)
+ * but that may mess up an error message.
+ * So, we peek ahead -- if the next character is
+ * "whitespace" we just get another character, if not,
+ * we modify the buffer. All in the name of purity.
+ */
+ if (*file->bptr == '\n'
+ || type[*file->bptr & 0xFF] == SPA)
+ goto newline;
+#if COMMENT_INVISIBLE
+ /*
+ * Return magic (old-fashioned) syntactic space.
+ */
+ return ((file->bptr[-1] = COM_SEP));
+#else
+ return ((file->bptr[-1] = ' '));
+#endif
+
+ case '\n': /* we'll need a #line */
+ if (!keepcomments)
+ wrongline = TRUE; /* later... */
+ default: /* Anything else is */
+ break; /* Just a character */
+ } /* End switch */
+ } /* End comment loop */
+ }
+ else{ /* c++ comment */
+/*MM c++ comment*/
+ for (;;) { /* Eat a comment */
+ c = get();
+ if (keepcomments && c != EOF_CHAR)
+ cput(c);
+ if( EOF_CHAR == c )
+ return (EOF_CHAR);
+ else if( '\n' == c ){
+ instring = FALSE; /* End of comment, */
+ return( c );
+ }
+ }
+ }
+ } /* End if in comment */
+ else if (!inmacro && c == '\\') { /* If backslash, peek */
+ if ((c = get()) == '\n') { /* for a <nl>. If so, */
+ wrongline = TRUE;
+ goto newline;
+ }
+ else { /* Backslash anything */
+ unget(); /* Get it later */
+ return ('\\'); /* Return the backslash */
+ }
+ }
+ else if (c == '\f' || c == VT) /* Form Feed, Vertical */
+ c = ' '; /* Tab are whitespace */
+ return (c); /* Just return the char */
+}
+
+unget()
+/*
+ * Backup the pointer to reread the last character. Fatal error
+ * (code bug) if we backup too far. unget() may be called,
+ * without problems, at end of file. Only one character may
+ * be ungotten. If you need to unget more, call ungetstring().
+ */
+{
+ register FILEINFO *file;
+
+ if ((file = infile) == NULL)
+ return; /* Unget after EOF */
+ if (--file->bptr < file->buffer)
+ cfatal("Too much pushback", NULLST);
+ if (*file->bptr == '\n') /* Ungetting a newline? */
+ --line; /* Unget the line number, too */
+}
+
+ungetstring(text)
+char *text;
+/*
+ * Push a string back on the input stream. This is done by treating
+ * the text as if it were a macro.
+ */
+{
+ register FILEINFO *file;
+#ifndef ZTC /* BP */
+ extern FILEINFO *getfile();
+#endif
+ file = getfile(strlen(text) + 1, "");
+ strcpy(file->buffer, text);
+}
+
+int
+cget()
+/*
+ * Get one character, absorb "funny space" after comments or
+ * token concatenation
+ */
+{
+ register int c;
+
+ do {
+ c = get();
+#if COMMENT_INVISIBLE
+ } while (c == TOK_SEP || c == COM_SEP);
+#else
+ } while (c == TOK_SEP);
+#endif
+ return (c);
+}
+
+/*
+ * Error messages and other hacks. The first byte of severity
+ * is 'S' for string arguments and 'I' for int arguments. This
+ * is needed for portability with machines that have int's that
+ * are shorter than char *'s.
+ */
+
+static
+domsg(severity, format, arg)
+char *severity; /* "Error", "Warning", "Fatal" */
+char *format; /* Format for the error message */
+void *arg; /* Something for the message */
+/*
+ * Print filenames, macro names, and line numbers for error messages.
+ */
+{
+ register char *tp;
+ register FILEINFO *file;
+
+ fprintf(stderr, "%sline %d, %s: ", MSG_PREFIX, line, &severity[1]);
+ if (*severity == 'S')
+ fprintf(stderr, format, (char *)arg);
+ else
+ fprintf(stderr, format, *((int *)arg) );
+ putc('\n', stderr);
+ if ((file = infile) == NULL)
+ return; /* At end of file */
+ if (file->fp != NULL) {
+ tp = file->buffer; /* Print current file */
+ fprintf(stderr, "%s", tp); /* name, making sure */
+ if (tp[strlen(tp) - 1] != '\n') /* there's a newline */
+ putc('\n', stderr);
+ }
+ while ((file = file->parent) != NULL) { /* Print #includes, too */
+ if (file->fp == NULL)
+ fprintf(stderr, "from macro %s\n", file->filename);
+ else {
+ tp = file->buffer;
+ fprintf(stderr, "from file %s, line %d:\n%s",
+ (file->progname != NULL)
+ ? file->progname : file->filename,
+ file->line, tp);
+ if (tp[strlen(tp) - 1] != '\n')
+ putc('\n', stderr);
+ }
+ }
+}
+
+cerror(format, sarg)
+char *format;
+char *sarg; /* Single string argument */
+/*
+ * Print a normal error message, string argument.
+ */
+{
+ domsg("SError", format, sarg);
+ errors++;
+}
+
+cierror(format, narg)
+char *format;
+int narg; /* Single numeric argument */
+/*
+ * Print a normal error message, numeric argument.
+ */
+{
+ domsg("IError", format, &narg);
+ errors++;
+}
+
+cfatal(format, sarg)
+char *format;
+char *sarg; /* Single string argument */
+/*
+ * A real disaster
+ */
+{
+ domsg("SFatal error", format, sarg);
+ exit(IO_ERROR);
+}
+
+cwarn(format, sarg)
+char *format;
+char *sarg; /* Single string argument */
+/*
+ * A non-fatal error, string argument.
+ */
+{
+ domsg("SWarning", format, sarg);
+}
+
+ciwarn(format, narg)
+char *format;
+int narg; /* Single numeric argument */
+/*
+ * A non-fatal error, numeric argument.
+ */
+{
+ domsg("IWarning", format, &narg);
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-01 00:43:53 +0000