[splint.git] / src / stateClauseList.c

/*
** LCLint - annotation-assisted static program checker
** Copyright (C) 1994-2001 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
*/
/*
** stateClauseList.c
*/

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

static /*@notnull@*/ stateClauseList stateClauseList_new (void)
{
  stateClauseList s = (stateClauseList) dmalloc (sizeof (*s));
  
  s->nelements = 0;
  s->nspace = stateClauseListBASESIZE;
  s->elements = (stateClause *) 
    dmalloc (sizeof (*s->elements) * stateClauseListBASESIZE);

  return (s);
}

static void
stateClauseList_grow (stateClauseList s)
{
  int i;
  stateClause *newelements;

  llassert (stateClauseList_isDefined (s));

  s->nspace += stateClauseListBASESIZE; 
  
  newelements = (stateClause *) 
    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;
}

stateClauseList stateClauseList_add (stateClauseList s, stateClause el)
{
  DPRINTF (("Adding: %s", stateClause_unparse (el)));

  if (stateClauseList_isUndefined (s))
    {
      s = stateClauseList_new ();
    }
  else
    {
      stateClauseList_elements (s, cl)
	{
	  if (stateClause_sameKind (cl, el))
	    {
	      voptgenerror
		(FLG_SYNTAX,
		 message ("Multiple %q clauses for one function (ignoring second)",
			  stateClause_unparseKind (cl)),
		 g_currentloc);

	      stateClause_free (el);
	      return s;
	    }
	} end_stateClauseList_elements ;
    }

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

  return s;
}

cstring stateClauseList_unparse (stateClauseList s)
{
  cstring st = cstring_undefined;
  int i;
  
  if (stateClauseList_isDefined (s))
    {
      for (i = 0; i < stateClauseList_size (s); i++)
	{
	  if (i == 0)
	    {
	      st = message ("%q;", stateClause_unparse (s->elements[i]));
	    }
	  else
	    st = message ("%q %q;", st, stateClause_unparse (s->elements[i]));
	}
    }
  
  return (st);
}

stateClauseList stateClauseList_copy (stateClauseList s)
{
  if (stateClauseList_isDefined (s))
    {
      stateClauseList t = (stateClauseList) dmalloc (sizeof (*t));
      int i;
      
      t->nelements = s->nelements;
      t->nspace = 0;
      
      if (s->nelements > 0)
	{
	  t->elements = (stateClause *) dmalloc (sizeof (*t->elements) * t->nelements);
	  for (i = 0; i < s->nelements; i++) 
	    {
	      t->elements[i] = stateClause_copy (s->elements[i]); 
	    }
	}
      else
	{
	  t->elements = NULL;
	}

      return t;
    }
  else
    {
      return stateClauseList_undefined;
    }
}

void
stateClauseList_free (stateClauseList s)
{
  if (!stateClauseList_isUndefined (s)) 
    {
      int i;

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

      sfree (s->elements);
      sfree (s);
    }
}

cstring stateClauseList_dump (stateClauseList s)
{
  cstring st = cstring_undefined;

  if (stateClauseList_isUndefined (s)) return st;
  
  stateClauseList_elements (s, current)
    {
      st = message ("%q%q$", st, stateClause_dump (current));
    } end_stateClauseList_elements;

  return st;
}

stateClauseList stateClauseList_undump (char **s)
{
  char c;
  stateClauseList pn = stateClauseList_new ();
  int paramno = 0;

  c = **s;

  while (c != '#' && c != '@')
    {
      stateClause sc = stateClause_undump (s);
      
      pn = stateClauseList_add (pn, sc);
      reader_checkChar (s, '$');
      c = **s;
      paramno++;
    }

  return pn;
}

int stateClauseList_compare (stateClauseList s1, stateClauseList s2)
{
  if (stateClauseList_isUndefined (s1)
      && stateClauseList_isUndefined (s2))
    {
      return 0;
    }
  else
    {
      if ((int) s1 > (int) s2) 
	{
	  return 1;
	}
      else
	{
	  return -1;
	}
    }
}
  
static /*@exposed@*/ sRefSet
stateClauseList_getClause (stateClauseList s, stateClause k)
{
  stateClauseList_elements (s, el)
    {
      if (stateClause_matchKind (el, k))
	{
	  return stateClause_getRefs (el);
	}
    } end_stateClauseList_elements ;

  return sRefSet_undefined;
}

void stateClauseList_checkAll (uentry ue)
{
  stateClauseList clauses = uentry_getStateClauseList (ue);
  sRef res = uentry_getSref (ue);		  
  bool specialResult = FALSE;

  DPRINTF (("Check state clauses: %s", uentry_unparseFull (ue)));

  stateClauseList_elements (clauses, cl)
    {
      bool isPre = stateClause_isBeforeOnly (cl);

      if (stateClause_isGlobal (cl))
	{
	  /*@i232@*/
	}
      else
	{
	  sRefSet refs = stateClause_getRefs (cl);
	  
	  sRefSet_allElements (refs, el)
	    {
	      sRef rb = sRef_getRootBase (el);

	      DPRINTF (("Check: %s", sRef_unparse (el)));
	      
	      if (stateClause_setsMetaState (cl))
		{
		  qual q = stateClause_getMetaQual (cl);
		  annotationInfo qa = qual_getAnnotationInfo (q);

		  if (!annotationInfo_matchesContextRef (qa, el))
		    {
		      if (optgenerror
			  (FLG_ANNOTATIONERROR,
			   message ("Meta state anntation %s used on inappropriate reference %q in %q clause of %q: %q",
				    qual_unparse (q),
				    sRef_unparse (el),
				    stateClause_unparseKind (cl),
				    uentry_getName (ue),
				    stateClause_unparse (cl)),
			   uentry_whereLast (ue)))
			{
			  /*@i! annotationInfo_showContextError (ainfo, ue); */
			}
		    }
		}

	      if (sRef_isResult (rb))
		{
		  if (isPre)
		    {
		      voptgenerror
			(FLG_INCONDEFS,
			 message ("Function result is used in %q clause of %q "
				  "(%q applies to the state before function is "
				  "called, so should not use result): %q",
				  stateClause_unparseKind (cl),
				  uentry_getName (ue),
				  stateClause_unparseKind (cl),
				  sRef_unparse (el)),
			 uentry_whereLast (ue));
		    }
		  else
		    {
		      if (!sRef_isStateSpecial (res))
			{
			  if (!specialResult)
			    {
			      sstate pstate = sRef_getDefState (res);
			      
			      if (!sRef_makeStateSpecial (res))
				{
				  voptgenerror
				    (FLG_INCONDEFS,
				     message ("Function result is used in %q clause of %q "
					      "but was previously annotated with %s: %q",
					      stateClause_unparseKind (cl),
					      uentry_getName (ue),
					      sstate_unparse (pstate),
					      sRef_unparse (el)),
				     uentry_whereLast (ue));
				}
			      
			      specialResult = TRUE;
			    }
			}
		      
		      (void) sRef_fixResultType (el, sRef_getType (res), ue);
		    }
		}
	      else if (sRef_isParam (rb))
		{
		  DPRINTF (("Make special: %s", sRef_unparseFull (rb)));
		  
		  if (!sRef_makeStateSpecial (rb))
		    {
		      if (fileloc_isXHFile (uentry_whereLast (ue)))
			{
			  ; /* Okay to override in .xh files */
			}
		      else
			{
			  voptgenerror 
			    (FLG_INCONDEFS,
			     message ("Reference %q used in %q clause of %q, "
				      "but was previously annotated with %s: %q",
				      sRef_unparse (rb),
				      stateClause_unparseKind (cl),
				      uentry_getName (ue),
				      sstate_unparse (sRef_getDefState (res)),
				      sRef_unparse (el)),
			     uentry_whereLast (ue));
			}
		    }
		  
		  DPRINTF (("Made special: %s", sRef_unparseFull (rb)));
		}
	      else if (sRef_isInvalid (rb))
		{
		  /*@innercontinue@*/ continue;
		}
	      else 
		{
		  BADBRANCHCONT;
		  /*@innercontinue@*/ continue;
		}
	      
	      if (stateClause_isMemoryAllocation (cl))
		{
		  if (!ctype_isVisiblySharable (sRef_getType (el)))
		    {
		      voptgenerror
			(FLG_ANNOTATIONERROR,
			 /*@-sefparams@*/ /* This is okay because its fresh storage. */ /*@i32@*/
			 message 
			 ("%q clauses includes %q of "
			  "non-dynamically allocated type %s",
			  cstring_capitalizeFree (stateClause_unparseKind (cl)),
			  sRef_unparse (el), 
			  ctype_unparse (sRef_getType (el))),
			 uentry_whereLast (ue));
		      /*@=sefparams@*/
		    }
		}
	      
	    } end_sRefSet_allElements ;
	}
    } end_stateClauseList_elements ;
}
  
void stateClauseList_checkEqual (uentry old, uentry unew)
{
  stateClauseList oldClauses = uentry_getStateClauseList (old);
  stateClauseList newClauses = uentry_getStateClauseList (unew);

  if (stateClauseList_isDefined (newClauses))
    {
      stateClauseList_elements (newClauses, cl)
	{
	  if (stateClause_isGlobal (cl))
	    {
	      ;
	    }
	  else
	    {
	      sRefSet sc = stateClauseList_getClause (oldClauses, cl);
	      
	      if (!sRefSet_equal (sc, stateClause_getRefs (cl)))
		{
		  if (optgenerror
		      (FLG_INCONDEFS,
		       message ("Function %q %rdeclared with inconsistent %q clause: %q",
				uentry_getName (old),
				uentry_isDeclared (old),
				stateClause_unparseKind (cl),
				sRefSet_unparsePlain (stateClause_getRefs (cl))),
		       g_currentloc))
		    {
		      uentry_showWhereLastExtra (old, sRefSet_unparsePlain (sc));
		    }
		}
	    }
	} end_stateClauseList_elements ;
	
      stateClauseList_elements (oldClauses, cl)
	{
	  if (stateClause_isGlobal (cl))
	    {
	      ; /*@i32@*/ 
	    }
	  else
	    {
	      sRefSet sc = stateClauseList_getClause (newClauses, cl);
	      
	      if (sRefSet_isUndefined (sc) && !sRefSet_isEmpty (stateClause_getRefs (cl)))
		{
		  if (optgenerror
		      (FLG_INCONDEFS,
		       message ("Function %q %rdeclared without %q clause (either "
				"use no special clauses in redeclaration, or "
				"they must match exactly: %q",
				uentry_getName (old),
				uentry_isDeclared (old),
				stateClause_unparseKind (cl),
				sRefSet_unparsePlain (stateClause_getRefs (cl))),
		       g_currentloc))
		    {
		      uentry_showWhereLastExtra (old, sRefSet_unparsePlain (sc));
		    }
		}
	    }
	} end_stateClauseList_elements ;
    }
}
Commit	Line	Data
28bf4b0b	1	/*
	2	** LCLint - annotation-assisted static program checker
	3	** Copyright (C) 1994-2001 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	** stateClauseList.c
	26	*/
	27
	28	# include "lclintMacros.nf"
	29	# include "basic.h"
	30
	31	static /@notnull@/ stateClauseList stateClauseList_new (void)
	32	{
	33	stateClauseList s = (stateClauseList) dmalloc (sizeof (*s));
	34
	35	s->nelements = 0;
	36	s->nspace = stateClauseListBASESIZE;
	37	s->elements = (stateClause *)
	38	dmalloc (sizeof (s->elements) stateClauseListBASESIZE);
	39
	40	return (s);
	41	}
	42
	43	static void
	44	stateClauseList_grow (stateClauseList s)
	45	{
	46	int i;
	47	stateClause *newelements;
	48
	49	llassert (stateClauseList_isDefined (s));
	50
	51	s->nspace += stateClauseListBASESIZE;
	52
	53	newelements = (stateClause *)
	54	dmalloc (sizeof (newelements) (s->nelements + s->nspace));
	55
	56	for (i = 0; i < s->nelements; i++)
	57	{
	58	newelements[i] = s->elements[i];
	59	}
	60
	61	sfree (s->elements);
	62	s->elements = newelements;
	63	}
	64
65	stateClauseList stateClauseList_add (stateClauseList s, stateClause el)
66	{
67	DPRINTF (("Adding: %s", stateClause_unparse (el)));
68
69	if (stateClauseList_isUndefined (s))
70	{
71	s = stateClauseList_new ();
72	}
73	else
74	{
75	stateClauseList_elements (s, cl)
76	{
77	if (stateClause_sameKind (cl, el))
78	{
79	voptgenerror
80	(FLG_SYNTAX,
81	message ("Multiple %q clauses for one function (ignoring second)",
82	stateClause_unparseKind (cl)),
83	g_currentloc);
84
85	stateClause_free (el);
86	return s;
87	}
88	} end_stateClauseList_elements ;
89	}
90
91	if (s->nspace <= 0)
92	{
93	stateClauseList_grow (s);
94	}
95
96	s->nspace--;
97	s->elements[s->nelements] = el;
98	s->nelements++;
99
100	return s;
101	}
102
103	cstring stateClauseList_unparse (stateClauseList s)
104	{
105	cstring st = cstring_undefined;
106	int i;
107
108	if (stateClauseList_isDefined (s))
109	{
110	for (i = 0; i < stateClauseList_size (s); i++)
111	{
112	if (i == 0)
113	{
114	st = message ("%q;", stateClause_unparse (s->elements[i]));
115	}
116	else
117	st = message ("%q %q;", st, stateClause_unparse (s->elements[i]));
118	}
119	}
120
121	return (st);
122	}
123
124	stateClauseList stateClauseList_copy (stateClauseList s)
125	{
126	if (stateClauseList_isDefined (s))
127	{
128	stateClauseList t = (stateClauseList) dmalloc (sizeof (*t));
129	int i;
130
131	t->nelements = s->nelements;
132	t->nspace = 0;
133
134	if (s->nelements > 0)
135	{
136	t->elements = (stateClause ) dmalloc (sizeof (t->elements) * t->nelements);
137	for (i = 0; i < s->nelements; i++)
138	{
139	t->elements[i] = stateClause_copy (s->elements[i]);
140	}
141	}
142	else
143	{
144	t->elements = NULL;
145	}
146
147	return t;
148	}
149	else
150	{
151	return stateClauseList_undefined;
152	}
153	}
154
155	void
156	stateClauseList_free (stateClauseList s)
157	{
158	if (!stateClauseList_isUndefined (s))
159	{
160	int i;
161
162	for (i = 0; i < s->nelements; i++)
163	{
164	stateClause_free (s->elements[i]);
165	}
166
167	sfree (s->elements);
168	sfree (s);
169	}
170	}
171
172	cstring stateClauseList_dump (stateClauseList s)
173	{
174	cstring st = cstring_undefined;
175
176	if (stateClauseList_isUndefined (s)) return st;
177
178	stateClauseList_elements (s, current)
179	{
180	st = message ("%q%q$", st, stateClause_dump (current));
181	} end_stateClauseList_elements;
182
183	return st;
184	}
185
186	stateClauseList stateClauseList_undump (char **s)
187	{
188	char c;
189	stateClauseList pn = stateClauseList_new ();
190	int paramno = 0;
191
192	c = **s;
193
194	while (c != '#' && c != '@')
195	{
196	stateClause sc = stateClause_undump (s);
197
198	pn = stateClauseList_add (pn, sc);
199	reader_checkChar (s, '$');
200	c = **s;
201	paramno++;
202	}
203
204	return pn;
205	}
206
207	int stateClauseList_compare (stateClauseList s1, stateClauseList s2)
208	{
209	if (stateClauseList_isUndefined (s1)
210	&& stateClauseList_isUndefined (s2))
211	{
212	return 0;
213	}
214	else
215	{
216	if ((int) s1 > (int) s2)
217	{
218	return 1;
219	}
220	else
221	{
222	return -1;
223	}
224	}
225	}
226
227	static /@exposed@/ sRefSet
228	stateClauseList_getClause (stateClauseList s, stateClause k)
229	{
230	stateClauseList_elements (s, el)
231	{
232	if (stateClause_matchKind (el, k))
233	{
234	return stateClause_getRefs (el);
235	}
236	} end_stateClauseList_elements ;
237
238	return sRefSet_undefined;
239	}
240
241	void stateClauseList_checkAll (uentry ue)
242	{
243	stateClauseList clauses = uentry_getStateClauseList (ue);
244	sRef res = uentry_getSref (ue);
245	bool specialResult = FALSE;
246
247	DPRINTF (("Check state clauses: %s", uentry_unparseFull (ue)));
248
249	stateClauseList_elements (clauses, cl)
250	{
251	bool isPre = stateClause_isBeforeOnly (cl);
252
253	if (stateClause_isGlobal (cl))
254	{
255	/@i232@/
256	}
257	else
258	{
259	sRefSet refs = stateClause_getRefs (cl);
260
261	sRefSet_allElements (refs, el)
262	{
263	sRef rb = sRef_getRootBase (el);
264
265	DPRINTF (("Check: %s", sRef_unparse (el)));
266
267	if (stateClause_setsMetaState (cl))
268	{
269	qual q = stateClause_getMetaQual (cl);
270	annotationInfo qa = qual_getAnnotationInfo (q);
271
272	if (!annotationInfo_matchesContextRef (qa, el))
273	{
274	if (optgenerror
275	(FLG_ANNOTATIONERROR,
276	message ("Meta state anntation %s used on inappropriate reference %q in %q clause of %q: %q",
277	qual_unparse (q),
278	sRef_unparse (el),
279	stateClause_unparseKind (cl),
280	uentry_getName (ue),
281	stateClause_unparse (cl)),
282	uentry_whereLast (ue)))
283	{
284	/@i! annotationInfo_showContextError (ainfo, ue); /
285	}
286	}
287	}
288
289	if (sRef_isResult (rb))
290	{
291	if (isPre)
292	{
293	voptgenerror
294	(FLG_INCONDEFS,
295	message ("Function result is used in %q clause of %q "
296	"(%q applies to the state before function is "
297	"called, so should not use result): %q",
298	stateClause_unparseKind (cl),
299	uentry_getName (ue),
300	stateClause_unparseKind (cl),
301	sRef_unparse (el)),
302	uentry_whereLast (ue));
303	}
304	else
305	{
306	if (!sRef_isStateSpecial (res))
307	{
308	if (!specialResult)
309	{
310	sstate pstate = sRef_getDefState (res);
311
312	if (!sRef_makeStateSpecial (res))
313	{
314	voptgenerror
315	(FLG_INCONDEFS,
316	message ("Function result is used in %q clause of %q "
317	"but was previously annotated with %s: %q",
318	stateClause_unparseKind (cl),
319	uentry_getName (ue),
320	sstate_unparse (pstate),
321	sRef_unparse (el)),
322	uentry_whereLast (ue));
323	}
324
325	specialResult = TRUE;
326	}
327	}
328
329	(void) sRef_fixResultType (el, sRef_getType (res), ue);
330	}
331	}
332	else if (sRef_isParam (rb))
333	{
334	DPRINTF (("Make special: %s", sRef_unparseFull (rb)));
335
336	if (!sRef_makeStateSpecial (rb))
337	{
338	if (fileloc_isXHFile (uentry_whereLast (ue)))
339	{
340	; /* Okay to override in .xh files */
341	}
342	else
343	{
344	voptgenerror
345	(FLG_INCONDEFS,
346	message ("Reference %q used in %q clause of %q, "
347	"but was previously annotated with %s: %q",
348	sRef_unparse (rb),
349	stateClause_unparseKind (cl),
350	uentry_getName (ue),
351	sstate_unparse (sRef_getDefState (res)),
352	sRef_unparse (el)),
353	uentry_whereLast (ue));
354	}
355	}
356
357	DPRINTF (("Made special: %s", sRef_unparseFull (rb)));
358	}
359	else if (sRef_isInvalid (rb))
360	{
361	/@innercontinue@/ continue;
362	}
363	else
364	{
365	BADBRANCHCONT;
366	/@innercontinue@/ continue;
367	}
368
369	if (stateClause_isMemoryAllocation (cl))
370	{
371	if (!ctype_isVisiblySharable (sRef_getType (el)))
372	{
373	voptgenerror
374	(FLG_ANNOTATIONERROR,
375	/@-sefparams@/ /* This is okay because its fresh storage. / /@i32@*/
376	message
377	("%q clauses includes %q of "
378	"non-dynamically allocated type %s",
379	cstring_capitalizeFree (stateClause_unparseKind (cl)),
380	sRef_unparse (el),
381	ctype_unparse (sRef_getType (el))),
382	uentry_whereLast (ue));
383	/@=sefparams@/
384	}
385	}
386
387	} end_sRefSet_allElements ;
388	}
389	} end_stateClauseList_elements ;
390	}
391
392	void stateClauseList_checkEqual (uentry old, uentry unew)
393	{
394	stateClauseList oldClauses = uentry_getStateClauseList (old);
395	stateClauseList newClauses = uentry_getStateClauseList (unew);
396
397	if (stateClauseList_isDefined (newClauses))
398	{
399	stateClauseList_elements (newClauses, cl)
400	{
401	if (stateClause_isGlobal (cl))
402	{
403	;
404	}
405	else
406	{
407	sRefSet sc = stateClauseList_getClause (oldClauses, cl);
408
409	if (!sRefSet_equal (sc, stateClause_getRefs (cl)))
410	{
411	if (optgenerror
412	(FLG_INCONDEFS,
413	message ("Function %q %rdeclared with inconsistent %q clause: %q",
414	uentry_getName (old),
415	uentry_isDeclared (old),
416	stateClause_unparseKind (cl),
417	sRefSet_unparsePlain (stateClause_getRefs (cl))),
418	g_currentloc))
419	{
420	uentry_showWhereLastExtra (old, sRefSet_unparsePlain (sc));
421	}
422	}
423	}
424	} end_stateClauseList_elements ;
425
426	stateClauseList_elements (oldClauses, cl)
427	{
428	if (stateClause_isGlobal (cl))
429	{
430	; /@i32@/
431	}
432	else
433	{
434	sRefSet sc = stateClauseList_getClause (newClauses, cl);
435
436	if (sRefSet_isUndefined (sc) && !sRefSet_isEmpty (stateClause_getRefs (cl)))
437	{
438	if (optgenerror
439	(FLG_INCONDEFS,
440	message ("Function %q %rdeclared without %q clause (either "
441	"use no special clauses in redeclaration, or "
442	"they must match exactly: %q",
443	uentry_getName (old),
444	uentry_isDeclared (old),
445	stateClause_unparseKind (cl),
446	sRefSet_unparsePlain (stateClause_getRefs (cl))),
447	g_currentloc))
448	{
449	uentry_showWhereLastExtra (old, sRefSet_unparsePlain (sc));
450	}
451	}
452	}
453	} end_stateClauseList_elements ;
454	}
455	}
456
457
458