aboutsummaryrefslogtreecommitdiffstats
path: root/lcc/cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lcc/cpp')
-rw-r--r--lcc/cpp/cpp.c322
-rw-r--r--lcc/cpp/cpp.h163
-rw-r--r--lcc/cpp/eval.c520
-rw-r--r--lcc/cpp/getopt.c53
-rw-r--r--lcc/cpp/hideset.c112
-rw-r--r--lcc/cpp/include.c122
-rw-r--r--lcc/cpp/lex.c580
-rw-r--r--lcc/cpp/macro.c515
-rw-r--r--lcc/cpp/nlist.c104
-rw-r--r--lcc/cpp/tokens.c370
-rw-r--r--lcc/cpp/unix.c116
11 files changed, 0 insertions, 2977 deletions
diff --git a/lcc/cpp/cpp.c b/lcc/cpp/cpp.c
deleted file mode 100644
index 6739e4d..0000000
--- a/lcc/cpp/cpp.c
+++ /dev/null
@@ -1,322 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <stdarg.h>
-#include "cpp.h"
-
-char rcsid[] = "cpp.c - faked rcsid";
-
-#define OUTS 16384
-char outbuf[OUTS];
-char *outp = outbuf;
-Source *cursource;
-int nerrs;
-struct token nltoken = { NL, 0, 0, 0, 1, (uchar*)"\n" };
-char *curtime;
-int incdepth;
-int ifdepth;
-int ifsatisfied[NIF];
-int skipping;
-
-
-int
-main(int argc, char **argv)
-{
- Tokenrow tr;
- time_t t;
- char ebuf[BUFSIZ];
-
- setbuf(stderr, ebuf);
- t = time(NULL);
- curtime = ctime(&t);
- maketokenrow(3, &tr);
- expandlex();
- setup(argc, argv);
- fixlex();
- iniths();
- genline();
- process(&tr);
- flushout();
- fflush(stderr);
- exit(nerrs > 0);
- return 0;
-}
-
-void
-process(Tokenrow *trp)
-{
- int anymacros = 0;
-
- for (;;) {
- if (trp->tp >= trp->lp) {
- trp->tp = trp->lp = trp->bp;
- outp = outbuf;
- anymacros |= gettokens(trp, 1);
- trp->tp = trp->bp;
- }
- if (trp->tp->type == END) {
- if (--incdepth>=0) {
- if (cursource->ifdepth)
- error(ERROR,
- "Unterminated conditional in #include");
- unsetsource();
- cursource->line += cursource->lineinc;
- trp->tp = trp->lp;
- genline();
- continue;
- }
- if (ifdepth)
- error(ERROR, "Unterminated #if/#ifdef/#ifndef");
- break;
- }
- if (trp->tp->type==SHARP) {
- trp->tp += 1;
- control(trp);
- } else if (!skipping && anymacros)
- expandrow(trp, NULL);
- if (skipping)
- setempty(trp);
- puttokens(trp);
- anymacros = 0;
- cursource->line += cursource->lineinc;
- if (cursource->lineinc>1) {
- genline();
- }
- }
-}
-
-void
-control(Tokenrow *trp)
-{
- Nlist *np;
- Token *tp;
-
- tp = trp->tp;
- if (tp->type!=NAME) {
- if (tp->type==NUMBER)
- goto kline;
- if (tp->type != NL)
- error(ERROR, "Unidentifiable control line");
- return; /* else empty line */
- }
- if ((np = lookup(tp, 0))==NULL || ((np->flag&ISKW)==0 && !skipping)) {
- error(WARNING, "Unknown preprocessor control %t", tp);
- return;
- }
- if (skipping) {
- switch (np->val) {
- case KENDIF:
- if (--ifdepth<skipping)
- skipping = 0;
- --cursource->ifdepth;
- setempty(trp);
- return;
-
- case KIFDEF:
- case KIFNDEF:
- case KIF:
- if (++ifdepth >= NIF)
- error(FATAL, "#if too deeply nested");
- ++cursource->ifdepth;
- return;
-
- case KELIF:
- case KELSE:
- if (ifdepth<=skipping)
- break;
- return;
-
- default:
- return;
- }
- }
- switch (np->val) {
- case KDEFINE:
- dodefine(trp);
- break;
-
- case KUNDEF:
- tp += 1;
- if (tp->type!=NAME || trp->lp - trp->bp != 4) {
- error(ERROR, "Syntax error in #undef");
- break;
- }
- if ((np = lookup(tp, 0)) != NULL)
- np->flag &= ~ISDEFINED;
- break;
-
- case KPRAGMA:
- return;
-
- case KIFDEF:
- case KIFNDEF:
- case KIF:
- if (++ifdepth >= NIF)
- error(FATAL, "#if too deeply nested");
- ++cursource->ifdepth;
- ifsatisfied[ifdepth] = 0;
- if (eval(trp, np->val))
- ifsatisfied[ifdepth] = 1;
- else
- skipping = ifdepth;
- break;
-
- case KELIF:
- if (ifdepth==0) {
- error(ERROR, "#elif with no #if");
- return;
- }
- if (ifsatisfied[ifdepth]==2)
- error(ERROR, "#elif after #else");
- if (eval(trp, np->val)) {
- if (ifsatisfied[ifdepth])
- skipping = ifdepth;
- else {
- skipping = 0;
- ifsatisfied[ifdepth] = 1;
- }
- } else
- skipping = ifdepth;
- break;
-
- case KELSE:
- if (ifdepth==0 || cursource->ifdepth==0) {
- error(ERROR, "#else with no #if");
- return;
- }
- if (ifsatisfied[ifdepth]==2)
- error(ERROR, "#else after #else");
- if (trp->lp - trp->bp != 3)
- error(ERROR, "Syntax error in #else");
- skipping = ifsatisfied[ifdepth]? ifdepth: 0;
- ifsatisfied[ifdepth] = 2;
- break;
-
- case KENDIF:
- if (ifdepth==0 || cursource->ifdepth==0) {
- error(ERROR, "#endif with no #if");
- return;
- }
- --ifdepth;
- --cursource->ifdepth;
- if (trp->lp - trp->bp != 3)
- error(WARNING, "Syntax error in #endif");
- break;
-
- case KERROR:
- trp->tp = tp+1;
- error(WARNING, "#error directive: %r", trp);
- break;
-
- case KLINE:
- trp->tp = tp+1;
- expandrow(trp, "<line>");
- tp = trp->bp+2;
- kline:
- if (tp+1>=trp->lp || tp->type!=NUMBER || tp+3<trp->lp
- || ((tp+3==trp->lp && ((tp+1)->type!=STRING))||*(tp+1)->t=='L')){
- error(ERROR, "Syntax error in #line");
- return;
- }
- cursource->line = atol((char*)tp->t)-1;
- if (cursource->line<0 || cursource->line>=32768)
- error(WARNING, "#line specifies number out of range");
- tp = tp+1;
- if (tp+1<trp->lp)
- cursource->filename=(char*)newstring(tp->t+1,tp->len-2,0);
- return;
-
- case KDEFINED:
- error(ERROR, "Bad syntax for control line");
- break;
-
- case KINCLUDE:
- doinclude(trp);
- trp->lp = trp->bp;
- return;
-
- case KEVAL:
- eval(trp, np->val);
- break;
-
- default:
- error(ERROR, "Preprocessor control `%t' not yet implemented", tp);
- break;
- }
- setempty(trp);
- return;
-}
-
-void *
-domalloc(int size)
-{
- void *p = malloc(size);
-
- if (p==NULL)
- error(FATAL, "Out of memory from malloc");
- return p;
-}
-
-void
-dofree(void *p)
-{
- free(p);
-}
-
-void
-error(enum errtype type, char *string, ...)
-{
- va_list ap;
- char *cp, *ep;
- Token *tp;
- Tokenrow *trp;
- Source *s;
- int i;
-
- fprintf(stderr, "cpp: ");
- for (s=cursource; s; s=s->next)
- if (*s->filename)
- fprintf(stderr, "%s:%d ", s->filename, s->line);
- va_start(ap, string);
- for (ep=string; *ep; ep++) {
- if (*ep=='%') {
- switch (*++ep) {
-
- case 's':
- cp = va_arg(ap, char *);
- fprintf(stderr, "%s", cp);
- break;
- case 'd':
- i = va_arg(ap, int);
- fprintf(stderr, "%d", i);
- break;
- case 't':
- tp = va_arg(ap, Token *);
- fprintf(stderr, "%.*s", tp->len, tp->t);
- break;
-
- case 'r':
- trp = va_arg(ap, Tokenrow *);
- for (tp=trp->tp; tp<trp->lp&&tp->type!=NL; tp++) {
- if (tp>trp->tp && tp->wslen)
- fputc(' ', stderr);
- fprintf(stderr, "%.*s", tp->len, tp->t);
- }
- break;
-
- default:
- fputc(*ep, stderr);
- break;
- }
- } else
- fputc(*ep, stderr);
- }
- va_end(ap);
- fputc('\n', stderr);
- if (type==FATAL)
- exit(1);
- if (type!=WARNING)
- nerrs = 1;
- fflush(stderr);
-}
diff --git a/lcc/cpp/cpp.h b/lcc/cpp/cpp.h
deleted file mode 100644
index d72f24a..0000000
--- a/lcc/cpp/cpp.h
+++ /dev/null
@@ -1,163 +0,0 @@
-#define INS 32768 /* input buffer */
-#define OBS 4096 /* outbut buffer */
-#define NARG 32 /* Max number arguments to a macro */
-#define NINCLUDE 32 /* Max number of include directories (-I) */
-#define NIF 32 /* depth of nesting of #if */
-#ifndef EOF
-#define EOF (-1)
-#endif
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef __alpha
-typedef unsigned char uchar;
-#endif
-
-enum toktype { END, UNCLASS, NAME, NUMBER, STRING, CCON, NL, WS, DSHARP,
- EQ, NEQ, LEQ, GEQ, LSH, RSH, LAND, LOR, PPLUS, MMINUS,
- ARROW, SBRA, SKET, LP, RP, DOT, AND, STAR, PLUS, MINUS,
- TILDE, NOT, SLASH, PCT, LT, GT, CIRC, OR, QUEST,
- COLON, ASGN, COMMA, SHARP, SEMIC, CBRA, CKET,
- ASPLUS, ASMINUS, ASSTAR, ASSLASH, ASPCT, ASCIRC, ASLSH,
- ASRSH, ASOR, ASAND, ELLIPS,
- DSHARP1, NAME1, DEFINED, UMINUS };
-
-enum kwtype { KIF, KIFDEF, KIFNDEF, KELIF, KELSE, KENDIF, KINCLUDE, KDEFINE,
- KUNDEF, KLINE, KERROR, KPRAGMA, KDEFINED,
- KLINENO, KFILE, KDATE, KTIME, KSTDC, KEVAL };
-
-#define ISDEFINED 01 /* has #defined value */
-#define ISKW 02 /* is PP keyword */
-#define ISUNCHANGE 04 /* can't be #defined in PP */
-#define ISMAC 010 /* builtin macro, e.g. __LINE__ */
-
-#define EOB 0xFE /* sentinel for end of input buffer */
-#define EOFC 0xFD /* sentinel for end of input file */
-#define XPWS 1 /* token flag: white space to assure token sep. */
-
-typedef struct token {
- unsigned char type;
- unsigned char flag;
- unsigned short hideset;
- unsigned int wslen;
- unsigned int len;
- uchar *t;
-} Token;
-
-typedef struct tokenrow {
- Token *tp; /* current one to scan */
- Token *bp; /* base (allocated value) */
- Token *lp; /* last+1 token used */
- int max; /* number allocated */
-} Tokenrow;
-
-typedef struct source {
- char *filename; /* name of file of the source */
- int line; /* current line number */
- int lineinc; /* adjustment for \\n lines */
- uchar *inb; /* input buffer */
- uchar *inp; /* input pointer */
- uchar *inl; /* end of input */
- int fd; /* input source */
- int ifdepth; /* conditional nesting in include */
- struct source *next; /* stack for #include */
-} Source;
-
-typedef struct nlist {
- struct nlist *next;
- uchar *name;
- int len;
- Tokenrow *vp; /* value as macro */
- Tokenrow *ap; /* list of argument names, if any */
- char val; /* value as preprocessor name */
- char flag; /* is defined, is pp name */
-} Nlist;
-
-typedef struct includelist {
- char deleted;
- char always;
- char *file;
-} Includelist;
-
-#define new(t) (t *)domalloc(sizeof(t))
-#define quicklook(a,b) (namebit[(a)&077] & (1<<((b)&037)))
-#define quickset(a,b) namebit[(a)&077] |= (1<<((b)&037))
-extern unsigned long namebit[077+1];
-
-enum errtype { WARNING, ERROR, FATAL };
-
-void expandlex(void);
-void fixlex(void);
-void setup(int, char **);
-int gettokens(Tokenrow *, int);
-int comparetokens(Tokenrow *, Tokenrow *);
-Source *setsource(char *, int, char *);
-void unsetsource(void);
-void puttokens(Tokenrow *);
-void process(Tokenrow *);
-void *domalloc(int);
-void dofree(void *);
-void error(enum errtype, char *, ...);
-void flushout(void);
-int fillbuf(Source *);
-int trigraph(Source *);
-int foldline(Source *);
-Nlist *lookup(Token *, int);
-void control(Tokenrow *);
-void dodefine(Tokenrow *);
-void doadefine(Tokenrow *, int);
-void doinclude(Tokenrow *);
-void doif(Tokenrow *, enum kwtype);
-void expand(Tokenrow *, Nlist *);
-void builtin(Tokenrow *, int);
-int gatherargs(Tokenrow *, Tokenrow **, int *);
-void substargs(Nlist *, Tokenrow *, Tokenrow **);
-void expandrow(Tokenrow *, char *);
-void maketokenrow(int, Tokenrow *);
-Tokenrow *copytokenrow(Tokenrow *, Tokenrow *);
-Token *growtokenrow(Tokenrow *);
-Tokenrow *normtokenrow(Tokenrow *);
-void adjustrow(Tokenrow *, int);
-void movetokenrow(Tokenrow *, Tokenrow *);
-void insertrow(Tokenrow *, int, Tokenrow *);
-void peektokens(Tokenrow *, char *);
-void doconcat(Tokenrow *);
-Tokenrow *stringify(Tokenrow *);
-int lookuparg(Nlist *, Token *);
-long eval(Tokenrow *, int);
-void genline(void);
-void setempty(Tokenrow *);
-void makespace(Tokenrow *);
-char *outnum(char *, int);
-int digit(int);
-uchar *newstring(uchar *, int, int);
-int checkhideset(int, Nlist *);
-void prhideset(int);
-int newhideset(int, Nlist *);
-int unionhideset(int, int);
-void iniths(void);
-void setobjname(char *);
-#define rowlen(tokrow) ((tokrow)->lp - (tokrow)->bp)
-
-extern char *outp;
-extern Token nltoken;
-extern Source *cursource;
-extern char *curtime;
-extern int incdepth;
-extern int ifdepth;
-extern int ifsatisfied[NIF];
-extern int Mflag;
-extern int skipping;
-extern int verbose;
-extern int Cplusplus;
-extern Nlist *kwdefined;
-extern Includelist includelist[NINCLUDE];
-extern char wd[];
-
-extern int creat(char *, int);
-extern int open(char *, int);
-extern int close(int);
-extern int dup2(int, int);
-extern int write(int, char *, size_t);
-extern int read(int, char *, size_t);
diff --git a/lcc/cpp/eval.c b/lcc/cpp/eval.c
deleted file mode 100644
index 7061eff..0000000
--- a/lcc/cpp/eval.c
+++ /dev/null
@@ -1,520 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-#define NSTAK 32
-#define SGN 0
-#define UNS 1
-#define UND 2
-
-#define UNSMARK 0x1000
-
-struct value {
- long val;
- int type;
-};
-
-/* conversion types */
-#define RELAT 1
-#define ARITH 2
-#define LOGIC 3
-#define SPCL 4
-#define SHIFT 5
-#define UNARY 6
-
-/* operator priority, arity, and conversion type, indexed by tokentype */
-struct pri {
- char pri;
- char arity;
- char ctype;
-} priority[] = {
- { 0, 0, 0 }, /* END */
- { 0, 0, 0 }, /* UNCLASS */
- { 0, 0, 0 }, /* NAME */
- { 0, 0, 0 }, /* NUMBER */
- { 0, 0, 0 }, /* STRING */
- { 0, 0, 0 }, /* CCON */
- { 0, 0, 0 }, /* NL */
- { 0, 0, 0 }, /* WS */
- { 0, 0, 0 }, /* DSHARP */
- { 11, 2, RELAT }, /* EQ */
- { 11, 2, RELAT }, /* NEQ */
- { 12, 2, RELAT }, /* LEQ */
- { 12, 2, RELAT }, /* GEQ */
- { 13, 2, SHIFT }, /* LSH */
- { 13, 2, SHIFT }, /* RSH */
- { 7, 2, LOGIC }, /* LAND */
- { 6, 2, LOGIC }, /* LOR */
- { 0, 0, 0 }, /* PPLUS */
- { 0, 0, 0 }, /* MMINUS */
- { 0, 0, 0 }, /* ARROW */
- { 0, 0, 0 }, /* SBRA */
- { 0, 0, 0 }, /* SKET */
- { 3, 0, 0 }, /* LP */
- { 3, 0, 0 }, /* RP */
- { 0, 0, 0 }, /* DOT */
- { 10, 2, ARITH }, /* AND */
- { 15, 2, ARITH }, /* STAR */
- { 14, 2, ARITH }, /* PLUS */
- { 14, 2, ARITH }, /* MINUS */
- { 16, 1, UNARY }, /* TILDE */
- { 16, 1, UNARY }, /* NOT */
- { 15, 2, ARITH }, /* SLASH */
- { 15, 2, ARITH }, /* PCT */
- { 12, 2, RELAT }, /* LT */
- { 12, 2, RELAT }, /* GT */
- { 9, 2, ARITH }, /* CIRC */
- { 8, 2, ARITH }, /* OR */
- { 5, 2, SPCL }, /* QUEST */
- { 5, 2, SPCL }, /* COLON */
- { 0, 0, 0 }, /* ASGN */
- { 4, 2, 0 }, /* COMMA */
- { 0, 0, 0 }, /* SHARP */
- { 0, 0, 0 }, /* SEMIC */
- { 0, 0, 0 }, /* CBRA */
- { 0, 0, 0 }, /* CKET */
- { 0, 0, 0 }, /* ASPLUS */
- { 0, 0, 0 }, /* ASMINUS */
- { 0, 0, 0 }, /* ASSTAR */
- { 0, 0, 0 }, /* ASSLASH */
- { 0, 0, 0 }, /* ASPCT */
- { 0, 0, 0 }, /* ASCIRC */
- { 0, 0, 0 }, /* ASLSH */
- { 0, 0, 0 }, /* ASRSH */
- { 0, 0, 0 }, /* ASOR */
- { 0, 0, 0 }, /* ASAND */
- { 0, 0, 0 }, /* ELLIPS */
- { 0, 0, 0 }, /* DSHARP1 */
- { 0, 0, 0 }, /* NAME1 */
- { 16, 1, UNARY }, /* DEFINED */
- { 16, 0, UNARY }, /* UMINUS */
-};
-
-int evalop(struct pri);
-struct value tokval(Token *);
-struct value vals[NSTAK], *vp;
-enum toktype ops[NSTAK], *op;
-
-/*
- * Evaluate an #if #elif #ifdef #ifndef line. trp->tp points to the keyword.
- */
-long
-eval(Tokenrow *trp, int kw)
-{
- Token *tp;
- Nlist *np;
- int ntok, rand;
-
- trp->tp++;
- if (kw==KIFDEF || kw==KIFNDEF) {
- if (trp->lp - trp->bp != 4 || trp->tp->type!=NAME) {
- error(ERROR, "Syntax error in #ifdef/#ifndef");
- return 0;
- }
- np = lookup(trp->tp, 0);
- return (kw==KIFDEF) == (np && np->flag&(ISDEFINED|ISMAC));
- }
- ntok = trp->tp - trp->bp;
- kwdefined->val = KDEFINED; /* activate special meaning of defined */
- expandrow(trp, "<if>");
- kwdefined->val = NAME;
- vp = vals;
- op = ops;
- *op++ = END;
- for (rand=0, tp = trp->bp+ntok; tp < trp->lp; tp++) {
- switch(tp->type) {
- case WS:
- case NL:
- continue;
-
- /* nilary */
- case NAME:
- case NAME1:
- case NUMBER:
- case CCON:
- case STRING:
- if (rand)
- goto syntax;
- *vp++ = tokval(tp);
- rand = 1;
- continue;
-
- /* unary */
- case DEFINED:
- case TILDE:
- case NOT:
- if (rand)
- goto syntax;
- *op++ = tp->type;
- continue;
-
- /* unary-binary */
- case PLUS: case MINUS: case STAR: case AND:
- if (rand==0) {
- if (tp->type==MINUS)
- *op++ = UMINUS;
- if (tp->type==STAR || tp->type==AND) {
- error(ERROR, "Illegal operator * or & in #if/#elsif");
- return 0;
- }
- continue;
- }
- /* flow through */
-
- /* plain binary */
- case EQ: case NEQ: case LEQ: case GEQ: case LSH: case RSH:
- case LAND: case LOR: case SLASH: case PCT:
- case LT: case GT: case CIRC: case OR: case QUEST:
- case COLON: case COMMA:
- if (rand==0)
- goto syntax;
- if (evalop(priority[tp->type])!=0)
- return 0;
- *op++ = tp->type;
- rand = 0;
- continue;
-
- case LP:
- if (rand)
- goto syntax;
- *op++ = LP;
- continue;
-
- case RP:
- if (!rand)
- goto syntax;
- if (evalop(priority[RP])!=0)
- return 0;
- if (op<=ops || op[-1]!=LP) {
- goto syntax;
- }
- op--;
- continue;
-
- default:
- error(ERROR,"Bad operator (%t) in #if/#elsif", tp);
- return 0;
- }
- }
- if (rand==0)
- goto syntax;
- if (evalop(priority[END])!=0)
- return 0;
- if (op!=&ops[1] || vp!=&vals[1]) {
- error(ERROR, "Botch in #if/#elsif");
- return 0;
- }
- if (vals[0].type==UND)
- error(ERROR, "Undefined expression value");
- return vals[0].val;
-syntax:
- error(ERROR, "Syntax error in #if/#elsif");
- return 0;
-}
-
-int
-evalop(struct pri pri)
-{
- struct value v1, v2;
- long rv1, rv2;
- int rtype, oper;
-
- rv2=0;
- rtype=0;
- while (pri.pri < priority[op[-1]].pri) {
- oper = *--op;
- if (priority[oper].arity==2) {
- v2 = *--vp;
- rv2 = v2.val;
- }
- v1 = *--vp;
- rv1 = v1.val;
-/*lint -e574 -e644 */
- switch (priority[oper].ctype) {
- case 0:
- default:
- error(WARNING, "Syntax error in #if/#endif");
- return 1;
- case ARITH:
- case RELAT:
- if (v1.type==UNS || v2.type==UNS)
- rtype = UNS;
- else
- rtype = SGN;
- if (v1.type==UND || v2.type==UND)
- rtype = UND;
- if (priority[oper].ctype==RELAT && rtype==UNS) {
- oper |= UNSMARK;
- rtype = SGN;
- }
- break;
- case SHIFT:
- if (v1.type==UND || v2.type==UND)
- rtype = UND;
- else
- rtype = v1.type;
- if (rtype==UNS)
- oper |= UNSMARK;
- break;
- case UNARY:
- rtype = v1.type;
- break;
- case LOGIC:
- case SPCL:
- break;
- }
- switch (oper) {
- case EQ: case EQ|UNSMARK:
- rv1 = rv1==rv2; break;
- case NEQ: case NEQ|UNSMARK:
- rv1 = rv1!=rv2; break;
- case LEQ:
- rv1 = rv1<=rv2; break;
- case GEQ:
- rv1 = rv1>=rv2; break;
- case LT:
- rv1 = rv1<rv2; break;
- case GT:
- rv1 = rv1>rv2; break;
- case LEQ|UNSMARK:
- rv1 = (unsigned long)rv1<=rv2; break;
- case GEQ|UNSMARK:
- rv1 = (unsigned long)rv1>=rv2; break;
- case LT|UNSMARK:
- rv1 = (unsigned long)rv1<rv2; break;
- case GT|UNSMARK:
- rv1 = (unsigned long)rv1>rv2; break;
- case LSH:
- rv1 <<= rv2; break;
- case LSH|UNSMARK:
- rv1 = (unsigned long)rv1<<rv2; break;
- case RSH:
- rv1 >>= rv2; break;
- case RSH|UNSMARK:
- rv1 = (unsigned long)rv1>>rv2; break;
- case LAND:
- rtype = UND;
- if (v1.type==UND)
- break;
- if (rv1!=0) {
- if (v2.type==UND)
- break;
- rv1 = rv2!=0;
- } else
- rv1 = 0;
- rtype = SGN;
- break;
- case LOR:
- rtype = UND;
- if (v1.type==UND)
- break;
- if (rv1==0) {
- if (v2.type==UND)
- break;
- rv1 = rv2!=0;
- } else
- rv1 = 1;
- rtype = SGN;
- break;
- case AND:
- rv1 &= rv2; break;
- case STAR:
- rv1 *= rv2; break;
- case PLUS:
- rv1 += rv2; break;
- case MINUS:
- rv1 -= rv2; break;
- case UMINUS:
- if (v1.type==UND)
- rtype = UND;
- rv1 = -rv1; break;
- case OR:
- rv1 |= rv2; break;
- case CIRC:
- rv1 ^= rv2; break;
- case TILDE:
- rv1 = ~rv1; break;
- case NOT:
- rv1 = !rv1; if (rtype!=UND) rtype = SGN; break;
- case SLASH:
- if (rv2==0) {
- rtype = UND;
- break;
- }
- if (rtype==UNS)
- rv1 /= (unsigned long)rv2;
- else
- rv1 /= rv2;
- break;
- case PCT:
- if (rv2==0) {
- rtype = UND;
- break;
- }
- if (rtype==UNS)
- rv1 %= (unsigned long)rv2;
- else
- rv1 %= rv2;
- break;
- case COLON:
- if (op[-1] != QUEST)
- error(ERROR, "Bad ?: in #if/endif");
- else {
- op--;
- if ((--vp)->val==0)
- v1 = v2;
- rtype = v1.type;
- rv1 = v1.val;
- }
- break;
- case DEFINED:
- break;
- default:
- error(ERROR, "Eval botch (unknown operator)");
- return 1;
- }
-/*lint +e574 +e644 */
- v1.val = rv1;
- v1.type = rtype;
- *vp++ = v1;
- }
- return 0;
-}
-
-struct value
-tokval(Token *tp)
-{
- struct value v;
- Nlist *np;
- int i, base, c;
- unsigned long n;
- uchar *p;
-
- v.type = SGN;
- v.val = 0;
- switch (tp->type) {
-
- case NAME:
- v.val = 0;
- break;
-
- case NAME1:
- if ((np = lookup(tp, 0)) != NULL && np->flag&(ISDEFINED|ISMAC))
- v.val = 1;
- break;
-
- case NUMBER:
- n = 0;
- base = 10;
- p = tp->t;
- c = p[tp->len];
- p[tp->len] = '\0';
- if (*p=='0') {
- base = 8;
- if (p[1]=='x' || p[1]=='X') {
- base = 16;
- p++;
- }
- p++;
- }
- for (;; p++) {
- if ((i = digit(*p)) < 0)
- break;
- if (i>=base)
- error(WARNING,
- "Bad digit in number %t", tp);
- n *= base;
- n += i;
- }
- if (n>=0x80000000 && base!=10)
- v.type = UNS;
- for (; *p; p++) {
- if (*p=='u' || *p=='U')
- v.type = UNS;
- else if (*p=='l' || *p=='L')
- ;
- else {
- error(ERROR,
- "Bad number %t in #if/#elsif", tp);
- break;
- }
- }
- v.val = n;
- tp->t[tp->len] = c;
- break;
-
- case CCON:
- n = 0;
- p = tp->t;
- if (*p=='L') {
- p += 1;
- error(WARNING, "Wide char constant value undefined");
- }
- p += 1;
- if (*p=='\\') {
- p += 1;
- if ((i = digit(*p))>=0 && i<=7) {
- n = i;
- p += 1;
- if ((i = digit(*p))>=0 && i<=7) {
- p += 1;
- n <<= 3;
- n += i;
- if ((i = digit(*p))>=0 && i<=7) {
- p += 1;
- n <<= 3;
- n += i;
- }
- }
- } else if (*p=='x') {
- p += 1;
- while ((i = digit(*p))>=0 && i<=15) {
- p += 1;
- n <<= 4;
- n += i;
- }
- } else {
- static char cvcon[]
- = "b\bf\fn\nr\rt\tv\v''\"\"??\\\\";
- for (i=0; i<sizeof(cvcon); i+=2) {
- if (*p == cvcon[i]) {
- n = cvcon[i+1];
- break;
- }
- }
- p += 1;
- if (i>=sizeof(cvcon))
- error(WARNING,
- "Undefined escape in character constant");
- }
- } else if (*p=='\'')
- error(ERROR, "Empty character constant");
- else
- n = *p++;
- if (*p!='\'')
- error(WARNING, "Multibyte character constant undefined");
- else if (n>127)
- error(WARNING, "Character constant taken as not signed");
- v.val = n;
- break;
-
- case STRING:
- error(ERROR, "String in #if/#elsif");
- break;
- }
- return v;
-}
-
-int
-digit(int i)
-{
- if ('0'<=i && i<='9')
- i -= '0';
- else if ('a'<=i && i<='f')
- i -= 'a'-10;
- else if ('A'<=i && i<='F')
- i -= 'A'-10;
- else
- i = -1;
- return i;
-}
diff --git a/lcc/cpp/getopt.c b/lcc/cpp/getopt.c
deleted file mode 100644
index abcb35f..0000000
--- a/lcc/cpp/getopt.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#define EPR fprintf(stderr,
-#define ERR(str, chr) if(opterr){EPR "%s%c\n", str, chr);}
-int opterr = 1;
-int optind = 1;
-int optopt;
-char *optarg;
-
-int
-getopt (int argc, char *const argv[], const char *opts)
-{
- static int sp = 1;
- int c;
- char *cp;
-
- if (sp == 1) {
- if (optind >= argc ||
- argv[optind][0] != '-' || argv[optind][1] == '\0')
- return -1;
- else if (strcmp(argv[optind], "--") == 0) {
- optind++;
- return -1;
- }
- }
- optopt = c = argv[optind][sp];
- if (c == ':' || (cp=strchr(opts, c)) == 0) {
- ERR (": illegal option -- ", c);
- if (argv[optind][++sp] == '\0') {
- optind++;
- sp = 1;
- }
- return '?';
- }
- if (*++cp == ':') {
- if (argv[optind][sp+1] != '\0')
- optarg = &argv[optind++][sp+1];
- else if (++optind >= argc) {
- ERR (": option requires an argument -- ", c);
- sp = 1;
- return '?';
- } else
- optarg = argv[optind++];
- sp = 1;
- } else {
- if (argv[optind][++sp] == '\0') {
- sp = 1;
- optind++;
- }
- optarg = 0;
- }
- return c;
-}
diff --git a/lcc/cpp/hideset.c b/lcc/cpp/hideset.c
deleted file mode 100644
index bd2540d..0000000
--- a/lcc/cpp/hideset.c
+++ /dev/null
@@ -1,112 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-/*
- * A hideset is a null-terminated array of Nlist pointers.
- * They are referred to by indices in the hidesets array.
- * Hideset 0 is empty.
- */
-
-#define HSSIZ 32
-typedef Nlist **Hideset;
-Hideset *hidesets;
-int nhidesets = 0;
-int maxhidesets = 3;
-int inserths(Hideset, Hideset, Nlist *);
-
-/*
- * Test for membership in a hideset
- */
-int
-checkhideset(int hs, Nlist *np)
-{
- Hideset hsp;
-
- if (hs>=nhidesets)
- abort();
- for (hsp = hidesets[hs]; *hsp; hsp++) {
- if (*hsp == np)
- return 1;
- }
- return 0;
-}
-
-/*
- * Return the (possibly new) hideset obtained by adding np to hs.
- */
-int
-newhideset(int hs, Nlist *np)
-{
- int i, len;
- Nlist *nhs[HSSIZ+3];
- Hideset hs1, hs2;
-
- len = inserths(nhs, hidesets[hs], np);
- for (i=0; i<nhidesets; i++) {
- for (hs1=nhs, hs2=hidesets[i]; *hs1==*hs2; hs1++, hs2++)
- if (*hs1 == NULL)
- return i;
- }
- if (len>=HSSIZ)
- return hs;
- if (nhidesets >= maxhidesets) {
- maxhidesets = 3*maxhidesets/2+1;
- hidesets = (Hideset *)realloc(hidesets, (sizeof (Hideset *))*maxhidesets);
- if (hidesets == NULL)
- error(FATAL, "Out of memory from realloc");
- }
- hs1 = (Hideset)domalloc(len*sizeof(Hideset));
- memmove(hs1, nhs, len*sizeof(Hideset));
- hidesets[nhidesets] = hs1;
- return nhidesets++;
-}
-
-int
-inserths(Hideset dhs, Hideset shs, Nlist *np)
-{
- Hideset odhs = dhs;
-
- while (*shs && *shs < np)
- *dhs++ = *shs++;
- if (*shs != np)
- *dhs++ = np;
- do {
- *dhs++ = *shs;
- } while (*shs++);
- return dhs - odhs;
-}
-
-/*
- * Hideset union
- */
-int
-unionhideset(int hs1, int hs2)
-{
- Hideset hp;
-
- for (hp = hidesets[hs2]; *hp; hp++)
- hs1 = newhideset(hs1, *hp);
- return hs1;
-}
-
-void
-iniths(void)
-{
- hidesets = (Hideset *)domalloc(maxhidesets*sizeof(Hideset *));
- hidesets[0] = (Hideset)domalloc(sizeof(Hideset));
- *hidesets[0] = NULL;
- nhidesets++;
-}
-
-void
-prhideset(int hs)
-{
- Hideset np;
-
- for (np = hidesets[hs]; *np; np++) {
- fprintf(stderr, (char*)(*np)->name, (*np)->len);
- fprintf(stderr, " ");
- }
-}
diff --git a/lcc/cpp/include.c b/lcc/cpp/include.c
deleted file mode 100644
index b3757e8..0000000
--- a/lcc/cpp/include.c
+++ /dev/null
@@ -1,122 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-Includelist includelist[NINCLUDE];
-
-extern char *objname;
-
-void
-doinclude(Tokenrow *trp)
-{
- char fname[256], iname[256];
- Includelist *ip;
- int angled, len, fd, i;
-
- trp->tp += 1;
- if (trp->tp>=trp->lp)
- goto syntax;
- if (trp->tp->type!=STRING && trp->tp->type!=LT) {
- len = trp->tp - trp->bp;
- expandrow(trp, "<include>");
- trp->tp = trp->bp+len;
- }
- if (trp->tp->type==STRING) {
- len = trp->tp->len-2;
- if (len > sizeof(fname) - 1)
- len = sizeof(fname) - 1;
- strncpy(fname, (char*)trp->tp->t+1, len);
- angled = 0;
- } else if (trp->tp->type==LT) {
- len = 0;
- trp->tp++;
- while (trp->tp->type!=GT) {
- if (trp->tp>trp->lp || len+trp->tp->len+2 >= sizeof(fname))
- goto syntax;
- strncpy(fname+len, (char*)trp->tp->t, trp->tp->len);
- len += trp->tp->len;
- trp->tp++;
- }
- angled = 1;
- } else
- goto syntax;
- trp->tp += 2;
- if (trp->tp < trp->lp || len==0)
- goto syntax;
- fname[len] = '\0';
- if (fname[0]=='/') {
- fd = open(fname, 0);
- strcpy(iname, fname);
- } else for (fd = -1,i=NINCLUDE-1; i>=0; i--) {
- ip = &includelist[i];
- if (ip->file==NULL || ip->deleted || (angled && ip->always==0))
- continue;
- if (strlen(fname)+strlen(ip->file)+2 > sizeof(iname))
- continue;
- strcpy(iname, ip->file);
- strcat(iname, "/");
- strcat(iname, fname);
- if ((fd = open(iname, 0)) >= 0)
- break;
- }
- if ( Mflag>1 || (!angled&&Mflag==1) ) {
- write(1,objname,strlen(objname));
- write(1,iname,strlen(iname));
- write(1,"\n",1);
- }
- if (fd >= 0) {
- if (++incdepth > 10)
- error(FATAL, "#include too deeply nested");
- setsource((char*)newstring((uchar*)iname, strlen(iname), 0), fd, NULL);
- genline();
- } else {
- trp->tp = trp->bp+2;
- error(ERROR, "Could not find include file %r", trp);
- }
- return;
-syntax:
- error(ERROR, "Syntax error in #include");
- return;
-}
-
-/*
- * Generate a line directive for cursource
- */
-void
-genline(void)
-{
- static Token ta = { UNCLASS };
- static Tokenrow tr = { &ta, &ta, &ta+1, 1 };
- uchar *p;
-
- ta.t = p = (uchar*)outp;
- strcpy((char*)p, "#line ");
- p += sizeof("#line ")-1;
- p = (uchar*)outnum((char*)p, cursource->line);
- *p++ = ' '; *p++ = '"';
- if (cursource->filename[0]!='/' && wd[0]) {
- strcpy((char*)p, wd);
- p += strlen(wd);
- *p++ = '/';
- }
- strcpy((char*)p, cursource->filename);
- p += strlen((char*)p);
- *p++ = '"'; *p++ = '\n';
- ta.len = (char*)p-outp;
- outp = (char*)p;
- tr.tp = tr.bp;
- puttokens(&tr);
-}
-
-void
-setobjname(char *f)
-{
- int n = strlen(f);
- objname = (char*)domalloc(n+5);
- strcpy(objname,f);
- if(objname[n-2]=='.'){
- strcpy(objname+n-1,"$O: ");
- }else{
- strcpy(objname+n,"$O: ");
- }
-}
diff --git a/lcc/cpp/lex.c b/lcc/cpp/lex.c
deleted file mode 100644
index 8030354..0000000
--- a/lcc/cpp/lex.c
+++ /dev/null
@@ -1,580 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-/*
- * lexical FSM encoding
- * when in state state, and one of the characters
- * in ch arrives, enter nextstate.
- * States >= S_SELF are either final, or at least require special action.
- * In 'fsm' there is a line for each state X charset X nextstate.
- * List chars that overwrite previous entries later (e.g. C_ALPH
- * can be overridden by '_' by a later entry; and C_XX is the
- * the universal set, and should always be first.
- * States above S_SELF are represented in the big table as negative values.
- * S_SELF and S_SELFB encode the resulting token type in the upper bits.
- * These actions differ in that S_SELF doesn't have a lookahead char,
- * S_SELFB does.
- *
- * The encoding is blown out into a big table for time-efficiency.
- * Entries have
- * nextstate: 6 bits; ?\ marker: 1 bit; tokentype: 9 bits.
- */
-
-#define MAXSTATE 32
-#define ACT(tok,act) ((tok<<7)+act)
-#define QBSBIT 0100
-#define GETACT(st) (st>>7)&0x1ff
-
-/* character classes */
-#define C_WS 1
-#define C_ALPH 2
-#define C_NUM 3
-#define C_EOF 4
-#define C_XX 5
-
-enum state {
- START=0, NUM1, NUM2, NUM3, ID1, ST1, ST2, ST3, COM1, COM2, COM3, COM4,
- CC1, CC2, WS1, PLUS1, MINUS1, STAR1, SLASH1, PCT1, SHARP1,
- CIRC1, GT1, GT2, LT1, LT2, OR1, AND1, ASG1, NOT1, DOTS1,
- S_SELF=MAXSTATE, S_SELFB, S_EOF, S_NL, S_EOFSTR,
- S_STNL, S_COMNL, S_EOFCOM, S_COMMENT, S_EOB, S_WS, S_NAME
-};
-
-int tottok;
-int tokkind[256];
-struct fsm {
- int state; /* if in this state */
- uchar ch[4]; /* and see one of these characters */
- int nextstate; /* enter this state if +ve */
-};
-
-/*const*/ struct fsm fsm[] = {
- /* start state */
- {START, { C_XX }, ACT(UNCLASS,S_SELF)},
- {START, { ' ', '\t', '\v' }, WS1},
- {START, { C_NUM }, NUM1},
- {START, { '.' }, NUM3},
- {START, { C_ALPH }, ID1},
- {START, { 'L' }, ST1},
- {START, { '"' }, ST2},
- {START, { '\'' }, CC1},
- {START, { '/' }, COM1},
- {START, { EOFC }, S_EOF},
- {START, { '\n' }, S_NL},
- {START, { '-' }, MINUS1},
- {START, { '+' }, PLUS1},
- {START, { '<' }, LT1},
- {START, { '>' }, GT1},
- {START, { '=' }, ASG1},
- {START, { '!' }, NOT1},
- {START, { '&' }, AND1},
- {START, { '|' }, OR1},
- {START, { '#' }, SHARP1},
- {START, { '%' }, PCT1},
- {START, { '[' }, ACT(SBRA,S_SELF)},
- {START, { ']' }, ACT(SKET,S_SELF)},
- {START, { '(' }, ACT(LP,S_SELF)},
- {START, { ')' }, ACT(RP,S_SELF)},
- {START, { '*' }, STAR1},
- {START, { ',' }, ACT(COMMA,S_SELF)},
- {START, { '?' }, ACT(QUEST,S_SELF)},
- {START, { ':' }, ACT(COLON,S_SELF)},
- {START, { ';' }, ACT(SEMIC,S_SELF)},
- {START, { '{' }, ACT(CBRA,S_SELF)},
- {START, { '}' }, ACT(CKET,S_SELF)},
- {START, { '~' }, ACT(TILDE,S_SELF)},
- {START, { '^' }, CIRC1},
-
- /* saw a digit */
- {NUM1, { C_XX }, ACT(NUMBER,S_SELFB)},
- {NUM1, { C_NUM, C_ALPH, '.' }, NUM1},
- {NUM1, { 'E', 'e' }, NUM2},
- {NUM1, { '_' }, ACT(NUMBER,S_SELFB)},
-
- /* saw possible start of exponent, digits-e */
- {NUM2, { C_XX }, ACT(NUMBER,S_SELFB)},
- {NUM2, { '+', '-' }, NUM1},
- {NUM2, { C_NUM, C_ALPH }, NUM1},
- {NUM2, { '_' }, ACT(NUMBER,S_SELFB)},
-
- /* saw a '.', which could be a number or an operator */
- {NUM3, { C_XX }, ACT(DOT,S_SELFB)},
- {NUM3, { '.' }, DOTS1},
- {NUM3, { C_NUM }, NUM1},
-
- {DOTS1, { C_XX }, ACT(UNCLASS, S_SELFB)},
- {DOTS1, { C_NUM }, NUM1},
- {DOTS1, { '.' }, ACT(ELLIPS, S_SELF)},
-
- /* saw a letter or _ */
- {ID1, { C_XX }, ACT(NAME,S_NAME)},
- {ID1, { C_ALPH, C_NUM }, ID1},
-
- /* saw L (start of wide string?) */
- {ST1, { C_XX }, ACT(NAME,S_NAME)},
- {ST1, { C_ALPH, C_NUM }, ID1},
- {ST1, { '"' }, ST2},
- {ST1, { '\'' }, CC1},
-
- /* saw " beginning string */
- {ST2, { C_XX }, ST2},
- {ST2, { '"' }, ACT(STRING, S_SELF)},
- {ST2, { '\\' }, ST3},
- {ST2, { '\n' }, S_STNL},
- {ST2, { EOFC }, S_EOFSTR},
-
- /* saw \ in string */
- {ST3, { C_XX }, ST2},
- {ST3, { '\n' }, S_STNL},
- {ST3, { EOFC }, S_EOFSTR},
-
- /* saw ' beginning character const */
- {CC1, { C_XX }, CC1},
- {CC1, { '\'' }, ACT(CCON, S_SELF)},
- {CC1, { '\\' }, CC2},
- {CC1, { '\n' }, S_STNL},
- {CC1, { EOFC }, S_EOFSTR},
-
- /* saw \ in ccon */
- {CC2, { C_XX }, CC1},
- {CC2, { '\n' }, S_STNL},
- {CC2, { EOFC }, S_EOFSTR},
-
- /* saw /, perhaps start of comment */
- {COM1, { C_XX }, ACT(SLASH, S_SELFB)},
- {COM1, { '=' }, ACT(ASSLASH, S_SELF)},
- {COM1, { '*' }, COM2},
- {COM1, { '/' }, COM4},
-
- /* saw / then *, start of comment */
- {COM2, { C_XX }, COM2},
- {COM2, { '\n' }, S_COMNL},
- {COM2, { '*' }, COM3},
- {COM2, { EOFC }, S_EOFCOM},
-
- /* saw the * possibly ending a comment */
- {COM3, { C_XX }, COM2},
- {COM3, { '\n' }, S_COMNL},
- {COM3, { '*' }, COM3},
- {COM3, { '/' }, S_COMMENT},
-
- /* // comment */
- {COM4, { C_XX }, COM4},
- {COM4, { '\n' }, S_NL},
- {COM4, { EOFC }, S_EOFCOM},
-
- /* saw white space, eat it up */
- {WS1, { C_XX }, S_WS},
- {WS1, { ' ', '\t', '\v' }, WS1},
-
- /* saw -, check --, -=, -> */
- {MINUS1, { C_XX }, ACT(MINUS, S_SELFB)},
- {MINUS1, { '-' }, ACT(MMINUS, S_SELF)},
- {MINUS1, { '=' }, ACT(ASMINUS,S_SELF)},
- {MINUS1, { '>' }, ACT(ARROW,S_SELF)},
-
- /* saw +, check ++, += */
- {PLUS1, { C_XX }, ACT(PLUS, S_SELFB)},
- {PLUS1, { '+' }, ACT(PPLUS, S_SELF)},
- {PLUS1, { '=' }, ACT(ASPLUS, S_SELF)},
-
- /* saw <, check <<, <<=, <= */
- {LT1, { C_XX }, ACT(LT, S_SELFB)},
- {LT1, { '<' }, LT2},
- {LT1, { '=' }, ACT(LEQ, S_SELF)},
- {LT2, { C_XX }, ACT(LSH, S_SELFB)},
- {LT2, { '=' }, ACT(ASLSH, S_SELF)},
-
- /* saw >, check >>, >>=, >= */
- {GT1, { C_XX }, ACT(GT, S_SELFB)},
- {GT1, { '>' }, GT2},
- {GT1, { '=' }, ACT(GEQ, S_SELF)},
- {GT2, { C_XX }, ACT(RSH, S_SELFB)},
- {GT2, { '=' }, ACT(ASRSH, S_SELF)},
-
- /* = */
- {ASG1, { C_XX }, ACT(ASGN, S_SELFB)},
- {ASG1, { '=' }, ACT(EQ, S_SELF)},
-
- /* ! */
- {NOT1, { C_XX }, ACT(NOT, S_SELFB)},
- {NOT1, { '=' }, ACT(NEQ, S_SELF)},
-
- /* & */
- {AND1, { C_XX }, ACT(AND, S_SELFB)},
- {AND1, { '&' }, ACT(LAND, S_SELF)},
- {AND1, { '=' }, ACT(ASAND, S_SELF)},
-
- /* | */
- {OR1, { C_XX }, ACT(OR, S_SELFB)},
- {OR1, { '|' }, ACT(LOR, S_SELF)},
- {OR1, { '=' }, ACT(ASOR, S_SELF)},
-
- /* # */
- {SHARP1, { C_XX }, ACT(SHARP, S_SELFB)},
- {SHARP1, { '#' }, ACT(DSHARP, S_SELF)},
-
- /* % */
- {PCT1, { C_XX }, ACT(PCT, S_SELFB)},
- {PCT1, { '=' }, ACT(ASPCT, S_SELF)},
-
- /* * */
- {STAR1, { C_XX }, ACT(STAR, S_SELFB)},
- {STAR1, { '=' }, ACT(ASSTAR, S_SELF)},
-
- /* ^ */
- {CIRC1, { C_XX }, ACT(CIRC, S_SELFB)},
- {CIRC1, { '=' }, ACT(ASCIRC, S_SELF)},
-
- {-1}
-};
-
-/* first index is char, second is state */
-/* increase #states to power of 2 to encourage use of shift */
-short bigfsm[256][MAXSTATE];
-
-void
-expandlex(void)
-{
- /*const*/ struct fsm *fp;
- int i, j, nstate;
-
- for (fp = fsm; fp->state>=0; fp++) {
- for (i=0; fp->ch[i]; i++) {
- nstate = fp->nextstate;
- if (nstate >= S_SELF)
- nstate = ~nstate;
- switch (fp->ch[i]) {
-
- case C_XX: /* random characters */
- for (j=0; j<256; j++)
- bigfsm[j][fp->state] = nstate;
- continue;
- case C_ALPH:
- for (j=0; j<=256; j++)
- if (('a'<=j&&j<='z') || ('A'<=j&&j<='Z')
- || j=='_')
- bigfsm[j][fp->state] = nstate;
- continue;
- case C_NUM:
- for (j='0'; j<='9'; j++)
- bigfsm[j][fp->state] = nstate;
- continue;
- default:
- bigfsm[fp->ch[i]][fp->state] = nstate;
- }
- }
- }
- /* install special cases for ? (trigraphs), \ (splicing), runes, and EOB */
- for (i=0; i<MAXSTATE; i++) {
- for (j=0; j<0xFF; j++)
- if (j=='?' || j=='\\') {
- if (bigfsm[j][i]>0)
- bigfsm[j][i] = ~bigfsm[j][i];
- bigfsm[j][i] &= ~QBSBIT;
- }
- bigfsm[EOB][i] = ~S_EOB;
- if (bigfsm[EOFC][i]>=0)
- bigfsm[EOFC][i] = ~S_EOF;
- }
-}
-
-void
-fixlex(void)
-{
- /* do C++ comments? */
- if (Cplusplus==0)
- bigfsm['/'][COM1] = bigfsm['x'][COM1];
-}
-
-/*
- * fill in a row of tokens from input, terminated by NL or END
- * First token is put at trp->lp.
- * Reset is non-zero when the input buffer can be "rewound."
- * The value is a flag indicating that possible macros have
- * been seen in the row.
- */
-int
-gettokens(Tokenrow *trp, int reset)
-{
- register int c, state, oldstate;
- register uchar *ip;
- register Token *tp, *maxp;
- int runelen;
- Source *s = cursource;
- int nmac = 0;
-
- tp = trp->lp;
- ip = s->inp;
- if (reset) {
- s->lineinc = 0;
- if (ip>=s->inl) { /* nothing in buffer */
- s->inl = s->inb;
- fillbuf(s);
- ip = s->inp = s->inb;
- } else if (ip >= s->inb+(3*INS/4)) {
- memmove(s->inb, ip, 4+s->inl-ip);
- s->inl = s->inb+(s->inl-ip);
- ip = s->inp = s->inb;
- }
- }
- maxp = &trp->bp[trp->max];
- runelen = 1;
- for (;;) {
- continue2:
- if (tp>=maxp) {
- trp->lp = tp;
- tp = growtokenrow(trp);
- maxp = &trp->bp[trp->max];
- }
- tp->type = UNCLASS;
- tp->hideset = 0;
- tp->t = ip;
- tp->wslen = 0;
- tp->flag = 0;
- state = START;
- for (;;) {
- oldstate = state;
- c = *ip;
- if ((state = bigfsm[c][state]) >= 0) {
- ip += runelen;
- runelen = 1;
- continue;
- }
- state = ~state;
- reswitch:
- switch (state&0177) {
- case S_SELF:
- ip += runelen;
- runelen = 1;
- case S_SELFB:
- tp->type = GETACT(state);
- tp->len = ip - tp->t;
- tp++;
- goto continue2;
-
- case S_NAME: /* like S_SELFB but with nmac check */
- tp->type = NAME;
- tp->len = ip - tp->t;
- nmac |= quicklook(tp->t[0], tp->len>1?tp->t[1]:0);
- tp++;
- goto continue2;
-
- case S_WS:
- tp->wslen = ip - tp->t;
- tp->t = ip;
- state = START;
- continue;
-
- default:
- if ((state&QBSBIT)==0) {
- ip += runelen;
- runelen = 1;
- continue;
- }
- state &= ~QBSBIT;
- s->inp = ip;
- if (c=='?') { /* check trigraph */
- if (trigraph(s)) {
- state = oldstate;
- continue;
- }
- goto reswitch;
- }
- if (c=='\\') { /* line-folding */
- if (foldline(s)) {
- s->lineinc++;
- state = oldstate;
- continue;
- }
- goto reswitch;
- }
- error(WARNING, "Lexical botch in cpp");
- ip += runelen;
- runelen = 1;
- continue;
-
- case S_EOB:
- s->inp = ip;
- fillbuf(cursource);
- state = oldstate;
- continue;
-
- case S_EOF:
- tp->type = END;
- tp->len = 0;
- s->inp = ip;
- if (tp!=trp->bp && (tp-1)->type!=NL && cursource->fd!=-1)
- error(WARNING,"No newline at end of file");
- trp->lp = tp+1;
- return nmac;
-
- case S_STNL:
- error(ERROR, "Unterminated string or char const");
- case S_NL:
- tp->t = ip;
- tp->type = NL;
- tp->len = 1;
- tp->wslen = 0;
- s->lineinc++;
- s->inp = ip+1;
- trp->lp = tp+1;
- return nmac;
-
- case S_EOFSTR:
- error(FATAL, "EOF in string or char constant");
- break;
-
- case S_COMNL:
- s->lineinc++;
- state = COM2;
- ip += runelen;
- runelen = 1;
- if (ip >= s->inb+(7*INS/8)) { /* very long comment */
- memmove(tp->t, ip, 4+s->inl-ip);
- s->inl -= ip-tp->t;
- ip = tp->t+1;
- }
- continue;
-
- case S_EOFCOM:
- error(WARNING, "EOF inside comment");
- --ip;
- case S_COMMENT:
- ++ip;
- tp->t = ip;
- tp->t[-1] = ' ';
- tp->wslen = 1;
- state = START;
- continue;
- }
- break;
- }
- ip += runelen;
- runelen = 1;
- tp->len = ip - tp->t;
- tp++;
- }
-}
-
-/* have seen ?; handle the trigraph it starts (if any) else 0 */
-int
-trigraph(Source *s)
-{
- int c;
-
- while (s->inp+2 >= s->inl && fillbuf(s)!=EOF)
- ;
- if (s->inp[1]!='?')
- return 0;
- c = 0;
- switch(s->inp[2]) {
- case '=':
- c = '#'; break;
- case '(':
- c = '['; break;
- case '/':
- c = '\\'; break;
- case ')':
- c = ']'; break;
- case '\'':
- c = '^'; break;
- case '<':
- c = '{'; break;
- case '!':
- c = '|'; break;
- case '>':
- c = '}'; break;
- case '-':
- c = '~'; break;
- }
- if (c) {
- *s->inp = c;
- memmove(s->inp+1, s->inp+3, s->inl-s->inp+2);
- s->inl -= 2;
- }
- return c;
-}
-
-int
-foldline(Source *s)
-{
- while (s->inp+1 >= s->inl && fillbuf(s)!=EOF)
- ;
- if (s->inp[1] == '\n') {
- memmove(s->inp, s->inp+2, s->inl-s->inp+3);
- s->inl -= 2;
- return 1;
- }
- return 0;
-}
-
-int
-fillbuf(Source *s)
-{
- int n, nr;
-
- nr = INS/8;
- if ((char *)s->inl+nr > (char *)s->inb+INS)
- error(FATAL, "Input buffer overflow");
- if (s->fd<0 || (n=read(s->fd, (char *)s->inl, INS/8)) <= 0)
- n = 0;
- if ((*s->inp&0xff) == EOB) /* sentinel character appears in input */
- *s->inp = EOFC;
- s->inl += n;
- s->inl[0] = s->inl[1]= s->inl[2]= s->inl[3] = EOB;
- if (n==0) {
- s->inl[0] = s->inl[1]= s->inl[2]= s->inl[3] = EOFC;
- return EOF;
- }
- return 0;
-}
-
-/*
- * Push down to new source of characters.
- * If fd>0 and str==NULL, then from a file `name';
- * if fd==-1 and str, then from the string.
- */
-Source *
-setsource(char *name, int fd, char *str)
-{
- Source *s = new(Source);
- int len;
-
- s->line = 1;
- s->lineinc = 0;
- s->fd = fd;
- s->filename = name;
- s->next = cursource;
- s->ifdepth = 0;
- cursource = s;
- /* slop at right for EOB */
- if (str) {
- len = strlen(str);
- s->inb = domalloc(len+4);
- s->inp = s->inb;
- strncpy((char *)s->inp, str, len);
- } else {
- s->inb = domalloc(INS+4);
- s->inp = s->inb;
- len = 0;
- }
- s->inl = s->inp+len;
- s->inl[0] = s->inl[1] = EOB;
- return s;
-}
-
-void
-unsetsource(void)
-{
- Source *s = cursource;
-
- if (s->fd>=0) {
- close(s->fd);
- dofree(s->inb);
- }
- cursource = s->next;
- dofree(s);
-}
diff --git a/lcc/cpp/macro.c b/lcc/cpp/macro.c
deleted file mode 100644
index 49d1129..0000000
--- a/lcc/cpp/macro.c
+++ /dev/null
@@ -1,515 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-/*
- * do a macro definition. tp points to the name being defined in the line
- */
-void
-dodefine(Tokenrow *trp)
-{
- Token *tp;
- Nlist *np;
- Tokenrow *def, *args;
-
- tp = trp->tp+1;
- if (tp>=trp->lp || tp->type!=NAME) {
- error(ERROR, "#defined token is not a name");
- return;
- }
- np = lookup(tp, 1);
- if (np->flag&ISUNCHANGE) {
- error(ERROR, "#defined token %t can't be redefined", tp);
- return;
- }
- /* collect arguments */
- tp += 1;
- args = NULL;
- if (tp<trp->lp && tp->type==LP && tp->wslen==0) {
- /* macro with args */
- int narg = 0;
- tp += 1;
- args = new(Tokenrow);
- maketokenrow(2, args);
- if (tp->type!=RP) {
- int err = 0;
- for (;;) {
- Token *atp;
- if (tp->type!=NAME) {
- err++;
- break;
- }
- if (narg>=args->max)
- growtokenrow(args);
- for (atp=args->bp; atp<args->lp; atp++)
- if (atp->len==tp->len
- && strncmp((char*)atp->t, (char*)tp->t, tp->len)==0)
- error(ERROR, "Duplicate macro argument");
- *args->lp++ = *tp;
- narg++;
- tp += 1;
- if (tp->type==RP)
- break;
- if (tp->type!=COMMA) {
- err++;
- break;
- }
- tp += 1;
- }
- if (err) {
- error(ERROR, "Syntax error in macro parameters");
- return;
- }
- }
- tp += 1;
- }
- trp->tp = tp;
- if (((trp->lp)-1)->type==NL)
- trp->lp -= 1;
- def = normtokenrow(trp);
- if (np->flag&ISDEFINED) {
- if (comparetokens(def, np->vp)
- || (np->ap==NULL) != (args==NULL)
- || (np->ap && comparetokens(args, np->ap)))
- error(ERROR, "Macro redefinition of %t", trp->bp+2);
- }
- if (args) {
- Tokenrow *tap;
- tap = normtokenrow(args);
- dofree(args->bp);
- args = tap;
- }
- np->ap = args;
- np->vp = def;
- np->flag |= ISDEFINED;
-}
-
-/*
- * Definition received via -D or -U
- */
-void
-doadefine(Tokenrow *trp, int type)
-{
- Nlist *np;
- static Token onetoken[1] = {{ NUMBER, 0, 0, 0, 1, (uchar*)"1" }};
- static Tokenrow onetr = { onetoken, onetoken, onetoken+1, 1 };
-
- trp->tp = trp->bp;
- if (type=='U') {
- if (trp->lp-trp->tp != 2 || trp->tp->type!=NAME)
- goto syntax;
- if ((np = lookup(trp->tp, 0)) == NULL)
- return;
- np->flag &= ~ISDEFINED;
- return;
- }
- if (trp->tp >= trp->lp || trp->tp->type!=NAME)
- goto syntax;
- np = lookup(trp->tp, 1);
- np->flag |= ISDEFINED;
- trp->tp += 1;
- if (trp->tp >= trp->lp || trp->tp->type==END) {
- np->vp = &onetr;
- return;
- }
- if (trp->tp->type!=ASGN)
- goto syntax;
- trp->tp += 1;
- if ((trp->lp-1)->type == END)
- trp->lp -= 1;
- np->vp = normtokenrow(trp);
- return;
-syntax:
- error(FATAL, "Illegal -D or -U argument %r", trp);
-}
-
-/*
- * Do macro expansion in a row of tokens.
- * Flag is NULL if more input can be gathered.
- */
-void
-expandrow(Tokenrow *trp, char *flag)
-{
- Token *tp;
- Nlist *np;
-
- if (flag)
- setsource(flag, -1, "");
- for (tp = trp->tp; tp<trp->lp; ) {
- if (tp->type!=NAME
- || quicklook(tp->t[0], tp->len>1?tp->t[1]:0)==0
- || (np = lookup(tp, 0))==NULL
- || (np->flag&(ISDEFINED|ISMAC))==0
- || (tp->hideset && checkhideset(tp->hideset, np))) {
- tp++;
- continue;
- }
- trp->tp = tp;
- if (np->val==KDEFINED) {
- tp->type = DEFINED;
- if ((tp+1)<trp->lp && (tp+1)->type==NAME)
- (tp+1)->type = NAME1;
- else if ((tp+3)<trp->lp && (tp+1)->type==LP
- && (tp+2)->type==NAME && (tp+3)->type==RP)
- (tp+2)->type = NAME1;
- else
- error(ERROR, "Incorrect syntax for `defined'");
- tp++;
- continue;
- }
- if (np->flag&ISMAC)
- builtin(trp, np->val);
- else {
- expand(trp, np);
- }
- tp = trp->tp;
- }
- if (flag)
- unsetsource();
-}
-
-/*
- * Expand the macro whose name is np, at token trp->tp, in the tokenrow.
- * Return trp->tp at the first token next to be expanded
- * (ordinarily the beginning of the expansion)
- */
-void
-expand(Tokenrow *trp, Nlist *np)
-{
- Tokenrow ntr;
- int ntokc, narg, i;
- Token *tp;
- Tokenrow *atr[NARG+1];
- int hs;
-
- copytokenrow(&ntr, np->vp); /* copy macro value */
- if (np->ap==NULL) /* parameterless */
- ntokc = 1;
- else {
- ntokc = gatherargs(trp, atr, &narg);
- if (narg<0) { /* not actually a call (no '(') */
- trp->tp++;
- return;
- }
- if (narg != rowlen(np->ap)) {
- error(ERROR, "Disagreement in number of macro arguments");
- trp->tp->hideset = newhideset(trp->tp->hideset, np);
- trp->tp += ntokc;
- return;
- }
- substargs(np, &ntr, atr); /* put args into replacement */
- for (i=0; i<narg; i++) {
- dofree(atr[i]->bp);
- dofree(atr[i]);
- }
- }
- doconcat(&ntr); /* execute ## operators */
- hs = newhideset(trp->tp->hideset, np);
- for (tp=ntr.bp; tp<ntr.lp; tp++) { /* distribute hidesets */
- if (tp->type==NAME) {
- if (tp->hideset==0)
- tp->hideset = hs;
- else
- tp->hideset = unionhideset(tp->hideset, hs);
- }
- }
- ntr.tp = ntr.bp;
- insertrow(trp, ntokc, &ntr);
- trp->tp -= rowlen(&ntr);
- dofree(ntr.bp);
- return;
-}
-
-/*
- * Gather an arglist, starting in trp with tp pointing at the macro name.
- * Return total number of tokens passed, stash number of args found.
- * trp->tp is not changed relative to the tokenrow.
- */
-int
-gatherargs(Tokenrow *trp, Tokenrow **atr, int *narg)
-{
- int parens = 1;
- int ntok = 0;
- Token *bp, *lp;
- Tokenrow ttr;
- int ntokp;
- int needspace;
-
- *narg = -1; /* means that there is no macro call */
- /* look for the ( */
- for (;;) {
- trp->tp++;
- ntok++;
- if (trp->tp >= trp->lp) {
- gettokens(trp, 0);
- if ((trp->lp-1)->type==END) {
- trp->lp -= 1;
- trp->tp -= ntok;
- return ntok;
- }
- }
- if (trp->tp->type==LP)
- break;
- if (trp->tp->type!=NL)
- return ntok;
- }
- *narg = 0;
- ntok++;
- ntokp = ntok;
- trp->tp++;
- /* search for the terminating ), possibly extending the row */
- needspace = 0;
- while (parens>0) {
- if (trp->tp >= trp->lp)
- gettokens(trp, 0);
- if (needspace) {
- needspace = 0;
- makespace(trp);
- }
- if (trp->tp->type==END) {
- trp->lp -= 1;
- trp->tp -= ntok;
- error(ERROR, "EOF in macro arglist");
- return ntok;
- }
- if (trp->tp->type==NL) {
- trp->tp += 1;
- adjustrow(trp, -1);
- trp->tp -= 1;
- makespace(trp);
- needspace = 1;
- continue;
- }
- if (trp->tp->type==LP)
- parens++;
- else if (trp->tp->type==RP)
- parens--;
- trp->tp++;
- ntok++;
- }
- trp->tp -= ntok;
- /* Now trp->tp won't move underneath us */
- lp = bp = trp->tp+ntokp;
- for (; parens>=0; lp++) {
- if (lp->type == LP) {
- parens++;
- continue;
- }
- if (lp->type==RP)
- parens--;
- if (lp->type==DSHARP)
- lp->type = DSHARP1; /* ## not special in arg */
- if ((lp->type==COMMA && parens==0) || (parens<0 && (lp-1)->type!=LP)) {
- if (*narg>=NARG-1)
- error(FATAL, "Sorry, too many macro arguments");
- ttr.bp = ttr.tp = bp;
- ttr.lp = lp;
- atr[(*narg)++] = normtokenrow(&ttr);
- bp = lp+1;
- }
- }
- return ntok;
-}
-
-/*
- * substitute the argument list into the replacement string
- * This would be simple except for ## and #
- */
-void
-substargs(Nlist *np, Tokenrow *rtr, Tokenrow **atr)
-{
- Tokenrow tatr;
- Token *tp;
- int ntok, argno;
-
- for (rtr->tp=rtr->bp; rtr->tp<rtr->lp; ) {
- if (rtr->tp->type==SHARP) { /* string operator */
- tp = rtr->tp;
- rtr->tp += 1;
- if ((argno = lookuparg(np, rtr->tp))<0) {
- error(ERROR, "# not followed by macro parameter");
- continue;
- }
- ntok = 1 + (rtr->tp - tp);
- rtr->tp = tp;
- insertrow(rtr, ntok, stringify(atr[argno]));
- continue;
- }
- if (rtr->tp->type==NAME
- && (argno = lookuparg(np, rtr->tp)) >= 0) {
- if ((rtr->tp+1)->type==DSHARP
- || (rtr->tp!=rtr->bp && (rtr->tp-1)->type==DSHARP))
- insertrow(rtr, 1, atr[argno]);
- else {
- copytokenrow(&tatr, atr[argno]);
- expandrow(&tatr, "<macro>");
- insertrow(rtr, 1, &tatr);
- dofree(tatr.bp);
- }
- continue;
- }
- rtr->tp++;
- }
-}
-
-/*
- * Evaluate the ## operators in a tokenrow
- */
-void
-doconcat(Tokenrow *trp)
-{
- Token *ltp, *ntp;
- Tokenrow ntr;
- int len;
-
- for (trp->tp=trp->bp; trp->tp<trp->lp; trp->tp++) {
- if (trp->tp->type==DSHARP1)
- trp->tp->type = DSHARP;
- else if (trp->tp->type==DSHARP) {
- char tt[128];
- ltp = trp->tp-1;
- ntp = trp->tp+1;
- if (ltp<trp->bp || ntp>=trp->lp) {
- error(ERROR, "## occurs at border of replacement");
- continue;
- }
- len = ltp->len + ntp->len;
- strncpy((char*)tt, (char*)ltp->t, ltp->len);
- strncpy((char*)tt+ltp->len, (char*)ntp->t, ntp->len);
- tt[len] = '\0';
- setsource("<##>", -1, tt);
- maketokenrow(3, &ntr);
- gettokens(&ntr, 1);
- unsetsource();
- if (ntr.lp-ntr.bp!=2 || ntr.bp->type==UNCLASS)
- error(WARNING, "Bad token %r produced by ##", &ntr);
- ntr.lp = ntr.bp+1;
- trp->tp = ltp;
- makespace(&ntr);
- insertrow(trp, (ntp-ltp)+1, &ntr);
- dofree(ntr.bp);
- trp->tp--;
- }
- }
-}
-
-/*
- * tp is a potential parameter name of macro mac;
- * look it up in mac's arglist, and if found, return the
- * corresponding index in the argname array. Return -1 if not found.
- */
-int
-lookuparg(Nlist *mac, Token *tp)
-{
- Token *ap;
-
- if (tp->type!=NAME || mac->ap==NULL)
- return -1;
- for (ap=mac->ap->bp; ap<mac->ap->lp; ap++) {
- if (ap->len==tp->len && strncmp((char*)ap->t,(char*)tp->t,ap->len)==0)
- return ap - mac->ap->bp;
- }
- return -1;
-}
-
-/*
- * Return a quoted version of the tokenrow (from # arg)
- */
-#define STRLEN 512
-Tokenrow *
-stringify(Tokenrow *vp)
-{
- static Token t = { STRING };
- static Tokenrow tr = { &t, &t, &t+1, 1 };
- Token *tp;
- uchar s[STRLEN];
- uchar *sp = s, *cp;
- int i, instring;
-
- *sp++ = '"';
- for (tp = vp->bp; tp < vp->lp; tp++) {
- instring = tp->type==STRING || tp->type==CCON;
- if (sp+2*tp->len >= &s[STRLEN-10]) {
- error(ERROR, "Stringified macro arg is too long");
- break;
- }
- if (tp->wslen && (tp->flag&XPWS)==0)
- *sp++ = ' ';
- for (i=0, cp=tp->t; i<tp->len; i++) {
- if (instring && (*cp=='"' || *cp=='\\'))
- *sp++ = '\\';
- *sp++ = *cp++;
- }
- }
- *sp++ = '"';
- *sp = '\0';
- sp = s;
- t.len = strlen((char*)sp);
- t.t = newstring(sp, t.len, 0);
- return &tr;
-}
-
-/*
- * expand a builtin name
- */
-void
-builtin(Tokenrow *trp, int biname)
-{
- char *op;
- Token *tp;
- Source *s;
-
- tp = trp->tp;
- trp->tp++;
- /* need to find the real source */
- s = cursource;
- while (s && s->fd==-1)
- s = s->next;
- if (s==NULL)
- s = cursource;
- /* most are strings */
- tp->type = STRING;
- if (tp->wslen) {
- *outp++ = ' ';
- tp->wslen = 1;
- }
- op = outp;
- *op++ = '"';
- switch (biname) {
-
- case KLINENO:
- tp->type = NUMBER;
- op = outnum(op-1, s->line);
- break;
-
- case KFILE: {
- char *src = s->filename;
- while ((*op++ = *src++) != 0)
- if (src[-1] == '\\')
- *op++ = '\\';
- op--;
- break;
- }
-
- case KDATE:
- strncpy(op, curtime+4, 7);
- strncpy(op+7, curtime+20, 4);
- op += 11;
- break;
-
- case KTIME:
- strncpy(op, curtime+11, 8);
- op += 8;
- break;
-
- default:
- error(ERROR, "cpp botch: unknown internal macro");
- return;
- }
- if (tp->type==STRING)
- *op++ = '"';
- tp->t = (uchar*)outp;
- tp->len = op - outp;
- outp = op;
-}
diff --git a/lcc/cpp/nlist.c b/lcc/cpp/nlist.c
deleted file mode 100644
index d857dfa..0000000
--- a/lcc/cpp/nlist.c
+++ /dev/null
@@ -1,104 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-extern int getopt(int, char *const *, const char *);
-extern char *optarg;
-extern int optind;
-extern int verbose;
-extern int Cplusplus;
-Nlist *kwdefined;
-char wd[128];
-
-#define NLSIZE 128
-
-static Nlist *nlist[NLSIZE];
-
-struct kwtab {
- char *kw;
- int val;
- int flag;
-} kwtab[] = {
- {"if", KIF, ISKW},
- {"ifdef", KIFDEF, ISKW},
- {"ifndef", KIFNDEF, ISKW},
- {"elif", KELIF, ISKW},
- {"else", KELSE, ISKW},
- {"endif", KENDIF, ISKW},
- {"include", KINCLUDE, ISKW},
- {"define", KDEFINE, ISKW},
- {"undef", KUNDEF, ISKW},
- {"line", KLINE, ISKW},
- {"error", KERROR, ISKW},
- {"pragma", KPRAGMA, ISKW},
- {"eval", KEVAL, ISKW},
- {"defined", KDEFINED, ISDEFINED+ISUNCHANGE},
- {"__LINE__", KLINENO, ISMAC+ISUNCHANGE},
- {"__FILE__", KFILE, ISMAC+ISUNCHANGE},
- {"__DATE__", KDATE, ISMAC+ISUNCHANGE},
- {"__TIME__", KTIME, ISMAC+ISUNCHANGE},
- {"__STDC__", KSTDC, ISUNCHANGE},
- {NULL}
-};
-
-unsigned long namebit[077+1];
-Nlist *np;
-
-void
-setup_kwtab(void)
-{
- struct kwtab *kp;
- Nlist *np;
- Token t;
- static Token deftoken[1] = {{ NAME, 0, 0, 0, 7, (uchar*)"defined" }};
- static Tokenrow deftr = { deftoken, deftoken, deftoken+1, 1 };
-
- for (kp=kwtab; kp->kw; kp++) {
- t.t = (uchar*)kp->kw;
- t.len = strlen(kp->kw);
- np = lookup(&t, 1);
- np->flag = kp->flag;
- np->val = kp->val;
- if (np->val == KDEFINED) {
- kwdefined = np;
- np->val = NAME;
- np->vp = &deftr;
- np->ap = 0;
- }
- }
-}
-
-Nlist *
-lookup(Token *tp, int install)
-{
- unsigned int h;
- Nlist *np;
- uchar *cp, *cpe;
-
- h = 0;
- for (cp=tp->t, cpe=cp+tp->len; cp<cpe; )
- h += *cp++;
- h %= NLSIZE;
- np = nlist[h];
- while (np) {
- if (*tp->t==*np->name && tp->len==np->len
- && strncmp((char*)tp->t, (char*)np->name, tp->len)==0)
- return np;
- np = np->next;
- }
- if (install) {
- np = new(Nlist);
- np->vp = NULL;
- np->ap = NULL;
- np->flag = 0;
- np->val = 0;
- np->len = tp->len;
- np->name = newstring(tp->t, tp->len, 0);
- np->next = nlist[h];
- nlist[h] = np;
- quickset(tp->t[0], tp->len>1? tp->t[1]:0);
- return np;
- }
- return NULL;
-}
diff --git a/lcc/cpp/tokens.c b/lcc/cpp/tokens.c
deleted file mode 100644
index 147569b..0000000
--- a/lcc/cpp/tokens.c
+++ /dev/null
@@ -1,370 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-static char wbuf[2*OBS];
-static char *wbp = wbuf;
-
-/*
- * 1 for tokens that don't need whitespace when they get inserted
- * by macro expansion
- */
-static const char wstab[] = {
- 0, /* END */
- 0, /* UNCLASS */
- 0, /* NAME */
- 0, /* NUMBER */
- 0, /* STRING */
- 0, /* CCON */
- 1, /* NL */
- 0, /* WS */
- 0, /* DSHARP */
- 0, /* EQ */
- 0, /* NEQ */
- 0, /* LEQ */
- 0, /* GEQ */
- 0, /* LSH */
- 0, /* RSH */
- 0, /* LAND */
- 0, /* LOR */
- 0, /* PPLUS */
- 0, /* MMINUS */
- 0, /* ARROW */
- 1, /* SBRA */
- 1, /* SKET */
- 1, /* LP */
- 1, /* RP */
- 0, /* DOT */
- 0, /* AND */
- 0, /* STAR */
- 0, /* PLUS */
- 0, /* MINUS */
- 0, /* TILDE */
- 0, /* NOT */
- 0, /* SLASH */
- 0, /* PCT */
- 0, /* LT */
- 0, /* GT */
- 0, /* CIRC */
- 0, /* OR */
- 0, /* QUEST */
- 0, /* COLON */
- 0, /* ASGN */
- 1, /* COMMA */
- 0, /* SHARP */
- 1, /* SEMIC */
- 1, /* CBRA */
- 1, /* CKET */
- 0, /* ASPLUS */
- 0, /* ASMINUS */
- 0, /* ASSTAR */
- 0, /* ASSLASH */
- 0, /* ASPCT */
- 0, /* ASCIRC */
- 0, /* ASLSH */
- 0, /* ASRSH */
- 0, /* ASOR */
- 0, /* ASAND */
- 0, /* ELLIPS */
- 0, /* DSHARP1 */
- 0, /* NAME1 */
- 0, /* DEFINED */
- 0, /* UMINUS */
-};
-
-void
-maketokenrow(int size, Tokenrow *trp)
-{
- trp->max = size;
- if (size>0)
- trp->bp = (Token *)domalloc(size*sizeof(Token));
- else
- trp->bp = NULL;
- trp->tp = trp->bp;
- trp->lp = trp->bp;
-}
-
-Token *
-growtokenrow(Tokenrow *trp)
-{
- int ncur = trp->tp - trp->bp;
- int nlast = trp->lp - trp->bp;
-
- trp->max = 3*trp->max/2 + 1;
- trp->bp = (Token *)realloc(trp->bp, trp->max*sizeof(Token));
- if (trp->bp == NULL)
- error(FATAL, "Out of memory from realloc");
- trp->lp = &trp->bp[nlast];
- trp->tp = &trp->bp[ncur];
- return trp->lp;
-}
-
-/*
- * Compare a row of tokens, ignoring the content of WS; return !=0 if different
- */
-int
-comparetokens(Tokenrow *tr1, Tokenrow *tr2)
-{
- Token *tp1, *tp2;
-
- tp1 = tr1->tp;
- tp2 = tr2->tp;
- if (tr1->lp-tp1 != tr2->lp-tp2)
- return 1;
- for (; tp1<tr1->lp ; tp1++, tp2++) {
- if (tp1->type != tp2->type
- || (tp1->wslen==0) != (tp2->wslen==0)
- || tp1->len != tp2->len
- || strncmp((char*)tp1->t, (char*)tp2->t, tp1->len)!=0)
- return 1;
- }
- return 0;
-}
-
-/*
- * replace ntok tokens starting at dtr->tp with the contents of str.
- * tp ends up pointing just beyond the replacement.
- * Canonical whitespace is assured on each side.
- */
-void
-insertrow(Tokenrow *dtr, int ntok, Tokenrow *str)
-{
- int nrtok = rowlen(str);
-
- dtr->tp += ntok;
- adjustrow(dtr, nrtok-ntok);
- dtr->tp -= ntok;
- movetokenrow(dtr, str);
- makespace(dtr);
- dtr->tp += nrtok;
- makespace(dtr);
-}
-
-/*
- * make sure there is WS before trp->tp, if tokens might merge in the output
- */
-void
-makespace(Tokenrow *trp)
-{
- uchar *tt;
- Token *tp = trp->tp;
-
- if (tp >= trp->lp)
- return;
- if (tp->wslen) {
- if (tp->flag&XPWS
- && (wstab[tp->type] || (trp->tp>trp->bp && wstab[(tp-1)->type]))) {
- tp->wslen = 0;
- return;
- }
- tp->t[-1] = ' ';
- return;
- }
- if (wstab[tp->type] || (trp->tp>trp->bp && wstab[(tp-1)->type]))
- return;
- tt = newstring(tp->t, tp->len, 1);
- *tt++ = ' ';
- tp->t = tt;
- tp->wslen = 1;
- tp->flag |= XPWS;
-}
-
-/*
- * Copy an entire tokenrow into another, at tp.
- * It is assumed that there is enough space.
- * Not strictly conforming.
- */
-void
-movetokenrow(Tokenrow *dtr, Tokenrow *str)
-{
- int nby;
-
- /* nby = sizeof(Token) * (str->lp - str->bp); */
- nby = (char *)str->lp - (char *)str->bp;
- memmove(dtr->tp, str->bp, nby);
-}
-
-/*
- * Move the tokens in a row, starting at tr->tp, rightward by nt tokens;
- * nt may be negative (left move).
- * The row may need to be grown.
- * Non-strictly conforming because of the (char *), but easily fixed
- */
-void
-adjustrow(Tokenrow *trp, int nt)
-{
- int nby, size;
-
- if (nt==0)
- return;
- size = (trp->lp - trp->bp) + nt;
- while (size > trp->max)
- growtokenrow(trp);
- /* nby = sizeof(Token) * (trp->lp - trp->tp); */
- nby = (char *)trp->lp - (char *)trp->tp;
- if (nby)
- memmove(trp->tp+nt, trp->tp, nby);
- trp->lp += nt;
-}
-
-/*
- * Copy a row of tokens into the destination holder, allocating
- * the space for the contents. Return the destination.
- */
-Tokenrow *
-copytokenrow(Tokenrow *dtr, Tokenrow *str)
-{
- int len = rowlen(str);
-
- maketokenrow(len, dtr);
- movetokenrow(dtr, str);
- dtr->lp += len;
- return dtr;
-}
-
-/*
- * Produce a copy of a row of tokens. Start at trp->tp.
- * The value strings are copied as well. The first token
- * has WS available.
- */
-Tokenrow *
-normtokenrow(Tokenrow *trp)
-{
- Token *tp;
- Tokenrow *ntrp = new(Tokenrow);
- int len;
-
- len = trp->lp - trp->tp;
- if (len<=0)
- len = 1;
- maketokenrow(len, ntrp);
- for (tp=trp->tp; tp < trp->lp; tp++) {
- *ntrp->lp = *tp;
- if (tp->len) {
- ntrp->lp->t = newstring(tp->t, tp->len, 1);
- *ntrp->lp->t++ = ' ';
- if (tp->wslen)
- ntrp->lp->wslen = 1;
- }
- ntrp->lp++;
- }
- if (ntrp->lp > ntrp->bp)
- ntrp->bp->wslen = 0;
- return ntrp;
-}
-
-/*
- * Debugging
- */
-void
-peektokens(Tokenrow *trp, char *str)
-{
- Token *tp;
-
- tp = trp->tp;
- flushout();
- if (str)
- fprintf(stderr, "%s ", str);
- if (tp<trp->bp || tp>trp->lp)
- fprintf(stderr, "(tp offset %d) ", tp-trp->bp);
- for (tp=trp->bp; tp<trp->lp && tp<trp->bp+32; tp++) {
- if (tp->type!=NL) {
- int c = tp->t[tp->len];
- tp->t[tp->len] = 0;
- fprintf(stderr, "%s", tp->t);
- tp->t[tp->len] = c;
- }
- if (tp->type==NAME) {
- fprintf(stderr, tp==trp->tp?"{*":"{");
- prhideset(tp->hideset);
- fprintf(stderr, "} ");
- } else
- fprintf(stderr, tp==trp->tp?"{%x*} ":"{%x} ", tp->type);
- }
- fprintf(stderr, "\n");
- fflush(stderr);
-}
-
-void
-puttokens(Tokenrow *trp)
-{
- Token *tp;
- int len;
- uchar *p;
-
- if (verbose)
- peektokens(trp, "");
- tp = trp->bp;
- for (; tp<trp->lp; tp++) {
- len = tp->len+tp->wslen;
- p = tp->t-tp->wslen;
- while (tp<trp->lp-1 && p+len == (tp+1)->t - (tp+1)->wslen) {
- tp++;
- len += tp->wslen+tp->len;
- }
- if (len>OBS/2) { /* handle giant token */
- if (wbp > wbuf)
- write(1, wbuf, wbp-wbuf);
- write(1, (char *)p, len);
- wbp = wbuf;
- } else {
- memcpy(wbp, p, len);
- wbp += len;
- }
- if (wbp >= &wbuf[OBS]) {
- write(1, wbuf, OBS);
- if (wbp > &wbuf[OBS])
- memcpy(wbuf, wbuf+OBS, wbp - &wbuf[OBS]);
- wbp -= OBS;
- }
- }
- trp->tp = tp;
- if (cursource->fd==0)
- flushout();
-}
-
-void
-flushout(void)
-{
- if (wbp>wbuf) {
- write(1, wbuf, wbp-wbuf);
- wbp = wbuf;
- }
-}
-
-/*
- * turn a row into just a newline
- */
-void
-setempty(Tokenrow *trp)
-{
- trp->tp = trp->bp;
- trp->lp = trp->bp+1;
- *trp->bp = nltoken;
-}
-
-/*
- * generate a number
- */
-char *
-outnum(char *p, int n)
-{
- if (n>=10)
- p = outnum(p, n/10);
- *p++ = n%10 + '0';
- return p;
-}
-
-/*
- * allocate and initialize a new string from s, of length l, at offset o
- * Null terminated.
- */
-uchar *
-newstring(uchar *s, int l, int o)
-{
- uchar *ns = (uchar *)domalloc(l+o+1);
-
- ns[l+o] = '\0';
- return (uchar*)strncpy((char*)ns+o, (char*)s, l) - o;
-}
diff --git a/lcc/cpp/unix.c b/lcc/cpp/unix.c
deleted file mode 100644
index a845a60..0000000
--- a/lcc/cpp/unix.c
+++ /dev/null
@@ -1,116 +0,0 @@
-#include <stdio.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include "cpp.h"
-
-extern int getopt(int, char *const *, const char *);
-extern char *optarg, rcsid[];
-extern int optind;
-int verbose;
-int Mflag; /* only print active include files */
-char *objname; /* "src.$O: " */
-int Cplusplus = 1;
-
-void
-setup(int argc, char **argv)
-{
- int c, fd, i;
- char *fp, *dp;
- Tokenrow tr;
- extern void setup_kwtab(void);
-
- setup_kwtab();
- while ((c = getopt(argc, argv, "MNOVv+I:D:U:F:lg")) != -1)
- switch (c) {
- case 'N':
- for (i=0; i<NINCLUDE; i++)
- if (includelist[i].always==1)
- includelist[i].deleted = 1;
- break;
- case 'I':
- for (i=NINCLUDE-2; i>=0; i--) {
- if (includelist[i].file==NULL) {
- includelist[i].always = 1;
- includelist[i].file = optarg;
- break;
- }
- }
- if (i<0)
- error(FATAL, "Too many -I directives");
- break;
- case 'D':
- case 'U':
- setsource("<cmdarg>", -1, optarg);
- maketokenrow(3, &tr);
- gettokens(&tr, 1);
- doadefine(&tr, c);
- unsetsource();
- break;
- case 'M':
- Mflag++;
- break;
- case 'v':
- fprintf(stderr, "%s %s\n", argv[0], rcsid);
- break;
- case 'V':
- verbose++;
- break;
- case '+':
- Cplusplus++;
- break;
- default:
- break;
- }
- dp = ".";
- fp = "<stdin>";
- fd = 0;
- if (optind<argc) {
- if ((fp = strrchr(argv[optind], '/')) != NULL) {
- int len = fp - argv[optind];
- dp = (char*)newstring((uchar*)argv[optind], len+1, 0);
- dp[len] = '\0';
- }
- fp = (char*)newstring((uchar*)argv[optind], strlen(argv[optind]), 0);
- if ((fd = open(fp, 0)) <= 0)
- error(FATAL, "Can't open input file %s", fp);
- }
- if (optind+1<argc) {
- int fdo = creat(argv[optind+1], 0666);
- if (fdo<0)
- error(FATAL, "Can't open output file %s", argv[optind+1]);
- dup2(fdo, 1);
- }
- if(Mflag)
- setobjname(fp);
- includelist[NINCLUDE-1].always = 0;
- includelist[NINCLUDE-1].file = dp;
- setsource(fp, fd, NULL);
-}
-
-
-
-/* memmove is defined here because some vendors don't provide it at
- all and others do a terrible job (like calling malloc) */
-void *
-memmove(void *dp, const void *sp, size_t n)
-{
- unsigned char *cdp, *csp;
-
- if (n<=0)
- return 0;
- cdp = dp;
- csp = (unsigned char *)sp;
- if (cdp < csp) {
- do {
- *cdp++ = *csp++;
- } while (--n);
- } else {
- cdp += n;
- csp += n;
- do {
- *--cdp = *--csp;
- } while (--n);
- }
- return 0;
-}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-28 12:30:45 +0000