[splint.git] / src / flagMarkerList.c

/*
** LCLint - annotation-assisted static program checker
** Copyright (C) 1994-2000 University of Virginia,
**         Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 2 of the License, or (at your
** option) any later version.
** 
** This program is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** General Public License for more details.
** 
** The GNU General Public License is available from http://www.gnu.org/ or
** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
** MA 02111-1307, USA.
**
** For information on lclint: lclint-request@cs.virginia.edu
** To report a bug: lclint-bug@cs.virginia.edu
** For more information: http://lclint.cs.virginia.edu
*/
/*
** flagMarkerList.c
**
** based on list_template.c
**
** where T has T_equal (or change this) and T_unparse
**
** invariant: flagMarker's are listed in order
*/

# include "lclintMacros.nf"
# include "basic.h"

flagMarkerList
  flagMarkerList_new ()
{
  flagMarkerList s = (flagMarkerList) dmalloc (sizeof (*s));
  
  s->nelements = 0;
  s->nspace = flagMarkerListBASESIZE; 
  s->elements = (flagMarker *)
    dmalloc (sizeof (*s->elements) * flagMarkerListBASESIZE);

  return (s);
}

static void
flagMarkerList_grow (flagMarkerList s)
{
  int i;
  flagMarker *newelements;
  
  s->nspace += flagMarkerListBASESIZE; 

  newelements = (flagMarker *) dmalloc (sizeof (*newelements) 
					* (s->nelements + s->nspace));

  for (i = 0; i < s->nelements; i++)
    {
      newelements[i] = s->elements[i];
    }
  
  sfree (s->elements);
  s->elements = newelements;
}

void flagMarkerList_add (flagMarkerList s, flagMarker fm)
{
  int i = s->nelements - 1;

  
  if (i > 0)
    {
      flagMarker last = s->elements[i];

      
      if (flagMarker_isIgnoreCount (last))
	{
	  if (!flagMarker_isIgnoreOff (fm))
	    {
	      if (flagMarker_isLocalSet (fm))
		{
		  llforceerror 
		    (FLG_WARNFLAGS,
		     cstring_makeLiteral ("Cannot set flag inside ignore "
					  "count region."),
		     flagMarker_getLoc (fm));
		  llgenindentmsg 
		    (cstring_makeLiteral ("Ignore count region starts"),
		     flagMarker_getLoc (last));

		}
	      else 
		{
		  if (flagMarker_isIgnoreOn (fm)) 
		    {
		      llforceerror 
			(FLG_WARNFLAGS,
			 cstring_makeLiteral ("Cannot nest ignore regions."),
			 flagMarker_getLoc (fm));
		      llgenindentmsg 
			(cstring_makeLiteral ("Previous ignore region starts"),
			 flagMarker_getLoc (last));
		    }
		}

	      flagMarker_free (fm);
	      return;
	    }
	}
      else 
	{
	  if (flagMarker_isIgnoreOff (last))
	    {
	      flagMarker nlast = s->elements [i - 1];
	      
	      if (flagMarker_isIgnoreCount (nlast))
		{
		  if (fileloc_sameFile (flagMarker_getLoc (fm),
					flagMarker_getLoc (last))
		      && fileloc_notAfter (flagMarker_getLoc (fm), 
					   flagMarker_getLoc (last)))
		    {
		      if (flagMarker_isLocalSet (fm))
			{
			  llforceerror 
			    (FLG_WARNFLAGS,
			     cstring_makeLiteral ("Cannot set flag inside ignore "
						  "count region."),
			     flagMarker_getLoc (fm));
			  llgenindentmsg 
			    (cstring_makeLiteral ("Ignore count region starts"),
			     flagMarker_getLoc (nlast));
			  
			}
		      else 
			{
			  if (flagMarker_isIgnoreOn (fm)) 
			    {
			      llforceerror 
				(FLG_WARNFLAGS,
				 cstring_makeLiteral ("Cannot nest ignore regions."),
				 flagMarker_getLoc (fm));
			      llgenindentmsg 
				(cstring_makeLiteral ("Previous ignore region starts"),
				 flagMarker_getLoc (nlast));
			    }
			}
		      
		      flagMarker_free (fm);
		      return;
		    }
		}
	    }
	}
    }

  
  /*
  ** all this code is necessary to check the invariant is preserved
  */

  while (i > 0
	 && !flagMarker_sameFile (s->elements[i],
				  flagMarker_getLoc (fm))) 
    {
      i--;
    }

  /*
  ** reprocessing header file, okay to be out of order
  */

  if (i >= 0 && !fileloc_isHeader (flagMarker_getLoc (fm)))
    {
                  
      /*
      llassert (!flagMarker_beforeMarker (s->elements[i], 
					  flagMarker_getLoc (fm)));
					  */
    }

  if (s->nspace <= 0)
    {
      flagMarkerList_grow (s);
    }
  
  s->nspace--;
  s->elements[s->nelements] = fm;
  s->nelements++;
  }

void flagMarkerList_checkSuppressCounts (flagMarkerList s)
{
  int nexpected = 0;
  int nsuppressed = 0;
  fileloc loc = fileloc_undefined;
  bool inCount = FALSE;
  int i;

  
  for (i = 0; i < s->nelements; i++)
    {
      flagMarker current = s->elements[i];

      if (flagMarker_isIgnoreCount (current))
	{
	  llassert (!inCount);
	  inCount = TRUE;
	  nexpected = flagMarker_getCount (current);
	  loc = flagMarker_getLoc (current);
	  nsuppressed = 0;
	  	}
      else if (flagMarker_isIgnoreOff (current))
	{
	  if (inCount)
	    {
	      inCount = FALSE;
	      llassert (fileloc_isDefined (loc));

	      if (nexpected > 0 && nexpected != nsuppressed)
		{
		  llforceerror 
		    (FLG_SUPCOUNTS,
		     message 
		     ("Line expects to suppress %d error%p, found %d error%p",
		      nexpected, nsuppressed),
		     loc);
		}
	    }
	}
      else if (flagMarker_isSuppress (current))
	{
	  nsuppressed++;
	}
      else
	{
	  ;
	}
    }

  llassert (!inCount);
}

static void flagMarkerList_splice (flagMarkerList s, 
				   int index,
				   /*@keep@*/ flagMarker fm)
{
  fileloc loc = flagMarker_getLoc (fm);
  fileloc beforeloc, afterloc;
  int i;

  llassert (index >= 0 && (index + 1 < s->nelements));
  
  beforeloc = flagMarker_getLoc (s->elements[index]);
  afterloc = flagMarker_getLoc (s->elements[index + 1]);;
  
  llassert (fileloc_sameFile (beforeloc, loc));
  llassert (fileloc_sameFile (afterloc, loc));

  if (s->nspace <= 0)
    {
      flagMarkerList_grow (s);
    }
  
  for (i = s->nelements; i > index + 1; i--)
    {
      s->elements[i] = s->elements[i - 1];
    }

  s->elements[index + 1] = fm;
  s->nelements++;
  s->nspace--;

  }

/*@only@*/ cstring
flagMarkerList_unparse (flagMarkerList s)
{
   int i;
   cstring st = cstring_makeLiteral ("[");

   for (i = 0; i < s->nelements; i++)
     {
       if (i == 0)
	 {
	   st = message ("%q %q", st, flagMarker_unparse (s->elements[i]));
	 }
       else
	 st = message ("%q, %q", st, flagMarker_unparse (s->elements[i]));
     }
   
   st = message ("%q ]", st);
   return st;
}

void
flagMarkerList_free (flagMarkerList s)
{
  int i;
  for (i = 0; i < s->nelements; i++)
    {
      flagMarker_free (s->elements[i]);
    }
  
  sfree (s->elements); 
  sfree (s);
}

/*
** returns YES iff
**    > in ignore region (there is an ignore ON marker not followed by OFF)
**    > code is OFF (-)
**
** returns NO iff
**    > not in ignore region
**    > code is ON (+)
**
** returns MAYBE iff
**    > not in ignore region
**    > code is unset or =
**
** requires: invariant for flagMarkerList:
**    flagMarker's are sorted by line and col
*/

static int
flagMarkerList_lastBeforeLoc (flagMarkerList s, fileloc loc)
{
  int i;

  for (i = s->nelements - 1; i >= 0; i--) 
    {
      flagMarker current = s->elements[i];
      
      if (fileloc_sameFile (current->loc, loc) 
	  && (!flagMarker_beforeMarker (current, loc)))
	{
	  return i;
	}
/*
      if (flagMarker_sameFile (current, loc) 
	  && (!flagMarker_beforeMarker (current, loc)))
	{
	  return i;
	}
*/
    }

  return -1;
}
	  
ynm
flagMarkerList_suppressError (flagMarkerList s, flagcode code, fileloc loc)
{
  int i;
  bool ignoreOff = FALSE;
  bool nameChecksOff = FALSE;
  bool flagOff = FALSE;
  ynm flagSet = MAYBE;
  bool islib = FALSE;
  bool isNameChecksFlag = flagcode_isNameChecksFlag (code);

  if (fileloc_isLib (loc))
    {
      i = s->nelements - 1;
      islib = TRUE;
    }
  else
    {
      i = flagMarkerList_lastBeforeLoc (s, loc);
    }

  
  if (i < 0)
    {
      return MAYBE;
    }
  
  /*
  ** Go backwards through the remaining flagMarkers in this file.
  */

  for (; i >= 0; i--) 
    {
      flagMarker current = s->elements[i];

      
      if (!islib && !flagMarker_sameFile (current, loc))
	{
	  break;
	}

      if (flagMarker_isIgnoreOff (current))
	{
	  ignoreOff = TRUE;
	}
      else if (flagMarker_isIgnoreOn (current))
	{
	  if (!ignoreOff)
	    {
	      return YES;
	    }
	}
      else if (flagMarker_isIgnoreCount (current))
	{
	  if (!ignoreOff)
	    {
	      flagMarkerList_splice (s, i,
				     flagMarker_createSuppress (code, loc));
	      return YES;
	    }
	}
      else if (flagMarker_isLocalSet (current))
	{
	  
	  if (!flagOff && flagMarker_getCode (current) == code)
	    {
	      ynm set  = flagMarker_getSet (current);
	      
	      if (ynm_isOff (set))
		{
		  return YES;
		}
	      else
		{
		  if (ynm_isOn (set))
		    {
		      flagOff = TRUE;
		      flagSet = NO;
		    }
		  else
		    {
		      		      flagOff = TRUE;
		      flagSet = MAYBE;
		    }
		  
		  if (ignoreOff)
		    {
		      if (isNameChecksFlag && !nameChecksOff)
			{
			  ;
			}
		      else
			{
			  return flagSet;
			}
		    }
		}
	    }
	  
	  if (flagMarker_getCode (current) == FLG_NAMECHECKS
	      && !nameChecksOff && isNameChecksFlag)
	    {
	      ynm set  = flagMarker_getSet (current);
	      
	      if (ynm_isOff (set))
		{
		  return YES;
		}
	      else
		{
		  if (ynm_isOn (set))
		    {
		      nameChecksOff = TRUE;
		      flagSet = NO;
		    }
		  else
		    {
		      		      nameChecksOff = TRUE;
		      flagSet = MAYBE;
		    }
		  
		  if (ignoreOff && flagOff)
		    {
		      return flagSet;
		    }
		}
	    }
	}
      else
	{
	  llassert (flagMarker_isSuppress (current));
	}
    }
  
  return flagSet;
}

bool
flagMarkerList_inIgnore (flagMarkerList s, fileloc loc)
{
  int i;

  if (fileloc_isLib (loc))
    {
      return FALSE;
    }

  i = flagMarkerList_lastBeforeLoc (s, loc);
  
  /*
  ** Go backwards through the remaining flagMarkers in this file.
  */

  for (; i >= 0; i--) 
    {
      flagMarker current = s->elements[i];
      
      if (!flagMarker_sameFile (current, loc))
	{
	  break;
	}

      if (flagMarker_isIgnoreOff (current))
	{
	  return FALSE;;
	}
      else if (flagMarker_isIgnoreOn (current))
	{
	  return TRUE;
	}
      else if (flagMarker_isIgnoreCount (current))
	{
	  flagMarkerList_splice (s, i,
				 flagMarker_createSuppress (SKIP_FLAG, loc));
	  return TRUE;
	}
      else
	{
	  llassert (flagMarker_isLocalSet (current)
		    || flagMarker_isSuppress (current));
	}
    }
  
  return FALSE;
}
Commit	Line	Data
616915dd	1	/*
	2	** LCLint - annotation-assisted static program checker
	3	** Copyright (C) 1994-2000 University of Virginia,
	4	** Massachusetts Institute of Technology
	5	**
	6	** This program is free software; you can redistribute it and/or modify it
	7	** under the terms of the GNU General Public License as published by the
	8	** Free Software Foundation; either version 2 of the License, or (at your
	9	** option) any later version.
	10	**
	11	** This program is distributed in the hope that it will be useful, but
	12	** WITHOUT ANY WARRANTY; without even the implied warranty of
	13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	** General Public License for more details.
	15	**
	16	** The GNU General Public License is available from http://www.gnu.org/ or
	17	** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	18	** MA 02111-1307, USA.
	19	**
	20	** For information on lclint: lclint-request@cs.virginia.edu
	21	** To report a bug: lclint-bug@cs.virginia.edu
	22	** For more information: http://lclint.cs.virginia.edu
	23	*/
	24	/*
	25	** flagMarkerList.c
	26	**
	27	** based on list_template.c
	28	**
	29	** where T has T_equal (or change this) and T_unparse
	30	**
	31	** invariant: flagMarker's are listed in order
	32	*/
	33
	34	# include "lclintMacros.nf"
	35	# include "basic.h"
	36
	37	flagMarkerList
	38	flagMarkerList_new ()
	39	{
	40	flagMarkerList s = (flagMarkerList) dmalloc (sizeof (*s));
	41
	42	s->nelements = 0;
	43	s->nspace = flagMarkerListBASESIZE;
	44	s->elements = (flagMarker *)
	45	dmalloc (sizeof (s->elements) flagMarkerListBASESIZE);
	46
	47	return (s);
	48	}
	49
	50	static void
	51	flagMarkerList_grow (flagMarkerList s)
	52	{
	53	int i;
	54	flagMarker *newelements;
	55
	56	s->nspace += flagMarkerListBASESIZE;
	57
	58	newelements = (flagMarker ) dmalloc (sizeof (newelements)
	59	* (s->nelements + s->nspace));
	60
	61	for (i = 0; i < s->nelements; i++)
	62	{
	63	newelements[i] = s->elements[i];
	64	}
65
66	sfree (s->elements);
67	s->elements = newelements;
68	}
69
70	void flagMarkerList_add (flagMarkerList s, flagMarker fm)
71	{
72	int i = s->nelements - 1;
73
74
75	if (i > 0)
76	{
77	flagMarker last = s->elements[i];
78
79
80	if (flagMarker_isIgnoreCount (last))
81	{
82	if (!flagMarker_isIgnoreOff (fm))
83	{
84	if (flagMarker_isLocalSet (fm))
85	{
86	llforceerror
87	(FLG_WARNFLAGS,
88	cstring_makeLiteral ("Cannot set flag inside ignore "
89	"count region."),
90	flagMarker_getLoc (fm));
91	llgenindentmsg
92	(cstring_makeLiteral ("Ignore count region starts"),
93	flagMarker_getLoc (last));
94
95	}
96	else
97	{
98	if (flagMarker_isIgnoreOn (fm))
99	{
100	llforceerror
101	(FLG_WARNFLAGS,
102	cstring_makeLiteral ("Cannot nest ignore regions."),
103	flagMarker_getLoc (fm));
104	llgenindentmsg
105	(cstring_makeLiteral ("Previous ignore region starts"),
106	flagMarker_getLoc (last));
107	}
108	}
109
110	flagMarker_free (fm);
111	return;
112	}
113	}
114	else
115	{
116	if (flagMarker_isIgnoreOff (last))
117	{
118	flagMarker nlast = s->elements [i - 1];
119
120	if (flagMarker_isIgnoreCount (nlast))
121	{
122	if (fileloc_sameFile (flagMarker_getLoc (fm),
123	flagMarker_getLoc (last))
124	&& fileloc_notAfter (flagMarker_getLoc (fm),
125	flagMarker_getLoc (last)))
126	{
127	if (flagMarker_isLocalSet (fm))
128	{
129	llforceerror
130	(FLG_WARNFLAGS,
131	cstring_makeLiteral ("Cannot set flag inside ignore "
132	"count region."),
133	flagMarker_getLoc (fm));
134	llgenindentmsg
135	(cstring_makeLiteral ("Ignore count region starts"),
136	flagMarker_getLoc (nlast));
137
138	}
139	else
140	{
141	if (flagMarker_isIgnoreOn (fm))
142	{
143	llforceerror
144	(FLG_WARNFLAGS,
145	cstring_makeLiteral ("Cannot nest ignore regions."),
146	flagMarker_getLoc (fm));
147	llgenindentmsg
148	(cstring_makeLiteral ("Previous ignore region starts"),
149	flagMarker_getLoc (nlast));
150	}
151	}
152
153	flagMarker_free (fm);
154	return;
155	}
156	}
157	}
158	}
159	}
160
161
162	/*
163	** all this code is necessary to check the invariant is preserved
164	*/
165
166	while (i > 0
167	&& !flagMarker_sameFile (s->elements[i],
168	flagMarker_getLoc (fm)))
169	{
170	i--;
171	}
172
173	/*
174	** reprocessing header file, okay to be out of order
175	*/
176
177	if (i >= 0 && !fileloc_isHeader (flagMarker_getLoc (fm)))
178	{
179
180	/*
181	llassert (!flagMarker_beforeMarker (s->elements[i],
182	flagMarker_getLoc (fm)));
183	*/
184	}
185
186	if (s->nspace <= 0)
187	{
188	flagMarkerList_grow (s);
189	}
190
191	s->nspace--;
192	s->elements[s->nelements] = fm;
193	s->nelements++;
194	}
195
196	void flagMarkerList_checkSuppressCounts (flagMarkerList s)
197	{
198	int nexpected = 0;
199	int nsuppressed = 0;
200	fileloc loc = fileloc_undefined;
201	bool inCount = FALSE;
202	int i;
203
204
205	for (i = 0; i < s->nelements; i++)
206	{
207	flagMarker current = s->elements[i];
208
209	if (flagMarker_isIgnoreCount (current))
210	{
211	llassert (!inCount);
212	inCount = TRUE;
213	nexpected = flagMarker_getCount (current);
214	loc = flagMarker_getLoc (current);
215	nsuppressed = 0;
216	}
217	else if (flagMarker_isIgnoreOff (current))
218	{
219	if (inCount)
220	{
221	inCount = FALSE;
222	llassert (fileloc_isDefined (loc));
223
224	if (nexpected > 0 && nexpected != nsuppressed)
225	{
226	llforceerror
227	(FLG_SUPCOUNTS,
228	message
229	("Line expects to suppress %d error%p, found %d error%p",
230	nexpected, nsuppressed),
231	loc);
232	}
233	}
234	}
235	else if (flagMarker_isSuppress (current))
236	{
237	nsuppressed++;
238	}
239	else
240	{
241	;
242	}
243	}
244
245	llassert (!inCount);
246	}
247
248	static void flagMarkerList_splice (flagMarkerList s,
249	int index,
250	/@keep@/ flagMarker fm)
251	{
252	fileloc loc = flagMarker_getLoc (fm);
253	fileloc beforeloc, afterloc;
254	int i;
255
256	llassert (index >= 0 && (index + 1 < s->nelements));
257
258	beforeloc = flagMarker_getLoc (s->elements[index]);
259	afterloc = flagMarker_getLoc (s->elements[index + 1]);;
260
261	llassert (fileloc_sameFile (beforeloc, loc));
262	llassert (fileloc_sameFile (afterloc, loc));
263
264	if (s->nspace <= 0)
265	{
266	flagMarkerList_grow (s);
267	}
268
269	for (i = s->nelements; i > index + 1; i--)
270	{
271	s->elements[i] = s->elements[i - 1];
272	}
273
274	s->elements[index + 1] = fm;
275	s->nelements++;
276	s->nspace--;
277
278	}
279
280	/@only@/ cstring
281	flagMarkerList_unparse (flagMarkerList s)
282	{
283	int i;
284	cstring st = cstring_makeLiteral ("[");
285
286	for (i = 0; i < s->nelements; i++)
287	{
288	if (i == 0)
289	{
290	st = message ("%q %q", st, flagMarker_unparse (s->elements[i]));
291	}
292	else
293	st = message ("%q, %q", st, flagMarker_unparse (s->elements[i]));
294	}
295
296	st = message ("%q ]", st);
297	return st;
298	}
299
300	void
301	flagMarkerList_free (flagMarkerList s)
302	{
303	int i;
304	for (i = 0; i < s->nelements; i++)
305	{
306	flagMarker_free (s->elements[i]);
307	}
308
309	sfree (s->elements);
310	sfree (s);
311	}
312
313	/*
314	** returns YES iff
315	** > in ignore region (there is an ignore ON marker not followed by OFF)
316	** > code is OFF (-)
317	**
318	** returns NO iff
319	** > not in ignore region
320	** > code is ON (+)
321	**
322	** returns MAYBE iff
323	** > not in ignore region
324	** > code is unset or =
325	**
326	** requires: invariant for flagMarkerList:
327	** flagMarker's are sorted by line and col
328	*/
329
330	static int
331	flagMarkerList_lastBeforeLoc (flagMarkerList s, fileloc loc)
332	{
333	int i;
334
335	for (i = s->nelements - 1; i >= 0; i--)
336	{
337	flagMarker current = s->elements[i];
338
339	if (fileloc_sameFile (current->loc, loc)
340	&& (!flagMarker_beforeMarker (current, loc)))
341	{
342	return i;
343	}
344	/*
345	if (flagMarker_sameFile (current, loc)
346	&& (!flagMarker_beforeMarker (current, loc)))
347	{
348	return i;
349	}
350	*/
351	}
352
353	return -1;
354	}
355
356	ynm
357	flagMarkerList_suppressError (flagMarkerList s, flagcode code, fileloc loc)
358	{
359	int i;
360	bool ignoreOff = FALSE;
361	bool nameChecksOff = FALSE;
362	bool flagOff = FALSE;
363	ynm flagSet = MAYBE;
364	bool islib = FALSE;
365	bool isNameChecksFlag = flagcode_isNameChecksFlag (code);
366
367	if (fileloc_isLib (loc))
368	{
369	i = s->nelements - 1;
370	islib = TRUE;
371	}
372	else
373	{
374	i = flagMarkerList_lastBeforeLoc (s, loc);
375	}
376
377
378	if (i < 0)
379	{
380	return MAYBE;
381	}
382
383	/*
384	** Go backwards through the remaining flagMarkers in this file.
385	*/
386
387	for (; i >= 0; i--)
388	{
389	flagMarker current = s->elements[i];
390
391
392	if (!islib && !flagMarker_sameFile (current, loc))
393	{
394	break;
395	}
396
397	if (flagMarker_isIgnoreOff (current))
398	{
399	ignoreOff = TRUE;
400	}
401	else if (flagMarker_isIgnoreOn (current))
402	{
403	if (!ignoreOff)
404	{
405	return YES;
406	}
407	}
408	else if (flagMarker_isIgnoreCount (current))
409	{
410	if (!ignoreOff)
411	{
412	flagMarkerList_splice (s, i,
413	flagMarker_createSuppress (code, loc));
414	return YES;
415	}
416	}
417	else if (flagMarker_isLocalSet (current))
418	{
419
420	if (!flagOff && flagMarker_getCode (current) == code)
421	{
422	ynm set = flagMarker_getSet (current);
423
424	if (ynm_isOff (set))
425	{
426	return YES;
427	}
428	else
429	{
430	if (ynm_isOn (set))
431	{
432	flagOff = TRUE;
433	flagSet = NO;
434	}
435	else
436	{
437	flagOff = TRUE;
438	flagSet = MAYBE;
439	}
440
441	if (ignoreOff)
442	{
443	if (isNameChecksFlag && !nameChecksOff)
444	{
445	;
446	}
447	else
448	{
449	return flagSet;
450	}
451	}
452	}
453	}
454
455	if (flagMarker_getCode (current) == FLG_NAMECHECKS
456	&& !nameChecksOff && isNameChecksFlag)
457	{
458	ynm set = flagMarker_getSet (current);
459
460	if (ynm_isOff (set))
461	{
462	return YES;
463	}
464	else
465	{
466	if (ynm_isOn (set))
467	{
468	nameChecksOff = TRUE;
469	flagSet = NO;
470	}
471	else
472	{
473	nameChecksOff = TRUE;
474	flagSet = MAYBE;
475	}
476
477	if (ignoreOff && flagOff)
478	{
479	return flagSet;
480	}
481	}
482	}
483	}
484	else
485	{
486	llassert (flagMarker_isSuppress (current));
487	}
488	}
489
490	return flagSet;
491	}
492
493	bool
494	flagMarkerList_inIgnore (flagMarkerList s, fileloc loc)
495	{
496	int i;
497
498	if (fileloc_isLib (loc))
499	{
500	return FALSE;
501	}
502
503	i = flagMarkerList_lastBeforeLoc (s, loc);
504
505	/*
506	** Go backwards through the remaining flagMarkers in this file.
507	*/
508
509	for (; i >= 0; i--)
510	{
511	flagMarker current = s->elements[i];
512
513	if (!flagMarker_sameFile (current, loc))
514	{
515	break;
516	}
517
518	if (flagMarker_isIgnoreOff (current))
519	{
520	return FALSE;;
521	}
522	else if (flagMarker_isIgnoreOn (current))
523	{
524	return TRUE;
525	}
526	else if (flagMarker_isIgnoreCount (current))
527	{
528	flagMarkerList_splice (s, i,
529	flagMarker_createSuppress (SKIP_FLAG, loc));
530	return TRUE;
531	}
532	else
533	{
534	llassert (flagMarker_isLocalSet (current)
535	\|\| flagMarker_isSuppress (current));
536	}
537	}
538
539	return FALSE;
540	}
541