Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <stdio.h>
21 : #include <stdlib.h>
22 : #include <string.h>
23 : #include <time.h>
24 : #include <stdarg.h>
25 : #include "cpp.h"
26 :
27 : #define OUTS 16384
28 : char outbuf[OUTS];
29 : char *outptr = outbuf;
30 : Source *cursource;
31 : int nerrs;
32 : struct token nltoken = {NL, 0, 0, 1, (uchar *) "\n", 0};
33 : char *curtime;
34 : int incdepth;
35 : int ifdepth;
36 : int ifsatisfied[NIF];
37 : int skipping;
38 :
39 : int
40 : #ifdef _WIN32
41 : __cdecl
42 : #endif // _WIN32
43 53 : main(int argc, char **argv)
44 : {
45 :
46 : Tokenrow tr;
47 : time_t t;
48 : char ebuf[BUFSIZ];
49 :
50 53 : setbuf(stderr, ebuf);
51 53 : t = time(NULL);
52 53 : curtime = ctime(&t);
53 53 : maketokenrow(3, &tr);
54 53 : expandlex();
55 : // coverity[tainted_string] - build time test tool
56 53 : setup(argc, argv);
57 53 : fixlex();
58 53 : if (!Pflag)
59 0 : genline();
60 53 : process(&tr);
61 53 : flushout();
62 53 : fflush(stderr);
63 53 : exit(nerrs > 0);
64 : }
65 :
66 : void
67 53 : process(Tokenrow * trp)
68 : {
69 53 : int anymacros = 0;
70 :
71 : for (;;)
72 : {
73 38027 : if (trp->tp >= trp->lp)
74 : {
75 38027 : trp->tp = trp->lp = trp->bp;
76 38027 : outptr = outbuf;
77 38027 : anymacros |= gettokens(trp, 1);
78 38027 : trp->tp = trp->bp;
79 : }
80 38027 : if (trp->tp->type == END)
81 : {
82 193 : if (--incdepth >= 0)
83 : {
84 140 : if (cursource->ifdepth)
85 0 : error(ERROR,
86 : "Unterminated conditional in #include");
87 140 : unsetsource();
88 140 : cursource->line += cursource->lineinc;
89 140 : trp->tp = trp->lp;
90 140 : if (!Pflag)
91 0 : genline();
92 140 : continue;
93 : }
94 53 : if (ifdepth)
95 0 : error(ERROR, "Unterminated #if/#ifdef/#ifndef");
96 53 : break;
97 : }
98 37834 : if (trp->tp->type == SHARP)
99 : {
100 10100 : trp->tp += 1;
101 10100 : control(trp);
102 : }
103 : else
104 27734 : if (!skipping && anymacros)
105 7729 : expandrow(trp, NULL);
106 37834 : if (skipping)
107 4121 : setempty(trp);
108 37834 : puttokens(trp);
109 37834 : anymacros = 0;
110 37834 : cursource->line += cursource->lineinc;
111 37834 : if (cursource->lineinc > 1)
112 : {
113 3855 : if (!Pflag)
114 0 : genline();
115 : }
116 37974 : }
117 53 : }
118 :
119 : void
120 10100 : control(Tokenrow * trp)
121 : {
122 : Nlist *np;
123 : Token *tp;
124 :
125 10100 : tp = trp->tp;
126 10100 : if (tp->type != NAME)
127 : {
128 0 : if (tp->type == NUMBER)
129 0 : goto kline;
130 0 : if (tp->type != NL)
131 0 : error(ERROR, "Unidentifiable control line");
132 0 : return; /* else empty line */
133 : }
134 10100 : if ((np = lookup(tp, 0)) == NULL || ((np->flag & ISKW) == 0 && !skipping))
135 : {
136 0 : error(WARNING, "Unknown preprocessor control %t", tp);
137 0 : return;
138 : }
139 10100 : if (skipping)
140 : {
141 2306 : switch (np->val)
142 : {
143 : case KENDIF:
144 480 : if (--ifdepth < skipping)
145 419 : skipping = 0;
146 480 : --cursource->ifdepth;
147 480 : setempty(trp);
148 480 : return;
149 :
150 : case KIFDEF:
151 : case KIFNDEF:
152 : case KIF:
153 61 : if (++ifdepth >= NIF)
154 0 : error(FATAL, "#if too deeply nested");
155 61 : ++cursource->ifdepth;
156 61 : return;
157 :
158 : case KELIF:
159 : case KELSE:
160 588 : if (ifdepth <= skipping)
161 536 : break;
162 52 : return;
163 :
164 : default:
165 1177 : return;
166 : }
167 : }
168 8330 : switch (np->val)
169 : {
170 : case KDEFINE:
171 5617 : dodefine(trp);
172 5617 : break;
173 :
174 : case KUNDEF:
175 0 : tp += 1;
176 0 : if (tp->type != NAME || trp->lp - trp->bp != 4)
177 : {
178 0 : error(ERROR, "Syntax error in #undef");
179 0 : break;
180 : }
181 0 : if ((np = lookup(tp, 0)) != NULL)
182 : {
183 0 : np->flag &= ~ISDEFINED;
184 :
185 0 : if (Mflag)
186 : {
187 0 : if (np->ap)
188 0 : error(INFO, "Macro deletion of %s(%r)", np->name, np->ap);
189 : else
190 0 : error(INFO, "Macro deletion of %s", np->name);
191 : }
192 : }
193 0 : break;
194 :
195 : case KPRAGMA:
196 : case KIDENT:
197 0 : for (tp = trp->tp - 1; ((tp->type != NL) && (tp < trp->lp)); tp++)
198 0 : tp->type = UNCLASS;
199 0 : return;
200 :
201 : case KIFDEF:
202 : case KIFNDEF:
203 : case KIF:
204 1118 : if (++ifdepth >= NIF)
205 0 : error(FATAL, "#if too deeply nested");
206 1118 : ++cursource->ifdepth;
207 1118 : ifsatisfied[ifdepth] = 0;
208 1118 : if (eval(trp, np->val))
209 435 : ifsatisfied[ifdepth] = 1;
210 : else
211 683 : skipping = ifdepth;
212 1118 : break;
213 :
214 : case KELIF:
215 52 : if (ifdepth == 0)
216 : {
217 0 : error(ERROR, "#elif with no #if");
218 0 : return;
219 : }
220 52 : if (ifsatisfied[ifdepth] == 2)
221 0 : error(ERROR, "#elif after #else");
222 52 : if (eval(trp, np->val))
223 : {
224 0 : if (ifsatisfied[ifdepth])
225 0 : skipping = ifdepth;
226 : else
227 : {
228 0 : skipping = 0;
229 0 : ifsatisfied[ifdepth] = 1;
230 : }
231 : }
232 : else
233 52 : skipping = ifdepth;
234 52 : break;
235 :
236 : case KELSE:
237 704 : if (ifdepth == 0 || cursource->ifdepth == 0)
238 : {
239 0 : error(ERROR, "#else with no #if");
240 0 : return;
241 : }
242 704 : if (ifsatisfied[ifdepth] == 2)
243 0 : error(ERROR, "#else after #else");
244 704 : if (trp->lp - trp->bp != 3)
245 0 : error(ERROR, "Syntax error in #else");
246 704 : skipping = ifsatisfied[ifdepth] ? ifdepth : 0;
247 704 : ifsatisfied[ifdepth] = 2;
248 704 : break;
249 :
250 : case KENDIF:
251 699 : if (ifdepth == 0 || cursource->ifdepth == 0)
252 : {
253 0 : error(ERROR, "#endif with no #if");
254 0 : return;
255 : }
256 699 : --ifdepth;
257 699 : --cursource->ifdepth;
258 699 : if (trp->lp - trp->bp != 3)
259 0 : error(WARNING, "Syntax error in #endif");
260 699 : break;
261 :
262 : case KERROR:
263 0 : trp->tp = tp + 1;
264 0 : error(WARNING, "#error directive: %r", trp);
265 0 : break;
266 :
267 : case KLINE:
268 0 : trp->tp = tp + 1;
269 0 : expandrow(trp, "<line>");
270 0 : tp = trp->bp + 2;
271 : kline:
272 0 : if (tp + 1 >= trp->lp || tp->type != NUMBER || tp + 3 < trp->lp
273 0 : || (tp + 3 == trp->lp
274 0 : && ((tp + 1)->type != STRING || *(tp + 1)->t == 'L')))
275 : {
276 0 : error(ERROR, "Syntax error in #line");
277 0 : return;
278 : }
279 0 : cursource->line = atol((char *) tp->t) - 1;
280 0 : if (cursource->line < 0 || cursource->line >= 32768)
281 0 : error(WARNING, "#line specifies number out of range");
282 0 : tp = tp + 1;
283 0 : if (tp + 1 < trp->lp)
284 0 : cursource->filename = (char *) newstring(tp->t + 1, tp->len - 2, 0);
285 0 : return;
286 :
287 : case KDEFINED:
288 0 : error(ERROR, "Bad syntax for control line");
289 0 : break;
290 :
291 : case KIMPORT:
292 0 : doinclude(trp, -1, 1);
293 0 : trp->lp = trp->bp;
294 0 : return;
295 :
296 : case KINCLUDE:
297 140 : doinclude(trp, -1, 0);
298 140 : trp->lp = trp->bp;
299 140 : return;
300 :
301 : case KINCLUDENEXT:
302 0 : doinclude(trp, cursource->pathdepth, 0);
303 0 : trp->lp = trp->bp;
304 0 : return;
305 :
306 : case KEVAL:
307 0 : eval(trp, np->val);
308 0 : break;
309 :
310 : default:
311 0 : error(ERROR, "Preprocessor control `%t' not yet implemented", tp);
312 0 : break;
313 : }
314 8190 : setempty(trp);
315 8190 : return;
316 : }
317 :
318 : void *
319 2336540 : domalloc(size_t size)
320 : {
321 2336540 : void *p = malloc(size);
322 :
323 2336540 : if (p == NULL)
324 0 : error(FATAL, "Out of memory from malloc");
325 2336540 : return p;
326 : }
327 :
328 : void
329 749584 : dofree(void *p)
330 : {
331 749584 : free(p);
332 749584 : }
333 :
334 : void
335 0 : error(enum errtype type, char *string,...)
336 : {
337 : va_list ap;
338 : char c, *cp, *ep;
339 : Token *tp;
340 : Tokenrow *trp;
341 : Source *s;
342 : int i;
343 :
344 0 : fprintf(stderr, "cpp: ");
345 0 : for (s = cursource; s; s = s->next)
346 0 : if (*s->filename)
347 0 : fprintf(stderr, "%s:%d ", s->filename, s->line);
348 0 : va_start(ap, string);
349 0 : for (ep = string; *ep; ep++)
350 : {
351 0 : if (*ep == '%')
352 : {
353 0 : switch (*++ep)
354 : {
355 :
356 : case 'c':
357 0 : c = (char) va_arg(ap, int);
358 0 : fprintf(stderr, "%c", c);
359 0 : break;
360 :
361 : case 's':
362 0 : cp = va_arg(ap, char *);
363 0 : fprintf(stderr, "%s", cp);
364 0 : break;
365 :
366 : case 'd':
367 0 : i = va_arg(ap, int);
368 0 : fprintf(stderr, "%d", i);
369 0 : break;
370 :
371 : case 't':
372 0 : tp = va_arg(ap, Token *);
373 0 : fprintf(stderr, "%.*s", (int)tp->len, tp->t);
374 0 : break;
375 :
376 : case 'r':
377 0 : trp = va_arg(ap, Tokenrow *);
378 0 : for (tp = trp->tp; tp < trp->lp && tp->type != NL; tp++)
379 : {
380 0 : if (tp > trp->tp && tp->wslen)
381 0 : fputc(' ', stderr);
382 0 : fprintf(stderr, "%.*s", (int)tp->len, tp->t);
383 : }
384 0 : break;
385 :
386 : default:
387 0 : fputc(*ep, stderr);
388 0 : break;
389 : }
390 : }
391 : else
392 0 : fputc(*ep, stderr);
393 : }
394 0 : va_end(ap);
395 0 : fputc('\n', stderr);
396 0 : if (type == FATAL)
397 0 : exit(1);
398 0 : if (type != WARNING)
399 0 : nerrs = 1;
400 0 : fflush(stderr);
401 0 : }
402 :
403 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
