From 6bf20c78f5b69d40bcc4931df93d29198435ab67 Mon Sep 17 00:00:00 2001 From: zakk Date: Fri, 26 Aug 2005 17:39:27 +0000 Subject: newlines fixed git-svn-id: svn://svn.icculus.org/quake3/trunk@6 edf5b092-35ff-0310-97b2-ce42778d08ea --- lcc/cpp/cpp.c | 644 ++++++++++++++--------------- lcc/cpp/cpp.h | 326 +++++++-------- lcc/cpp/eval.c | 1040 +++++++++++++++++++++++------------------------ lcc/cpp/getopt.c | 104 ++--- lcc/cpp/hideset.c | 224 +++++------ lcc/cpp/include.c | 244 +++++------ lcc/cpp/lex.c | 1162 ++++++++++++++++++++++++++--------------------------- lcc/cpp/macro.c | 1030 +++++++++++++++++++++++------------------------ lcc/cpp/nlist.c | 208 +++++----- lcc/cpp/tokens.c | 740 +++++++++++++++++----------------- lcc/cpp/unix.c | 232 +++++------ 11 files changed, 2977 insertions(+), 2977 deletions(-) (limited to 'lcc/cpp') diff --git a/lcc/cpp/cpp.c b/lcc/cpp/cpp.c index f632332..6baa473 100755 --- a/lcc/cpp/cpp.c +++ b/lcc/cpp/cpp.c @@ -1,322 +1,322 @@ -#include -#include -#include -#include -#include -#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 (--ifdepthifdepth; - 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, ""); - tp = trp->bp+2; - kline: - if (tp+1>=trp->lp || tp->type!=NUMBER || tp+3lp - || (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+1lp) - 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; tplp&&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); -} +#include +#include +#include +#include +#include +#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 (--ifdepthifdepth; + 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, ""); + tp = trp->bp+2; + kline: + if (tp+1>=trp->lp || tp->type!=NUMBER || tp+3lp + || (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+1lp) + 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; tplp&&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 index 3c8a61c..d72f24a 100755 --- a/lcc/cpp/cpp.h +++ b/lcc/cpp/cpp.h @@ -1,163 +1,163 @@ -#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); +#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 index 2442ac2..7061eff 100755 --- a/lcc/cpp/eval.c +++ b/lcc/cpp/eval.c @@ -1,520 +1,520 @@ -#include -#include -#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, ""); - 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 = rv1rv2; 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)rv1rv2; break; - case LSH: - rv1 <<= rv2; break; - case LSH|UNSMARK: - rv1 = (unsigned long)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)) - 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; -} +#include +#include +#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, ""); + 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 = rv1rv2; 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)rv1rv2; break; + case LSH: + rv1 <<= rv2; break; + case LSH|UNSMARK: + rv1 = (unsigned long)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)) + 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 index 69e9ab4..07fd798 100755 --- a/lcc/cpp/getopt.c +++ b/lcc/cpp/getopt.c @@ -1,52 +1,52 @@ -#include -#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; -char *strchr(); - -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; -} +#include +#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; +char *strchr(); + +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 index 637a441..bd2540d 100755 --- a/lcc/cpp/hideset.c +++ b/lcc/cpp/hideset.c @@ -1,112 +1,112 @@ -#include -#include -#include -#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=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, " "); - } -} +#include +#include +#include +#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=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 index 66f1fc3..72ec8ae 100755 --- a/lcc/cpp/include.c +++ b/lcc/cpp/include.c @@ -1,122 +1,122 @@ -#include -#include -#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, ""); - 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: "); - } -} +#include +#include +#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, ""); + 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 index 8513a17..fc4c5db 100755 --- a/lcc/cpp/lex.c +++ b/lcc/cpp/lex.c @@ -1,581 +1,581 @@ -#include -#include -#include -#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; i0) - 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; - extern char outbuf[]; - - 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); -} +#include +#include +#include +#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; i0) + 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; + extern char outbuf[]; + + 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 index 2268c4b..55b4b2c 100755 --- a/lcc/cpp/macro.c +++ b/lcc/cpp/macro.c @@ -1,515 +1,515 @@ -#include -#include -#include -#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 (tplp && 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; atplp; 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; tplp; ) { - 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)lp && (tp+1)->type==NAME) - (tp+1)->type = NAME1; - else if ((tp+3)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; ibp); - dofree(atr[i]); - } - } - doconcat(&ntr); /* execute ## operators */ - hs = newhideset(trp->tp->hideset, np); - for (tp=ntr.bp; tptype==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->tplp; ) { - 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, ""); - 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->tplp; 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 (ltpbp || 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; apap->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; ilen; 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; -} +#include +#include +#include +#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 (tplp && 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; atplp; 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; tplp; ) { + 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)lp && (tp+1)->type==NAME) + (tp+1)->type = NAME1; + else if ((tp+3)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; ibp); + dofree(atr[i]); + } + } + doconcat(&ntr); /* execute ## operators */ + hs = newhideset(trp->tp->hideset, np); + for (tp=ntr.bp; tptype==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->tplp; ) { + 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, ""); + 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->tplp; 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 (ltpbp || 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; apap->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; ilen; 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 index c77fff1..33c2db9 100755 --- a/lcc/cpp/nlist.c +++ b/lcc/cpp/nlist.c @@ -1,104 +1,104 @@ -#include -#include -#include -#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; cpt==*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; -} +#include +#include +#include +#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; cpt==*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 index 701cbcc..ebbd186 100755 --- a/lcc/cpp/tokens.c +++ b/lcc/cpp/tokens.c @@ -1,370 +1,370 @@ -#include -#include -#include -#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 (; tp1lp ; 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 (tpbp || tp>trp->lp) - fprintf(stderr, "(tp offset %d) ", tp-trp->bp); - for (tp=trp->bp; tplp && tpbp+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 (; tplp; tp++) { - len = tp->len+tp->wslen; - p = tp->t-tp->wslen; - while (tplp-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; -} +#include +#include +#include +#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 (; tp1lp ; 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 (tpbp || tp>trp->lp) + fprintf(stderr, "(tp offset %d) ", tp-trp->bp); + for (tp=trp->bp; tplp && tpbp+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 (; tplp; tp++) { + len = tp->len+tp->wslen; + p = tp->t-tp->wslen; + while (tplp-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 index 332ab0c..a845a60 100755 --- a/lcc/cpp/unix.c +++ b/lcc/cpp/unix.c @@ -1,116 +1,116 @@ -#include -#include -#include -#include -#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=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("", -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 = ""; - fd = 0; - if (optind +#include +#include +#include +#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=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("", -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 = ""; + fd = 0; + if (optind