1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1987, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #if 0
33 #ifndef lint
34 static char sccsid[] = "@(#)C.c 8.4 (Berkeley) 4/2/94";
35 #endif
36 #endif
37
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40
41 #include <limits.h>
42 #include <stdio.h>
43 #include <string.h>
44
45 #include "ctags.h"
46
47 static int func_entry(void);
48 static void hash_entry(void);
49 static void skip_string(int);
50 static int str_entry(int);
51
52 /*
53 * c_entries --
54 * read .c and .h files and call appropriate routines
55 */
56 void
c_entries(void)57 c_entries(void)
58 {
59 int c; /* current character */
60 int level; /* brace level */
61 int token; /* if reading a token */
62 int t_def; /* if reading a typedef */
63 int t_level; /* typedef's brace level */
64 char *sp; /* buffer pointer */
65 char tok[MAXTOKEN]; /* token buffer */
66
67 lineftell = ftell(inf);
68 sp = tok; token = t_def = NO; t_level = -1; level = 0; lineno = 1;
69 while (GETC(!=, EOF)) {
70 switch (c) {
71 /*
72 * Here's where it DOESN'T handle: {
73 * foo(a)
74 * {
75 * #ifdef notdef
76 * }
77 * #endif
78 * if (a)
79 * puts("hello, world");
80 * }
81 */
82 case '{':
83 ++level;
84 goto endtok;
85 case '}':
86 /*
87 * if level goes below zero, try and fix
88 * it, even though we've already messed up
89 */
90 if (--level < 0)
91 level = 0;
92 goto endtok;
93
94 case '\n':
95 SETLINE;
96 /*
97 * the above 3 cases are similar in that they
98 * are special characters that also end tokens.
99 */
100 endtok: if (sp > tok) {
101 *sp = EOS;
102 token = YES;
103 sp = tok;
104 }
105 else
106 token = NO;
107 continue;
108
109 /*
110 * We ignore quoted strings and character constants
111 * completely.
112 */
113 case '"':
114 case '\'':
115 skip_string(c);
116 break;
117
118 /*
119 * comments can be fun; note the state is unchanged after
120 * return, in case we found:
121 * "foo() XX comment XX { int bar; }"
122 */
123 case '/':
124 if (GETC(==, '*') || c == '/') {
125 skip_comment(c);
126 continue;
127 }
128 (void)ungetc(c, inf);
129 c = '/';
130 goto storec;
131
132 /* hash marks flag #define's. */
133 case '#':
134 if (sp == tok) {
135 hash_entry();
136 break;
137 }
138 goto storec;
139
140 /*
141 * if we have a current token, parenthesis on
142 * level zero indicates a function.
143 */
144 case '(':
145 if (!level && token) {
146 int curline;
147
148 if (sp != tok)
149 *sp = EOS;
150 /*
151 * grab the line immediately, we may
152 * already be wrong, for example,
153 * foo\n
154 * (arg1,
155 */
156 get_line();
157 curline = lineno;
158 if (func_entry()) {
159 ++level;
160 pfnote(tok, curline);
161 }
162 break;
163 }
164 goto storec;
165
166 /*
167 * semi-colons indicate the end of a typedef; if we find a
168 * typedef we search for the next semi-colon of the same
169 * level as the typedef. Ignoring "structs", they are
170 * tricky, since you can find:
171 *
172 * "typedef long time_t;"
173 * "typedef unsigned int u_int;"
174 * "typedef unsigned int u_int [10];"
175 *
176 * If looking at a typedef, we save a copy of the last token
177 * found. Then, when we find the ';' we take the current
178 * token if it starts with a valid token name, else we take
179 * the one we saved. There's probably some reasonable
180 * alternative to this...
181 */
182 case ';':
183 if (t_def && level == t_level) {
184 t_def = NO;
185 get_line();
186 if (sp != tok)
187 *sp = EOS;
188 pfnote(tok, lineno);
189 break;
190 }
191 goto storec;
192
193 /*
194 * store characters until one that can't be part of a token
195 * comes along; check the current token against certain
196 * reserved words.
197 */
198 default:
199 /* ignore whitespace */
200 if (c == ' ' || c == '\t') {
201 int save = c;
202 while (GETC(!=, EOF) && (c == ' ' || c == '\t'))
203 ;
204 if (c == EOF)
205 return;
206 (void)ungetc(c, inf);
207 c = save;
208 }
209 storec: if (!intoken(c)) {
210 if (sp == tok)
211 break;
212 *sp = EOS;
213 if (tflag) {
214 /* no typedefs inside typedefs */
215 if (!t_def &&
216 !memcmp(tok, "typedef",8)) {
217 t_def = YES;
218 t_level = level;
219 break;
220 }
221 /* catch "typedef struct" */
222 if ((!t_def || t_level < level)
223 && (!memcmp(tok, "struct", 7)
224 || !memcmp(tok, "union", 6)
225 || !memcmp(tok, "enum", 5))) {
226 /*
227 * get line immediately;
228 * may change before '{'
229 */
230 get_line();
231 if (str_entry(c))
232 ++level;
233 break;
234 /* } */
235 }
236 }
237 sp = tok;
238 }
239 else if (sp != tok || begtoken(c)) {
240 if (sp == tok + sizeof tok - 1)
241 /* Too long -- truncate it */
242 *sp = EOS;
243 else
244 *sp++ = c;
245 token = YES;
246 }
247 continue;
248 }
249
250 sp = tok;
251 token = NO;
252 }
253 }
254
255 /*
256 * func_entry --
257 * handle a function reference
258 */
259 static int
func_entry(void)260 func_entry(void)
261 {
262 int c; /* current character */
263 int level = 0; /* for matching '()' */
264
265 /*
266 * Find the end of the assumed function declaration.
267 * Note that ANSI C functions can have type definitions so keep
268 * track of the parentheses nesting level.
269 */
270 while (GETC(!=, EOF)) {
271 switch (c) {
272 case '\'':
273 case '"':
274 /* skip strings and character constants */
275 skip_string(c);
276 break;
277 case '/':
278 /* skip comments */
279 if (GETC(==, '*') || c == '/')
280 skip_comment(c);
281 break;
282 case '(':
283 level++;
284 break;
285 case ')':
286 if (level == 0)
287 goto fnd;
288 level--;
289 break;
290 case '\n':
291 SETLINE;
292 }
293 }
294 return (NO);
295 fnd:
296 /*
297 * we assume that the character after a function's right paren
298 * is a token character if it's a function and a non-token
299 * character if it's a declaration. Comments don't count...
300 */
301 for (;;) {
302 while (GETC(!=, EOF) && iswhite(c))
303 if (c == '\n')
304 SETLINE;
305 if (intoken(c) || c == '{')
306 break;
307 if (c == '/' && (GETC(==, '*') || c == '/'))
308 skip_comment(c);
309 else { /* don't ever "read" '/' */
310 (void)ungetc(c, inf);
311 return (NO);
312 }
313 }
314 if (c != '{')
315 (void)skip_key('{');
316 return (YES);
317 }
318
319 /*
320 * hash_entry --
321 * handle a line starting with a '#'
322 */
323 static void
hash_entry(void)324 hash_entry(void)
325 {
326 int c; /* character read */
327 int curline; /* line started on */
328 char *sp; /* buffer pointer */
329 char tok[MAXTOKEN]; /* storage buffer */
330
331 /* ignore leading whitespace */
332 while (GETC(!=, EOF) && (c == ' ' || c == '\t'))
333 ;
334 (void)ungetc(c, inf);
335
336 curline = lineno;
337 for (sp = tok;;) { /* get next token */
338 if (GETC(==, EOF))
339 return;
340 if (iswhite(c))
341 break;
342 if (sp == tok + sizeof tok - 1)
343 /* Too long -- truncate it */
344 *sp = EOS;
345 else
346 *sp++ = c;
347 }
348 *sp = EOS;
349 if (memcmp(tok, "define", 6)) /* only interested in #define's */
350 goto skip;
351 for (;;) { /* this doesn't handle "#define \n" */
352 if (GETC(==, EOF))
353 return;
354 if (!iswhite(c))
355 break;
356 }
357 for (sp = tok;;) { /* get next token */
358 if (sp == tok + sizeof tok - 1)
359 /* Too long -- truncate it */
360 *sp = EOS;
361 else
362 *sp++ = c;
363 if (GETC(==, EOF))
364 return;
365 /*
366 * this is where it DOESN'T handle
367 * "#define \n"
368 */
369 if (!intoken(c))
370 break;
371 }
372 *sp = EOS;
373 if (dflag || c == '(') { /* only want macros */
374 get_line();
375 pfnote(tok, curline);
376 }
377 skip: if (c == '\n') { /* get rid of rest of define */
378 SETLINE
379 if (*(sp - 1) != '\\')
380 return;
381 }
382 (void)skip_key('\n');
383 }
384
385 /*
386 * str_entry --
387 * handle a struct, union or enum entry
388 */
389 static int
str_entry(int c)390 str_entry(int c) /* c is current character */
391 {
392 int curline; /* line started on */
393 char *sp; /* buffer pointer */
394 char tok[LINE_MAX]; /* storage buffer */
395
396 curline = lineno;
397 while (iswhite(c))
398 if (GETC(==, EOF))
399 return (NO);
400 if (c == '{') /* it was "struct {" */
401 return (YES);
402 for (sp = tok;;) { /* get next token */
403 if (sp == tok + sizeof tok - 1)
404 /* Too long -- truncate it */
405 *sp = EOS;
406 else
407 *sp++ = c;
408 if (GETC(==, EOF))
409 return (NO);
410 if (!intoken(c))
411 break;
412 }
413 switch (c) {
414 case '{': /* it was "struct foo{" */
415 --sp;
416 break;
417 case '\n': /* it was "struct foo\n" */
418 SETLINE;
419 /*FALLTHROUGH*/
420 default: /* probably "struct foo " */
421 while (GETC(!=, EOF))
422 if (!iswhite(c))
423 break;
424 if (c != '{') {
425 (void)ungetc(c, inf);
426 return (NO);
427 }
428 }
429 *sp = EOS;
430 pfnote(tok, curline);
431 return (YES);
432 }
433
434 /*
435 * skip_comment --
436 * skip over comment
437 */
438 void
skip_comment(int t)439 skip_comment(int t) /* t is comment character */
440 {
441 int c; /* character read */
442 int star; /* '*' flag */
443
444 for (star = 0; GETC(!=, EOF);)
445 switch(c) {
446 /* comments don't nest, nor can they be escaped. */
447 case '*':
448 star = YES;
449 break;
450 case '/':
451 if (star && t == '*')
452 return;
453 break;
454 case '\n':
455 if (t == '/')
456 return;
457 SETLINE;
458 /*FALLTHROUGH*/
459 default:
460 star = NO;
461 break;
462 }
463 }
464
465 /*
466 * skip_string --
467 * skip to the end of a string or character constant.
468 */
469 void
skip_string(int key)470 skip_string(int key)
471 {
472 int c,
473 skip;
474
475 for (skip = NO; GETC(!=, EOF); )
476 switch (c) {
477 case '\\': /* a backslash escapes anything */
478 skip = !skip; /* we toggle in case it's "\\" */
479 break;
480 case '\n':
481 SETLINE;
482 /*FALLTHROUGH*/
483 default:
484 if (c == key && !skip)
485 return;
486 skip = NO;
487 }
488 }
489
490 /*
491 * skip_key --
492 * skip to next char "key"
493 */
494 int
skip_key(int key)495 skip_key(int key)
496 {
497 int c,
498 skip,
499 retval;
500
501 for (skip = retval = NO; GETC(!=, EOF);)
502 switch(c) {
503 case '\\': /* a backslash escapes anything */
504 skip = !skip; /* we toggle in case it's "\\" */
505 break;
506 case ';': /* special case for yacc; if one */
507 case '|': /* of these chars occurs, we may */
508 retval = YES; /* have moved out of the rule */
509 break; /* not used by C */
510 case '\'':
511 case '"':
512 /* skip strings and character constants */
513 skip_string(c);
514 break;
515 case '/':
516 /* skip comments */
517 if (GETC(==, '*') || c == '/') {
518 skip_comment(c);
519 break;
520 }
521 (void)ungetc(c, inf);
522 c = '/';
523 goto norm;
524 case '\n':
525 SETLINE;
526 /*FALLTHROUGH*/
527 default:
528 norm:
529 if (c == key && !skip)
530 return (retval);
531 skip = NO;
532 }
533 return (retval);
534 }
535