[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 annotation %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))
			{
			  DPRINTF (("Here we are: %s", sRef_unparseFull (res)));

			  if (!specialResult)
			    {
			      sstate pstate = sRef_getDefState (res);
			      
			      if (!sRef_makeStateSpecial (res))
				{
				  if (optgenerror
				      (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;
				    }
				}			      
			    }
			}
		      
		      DPRINTF (("Fixing result type! %s", sRef_unparseFull (el)));
		      (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,
6970c11b	276	message ("Meta state annotation %s used on inappropriate reference %q in %q clause of %q: %q",
28bf4b0b	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	{
ccf0a4a8	308	DPRINTF (("Here we are: %s", sRef_unparseFull (res)));
ccf0a4a8	309
28bf4b0b	310	if (!specialResult)
	311	{
	312	sstate pstate = sRef_getDefState (res);
	313
	314	if (!sRef_makeStateSpecial (res))
	315	{
ccf0a4a8	316	if (optgenerror
	317	(FLG_INCONDEFS,
	318	message ("Function result is used in %q clause of %q "
	319	"but was previously annotated with %s: %q",
	320	stateClause_unparseKind (cl),
	321	uentry_getName (ue),
	322	sstate_unparse (pstate),
	323	sRef_unparse (el)),
	324	uentry_whereLast (ue)))
	325	{
	326	specialResult = TRUE;
	327	}
	328	}
28bf4b0b	329	}
	330	}
	331
ccf0a4a8	332	DPRINTF (("Fixing result type! %s", sRef_unparseFull (el)));
28bf4b0b	333	(void) sRef_fixResultType (el, sRef_getType (res), ue);
	334	}
	335	}
	336	else if (sRef_isParam (rb))
	337	{
	338	DPRINTF (("Make special: %s", sRef_unparseFull (rb)));
	339
	340	if (!sRef_makeStateSpecial (rb))
	341	{
	342	if (fileloc_isXHFile (uentry_whereLast (ue)))
	343	{
	344	; /* Okay to override in .xh files */
	345	}
	346	else
	347	{
	348	voptgenerror
	349	(FLG_INCONDEFS,
	350	message ("Reference %q used in %q clause of %q, "
	351	"but was previously annotated with %s: %q",
	352	sRef_unparse (rb),
	353	stateClause_unparseKind (cl),
	354	uentry_getName (ue),
	355	sstate_unparse (sRef_getDefState (res)),
	356	sRef_unparse (el)),
	357	uentry_whereLast (ue));
	358	}
	359	}
	360
	361	DPRINTF (("Made special: %s", sRef_unparseFull (rb)));
	362	}
	363	else if (sRef_isInvalid (rb))
	364	{
	365	/@innercontinue@/ continue;
	366	}
	367	else
	368	{
	369	BADBRANCHCONT;
	370	/@innercontinue@/ continue;
	371	}
	372
	373	if (stateClause_isMemoryAllocation (cl))
	374	{
	375	if (!ctype_isVisiblySharable (sRef_getType (el)))
	376	{
	377	voptgenerror
	378	(FLG_ANNOTATIONERROR,
	379	/@-sefparams@/ /* This is okay because its fresh storage. / /@i32@*/
	380	message
	381	("%q clauses includes %q of "
	382	"non-dynamically allocated type %s",
	383	cstring_capitalizeFree (stateClause_unparseKind (cl)),
	384	sRef_unparse (el),
	385	ctype_unparse (sRef_getType (el))),
	386	uentry_whereLast (ue));
	387	/@=sefparams@/
	388	}
	389	}
	390
	391	} end_sRefSet_allElements ;
	392	}
	393	} end_stateClauseList_elements ;
	394	}
	395
	396	void stateClauseList_checkEqual (uentry old, uentry unew)
397	{
398	stateClauseList oldClauses = uentry_getStateClauseList (old);
399	stateClauseList newClauses = uentry_getStateClauseList (unew);
400
401	if (stateClauseList_isDefined (newClauses))
402	{
403	stateClauseList_elements (newClauses, cl)
404	{
405	if (stateClause_isGlobal (cl))
406	{
407	;
408	}
409	else
410	{
411	sRefSet sc = stateClauseList_getClause (oldClauses, cl);
412
413	if (!sRefSet_equal (sc, stateClause_getRefs (cl)))
414	{
415	if (optgenerror
416	(FLG_INCONDEFS,
417	message ("Function %q %rdeclared with inconsistent %q clause: %q",
418	uentry_getName (old),
419	uentry_isDeclared (old),
420	stateClause_unparseKind (cl),
421	sRefSet_unparsePlain (stateClause_getRefs (cl))),
422	g_currentloc))
423	{
424	uentry_showWhereLastExtra (old, sRefSet_unparsePlain (sc));
425	}
426	}
427	}
428	} end_stateClauseList_elements ;
429
430	stateClauseList_elements (oldClauses, cl)
431	{
432	if (stateClause_isGlobal (cl))
433	{
434	; /@i32@/
435	}
436	else
437	{
438	sRefSet sc = stateClauseList_getClause (newClauses, cl);
439
440	if (sRefSet_isUndefined (sc) && !sRefSet_isEmpty (stateClause_getRefs (cl)))
441	{
442	if (optgenerror
443	(FLG_INCONDEFS,
444	message ("Function %q %rdeclared without %q clause (either "
445	"use no special clauses in redeclaration, or "
446	"they must match exactly: %q",
447	uentry_getName (old),
448	uentry_isDeclared (old),
449	stateClause_unparseKind (cl),
450	sRefSet_unparsePlain (stateClause_getRefs (cl))),
451	g_currentloc))
452	{
453	uentry_showWhereLastExtra (old, sRefSet_unparsePlain (sc));
454	}
455	}
456	}
457	} end_stateClauseList_elements ;
458	}
459	}
460
461
462