/usr/src/usr.bin/ctags/C.c

Bug Summary

File:	src/usr.bin/ctags/C.c
Warning:	line 422, column 17 The left operand of '!=' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name C.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/ctags/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/usr.bin/ctags -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/ctags/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.bin/ctags/C.c

1/*	$OpenBSD: C.c,v 1.15 2014/12/08 03:58:56 jsg Exp $	*/
2/*	$NetBSD: C.c,v 1.3 1995/03/26 20:14:02 glass Exp $	*/

4/*
* Copyright (c) 1987, 1993, 1994
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

33#include <limits.h>
34#include <stdio.h>
35#include <string.h>

37#include "ctags.h"

39static int	func_entry(void);
40static void	hash_entry(void);
41static void	skip_string(int);
42static int	str_entry(int);

44/*
* c_entries --
*	read .c and .h files and call appropriate routines
*/
48void
49c_entries(void)
50{
int	c;			/* current character */
int	level;			/* brace level */
int	token;			/* if reading a token */
int	t_def;			/* if reading a typedef */
int	t_level;		/* typedef's brace level */
char	*sp;			/* buffer pointer */
char	tok[MAXTOKEN250];		/* token buffer */

lineftell = ftell(inf);
sp = tok; token = t_def = NO0; t_level = -1; level = 0; lineno = 1;
while (GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1))) {
1
Assuming '__isthreaded' is not equal to 0→
2
←
'?' condition is false→
3
←
Assuming the condition is true→
4
←
Loop condition is true.  Entering loop body→
switch (c) {
5
←
Control jumps to 'case 35:'  at line 128→
/*
 * Here's where it DOESN'T handle: {
 *	foo(a)
 *	{
 *	#ifdef notdef
 *		}
 *	#endif
 *		if (a)
 *			puts("hello, world");
 *	}
 */
case '{':
	++level;
	goto endtok;
case '}':
	/*
	 * if level goes below zero, try and fix
	 * it, even though we've already messed up
	 */
	if (--level < 0)
		level = 0;
	goto endtok;

case '\n':
	SETLINE{++lineno;lineftell = ftell(inf);};
	/*
	 * the above 3 cases are similar in that they
	 * are special characters that also end tokens.
	 */
92endtok:			if (sp > tok) {
		*sp = EOS'\0';
		token = YES1;
		sp = tok;
	}
	else
		token = NO0;
	continue;

/*
 * We ignore quoted strings and character constants
 * completely.
 */
case '"':
case '\'':
	(void)skip_string(c);
	break;

/*
 * comments can be fun; note the state is unchanged after
 * return, in case we found:
 *	"foo() XX comment XX { int bar; }"
 */
case '/':
	if (GETC(==, '*')((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)'*')) {
		skip_comment(c);
		continue;
	} else if (c == '/') {
		skip_comment(c);
		continue;
	}
	(void)ungetc(c, inf);
	c = '/';
	goto storec;

/* hash marks flag #define's. */
case '#':
	if (sp5.1
'sp' is equal to 'tok'
 == tok) {
6
←
Taking true branch→
		hash_entry();
7
←
Calling 'hash_entry'→
		break;
	}
	goto storec;

/*
 * if we have a current token, parenthesis on
 * level zero indicates a function.
 */
case '(':
	do {
		if (GETC(==, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)(-1)))
			return;
	} while (iswhite(c)(_wht[(unsigned)c]));
	if (c == '*')
		break;
	else
		ungetc(c, inf);
	if (!level && token) {
		int	curline;

		if (sp != tok)
			*sp = EOS'\0';
		/*
		 * grab the line immediately, we may
		 * already be wrong, for example,
		 *	foo\n
		 *	(arg1,
		 */
		get_line();
		curline = lineno;
		if (func_entry()) {
			++level;
			pfnote(tok, curline);
		}
		break;
	}
	goto storec;

/*
 * semi-colons indicate the end of a typedef; if we find a
 * typedef we search for the next semi-colon of the same
 * level as the typedef.  Ignoring "structs", they are
 * tricky, since you can find:
 *
 *	"typedef int time_t;"
 *	"typedef unsigned int u_int;"
 *	"typedef unsigned int u_int [10];"
 *
 * If looking at a typedef, we save a copy of the last token
 * found.  Then, when we find the ';' we take the current
 * token if it starts with a valid token name, else we take
 * the one we saved.  There's probably some reasonable
 * alternative to this...
 */
case ';':
	if (t_def && level == t_level) {
		t_def = NO0;
		get_line();
		if (sp != tok)
			*sp = EOS'\0';
		pfnote(tok, lineno);
		break;
	}
	goto storec;

/*
 * store characters until one that can't be part of a token
 * comes along; check the current token against certain
 * reserved words.
 */
default:
	/*
	 * to treat following function.
	 * func      (arg) {
	 * ....
	 * }
	 */
	if (c == ' ' || c == '\t') {
		int save = c;
		while (GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1)) && (c == ' ' || c == '\t'))
			;
		if (c == EOF(-1))
			return;
		(void)ungetc(c, inf);
		c = save;
	}
storec:		if (!intoken(c)(_itk[(unsigned)c])) {
		if (sp == tok)
			break;
		*sp = EOS'\0';
		/* no typedefs inside typedefs */
		if (!t_def &&
			   !memcmp(tok, "typedef",8)) {
			t_def = YES1;
			t_level = level;
			break;
		}
		/* catch "typedef struct" */
		if ((!t_def || t_level < level)
		    && (!memcmp(tok, "struct", 7)
		    || !memcmp(tok, "union", 6)
		    || !memcmp(tok, "enum", 5))) {
			/*
			 * get line immediately;
			 * may change before '{'
			 */
			get_line();
			if (str_entry(c))
				++level;
			break;
			/* } */
		}
		sp = tok;
	}
	else if (sp != tok || begtoken(c)(_btk[(unsigned)c])) {
		/* hell... truncate it */
		if (sp == tok + sizeof tok - 1)
			*sp = EOS'\0';
		else 
			*sp++ = c;
		token = YES1;
	}
	continue;
}

sp = tok;
token = NO0;
}
259}

261/*
* func_entry --
*	handle a function reference
*/
265static int
266func_entry(void)
267{
int	c;			/* current character */
int	level = 0;		/* for matching '()' */
static char attribute[] = "__attribute__";
char maybe_attribute[sizeof attribute + 1];
char *anext;

/*
* Find the end of the assumed function declaration.
* Note that ANSI C functions can have type definitions so keep
* track of the parentheses nesting level.
*/
while (GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1))) {
switch (c) {
case '\'':
case '"':
	/* skip strings and character constants */
	skip_string(c);
	break;
case '/':
	/* skip comments */
	if (GETC(==, '*')((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)'*'))
		skip_comment(c);
	else if (c == '/')
		skip_comment(c);
	break;
case '(':
	level++;
	break;
case ')':
	if (level == 0)
		goto fnd;
	level--;
	break;
case '\n':
	SETLINE{++lineno;lineftell = ftell(inf);};
}
}
return (NO0);
306fnd:
/*
* we assume that the character after a function's right paren
* is a token character if it's a function and a non-token
* character if it's a declaration.  Comments don't count...
*/
for (anext = maybe_attribute;;) {
while (GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1)) && iswhite(c)(_wht[(unsigned)c]))
	if (c == '\n')
		SETLINE{++lineno;lineftell = ftell(inf);};
if (c == EOF(-1))
	return NO0;
/*
 * Recognize the GNU __attribute__ extension, which would
 * otherwise make the heuristic test DTWT
 */
if (anext == maybe_attribute) {
	if (intoken(c)(_itk[(unsigned)c])) {
		*anext++ = c;
		continue;
	}
} else {
	if (intoken(c)(_itk[(unsigned)c])) {
		if (anext - maybe_attribute < (int)(sizeof attribute - 1))
			*anext++ = c;
		else
			break;
		continue;
	} else {
		*anext++ = '\0';
		if (strcmp(maybe_attribute, attribute) == 0) {
			(void)ungetc(c, inf);
			return NO0;
		}
		break;
	}
}
if (intoken(c)(_itk[(unsigned)c]) || c == '{')
	break;
if (c == '/' && GETC(==, '*')((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)'*'))
	skip_comment(c);
else if (c == '/')
	skip_comment(c);
else {				/* don't ever "read" '/' */
	(void)ungetc(c, inf);
	return (NO0);
}
}
if (c != '{')
(void)skip_key('{');
return (YES1);
357}

359/*
* hash_entry --
*	handle a line starting with a '#'
*/
363static void
364hash_entry(void)
365{
int	c;			/* character read */
int	curline;		/* line started on */
char	*sp;			/* buffer pointer */
char	tok[MAXTOKEN250];		/* storage buffer */

/*
* to treat following macro.
* #     macro(arg)        ....
*/
while (GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1)) && (c == ' ' || c == '\t'))
8
←
Assuming '__isthreaded' is not equal to 0→
9
←
'?' condition is false→
10
←
Assuming the condition is false→
;
(void)ungetc(c, inf);

curline = lineno;
for (sp = tok;;) {		/* get next token */
if (GETC(==, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)(-1)))
11
←
Loop condition is true.  Entering loop body→
12
←
Assuming '__isthreaded' is not equal to 0→
13
←
'?' condition is false→
14
←
Assuming the condition is false→
15
←
Taking false branch→
	return;
if (iswhite(c)(_wht[(unsigned)c]))
16
←
Assuming the condition is true→
17
←
Taking true branch→
	break;
/* hell... truncate it */
if (sp == tok + sizeof tok - 1)
	*sp = EOS'\0';
else 
	*sp++ = c;
}
*sp = EOS'\0';
18
←
 Execution continues on line 391→
if (memcmp(tok, "define", 6))	/* only interested in #define's */
19
←
Assuming the condition is true→
20
←
Taking true branch→
goto skip;
21
←
Control jumps to line 420→
for (;;) {			/* this doesn't handle "#define \n" */
if (GETC(==, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)(-1)))
	return;
if (!iswhite(c)(_wht[(unsigned)c]))
	break;
}
for (sp = tok;;) {		/* get next token */
/* hell... truncate it */
if (sp == tok + sizeof tok - 1)
	*sp = EOS'\0';
else 
	*sp++ = c;
if (GETC(==, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)(-1)))
	return;
/*
 * this is where it DOESN'T handle
 * "#define \n"
 */
if (!intoken(c)(_itk[(unsigned)c]))
	break;
}
*sp = EOS'\0';
if (dflag || c == '(') {	/* only want macros */
get_line();
pfnote(tok, curline);
}
420skip:	if (c == '\n') {		/* get rid of rest of define */
22
←
Assuming the condition is true→
23
←
Taking true branch→
SETLINE{++lineno;lineftell = ftell(inf);}
if (*(sp - 1) != '\\')
24
←
The left operand of '!=' is a garbage value
	return;
}
(void)skip_key('\n');
426}

428/*
* str_entry --
*	handle a struct, union or enum entry
*/
432static int
433str_entry(int c)
434{
int	curline;		/* line started on */
char	*sp;			/* buffer pointer */
char	tok[LINE_MAX2048];		/* storage buffer */

curline = lineno;
while (iswhite(c)(_wht[(unsigned)c]))
if (GETC(==, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)(-1)))
	return (NO0);
if (c == '{')		/* it was "struct {" */
return (YES1);
for (sp = tok;;) {		/* get next token */
/* hell... truncate it */
if (sp == tok + sizeof tok - 1)
	*sp = EOS'\0';
else 
	*sp++ = c;
if (GETC(==, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)(-1)))
	return (NO0);
if (!intoken(c)(_itk[(unsigned)c]))
	break;
}
switch (c) {
case '{':		/* it was "struct foo{" */
	--sp;
	break;
case '\n':		/* it was "struct foo\n" */
	SETLINE{++lineno;lineftell = ftell(inf);};
	/*FALLTHROUGH*/
default:		/* probably "struct foo " */
	while (GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1)))
		if (!iswhite(c)(_wht[(unsigned)c]))
			break;
	if (c != '{') {
		(void)ungetc(c, inf);
		return (NO0);
	}
}
*sp = EOS'\0';
pfnote(tok, curline);
return (YES1);
475}

477/*
* skip_comment --
*	skip over comment
*/
481void
482skip_comment(int commenttype)
483{
int	c;			/* character read */
int	star;			/* '*' flag */

for (star = 0; GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1));)
switch(c) {
/* comments don't nest, nor can they be escaped. */
case '*':
	star = YES1;
	break;
case '/':
	if (commenttype == '*' && star)
		return;
	break;
case '\n':
	if (commenttype == '/') {
		/* We don't really parse C, so sometimes it
		 * is necessary to see the newline
		 */
		ungetc(c, inf);
		return;
	}
	SETLINE{++lineno;lineftell = ftell(inf);};
	/*FALLTHROUGH*/
default:
	star = NO0;
	break;
}
511}

513/*
* skip_string --
*	skip to the end of a string or character constant.
*/
517static void
518skip_string(int key)
519{
int	c,
skip;

for (skip = NO0; GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1)); )
switch (c) {
case '\\':		/* a backslash escapes anything */
	skip = !skip;	/* we toggle in case it's "\\" */
	break;
case '\n':
	SETLINE{++lineno;lineftell = ftell(inf);};
	/*FALLTHROUGH*/
default:
	if (c == key && !skip)
		return;
	skip = NO0;
}
536}

538/*
* skip_key --
*	skip to next char "key"
*/
542int
543skip_key(int key)
544{
int	c,
skip,
retval;

for (skip = retval = NO0; GETC(!=, EOF)((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) != (int)(-1));)
switch(c) {
case '\\':		/* a backslash escapes anything */
	skip = !skip;	/* we toggle in case it's "\\" */
	break;
case ';':		/* special case for yacc; if one */
case '|':		/* of these chars occurs, we may */
	retval = YES1;	/* have moved out of the rule */
	break;		/* not used by C */
case '\'':
case '"':
	/* skip strings and character constants */
	skip_string(c);
	break;
case '/':
	/* skip comments */
	if (GETC(==, '*')((c = (!__isthreaded ? (--(inf)->_r < 0 ? __srget(inf) :
 (int)(*(inf)->_p++)) : (getc)(inf))) == (int)'*')) {
		skip_comment(c);
		break;
	} else if (c == '/') {
		skip_comment(c);
		break;
	}
	(void)ungetc(c, inf);
	c = '/';
	goto norm;
case '\n':
	SETLINE{++lineno;lineftell = ftell(inf);};
	/*FALLTHROUGH*/
default:
norm:
	if (c == key && !skip)
		return (retval);
	skip = NO0;
}
return (retval);
585}