Kernel

Kernel Git Source Tree

Root/scripts/unifdef.c

1	/*
2	* Copyright (c) 2002 - 2011 Tony Finch <dot@dotat.at>
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions
6	* are met:
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	*
13	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23	* SUCH DAMAGE.
24	*/
25
26	/*
27	* unifdef - remove ifdef'ed lines
28	*
29	* This code was derived from software contributed to Berkeley by Dave Yost.
30	* It was rewritten to support ANSI C by Tony Finch. The original version
31	* of unifdef carried the 4-clause BSD copyright licence. None of its code
32	* remains in this version (though some of the names remain) so it now
33	* carries a more liberal licence.
34	*
35	* Wishlist:
36	* provide an option which will append the name of the
37	* appropriate symbol after #else's and #endif's
38	* provide an option which will check symbols after
39	* #else's and #endif's to see that they match their
40	* corresponding #ifdef or #ifndef
41	*
42	* These require better buffer handling, which would also make
43	* it possible to handle all "dodgy" directives correctly.
44	*/
45
46	#include <sys/types.h>
47	#include <sys/stat.h>
48
49	#include <ctype.h>
50	#include <err.h>
51	#include <errno.h>
52	#include <stdarg.h>
53	#include <stdbool.h>
54	#include <stdio.h>
55	#include <stdlib.h>
56	#include <string.h>
57	#include <unistd.h>
58
59	const char copyright[] =
60	"@(#) $Version: unifdef-2.5 $\n"
61	"@(#) $Author: Tony Finch (dot@dotat.at) $\n"
62	"@(#) $URL: http://dotat.at/prog/unifdef $\n"
63	;
64
65	/* types of input lines: */
66	typedef enum {
67	LT_TRUEI, /* a true #if with ignore flag */
68	LT_FALSEI, /* a false #if with ignore flag */
69	LT_IF, /* an unknown #if */
70	LT_TRUE, /* a true #if */
71	LT_FALSE, /* a false #if */
72	LT_ELIF, /* an unknown #elif */
73	LT_ELTRUE, /* a true #elif */
74	LT_ELFALSE, /* a false #elif */
75	LT_ELSE, /* #else */
76	LT_ENDIF, /* #endif */
77	LT_DODGY, /* flag: directive is not on one line */
78	LT_DODGY_LAST = LT_DODGY + LT_ENDIF,
79	LT_PLAIN, /* ordinary line */
80	LT_EOF, /* end of file */
81	LT_ERROR, /* unevaluable #if */
82	LT_COUNT
83	} Linetype;
84
85	static char const * const linetype_name[] = {
86	"TRUEI", "FALSEI", "IF", "TRUE", "FALSE",
87	"ELIF", "ELTRUE", "ELFALSE", "ELSE", "ENDIF",
88	"DODGY TRUEI", "DODGY FALSEI",
89	"DODGY IF", "DODGY TRUE", "DODGY FALSE",
90	"DODGY ELIF", "DODGY ELTRUE", "DODGY ELFALSE",
91	"DODGY ELSE", "DODGY ENDIF",
92	"PLAIN", "EOF", "ERROR"
93	};
94
95	/* state of #if processing */
96	typedef enum {
97	IS_OUTSIDE,
98	IS_FALSE_PREFIX, /* false #if followed by false #elifs */
99	IS_TRUE_PREFIX, /* first non-false #(el)if is true */
100	IS_PASS_MIDDLE, /* first non-false #(el)if is unknown */
101	IS_FALSE_MIDDLE, /* a false #elif after a pass state */
102	IS_TRUE_MIDDLE, /* a true #elif after a pass state */
103	IS_PASS_ELSE, /* an else after a pass state */
104	IS_FALSE_ELSE, /* an else after a true state */
105	IS_TRUE_ELSE, /* an else after only false states */
106	IS_FALSE_TRAILER, /* #elifs after a true are false */
107	IS_COUNT
108	} Ifstate;
109
110	static char const * const ifstate_name[] = {
111	"OUTSIDE", "FALSE_PREFIX", "TRUE_PREFIX",
112	"PASS_MIDDLE", "FALSE_MIDDLE", "TRUE_MIDDLE",
113	"PASS_ELSE", "FALSE_ELSE", "TRUE_ELSE",
114	"FALSE_TRAILER"
115	};
116
117	/* state of comment parser */
118	typedef enum {
119	NO_COMMENT = false, /* outside a comment */
120	C_COMMENT, /* in a comment like this one */
121	CXX_COMMENT, /* between // and end of line */
122	STARTING_COMMENT, /* just after slash-backslash-newline */
123	FINISHING_COMMENT, /* star-backslash-newline in a C comment */
124	CHAR_LITERAL, /* inside '' */
125	STRING_LITERAL /* inside "" */
126	} Comment_state;
127
128	static char const * const comment_name[] = {
129	"NO", "C", "CXX", "STARTING", "FINISHING", "CHAR", "STRING"
130	};
131
132	/* state of preprocessor line parser */
133	typedef enum {
134	LS_START, /* only space and comments on this line */
135	LS_HASH, /* only space, comments, and a hash */
136	LS_DIRTY /* this line can't be a preprocessor line */
137	} Line_state;
138
139	static char const * const linestate_name[] = {
140	"START", "HASH", "DIRTY"
141	};
142
143	/*
144	* Minimum translation limits from ISO/IEC 9899:1999 5.2.4.1
145	*/
146	#define MAXDEPTH 64 /* maximum #if nesting */
147	#define MAXLINE 4096 /* maximum length of line */
148	#define MAXSYMS 4096 /* maximum number of symbols */
149
150	/*
151	* Sometimes when editing a keyword the replacement text is longer, so
152	* we leave some space at the end of the tline buffer to accommodate this.
153	*/
154	#define EDITSLOP 10
155
156	/*
157	* For temporary filenames
158	*/
159	#define TEMPLATE "unifdef.XXXXXX"
160
161	/*
162	* Globals.
163	*/
164
165	static bool compblank; /* -B: compress blank lines */
166	static bool lnblank; /* -b: blank deleted lines */
167	static bool complement; /* -c: do the complement */
168	static bool debugging; /* -d: debugging reports */
169	static bool iocccok; /* -e: fewer IOCCC errors */
170	static bool strictlogic; /* -K: keep ambiguous #ifs */
171	static bool killconsts; /* -k: eval constant #ifs */
172	static bool lnnum; /* -n: add #line directives */
173	static bool symlist; /* -s: output symbol list */
174	static bool symdepth; /* -S: output symbol depth */
175	static bool text; /* -t: this is a text file */
176
177	static const char symname[MAXSYMS]; / symbol name */
178	static const char value[MAXSYMS]; / -Dsym=value */
179	static bool ignore[MAXSYMS]; /* -iDsym or -iUsym */
180	static int nsyms; /* number of symbols */
181
182	static FILE input; / input file pointer */
183	static const char filename; / input file name */
184	static int linenum; /* current line number */
185	static FILE output; / output file pointer */
186	static const char ofilename; / output file name */
187	static bool overwriting; /* output overwrites input */
188	static char tempname[FILENAME_MAX]; /* used when overwriting */
189
190	static char tline[MAXLINE+EDITSLOP];/* input buffer plus space */
191	static char keyword; / used for editing #elif's */
192
193	static const char newline; / input file format */
194	static const char newline_unix[] = "\n";
195	static const char newline_crlf[] = "\r\n";
196
197	static Comment_state incomment; /* comment parser state */
198	static Line_state linestate; /* #if line parser state */
199	static Ifstate ifstate[MAXDEPTH]; /* #if processor state */
200	static bool ignoring[MAXDEPTH]; /* ignore comments state */
201	static int stifline[MAXDEPTH]; /* start of current #if */
202	static int depth; /* current #if nesting */
203	static int delcount; /* count of deleted lines */
204	static unsigned blankcount; /* count of blank lines */
205	static unsigned blankmax; /* maximum recent blankcount */
206	static bool constexpr; /* constant #if expression */
207	static bool zerosyms = true; /* to format symdepth output */
208	static bool firstsym; /* ditto */
209
210	static int exitstat; /* program exit status */
211
212	static void addsym(bool, bool, char *);
213	static void closeout(void);
214	static void debug(const char *, ...);
215	static void done(void);
216	static void error(const char *);
217	static int findsym(const char *);
218	static void flushline(bool);
219	static Linetype parseline(void);
220	static Linetype ifeval(const char **);
221	static void ignoreoff(void);
222	static void ignoreon(void);
223	static void keywordedit(const char *);
224	static void nest(void);
225	static void process(void);
226	static const char skipargs(const char );
227	static const char skipcomment(const char );
228	static const char skipsym(const char );
229	static void state(Ifstate);
230	static int strlcmp(const char , const char , size_t);
231	static void unnest(void);
232	static void usage(void);
233	static void version(void);
234
235	#define endsym(c) (!isalnum((unsigned char)c) && c != '_')
236
237	/*
238	* The main program.
239	*/
240	int
241	main(int argc, char *argv[])
242	{
243	int opt;
244
245	while ((opt = getopt(argc, argv, "i:D:U:I:o:bBcdeKklnsStV")) != -1)
246	switch (opt) {
247	case 'i': /* treat stuff controlled by these symbols as text */
248	/*
249	* For strict backwards-compatibility the U or D
250	* should be immediately after the -i but it doesn't
251	* matter much if we relax that requirement.
252	*/
253	opt = *optarg++;
254	if (opt == 'D')
255	addsym(true, true, optarg);
256	else if (opt == 'U')
257	addsym(true, false, optarg);
258	else
259	usage();
260	break;
261	case 'D': /* define a symbol */
262	addsym(false, true, optarg);
263	break;
264	case 'U': /* undef a symbol */
265	addsym(false, false, optarg);
266	break;
267	case 'I': /* no-op for compatibility with cpp */
268	break;
269	case 'b': /* blank deleted lines instead of omitting them */
270	case 'l': /* backwards compatibility */
271	lnblank = true;
272	break;
273	case 'B': /* compress blank lines around removed section */
274	compblank = true;
275	break;
276	case 'c': /* treat -D as -U and vice versa */
277	complement = true;
278	break;
279	case 'd':
280	debugging = true;
281	break;
282	case 'e': /* fewer errors from dodgy lines */
283	iocccok = true;
284	break;
285	case 'K': /* keep ambiguous #ifs */
286	strictlogic = true;
287	break;
288	case 'k': /* process constant #ifs */
289	killconsts = true;
290	break;
291	case 'n': /* add #line directive after deleted lines */
292	lnnum = true;
293	break;
294	case 'o': /* output to a file */
295	ofilename = optarg;
296	break;
297	case 's': /* only output list of symbols that control #ifs */
298	symlist = true;
299	break;
300	case 'S': /* list symbols with their nesting depth */
301	symlist = symdepth = true;
302	break;
303	case 't': /* don't parse C comments */
304	text = true;
305	break;
306	case 'V': /* print version */
307	version();
308	default:
309	usage();
310	}
311	argc -= optind;
312	argv += optind;
313	if (compblank && lnblank)
314	errx(2, "-B and -b are mutually exclusive");
315	if (argc > 1) {
316	errx(2, "can only do one file");
317	} else if (argc == 1 && strcmp(*argv, "-") != 0) {
318	filename = *argv;
319	input = fopen(filename, "rb");
320	if (input == NULL)
321	err(2, "can't open %s", filename);
322	} else {
323	filename = "[stdin]";
324	input = stdin;
325	}
326	if (ofilename == NULL) {
327	ofilename = "[stdout]";
328	output = stdout;
329	} else {
330	struct stat ist, ost;
331	if (stat(ofilename, &ost) == 0 &&
332	fstat(fileno(input), &ist) == 0)
333	overwriting = (ist.st_dev == ost.st_dev
334	&& ist.st_ino == ost.st_ino);
335	if (overwriting) {
336	const char *dirsep;
337	int ofd;
338
339	dirsep = strrchr(ofilename, '/');
340	if (dirsep != NULL)
341	snprintf(tempname, sizeof(tempname),
342	"%.*s/" TEMPLATE,
343	(int)(dirsep - ofilename), ofilename);
344	else
345	snprintf(tempname, sizeof(tempname),
346	TEMPLATE);
347	ofd = mkstemp(tempname);
348	if (ofd != -1)
349	output = fdopen(ofd, "wb+");
350	if (output == NULL)
351	err(2, "can't create temporary file");
352	fchmod(ofd, ist.st_mode & (S_IRWXU\|S_IRWXG\|S_IRWXO));
353	} else {
354	output = fopen(ofilename, "wb");
355	if (output == NULL)
356	err(2, "can't open %s", ofilename);
357	}
358	}
359	process();
360	abort(); /* bug */
361	}
362
363	static void
364	version(void)
365	{
366	const char *c = copyright;
367	for (;;) {
368	while (*++c != '$')
369	if (*c == '\0')
370	exit(0);
371	while (*++c != '$')
372	putc(*c, stderr);
373	putc('\n', stderr);
374	}
375	}
376
377	static void
378	usage(void)
379	{
380	fprintf(stderr, "usage: unifdef [-bBcdeKknsStV] [-Ipath]"
381	" [-Dsym[=val]] [-Usym] [-iDsym[=val]] [-iUsym] ... [file]\n");
382	exit(2);
383	}
384
385	/*
386	* A state transition function alters the global #if processing state
387	* in a particular way. The table below is indexed by the current
388	* processing state and the type of the current line.
389	*
390	* Nesting is handled by keeping a stack of states; some transition
391	* functions increase or decrease the depth. They also maintain the
392	* ignore state on a stack. In some complicated cases they have to
393	* alter the preprocessor directive, as follows.
394	*
395	* When we have processed a group that starts off with a known-false
396	* #if/#elif sequence (which has therefore been deleted) followed by a
397	* #elif that we don't understand and therefore must keep, we edit the
398	* latter into a #if to keep the nesting correct. We use strncpy() to
399	* overwrite the 4 byte token "elif" with "if " without a '\0' byte.
400	*
401	* When we find a true #elif in a group, the following block will
402	* always be kept and the rest of the sequence after the next #elif or
403	* #else will be discarded. We edit the #elif into a #else and the
404	* following directive to #endif since this has the desired behaviour.
405	*
406	* "Dodgy" directives are split across multiple lines, the most common
407	* example being a multi-line comment hanging off the right of the
408	* directive. We can handle them correctly only if there is no change
409	* from printing to dropping (or vice versa) caused by that directive.
410	* If the directive is the first of a group we have a choice between
411	* failing with an error, or passing it through unchanged instead of
412	* evaluating it. The latter is not the default to avoid questions from
413	* users about unifdef unexpectedly leaving behind preprocessor directives.
414	*/
415	typedef void state_fn(void);
416
417	/* report an error */
418	static void Eelif (void) { error("Inappropriate #elif"); }
419	static void Eelse (void) { error("Inappropriate #else"); }
420	static void Eendif(void) { error("Inappropriate #endif"); }
421	static void Eeof (void) { error("Premature EOF"); }
422	static void Eioccc(void) { error("Obfuscated preprocessor control line"); }
423	/* plain line handling */
424	static void print (void) { flushline(true); }
425	static void drop (void) { flushline(false); }
426	/* output lacks group's start line */
427	static void Strue (void) { drop(); ignoreoff(); state(IS_TRUE_PREFIX); }
428	static void Sfalse(void) { drop(); ignoreoff(); state(IS_FALSE_PREFIX); }
429	static void Selse (void) { drop(); state(IS_TRUE_ELSE); }
430	/* print/pass this block */
431	static void Pelif (void) { print(); ignoreoff(); state(IS_PASS_MIDDLE); }
432	static void Pelse (void) { print(); state(IS_PASS_ELSE); }
433	static void Pendif(void) { print(); unnest(); }
434	/* discard this block */
435	static void Dfalse(void) { drop(); ignoreoff(); state(IS_FALSE_TRAILER); }
436	static void Delif (void) { drop(); ignoreoff(); state(IS_FALSE_MIDDLE); }
437	static void Delse (void) { drop(); state(IS_FALSE_ELSE); }
438	static void Dendif(void) { drop(); unnest(); }
439	/* first line of group */
440	static void Fdrop (void) { nest(); Dfalse(); }
441	static void Fpass (void) { nest(); Pelif(); }
442	static void Ftrue (void) { nest(); Strue(); }
443	static void Ffalse(void) { nest(); Sfalse(); }
444	/* variable pedantry for obfuscated lines */
445	static void Oiffy (void) { if (!iocccok) Eioccc(); Fpass(); ignoreon(); }
446	static void Oif (void) { if (!iocccok) Eioccc(); Fpass(); }
447	static void Oelif (void) { if (!iocccok) Eioccc(); Pelif(); }
448	/* ignore comments in this block */
449	static void Idrop (void) { Fdrop(); ignoreon(); }
450	static void Itrue (void) { Ftrue(); ignoreon(); }
451	static void Ifalse(void) { Ffalse(); ignoreon(); }
452	/* modify this line */
453	static void Mpass (void) { strncpy(keyword, "if ", 4); Pelif(); }
454	static void Mtrue (void) { keywordedit("else"); state(IS_TRUE_MIDDLE); }
455	static void Melif (void) { keywordedit("endif"); state(IS_FALSE_TRAILER); }
456	static void Melse (void) { keywordedit("endif"); state(IS_FALSE_ELSE); }
457
458	static state_fn * const trans_table[IS_COUNT][LT_COUNT] = {
459	/* IS_OUTSIDE */
460	{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Eendif,
461	Oiffy, Oiffy, Fpass, Oif, Oif, Eelif, Eelif, Eelif, Eelse, Eendif,
462	print, done, abort },
463	/* IS_FALSE_PREFIX */
464	{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Mpass, Strue, Sfalse,Selse, Dendif,
465	Idrop, Idrop, Fdrop, Fdrop, Fdrop, Mpass, Eioccc,Eioccc,Eioccc,Eioccc,
466	drop, Eeof, abort },
467	/* IS_TRUE_PREFIX */
468	{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Dfalse,Dfalse,Dfalse,Delse, Dendif,
469	Oiffy, Oiffy, Fpass, Oif, Oif, Eioccc,Eioccc,Eioccc,Eioccc,Eioccc,
470	print, Eeof, abort },
471	/* IS_PASS_MIDDLE */
472	{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Pelif, Mtrue, Delif, Pelse, Pendif,
473	Oiffy, Oiffy, Fpass, Oif, Oif, Pelif, Oelif, Oelif, Pelse, Pendif,
474	print, Eeof, abort },
475	/* IS_FALSE_MIDDLE */
476	{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Pelif, Mtrue, Delif, Pelse, Pendif,
477	Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eioccc,Eioccc,Eioccc,Eioccc,Eioccc,
478	drop, Eeof, abort },
479	/* IS_TRUE_MIDDLE */
480	{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Melif, Melif, Melif, Melse, Pendif,
481	Oiffy, Oiffy, Fpass, Oif, Oif, Eioccc,Eioccc,Eioccc,Eioccc,Pendif,
482	print, Eeof, abort },
483	/* IS_PASS_ELSE */
484	{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Pendif,
485	Oiffy, Oiffy, Fpass, Oif, Oif, Eelif, Eelif, Eelif, Eelse, Pendif,
486	print, Eeof, abort },
487	/* IS_FALSE_ELSE */
488	{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eelif, Eelif, Eelif, Eelse, Dendif,
489	Idrop, Idrop, Fdrop, Fdrop, Fdrop, Eelif, Eelif, Eelif, Eelse, Eioccc,
490	drop, Eeof, abort },
491	/* IS_TRUE_ELSE */
492	{ Itrue, Ifalse,Fpass, Ftrue, Ffalse,Eelif, Eelif, Eelif, Eelse, Dendif,
493	Oiffy, Oiffy, Fpass, Oif, Oif, Eelif, Eelif, Eelif, Eelse, Eioccc,
494	print, Eeof, abort },
495	/* IS_FALSE_TRAILER */
496	{ Idrop, Idrop, Fdrop, Fdrop, Fdrop, Dfalse,Dfalse,Dfalse,Delse, Dendif,
497	Idrop, Idrop, Fdrop, Fdrop, Fdrop, Dfalse,Dfalse,Dfalse,Delse, Eioccc,
498	drop, Eeof, abort }
499	/*TRUEI FALSEI IF TRUE FALSE ELIF ELTRUE ELFALSE ELSE ENDIF
500	TRUEI FALSEI IF TRUE FALSE ELIF ELTRUE ELFALSE ELSE ENDIF (DODGY)
501	PLAIN EOF ERROR */
502	};
503
504	/*
505	* State machine utility functions
506	*/
507	static void
508	ignoreoff(void)
509	{
510	if (depth == 0)
511	abort(); /* bug */
512	ignoring[depth] = ignoring[depth-1];
513	}
514	static void
515	ignoreon(void)
516	{
517	ignoring[depth] = true;
518	}
519	static void
520	keywordedit(const char *replacement)
521	{
522	snprintf(keyword, tline + sizeof(tline) - keyword,
523	"%s%s", replacement, newline);
524	print();
525	}
526	static void
527	nest(void)
528	{
529	if (depth > MAXDEPTH-1)
530	abort(); /* bug */
531	if (depth == MAXDEPTH-1)
532	error("Too many levels of nesting");
533	depth += 1;
534	stifline[depth] = linenum;
535	}
536	static void
537	unnest(void)
538	{
539	if (depth == 0)
540	abort(); /* bug */
541	depth -= 1;
542	}
543	static void
544	state(Ifstate is)
545	{
546	ifstate[depth] = is;
547	}
548
549	/*
550	* Write a line to the output or not, according to command line options.
551	*/
552	static void
553	flushline(bool keep)
554	{
555	if (symlist)
556	return;
557	if (keep ^ complement) {
558	bool blankline = tline[strspn(tline, " \t\r\n")] == '\0';
559	if (blankline && compblank && blankcount != blankmax) {
560	delcount += 1;
561	blankcount += 1;
562	} else {
563	if (lnnum && delcount > 0)
564	printf("#line %d%s", linenum, newline);
565	fputs(tline, output);
566	delcount = 0;
567	blankmax = blankcount = blankline ? blankcount + 1 : 0;
568	}
569	} else {
570	if (lnblank)
571	fputs(newline, output);
572	exitstat = 1;
573	delcount += 1;
574	blankcount = 0;
575	}
576	if (debugging)
577	fflush(output);
578	}
579
580	/*
581	* The driver for the state machine.
582	*/
583	static void
584	process(void)
585	{
586	/* When compressing blank lines, act as if the file
587	is preceded by a large number of blank lines. */
588	blankmax = blankcount = 1000;
589	for (;;) {
590	Linetype lineval = parseline();
591	trans_table[ifstate[depth]][lineval]();
592	debug("process line %d %s -> %s depth %d",
593	linenum, linetype_name[lineval],
594	ifstate_name[ifstate[depth]], depth);
595	}
596	}
597
598	/*
599	* Flush the output and handle errors.
600	*/
601	static void
602	closeout(void)
603	{
604	if (symdepth && !zerosyms)
605	printf("\n");
606	if (fclose(output) == EOF) {
607	warn("couldn't write to %s", ofilename);
608	if (overwriting) {
609	unlink(tempname);
610	errx(2, "%s unchanged", filename);
611	} else {
612	exit(2);
613	}
614	}
615	}
616
617	/*
618	* Clean up and exit.
619	*/
620	static void
621	done(void)
622	{
623	if (incomment)
624	error("EOF in comment");
625	closeout();
626	if (overwriting && rename(tempname, ofilename) == -1) {
627	warn("couldn't rename temporary file");
628	unlink(tempname);
629	errx(2, "%s unchanged", ofilename);
630	}
631	exit(exitstat);
632	}
633
634	/*
635	* Parse a line and determine its type. We keep the preprocessor line
636	* parser state between calls in the global variable linestate, with
637	* help from skipcomment().
638	*/
639	static Linetype
640	parseline(void)
641	{
642	const char *cp;
643	int cursym;
644	int kwlen;
645	Linetype retval;
646	Comment_state wascomment;
647
648	linenum++;
649	if (fgets(tline, MAXLINE, input) == NULL)
650	return (LT_EOF);
651	if (newline == NULL) {
652	if (strrchr(tline, '\n') == strrchr(tline, '\r') + 1)
653	newline = newline_crlf;
654	else
655	newline = newline_unix;
656	}
657	retval = LT_PLAIN;
658	wascomment = incomment;
659	cp = skipcomment(tline);
660	if (linestate == LS_START) {
661	if (*cp == '#') {
662	linestate = LS_HASH;
663	firstsym = true;
664	cp = skipcomment(cp + 1);
665	} else if (*cp != '\0')
666	linestate = LS_DIRTY;
667	}
668	if (!incomment && linestate == LS_HASH) {
669	keyword = tline + (cp - tline);
670	cp = skipsym(cp);
671	kwlen = cp - keyword;
672	/* no way can we deal with a continuation inside a keyword */
673	if (strncmp(cp, "\\\r\n", 3) == 0 \|\|
674	strncmp(cp, "\\\n", 2) == 0)
675	Eioccc();
676	if (strlcmp("ifdef", keyword, kwlen) == 0 \|\|
677	strlcmp("ifndef", keyword, kwlen) == 0) {
678	cp = skipcomment(cp);
679	if ((cursym = findsym(cp)) < 0)
680	retval = LT_IF;
681	else {
682	retval = (keyword[2] == 'n')
683	? LT_FALSE : LT_TRUE;
684	if (value[cursym] == NULL)
685	retval = (retval == LT_TRUE)
686	? LT_FALSE : LT_TRUE;
687	if (ignore[cursym])
688	retval = (retval == LT_TRUE)
689	? LT_TRUEI : LT_FALSEI;
690	}
691	cp = skipsym(cp);
692	} else if (strlcmp("if", keyword, kwlen) == 0)
693	retval = ifeval(&cp);
694	else if (strlcmp("elif", keyword, kwlen) == 0)
695	retval = ifeval(&cp) - LT_IF + LT_ELIF;
696	else if (strlcmp("else", keyword, kwlen) == 0)
697	retval = LT_ELSE;
698	else if (strlcmp("endif", keyword, kwlen) == 0)
699	retval = LT_ENDIF;
700	else {
701	linestate = LS_DIRTY;
702	retval = LT_PLAIN;
703	}
704	cp = skipcomment(cp);
705	if (*cp != '\0') {
706	linestate = LS_DIRTY;
707	if (retval == LT_TRUE \|\| retval == LT_FALSE \|\|
708	retval == LT_TRUEI \|\| retval == LT_FALSEI)
709	retval = LT_IF;
710	if (retval == LT_ELTRUE \|\| retval == LT_ELFALSE)
711	retval = LT_ELIF;
712	}
713	if (retval != LT_PLAIN && (wascomment \|\| incomment)) {
714	retval += LT_DODGY;
715	if (incomment)
716	linestate = LS_DIRTY;
717	}
718	/* skipcomment normally changes the state, except
719	if the last line of the file lacks a newline, or
720	if there is too much whitespace in a directive */
721	if (linestate == LS_HASH) {
722	size_t len = cp - tline;
723	if (fgets(tline + len, MAXLINE - len, input) == NULL) {
724	/* append the missing newline */
725	strcpy(tline + len, newline);
726	cp += strlen(newline);
727	linestate = LS_START;
728	} else {
729	linestate = LS_DIRTY;
730	}
731	}
732	}
733	if (linestate == LS_DIRTY) {
734	while (*cp != '\0')
735	cp = skipcomment(cp + 1);
736	}
737	debug("parser line %d state %s comment %s line", linenum,
738	comment_name[incomment], linestate_name[linestate]);
739	return (retval);
740	}
741
742	/*
743	* These are the binary operators that are supported by the expression
744	* evaluator.
745	*/
746	static Linetype op_strict(int *p, int v, Linetype at, Linetype bt) {
747	if(at == LT_IF \|\| bt == LT_IF) return (LT_IF);
748	return (*p = v, v ? LT_TRUE : LT_FALSE);
749	}
750	static Linetype op_lt(int *p, Linetype at, int a, Linetype bt, int b) {
751	return op_strict(p, a < b, at, bt);
752	}
753	static Linetype op_gt(int *p, Linetype at, int a, Linetype bt, int b) {
754	return op_strict(p, a > b, at, bt);
755	}
756	static Linetype op_le(int *p, Linetype at, int a, Linetype bt, int b) {
757	return op_strict(p, a <= b, at, bt);
758	}
759	static Linetype op_ge(int *p, Linetype at, int a, Linetype bt, int b) {
760	return op_strict(p, a >= b, at, bt);
761	}
762	static Linetype op_eq(int *p, Linetype at, int a, Linetype bt, int b) {
763	return op_strict(p, a == b, at, bt);
764	}
765	static Linetype op_ne(int *p, Linetype at, int a, Linetype bt, int b) {
766	return op_strict(p, a != b, at, bt);
767	}
768	static Linetype op_or(int *p, Linetype at, int a, Linetype bt, int b) {
769	if (!strictlogic && (at == LT_TRUE \|\| bt == LT_TRUE))
770	return (*p = 1, LT_TRUE);
771	return op_strict(p, a \|\| b, at, bt);
772	}
773	static Linetype op_and(int *p, Linetype at, int a, Linetype bt, int b) {
774	if (!strictlogic && (at == LT_FALSE \|\| bt == LT_FALSE))
775	return (*p = 0, LT_FALSE);
776	return op_strict(p, a && b, at, bt);
777	}
778
779	/*
780	* An evaluation function takes three arguments, as follows: (1) a pointer to
781	* an element of the precedence table which lists the operators at the current
782	* level of precedence; (2) a pointer to an integer which will receive the
783	* value of the expression; and (3) a pointer to a char* that points to the
784	* expression to be evaluated and that is updated to the end of the expression
785	* when evaluation is complete. The function returns LT_FALSE if the value of
786	* the expression is zero, LT_TRUE if it is non-zero, LT_IF if the expression
787	* depends on an unknown symbol, or LT_ERROR if there is a parse failure.
788	*/
789	struct ops;
790
791	typedef Linetype eval_fn(const struct ops , int , const char **);
792
793	static eval_fn eval_table, eval_unary;
794
795	/*
796	* The precedence table. Expressions involving binary operators are evaluated
797	* in a table-driven way by eval_table. When it evaluates a subexpression it
798	* calls the inner function with its first argument pointing to the next
799	* element of the table. Innermost expressions have special non-table-driven
800	* handling.
801	*/
802	static const struct ops {
803	eval_fn *inner;
804	struct op {
805	const char *str;
806	Linetype (fn)(int , Linetype, int, Linetype, int);
807	} op[5];
808	} eval_ops[] = {
809	{ eval_table, { { "\|\|", op_or } } },
810	{ eval_table, { { "&&", op_and } } },
811	{ eval_table, { { "==", op_eq },
812	{ "!=", op_ne } } },
813	{ eval_unary, { { "<=", op_le },
814	{ ">=", op_ge },
815	{ "<", op_lt },
816	{ ">", op_gt } } }
817	};
818
819	/*
820	* Function for evaluating the innermost parts of expressions,
821	* viz. !expr (expr) number defined(symbol) symbol
822	* We reset the constexpr flag in the last two cases.
823	*/
824	static Linetype
825	eval_unary(const struct ops ops, int valp, const char **cpp)
826	{
827	const char *cp;
828	char *ep;
829	int sym;
830	bool defparen;
831	Linetype lt;
832
833	cp = skipcomment(*cpp);
834	if (*cp == '!') {
835	debug("eval%d !", ops - eval_ops);
836	cp++;
837	lt = eval_unary(ops, valp, &cp);
838	if (lt == LT_ERROR)
839	return (LT_ERROR);
840	if (lt != LT_IF) {
841	valp = !valp;
842	lt = *valp ? LT_TRUE : LT_FALSE;
843	}
844	} else if (*cp == '(') {
845	cp++;
846	debug("eval%d (", ops - eval_ops);
847	lt = eval_table(eval_ops, valp, &cp);
848	if (lt == LT_ERROR)
849	return (LT_ERROR);
850	cp = skipcomment(cp);
851	if (*cp++ != ')')
852	return (LT_ERROR);
853	} else if (isdigit((unsigned char)*cp)) {
854	debug("eval%d number", ops - eval_ops);
855	*valp = strtol(cp, &ep, 0);
856	if (ep == cp)
857	return (LT_ERROR);
858	lt = *valp ? LT_TRUE : LT_FALSE;
859	cp = skipsym(cp);
860	} else if (strncmp(cp, "defined", 7) == 0 && endsym(cp[7])) {
861	cp = skipcomment(cp+7);
862	debug("eval%d defined", ops - eval_ops);
863	if (*cp == '(') {
864	cp = skipcomment(cp+1);
865	defparen = true;
866	} else {
867	defparen = false;
868	}
869	sym = findsym(cp);
870	if (sym < 0) {
871	lt = LT_IF;
872	} else {
873	*valp = (value[sym] != NULL);
874	lt = *valp ? LT_TRUE : LT_FALSE;
875	}
876	cp = skipsym(cp);
877	cp = skipcomment(cp);
878	if (defparen && *cp++ != ')')
879	return (LT_ERROR);
880	constexpr = false;
881	} else if (!endsym(*cp)) {
882	debug("eval%d symbol", ops - eval_ops);
883	sym = findsym(cp);
884	cp = skipsym(cp);
885	if (sym < 0) {
886	lt = LT_IF;
887	cp = skipargs(cp);
888	} else if (value[sym] == NULL) {
889	*valp = 0;
890	lt = LT_FALSE;
891	} else {
892	*valp = strtol(value[sym], &ep, 0);
893	if (*ep != '\0' \|\| ep == value[sym])
894	return (LT_ERROR);
895	lt = *valp ? LT_TRUE : LT_FALSE;
896	cp = skipargs(cp);
897	}
898	constexpr = false;
899	} else {
900	debug("eval%d bad expr", ops - eval_ops);
901	return (LT_ERROR);
902	}
903
904	*cpp = cp;
905	debug("eval%d = %d", ops - eval_ops, *valp);
906	return (lt);
907	}
908
909	/*
910	* Table-driven evaluation of binary operators.
911	*/
912	static Linetype
913	eval_table(const struct ops ops, int valp, const char **cpp)
914	{
915	const struct op *op;
916	const char *cp;
917	int val;
918	Linetype lt, rt;
919
920	debug("eval%d", ops - eval_ops);
921	cp = *cpp;
922	lt = ops->inner(ops+1, valp, &cp);
923	if (lt == LT_ERROR)
924	return (LT_ERROR);
925	for (;;) {
926	cp = skipcomment(cp);
927	for (op = ops->op; op->str != NULL; op++)
928	if (strncmp(cp, op->str, strlen(op->str)) == 0)
929	break;
930	if (op->str == NULL)
931	break;
932	cp += strlen(op->str);
933	debug("eval%d %s", ops - eval_ops, op->str);
934	rt = ops->inner(ops+1, &val, &cp);
935	if (rt == LT_ERROR)
936	return (LT_ERROR);
937	lt = op->fn(valp, lt, *valp, rt, val);
938	}
939
940	*cpp = cp;
941	debug("eval%d = %d", ops - eval_ops, *valp);
942	debug("eval%d lt = %s", ops - eval_ops, linetype_name[lt]);
943	return (lt);
944	}
945
946	/*
947	* Evaluate the expression on a #if or #elif line. If we can work out
948	* the result we return LT_TRUE or LT_FALSE accordingly, otherwise we
949	* return just a generic LT_IF.
950	*/
951	static Linetype
952	ifeval(const char **cpp)
953	{
954	int ret;
955	int val = 0;
956
957	debug("eval %s", *cpp);
958	constexpr = killconsts ? false : true;
959	ret = eval_table(eval_ops, &val, cpp);
960	debug("eval = %d", val);
961	return (constexpr ? LT_IF : ret == LT_ERROR ? LT_IF : ret);
962	}
963
964	/*
965	* Skip over comments, strings, and character literals and stop at the
966	* next character position that is not whitespace. Between calls we keep
967	* the comment state in the global variable incomment, and we also adjust
968	* the global variable linestate when we see a newline.
969	* XXX: doesn't cope with the buffer splitting inside a state transition.
970	*/
971	static const char *
972	skipcomment(const char *cp)
973	{
974	if (text \|\| ignoring[depth]) {
975	for (; isspace((unsigned char)*cp); cp++)
976	if (*cp == '\n')
977	linestate = LS_START;
978	return (cp);
979	}
980	while (*cp != '\0')
981	/* don't reset to LS_START after a line continuation */
982	if (strncmp(cp, "\\\r\n", 3) == 0)
983	cp += 3;
984	else if (strncmp(cp, "\\\n", 2) == 0)
985	cp += 2;
986	else switch (incomment) {
987	case NO_COMMENT:
988	if (strncmp(cp, "/\\\r\n", 4) == 0) {
989	incomment = STARTING_COMMENT;
990	cp += 4;
991	} else if (strncmp(cp, "/\\\n", 3) == 0) {
992	incomment = STARTING_COMMENT;
993	cp += 3;
994	} else if (strncmp(cp, "/*", 2) == 0) {
995	incomment = C_COMMENT;
996	cp += 2;
997	} else if (strncmp(cp, "//", 2) == 0) {
998	incomment = CXX_COMMENT;
999	cp += 2;
1000	} else if (strncmp(cp, "\'", 1) == 0) {
1001	incomment = CHAR_LITERAL;
1002	linestate = LS_DIRTY;
1003	cp += 1;
1004	} else if (strncmp(cp, "\"", 1) == 0) {
1005	incomment = STRING_LITERAL;
1006	linestate = LS_DIRTY;
1007	cp += 1;
1008	} else if (strncmp(cp, "\n", 1) == 0) {
1009	linestate = LS_START;
1010	cp += 1;
1011	} else if (strchr(" \r\t", *cp) != NULL) {
1012	cp += 1;
1013	} else
1014	return (cp);
1015	continue;
1016	case CXX_COMMENT:
1017	if (strncmp(cp, "\n", 1) == 0) {
1018	incomment = NO_COMMENT;
1019	linestate = LS_START;
1020	}
1021	cp += 1;
1022	continue;
1023	case CHAR_LITERAL:
1024	case STRING_LITERAL:
1025	if ((incomment == CHAR_LITERAL && cp[0] == '\'') \|\|
1026	(incomment == STRING_LITERAL && cp[0] == '\"')) {
1027	incomment = NO_COMMENT;
1028	cp += 1;
1029	} else if (cp[0] == '\\') {
1030	if (cp[1] == '\0')
1031	cp += 1;
1032	else
1033	cp += 2;
1034	} else if (strncmp(cp, "\n", 1) == 0) {
1035	if (incomment == CHAR_LITERAL)
1036	error("unterminated char literal");
1037	else
1038	error("unterminated string literal");
1039	} else
1040	cp += 1;
1041	continue;
1042	case C_COMMENT:
1043	if (strncmp(cp, "*\\\r\n", 4) == 0) {
1044	incomment = FINISHING_COMMENT;
1045	cp += 4;
1046	} else if (strncmp(cp, "*\\\n", 3) == 0) {
1047	incomment = FINISHING_COMMENT;
1048	cp += 3;
1049	} else if (strncmp(cp, "*/", 2) == 0) {
1050	incomment = NO_COMMENT;
1051	cp += 2;
1052	} else
1053	cp += 1;
1054	continue;
1055	case STARTING_COMMENT:
1056	if (cp == '') {
1057	incomment = C_COMMENT;
1058	cp += 1;
1059	} else if (*cp == '/') {
1060	incomment = CXX_COMMENT;
1061	cp += 1;
1062	} else {
1063	incomment = NO_COMMENT;
1064	linestate = LS_DIRTY;
1065	}
1066	continue;
1067	case FINISHING_COMMENT:
1068	if (*cp == '/') {
1069	incomment = NO_COMMENT;
1070	cp += 1;
1071	} else
1072	incomment = C_COMMENT;
1073	continue;
1074	default:
1075	abort(); /* bug */
1076	}
1077	return (cp);
1078	}
1079
1080	/*
1081	* Skip macro arguments.
1082	*/
1083	static const char *
1084	skipargs(const char *cp)
1085	{
1086	const char *ocp = cp;
1087	int level = 0;
1088	cp = skipcomment(cp);
1089	if (*cp != '(')
1090	return (cp);
1091	do {
1092	if (*cp == '(')
1093	level++;
1094	if (*cp == ')')
1095	level--;
1096	cp = skipcomment(cp+1);
1097	} while (level != 0 && *cp != '\0');
1098	if (level == 0)
1099	return (cp);
1100	else
1101	/* Rewind and re-detect the syntax error later. */
1102	return (ocp);
1103	}
1104
1105	/*
1106	* Skip over an identifier.
1107	*/
1108	static const char *
1109	skipsym(const char *cp)
1110	{
1111	while (!endsym(*cp))
1112	++cp;
1113	return (cp);
1114	}
1115
1116	/*
1117	* Look for the symbol in the symbol table. If it is found, we return
1118	* the symbol table index, else we return -1.
1119	*/
1120	static int
1121	findsym(const char *str)
1122	{
1123	const char *cp;
1124	int symind;
1125
1126	cp = skipsym(str);
1127	if (cp == str)
1128	return (-1);
1129	if (symlist) {
1130	if (symdepth && firstsym)
1131	printf("%s%3d", zerosyms ? "" : "\n", depth);
1132	firstsym = zerosyms = false;
1133	printf("%s%.*s%s",
1134	symdepth ? " " : "",
1135	(int)(cp-str), str,
1136	symdepth ? "" : "\n");
1137	/* we don't care about the value of the symbol */
1138	return (0);
1139	}
1140	for (symind = 0; symind < nsyms; ++symind) {
1141	if (strlcmp(symname[symind], str, cp-str) == 0) {
1142	debug("findsym %s %s", symname[symind],
1143	value[symind] ? value[symind] : "");
1144	return (symind);
1145	}
1146	}
1147	return (-1);
1148	}
1149
1150	/*
1151	* Add a symbol to the symbol table.
1152	*/
1153	static void
1154	addsym(bool ignorethis, bool definethis, char *sym)
1155	{
1156	int symind;
1157	char *val;
1158
1159	symind = findsym(sym);
1160	if (symind < 0) {
1161	if (nsyms >= MAXSYMS)
1162	errx(2, "too many symbols");
1163	symind = nsyms++;
1164	}
1165	symname[symind] = sym;
1166	ignore[symind] = ignorethis;
1167	val = sym + (skipsym(sym) - sym);
1168	if (definethis) {
1169	if (*val == '=') {
1170	value[symind] = val+1;
1171	*val = '\0';
1172	} else if (*val == '\0')
1173	value[symind] = "1";
1174	else
1175	usage();
1176	} else {
1177	if (*val != '\0')
1178	usage();
1179	value[symind] = NULL;
1180	}
1181	debug("addsym %s=%s", symname[symind],
1182	value[symind] ? value[symind] : "undef");
1183	}
1184
1185	/*
1186	* Compare s with n characters of t.
1187	* The same as strncmp() except that it checks that s[n] == '\0'.
1188	*/
1189	static int
1190	strlcmp(const char s, const char t, size_t n)
1191	{
1192	while (n-- && *t != '\0')
1193	if (s != t)
1194	return ((unsigned char)s - (unsigned char)t);
1195	else
1196	++s, ++t;
1197	return ((unsigned char)*s);
1198	}
1199
1200	/*
1201	* Diagnostics.
1202	*/
1203	static void
1204	debug(const char *msg, ...)
1205	{
1206	va_list ap;
1207
1208	if (debugging) {
1209	va_start(ap, msg);
1210	vwarnx(msg, ap);
1211	va_end(ap);
1212	}
1213	}
1214
1215	static void
1216	error(const char *msg)
1217	{
1218	if (depth == 0)
1219	warnx("%s: %d: %s", filename, linenum, msg);
1220	else
1221	warnx("%s: %d: %s (#if line %d depth %d)",
1222	filename, linenum, msg, stifline[depth], depth);
1223	closeout();
1224	errx(2, "output may be truncated");
1225	}
1226

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/scripts/unifdef.c

interactive