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