URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [lcc/] [cpp/] [cpp.c] - Blame information for rev 149

Go to most recent revision | Details | Compare with Previous | View Log


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdarg.h>
#include "cpp.h"
 
#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;
 
char rcsid[] = "$Revision: 1.6 $ $Date: 2001/03/27 19:37:59 $";
 
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) {
                if ((np->flag&ISKW)==0)
                        return;
                switch (np->val) {
                case KENDIF:
                        if (--ifdepth<skipping)
                                skipping = 0;
                        --cursource->ifdepth;
                        setempty(trp);
                        return;
 
                case KIFDEF:
                case KIFNDEF:
                case KIF:
                        if (++ifdepth >= NIF)
                                error(FATAL, "#if too deeply nested");
                        ++cursource->ifdepth;
                        return;
 
                case KELIF:
                case KELSE:
                        if (ifdepth<=skipping)
                                break;
                        return;
 
                default:
                        return;
                }
        }
        switch (np->val) {
        case KDEFINE:
                dodefine(trp);
                break;
 
        case KUNDEF:
                tp += 1;
                if (tp->type!=NAME || trp->lp - trp->bp != 4) {
                        error(ERROR, "Syntax error in #undef");
                        break;
                }
                if ((np = lookup(tp, 0)) != NULL)
                        np->flag &= ~ISDEFINED;
                break;
 
        case KPRAGMA:
                return;
 
        case KIFDEF:
        case KIFNDEF:
        case KIF:
                if (++ifdepth >= NIF)
                        error(FATAL, "#if too deeply nested");
                ++cursource->ifdepth;
                ifsatisfied[ifdepth] = 0;
                if (eval(trp, np->val))
                        ifsatisfied[ifdepth] = 1;
                else
                        skipping = ifdepth;
                break;
 
        case KELIF:
                if (ifdepth==0) {
                        error(ERROR, "#elif with no #if");
                        return;
                }
                if (ifsatisfied[ifdepth]==2)
                        error(ERROR, "#elif after #else");
                if (eval(trp, np->val)) {
                        if (ifsatisfied[ifdepth])
                                skipping = ifdepth;
                        else {
                                skipping = 0;
                                ifsatisfied[ifdepth] = 1;
                        }
                } else
                        skipping = ifdepth;
                break;
 
        case KELSE:
                if (ifdepth==0 || cursource->ifdepth==0) {
                        error(ERROR, "#else with no #if");
                        return;
                }
                if (ifsatisfied[ifdepth]==2)
                        error(ERROR, "#else after #else");
                if (trp->lp - trp->bp != 3)
                        error(ERROR, "Syntax error in #else");
                skipping = ifsatisfied[ifdepth]? ifdepth: 0;
                ifsatisfied[ifdepth] = 2;
                break;
 
        case KENDIF:
                if (ifdepth==0 || cursource->ifdepth==0) {
                        error(ERROR, "#endif with no #if");
                        return;
                }
                --ifdepth;
                --cursource->ifdepth;
                if (trp->lp - trp->bp != 3)
                        error(WARNING, "Syntax error in #endif");
                break;
 
        case KERROR:
                trp->tp = tp+1;
                error(WARNING, "#error directive: %r", trp);
                break;
 
        case KLINE:
                trp->tp = tp+1;
                expandrow(trp, "<line>");
                tp = trp->bp+2;
        kline:
                if (tp+1>=trp->lp || tp->type!=NUMBER || tp+3<trp->lp
                 || (tp+3==trp->lp && ((tp+1)->type!=STRING)||*(tp+1)->t=='L')){
                        error(ERROR, "Syntax error in #line");
                        return;
                }
                cursource->line = atol((char*)tp->t)-1;
                if (cursource->line<0 || cursource->line>=32768)
                        error(WARNING, "#line specifies number out of range");
                tp = tp+1;
                if (tp+1<trp->lp)
                        cursource->filename=(char*)newstring(tp->t+1,tp->len-2,0);
                return;
 
        case KDEFINED:
                error(ERROR, "Bad syntax for control line");
                break;
 
        case KINCLUDE:
                doinclude(trp);
                trp->lp = trp->bp;
                return;
 
        case KEVAL:
                eval(trp, np->val);
                break;
 
        default:
                error(ERROR, "Preprocessor control `%t' not yet implemented", tp);
                break;
        }
        setempty(trp);
        return;
}
 
void *
domalloc(int size)
{
        void *p = malloc(size);
 
        if (p==NULL)
                error(FATAL, "Out of memory from malloc");
        return p;
}
 
void
dofree(void *p)
{
        free(p);
}
 
void
error(enum errtype type, char *string, ...)
{
        va_list ap;
        char *cp, *ep;
        Token *tp;
        Tokenrow *trp;
        Source *s;
        int i;
 
        fprintf(stderr, "cpp: ");
        for (s=cursource; s; s=s->next)
                if (*s->filename)
                        fprintf(stderr, "%s:%d ", s->filename, s->line);
        va_start(ap, string);
        for (ep=string; *ep; ep++) {
                if (*ep=='%') {
                        switch (*++ep) {
 
                        case 's':
                                cp = va_arg(ap, char *);
                                fprintf(stderr, "%s", cp);
                                break;
                        case 'd':
                                i = va_arg(ap, int);
                                fprintf(stderr, "%d", i);
                                break;
                        case 't':
                                tp = va_arg(ap, Token *);
                                fprintf(stderr, "%.*s", tp->len, tp->t);
                                break;
 
                        case 'r':
                                trp = va_arg(ap, Tokenrow *);
                                for (tp=trp->tp; tp<trp->lp&&tp->type!=NL; tp++) {
                                        if (tp>trp->tp && tp->wslen)
                                                fputc(' ', stderr);
                                        fprintf(stderr, "%.*s", tp->len, tp->t);
                                }
                                break;
 
                        default:
                                fputc(*ep, stderr);
                                break;
                        }
                } else
                        fputc(*ep, stderr);
        }
        va_end(ap);
        fputc('\n', stderr);
        if (type==FATAL)
                exit(1);
        if (type!=WARNING)
                nerrs = 1;
        fflush(stderr);
}

Browse

Tools

Subversion Repositories eco32

[/] [eco32/] [trunk/] [lcc/] [cpp/] [cpp.c] - Blame information for rev 149

Line No.	Rev	Author	Line
1	4	hellwig	`#include <stdio.h>`
2			`#include <stdlib.h>`
3			`#include <string.h>`
4			`#include <time.h>`
5			`#include <stdarg.h>`
6			`#include "cpp.h"`
7
8			`#define OUTS 16384`
9			`char outbuf[OUTS];`
10			`char *outp = outbuf;`
11			`Source *cursource;`
12			`int nerrs;`
13			`struct token nltoken = { NL, 0, 0, 0, 1, (uchar*)"\n" };`
14			`char *curtime;`
15			`int incdepth;`
16			`int ifdepth;`
17			`int ifsatisfied[NIF];`
18			`int skipping;`
19
20			`char rcsid[] = "$Revision: 1.6 $ $Date: 2001/03/27 19:37:59 $";`
21
22			`int`
23			`main(int argc, char **argv)`
24			`{`
25			`Tokenrow tr;`
26			`time_t t;`
27			`char ebuf[BUFSIZ];`
28
29			`setbuf(stderr, ebuf);`
30			`t = time(NULL);`
31			`curtime = ctime(&t);`
32			`maketokenrow(3, &tr);`
33			`expandlex();`
34			`setup(argc, argv);`
35			`fixlex();`
36			`iniths();`
37			`genline();`
38			`process(&tr);`
39			`flushout();`
40			`fflush(stderr);`
41			`exit(nerrs > 0);`
42			`return 0;`
43			`}`
44
45			`void`
46			`process(Tokenrow *trp)`
47			`{`
48			`int anymacros = 0;`
49
50			`for (;;) {`
51			`if (trp->tp >= trp->lp) {`
52			`trp->tp = trp->lp = trp->bp;`
53			`outp = outbuf;`
54			`anymacros \|= gettokens(trp, 1);`
55			`trp->tp = trp->bp;`
56			`}`
57			`if (trp->tp->type == END) {`
58			`if (--incdepth>=0) {`
59			`if (cursource->ifdepth)`
60			`error(ERROR,`
61			`"Unterminated conditional in #include");`
62			`unsetsource();`
63			`cursource->line += cursource->lineinc;`
64			`trp->tp = trp->lp;`
65			`genline();`
66			`continue;`
67			`}`
68			`if (ifdepth)`
69			`error(ERROR, "Unterminated #if/#ifdef/#ifndef");`
70			`break;`
71			`}`
72			`if (trp->tp->type==SHARP) {`
73			`trp->tp += 1;`
74			`control(trp);`
75			`} else if (!skipping && anymacros)`
76			`expandrow(trp, NULL);`
77			`if (skipping)`
78			`setempty(trp);`
79			`puttokens(trp);`
80			`anymacros = 0;`
81			`cursource->line += cursource->lineinc;`
82			`if (cursource->lineinc>1) {`
83			`genline();`
84			`}`
85			`}`
86			`}`
87
88			`void`
89			`control(Tokenrow *trp)`
90			`{`
91			`Nlist *np;`
92			`Token *tp;`
93
94			`tp = trp->tp;`
95			`if (tp->type!=NAME) {`
96			`if (tp->type==NUMBER)`
97			`goto kline;`
98			`if (tp->type != NL)`
99			`error(ERROR, "Unidentifiable control line");`
100			`return; /* else empty line */`
101			`}`
102			`if ((np = lookup(tp, 0))==NULL \|\| (np->flag&ISKW)==0 && !skipping) {`
103			`error(WARNING, "Unknown preprocessor control %t", tp);`
104			`return;`
105			`}`
106			`if (skipping) {`
107			`if ((np->flag&ISKW)==0)`
108			`return;`
109			`switch (np->val) {`
110			`case KENDIF:`
111			`if (--ifdepth<skipping)`
112			`skipping = 0;`
113			`--cursource->ifdepth;`
114			`setempty(trp);`
115			`return;`
116
117			`case KIFDEF:`
118			`case KIFNDEF:`
119			`case KIF:`
120			`if (++ifdepth >= NIF)`
121			`error(FATAL, "#if too deeply nested");`
122			`++cursource->ifdepth;`
123			`return;`
124
125			`case KELIF:`
126			`case KELSE:`
127			`if (ifdepth<=skipping)`
128			`break;`
129			`return;`
130
131			`default:`
132			`return;`
133			`}`
134			`}`
135			`switch (np->val) {`
136			`case KDEFINE:`
137			`dodefine(trp);`
138			`break;`
139
140			`case KUNDEF:`
141			`tp += 1;`
142			`if (tp->type!=NAME \|\| trp->lp - trp->bp != 4) {`
143			`error(ERROR, "Syntax error in #undef");`
144			`break;`
145			`}`
146			`if ((np = lookup(tp, 0)) != NULL)`
147			`np->flag &= ~ISDEFINED;`
148			`break;`
149
150			`case KPRAGMA:`
151			`return;`
152
153			`case KIFDEF:`
154			`case KIFNDEF:`
155			`case KIF:`
156			`if (++ifdepth >= NIF)`
157			`error(FATAL, "#if too deeply nested");`
158			`++cursource->ifdepth;`
159			`ifsatisfied[ifdepth] = 0;`
160			`if (eval(trp, np->val))`
161			`ifsatisfied[ifdepth] = 1;`
162			`else`
163			`skipping = ifdepth;`
164			`break;`
165
166			`case KELIF:`
167			`if (ifdepth==0) {`
168			`error(ERROR, "#elif with no #if");`
169			`return;`
170			`}`
171			`if (ifsatisfied[ifdepth]==2)`
172			`error(ERROR, "#elif after #else");`
173			`if (eval(trp, np->val)) {`
174			`if (ifsatisfied[ifdepth])`
175			`skipping = ifdepth;`
176			`else {`
177			`skipping = 0;`
178			`ifsatisfied[ifdepth] = 1;`
179			`}`
180			`} else`
181			`skipping = ifdepth;`
182			`break;`
183
184			`case KELSE:`
185			`if (ifdepth==0 \|\| cursource->ifdepth==0) {`
186			`error(ERROR, "#else with no #if");`
187			`return;`
188			`}`
189			`if (ifsatisfied[ifdepth]==2)`
190			`error(ERROR, "#else after #else");`
191			`if (trp->lp - trp->bp != 3)`
192			`error(ERROR, "Syntax error in #else");`
193			`skipping = ifsatisfied[ifdepth]? ifdepth: 0;`
194			`ifsatisfied[ifdepth] = 2;`
195			`break;`
196
197			`case KENDIF:`
198			`if (ifdepth==0 \|\| cursource->ifdepth==0) {`
199			`error(ERROR, "#endif with no #if");`
200			`return;`
201			`}`
202			`--ifdepth;`
203			`--cursource->ifdepth;`
204			`if (trp->lp - trp->bp != 3)`
205			`error(WARNING, "Syntax error in #endif");`
206			`break;`
207
208			`case KERROR:`
209			`trp->tp = tp+1;`
210			`error(WARNING, "#error directive: %r", trp);`
211			`break;`
212
213			`case KLINE:`
214			`trp->tp = tp+1;`
215			`expandrow(trp, "<line>");`
216			`tp = trp->bp+2;`
217			`kline:`
218			`if (tp+1>=trp->lp \|\| tp->type!=NUMBER \|\| tp+3<trp->lp`
219			`\|\| (tp+3==trp->lp && ((tp+1)->type!=STRING)\|\|*(tp+1)->t=='L')){`
220			`error(ERROR, "Syntax error in #line");`
221			`return;`
222			`}`
223			`cursource->line = atol((char*)tp->t)-1;`
224			`if (cursource->line<0 \|\| cursource->line>=32768)`
225			`error(WARNING, "#line specifies number out of range");`
226			`tp = tp+1;`
227			`if (tp+1<trp->lp)`
228			`cursource->filename=(char*)newstring(tp->t+1,tp->len-2,0);`
229			`return;`
230
231			`case KDEFINED:`
232			`error(ERROR, "Bad syntax for control line");`
233			`break;`
234
235			`case KINCLUDE:`
236			`doinclude(trp);`
237			`trp->lp = trp->bp;`
238			`return;`
239
240			`case KEVAL:`
241			`eval(trp, np->val);`
242			`break;`
243
244			`default:`
245			error(ERROR, "Preprocessor control `%t' not yet implemented", tp);
246			`break;`
247			`}`
248			`setempty(trp);`
249			`return;`
250			`}`
251
252			`void *`
253			`domalloc(int size)`
254			`{`
255			`void *p = malloc(size);`
256
257			`if (p==NULL)`
258			`error(FATAL, "Out of memory from malloc");`
259			`return p;`
260			`}`
261
262			`void`
263			`dofree(void *p)`
264			`{`
265			`free(p);`
266			`}`
267
268			`void`
269			`error(enum errtype type, char *string, ...)`
270			`{`
271			`va_list ap;`
272			`char cp, ep;`
273			`Token *tp;`
274			`Tokenrow *trp;`
275			`Source *s;`
276			`int i;`
277
278			`fprintf(stderr, "cpp: ");`
279			`for (s=cursource; s; s=s->next)`
280			`if (*s->filename)`
281			`fprintf(stderr, "%s:%d ", s->filename, s->line);`
282			`va_start(ap, string);`
283			`for (ep=string; *ep; ep++) {`
284			`if (*ep=='%') {`
285			`switch (*++ep) {`
286
287			`case 's':`
288			`cp = va_arg(ap, char *);`
289			`fprintf(stderr, "%s", cp);`
290			`break;`
291			`case 'd':`
292			`i = va_arg(ap, int);`
293			`fprintf(stderr, "%d", i);`
294			`break;`
295			`case 't':`
296			`tp = va_arg(ap, Token *);`
297			`fprintf(stderr, "%.*s", tp->len, tp->t);`
298			`break;`
299
300			`case 'r':`
301			`trp = va_arg(ap, Tokenrow *);`
302			`for (tp=trp->tp; tp<trp->lp&&tp->type!=NL; tp++) {`
303			`if (tp>trp->tp && tp->wslen)`
304			`fputc(' ', stderr);`
305			`fprintf(stderr, "%.*s", tp->len, tp->t);`
306			`}`
307			`break;`
308
309			`default:`
310			`fputc(*ep, stderr);`
311			`break;`
312			`}`
313			`} else`
314			`fputc(*ep, stderr);`
315			`}`
316			`va_end(ap);`
317			`fputc('\n', stderr);`
318			`if (type==FATAL)`
319			`exit(1);`
320			`if (type!=WARNING)`
321			`nerrs = 1;`
322			`fflush(stderr);`
323			`}`