Merged this branch with the one in the splint.sf.net repository.

[splint.git] / src / idDecl.c

/*
** Splint - annotation-assisted static program checker
** Copyright (C) 1994-2002 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 splint: info@splint.org
** To report a bug: splint-bug@splint.org
** For more information: http://www.splint.org
*/
/*
** idDecl.c
*/

# include "splintMacros.nf"
# include "basic.h"

/*@only@*/ idDecl
  idDecl_createClauses (/*@only@*/ cstring s, /*@only@*/ qtype t, /*@only@*/ functionClauseList clauses)
{
  idDecl d = (idDecl) dmalloc (sizeof (*d));

  d->id = s;
  d->typ = t;
  d->clauses = clauses;

  return (d);
}

/*@only@*/ idDecl
  idDecl_create (/*@only@*/ cstring s, /*@only@*/ qtype t)
{
  return idDecl_createClauses (s, t, functionClauseList_undefined);
}

void
idDecl_free (idDecl t)
{
  if (idDecl_isDefined (t))
    {
      /*@i523 functionClauseList_free (t->clauses); */ /* evans 2002-01-03: splint catches this now! */
      qtype_free (t->typ);
      cstring_free (t->id);

      /*@-compdestroy@*/ sfree (t); /*@=compdestroy@*/
    }
}

cstring
idDecl_unparse (idDecl d)
{
  if (idDecl_isDefined (d))
    {
      if (functionClauseList_isDefined (d->clauses)) 
	{
	  return (message ("%s : %q / %q", d->id, qtype_unparse (d->typ),
			   functionClauseList_unparse (d->clauses)));
	}
      else
	{
	  return (message ("%s : %q", d->id, qtype_unparse (d->typ)));
	}
    }
  else
    {
      return (cstring_makeLiteral ("<undefined id>"));
    }
}

/*drl added 04-22-2002
  for code generate code
*/

cstring
idDecl_unparseCNoType (idDecl d)
{

  if (ctype_isFunction ( qtype_getType (d->typ ) ) )
    {

      return idDecl_unparseC(d);
    }
  if (idDecl_isDefined (d))
    {
      return (message ("%s", d->id));
    }
  else
    {
      llassert(FALSE);
      return (cstring_makeLiteral ("<undefined id>"));
    }
}

cstring
idDecl_unparseC (idDecl d)
{
  if (idDecl_isDefined (d))
    {
      if (qtype_isFixedArray(d->typ) )
	{
	  cstring ret, arType, size;
	  
	  arType = qtype_unparseArrayType(d->typ);
	  size   = qtype_unparseArraySize(d->typ);
	  ret    = message ("%q %s %q", arType, d->id, size);
	  return ret;
	}
      else if (qtype_isArray(d->typ) )
	{
	  cstring ret, arType;
	  
	  arType = qtype_unparseArrayType(d->typ);
	  ret    = message ("%q %s[]", arType, d->id);
	  return ret;
	}
      
      else if (ctype_isFunction ( qtype_getType (d->typ ) ) )
	{
	  cstring st, tmp, cQuals, ret;
	  
	  st = cstring_copy (d->id);
	  tmp =  ctype_unparseFunction ( qtype_getType (d->typ ), st);
	  if ( qualList_isDefined(idDecl_getQuals (d) ) )
	    {
	      cQuals = qualList_unparse(idDecl_getQuals(d) );
	    }
	  else
	    {
	      cQuals = cstring_undefined;
	    }
	  
	  ret = message("%q %q", cQuals, tmp);
	  return ret;
	}
      else
	{
	  uentry ue;
	  fileloc loc;
	  typeId tId;

	  tId = ctype_typeId(qtype_getType(d->typ) );

	  ue = usymtab_getTypeEntry (tId);
	  
	  loc = uentry_whereDeclared(ue) ;
	  
	  DPRINTF(( message("id = %s ue: %s at %s", d->id, uentry_unparse(ue), fileloc_unparse(loc) ) ));
	  return (message ("%q %s", qtypetryToPrintStruct (d->typ), d->id));
	}
    }
  else
    {
      return (cstring_makeLiteral ("<undefined id>"));
    }
}


/*drl added 04-24-2002*/
cstring
idDecl_unparseCLoc (idDecl d, fileloc dLoc)
{
  if (idDecl_isDefined (d))
    {
      if (qtype_isFixedArray(d->typ) )
	{
	  cstring ret, arType, size;
	  
	  arType = qtype_unparseArrayType(d->typ);
	  size   = qtype_unparseArraySize(d->typ);
	  ret    = message ("%q %s %q", arType, d->id, size);
	  return ret;
	}
      else if (qtype_isArray(d->typ) )
	{
	  cstring ret, arType;
	  
	  arType = qtype_unparseArrayType(d->typ);
	  ret    = message ("%q %s[]", arType, d->id);
	  return ret;
	}
      else if (ctype_isFunctionPointer ( qtype_getType (d->typ ) ) )
	{
	  cstring st, tmp, cQuals, ret;
	  
	  st = cstring_copy (d->id);
	 	  
	  if ( qualList_isDefined(idDecl_getQuals (d) ) )
	    {
	      cQuals = qualList_unparse(idDecl_getQuals(d) );
	    }
	  else
	    {
	      cQuals = cstring_undefined;
	    }
	  
	  tmp = ctype_unparseFunctionPointer ( qtype_getType (d->typ ), cQuals, st);
 
	  ret = message("%q", tmp);
	  cstring_free(cQuals);
	  return ret;
	}
      else if (ctype_isFunction ( qtype_getType (d->typ ) ) )
	{
	  cstring st, tmp, cQuals, ret;
	  
	  st = cstring_copy (d->id);
	  tmp =  ctype_unparseFunction ( qtype_getType (d->typ ), st);
	  if ( qualList_isDefined(idDecl_getQuals (d) ) )
	    {
	      cQuals = qualList_unparse(idDecl_getQuals(d) );
	    }
	  else
	    {
	      cQuals = cstring_undefined;
	    }
	  
	  ret = message("%q %q", cQuals, tmp);
	  return ret;
	}
      else
	{
	  uentry ue;
	  fileloc loc;
	  typeId tId;

	  if (ctype_isUser(qtype_getType(d->typ) ) )
	    {
	      tId = ctype_typeId(qtype_getType(d->typ) );

	      ue = usymtab_getTypeEntry (tId);
	      
	      loc = uentry_whereDeclared(ue) ;
	      
	      DPRINTF(( message("id = %s ue: %s at %s", d->id, uentry_unparse(ue), fileloc_unparse(loc) ) ));
	      
	      if (fileloc_sameFileAndLine (loc, dLoc) )
		return (message ("%q %s", qtypetryToPrintStruct (d->typ), d->id));
	    }
	  
	  return (message ("%s %s", qtype_unparse (d->typ), d->id));
	  
	} /*end if (ctype_isFunction ...*/
    }
  else
    {
      return (cstring_makeLiteral ("<undefined id>"));
    }
}


/*@observer@*/ cstring
idDecl_observeId (idDecl d)
{
  if (idDecl_isDefined (d))
    {
      return (d->id);
    }
  else
    {
      return cstring_undefined;
    }
}

qtype
idDecl_getTyp (idDecl d)
{
  llassert (idDecl_isDefined (d));

  return d->typ;
}

ctype
idDecl_getCtype (idDecl d)
{
  if (idDecl_isDefined (d))
    {
      return (qtype_getType (d->typ));
    }
  else
    {
      return ctype_unknown;
    }
}

qualList
idDecl_getQuals (idDecl d)
{
  if (idDecl_isDefined (d))
    {
      return (qtype_getQuals (d->typ));
    }
  else
    {
      return qualList_undefined;
    }
}

functionClauseList
idDecl_getClauses (idDecl d)
{
  if (idDecl_isDefined (d))
    {
      return (d->clauses);
    }
  else
    {
      return functionClauseList_undefined;
    }
}

void
idDecl_addQual (idDecl d, qual q)
{
  llassert (idDecl_isDefined (d));

  (void) qtype_addQual (d->typ, q);
}

void
idDecl_setTyp (idDecl d, qtype c)
{
  llassert (idDecl_isDefined (d));

  qtype_free (d->typ);
  d->typ = c;
}

idDecl
idDecl_replaceCtype (/*@returned@*/ idDecl d, ctype c)
{
  llassert (idDecl_isDefined (d));

  DPRINTF (("Replace type: %s / %s", idDecl_unparse (d), ctype_unparse (c)));
  qtype_setType (d->typ, c);
  return d;
}

idDecl
idDecl_fixBase (/*@returned@*/ idDecl t, qtype b)
{
  llassert (idDecl_isDefined (t));

  t->typ = qtype_newQbase (t->typ, b);
  return t;
}

idDecl
idDecl_fixParamBase (/*@returned@*/ idDecl t, qtype b)
{
  qtype q;
  ctype c;

  llassert (idDecl_isDefined (t));

  q = qtype_newQbase (t->typ, b);
  c = qtype_getType (q);

  /*
  ** For some reason, C adds an implicit pointer to function
  ** parameters.  It is "optional" syntax.
  */

  if (ctype_isFunction (c) && !ctype_isPointer (c))
    {
      qtype_setType (q, ctype_makePointer (c));
    }

  t->typ = q;
  /* Splint thinks t->typ is kept. */
  /*@-compmempass@*/ return t; /*@=compmempass@*/
}

idDecl
idDecl_expectFunction (/*@returned@*/ idDecl d)
{
  llassert (idDecl_isDefined (d));

  qtype_setType (d->typ, ctype_expectFunction (qtype_getType (d->typ)));
  return d;
}

/*
** evans 2002-02-09: This is a bit of a kludge, but we 
** need it to fix declarations like int (*p)[];
*/

void
idDecl_notExpectingFunction (/*@returned@*/ idDecl d)
{
  if (idDecl_isDefined (d)) 
    {
      ctype ct = qtype_getType (d->typ);

      if (ctype_isExpFcn (ct))
	{
	  qtype_setType (d->typ, ctype_dontExpectFunction (ct));
	}
    }
}

void
idDecl_addClauses (idDecl d, functionClauseList clauses)
{
  llassert (idDecl_isDefined (d));
  llassert (functionClauseList_isUndefined (d->clauses));
  d->clauses = clauses;
}