[splint.git] / src / qual.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
*/
/*
** qual.c
**
** representation of type qualifiers
*/

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

static qual qual_createPlainAux (int i)
{
  qual res = (qual) dmalloc (sizeof (*res));
  res->kind = (quenum) i;
  res->info = annotationInfo_undefined;

  sfreeEventually (res); /* stored in qtable */
  return res;
}

extern qual qual_createPlain (quenum q)
{
  static bool isinit = FALSE;
  static qual qtable[QU_LAST];

  if (!isinit) {
    int i = (int) QU_UNKNOWN;

    while (i < (int) QU_LAST) {
      qtable[i] = qual_createPlainAux (i);
      i++;
    }

    isinit = TRUE;
  }

  llassert (q != QU_USERANNOT && q < QU_LAST);
  return qtable[(int) q];
}

extern qual qual_createMetaState (annotationInfo info)
{
  qual res;

  res = (qual) dmalloc (sizeof (*res));
  res->kind = QU_USERANNOT;
  res->info = info;

  sfreeEventually (res); /* Memory leak */
  return res;
}
  
static bool quenum_isValid (int q)
{
  return ((quenum) q >= QU_UNKNOWN 
	  && ((quenum) q < QU_LAST));
}

qual qual_fromInt (int q)
{
  llassertprint (quenum_isValid (q), ("Invalid qual: %d", q));
  return (qual_createPlain ((quenum) q));
}

cstring qual_unparse (qual q)
{
  if (q->kind == QU_USERANNOT) {
    return (annotationInfo_unparse (q->info));
  } else {
    switch (q->kind)
      {
      case QU_UNKNOWN:    return cstring_makeLiteralTemp ("unknown");
      case QU_ABSTRACT:   return cstring_makeLiteralTemp ("abstract");
      case QU_CONCRETE:   return cstring_makeLiteralTemp ("concrete");
      case QU_MUTABLE:    return cstring_makeLiteralTemp ("mutable");
      case QU_IMMUTABLE:  return cstring_makeLiteralTemp ("immutable");
      case QU_SHORT:      return cstring_makeLiteralTemp ("short");
      case QU_LONG:       return cstring_makeLiteralTemp ("long");
      case QU_SIGNED:     return cstring_makeLiteralTemp ("signed");
      case QU_UNSIGNED:   return cstring_makeLiteralTemp ("unsigned");
      case QU_CONST:      return cstring_makeLiteralTemp ("const");
      case QU_VOLATILE:   return cstring_makeLiteralTemp ("volatile");
      case QU_INLINE:     return cstring_makeLiteralTemp ("inline");
      case QU_EXTERN:     return cstring_makeLiteralTemp ("extern");
      case QU_STATIC:     return cstring_makeLiteralTemp ("static");
      case QU_AUTO:       return cstring_makeLiteralTemp ("auto");
      case QU_REGISTER:   return cstring_makeLiteralTemp ("register");
      case QU_OUT:        return cstring_makeLiteralTemp ("out");
      case QU_IN:         return cstring_makeLiteralTemp ("in");
      case QU_RELDEF:     return cstring_makeLiteralTemp ("reldef");
      case QU_ONLY:       return cstring_makeLiteralTemp ("only");
      case QU_IMPONLY:    return cstring_makeLiteralTemp ("only");
      case QU_PARTIAL:    return cstring_makeLiteralTemp ("partial");
      case QU_SPECIAL:    return cstring_makeLiteralTemp ("special");
      case QU_KEEP:       return cstring_makeLiteralTemp ("keep");
      case QU_KEPT:       return cstring_makeLiteralTemp ("kept");
      case QU_YIELD:      return cstring_makeLiteralTemp ("yield");
      case QU_TEMP:       return cstring_makeLiteralTemp ("temp");
      case QU_SHARED:     return cstring_makeLiteralTemp ("shared");
      case QU_UNIQUE:     return cstring_makeLiteralTemp ("unique");
      case QU_UNCHECKED:  return cstring_makeLiteralTemp ("unchecked");
      case QU_CHECKED:    return cstring_makeLiteralTemp ("checked");
      case QU_CHECKMOD:   return cstring_makeLiteralTemp ("checkmod");
      case QU_CHECKEDSTRICT: return cstring_makeLiteralTemp ("checkedstrict");
      case QU_TRUENULL:   return cstring_makeLiteralTemp ("truenull");
      case QU_FALSENULL:  return cstring_makeLiteralTemp ("falsenull");
      case QU_NULL:       return cstring_makeLiteralTemp ("null");
      case QU_ISNULL:     return cstring_makeLiteralTemp ("isnull");
      case QU_RELNULL:    return cstring_makeLiteralTemp ("relnull");
      case QU_NOTNULL:    return cstring_makeLiteralTemp ("notnull");
      case QU_NULLTERMINATED: return cstring_makeLiteralTemp ("nullterminated");
      case QU_RETURNED:   return cstring_makeLiteralTemp ("returned");
      case QU_EXPOSED:    return cstring_makeLiteralTemp ("exposed");
      case QU_EXITS:      return cstring_makeLiteralTemp ("noreturn");
      case QU_MAYEXIT:    return cstring_makeLiteralTemp ("maynotreturn");
      case QU_UNUSED:     return cstring_makeLiteralTemp ("unused");
      case QU_EXTERNAL:   return cstring_makeLiteralTemp ("external");
      case QU_SEF:        return cstring_makeLiteralTemp ("sef");
      case QU_OBSERVER:   return cstring_makeLiteralTemp ("observer");
      case QU_REFCOUNTED: return cstring_makeLiteralTemp ("refcounted"); 
      case QU_REFS:       return cstring_makeLiteralTemp ("refs"); 
      case QU_NEWREF:     return cstring_makeLiteralTemp ("newref"); 
      case QU_KILLREF:    return cstring_makeLiteralTemp ("killref"); 
      case QU_TEMPREF:    return cstring_makeLiteralTemp ("tempref"); 
      case QU_OWNED:      return cstring_makeLiteralTemp ("owned");
      case QU_DEPENDENT:  return cstring_makeLiteralTemp ("dependent");
      case QU_NEVEREXIT:  return cstring_makeLiteralTemp ("alwaysreturns");
      case QU_TRUEEXIT:   return cstring_makeLiteralTemp ("noreturnwhentrue");
      case QU_FALSEEXIT:  return cstring_makeLiteralTemp ("noreturnwhenfalse");
      case QU_UNDEF:      return cstring_makeLiteralTemp ("undef");
      case QU_KILLED:     return cstring_makeLiteralTemp ("killed");
      case QU_PRINTFLIKE: return cstring_makeLiteralTemp ("printflike");
      case QU_SCANFLIKE:  return cstring_makeLiteralTemp ("scanflike");
      case QU_MESSAGELIKE:return cstring_makeLiteralTemp ("messagelike");
      case QU_SETBUFFERSIZE: return cstring_makeLiteralTemp("<qsetbuffersize>");
      case QU_LAST:       return cstring_makeLiteralTemp ("< last >");
      case QU_USERANNOT:  return cstring_makeLiteralTemp ("<user>");
      case QU_INNERCONST:  return cstring_makeLiteralTemp ("");
      }
  }

  BADEXIT;
}

extern bool qual_match (qual q1, qual q2)
{
  if (q1->kind == q2->kind) {
    if (q1->kind == QU_USERANNOT) {
      return (annotationInfo_equal (q1->info, q2->info));
    } else {
      return TRUE;
    }
  }
  
  return FALSE;
}

extern annotationInfo qual_getAnnotationInfo (qual q)
{
  llassert (qual_isMetaState (q));
  return q->info;
}

/* Cannot call qual_create after this... */

# if 0
static void qual_free (qual q)
{
  llassert (FALSE);
  sfree (q);
}
# endif

extern cstring qual_dump (qual q)
{
  if (q->kind == QU_USERANNOT)
    {
      return message ("%d.%s",
		      (int) q->kind,
		      annotationInfo_dump (q->info));
    }
  else
    {
      return message ("%d", (int) q->kind);
    }
}


extern qual qual_undump (char **s)
{
  quenum q = (quenum) reader_getInt (s); 

  if (q == QU_USERANNOT)
    {
      annotationInfo ai;

      reader_checkChar (s, '.');
      ai = annotationInfo_undump (s);

      return qual_createMetaState (ai);
    }
  else
    {
      return qual_createPlain (q);
    }
}
/*drl added 04-26-2002*/
static bool innerConstQual = FALSE;

extern void setInnerConstQual ()
{
  innerConstQual = TRUE;
}
/*drl added 04-26-2002*/
extern void resetInnerConstQual ()
{
  innerConstQual = FALSE;
}
/*drl added 04-26-2002*/
bool hasInnerConstQual()
{
  return innerConstQual;
}
/*drl added 04-26-2002*/
/*assume fullId is something like type * * id */
cstring insertInnerConstQual(/*@only@*/cstring fullId)
{
  cstring tmp, tmp2, tmp3, ret;

  tmp = cstring_afterChar (fullId, '*');

  DPRINTF( (message("insertInnerConstQual: %s", tmp) ));
  
  tmp2 = cstring_copy ( (tmp + 1) );
  if (cstring_isUndefined(tmp2) )
    {
      llassert(FALSE);
      return fullId;
    }


  tmp3 = cstring_beforeChar (fullId, '*');

  ret = cstring_concatChars(tmp3, " * const ");

  ret = cstring_concat(ret, tmp2);

  return ret;
}
Commit	Line	Data
616915dd	1	/*
11db3170	2	** Splint - annotation-assisted static program checker
77d37419	3	** Copyright (C) 1994-2002 University of Virginia,
616915dd	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	**
155af98d	20	** For information on splint: info@splint.org
155af98d	21	** To report a bug: splint-bug@splint.org
11db3170	22	** For more information: http://www.splint.org
616915dd	23	*/
	24	/*
	25	** qual.c
	26	**
	27	** representation of type qualifiers
	28	*/
	29
1b8ae690	30	# include "splintMacros.nf"
616915dd	31	# include "basic.h"
616915dd	32
28bf4b0b	33	static qual qual_createPlainAux (int i)
616915dd	34	{
28bf4b0b	35	qual res = (qual) dmalloc (sizeof (*res));
	36	res->kind = (quenum) i;
	37	res->info = annotationInfo_undefined;
	38
15b3d2b2	39	sfreeEventually (res); /* stored in qtable */
15b3d2b2	40	return res;
28bf4b0b	41	}
	42
	43	extern qual qual_createPlain (quenum q)
	44	{
	45	static bool isinit = FALSE;
	46	static qual qtable[QU_LAST];
	47
	48	if (!isinit) {
	49	int i = (int) QU_UNKNOWN;
	50
	51	while (i < (int) QU_LAST) {
	52	qtable[i] = qual_createPlainAux (i);
	53	i++;
	54	}
	55
	56	isinit = TRUE;
	57	}
	58
	59	llassert (q != QU_USERANNOT && q < QU_LAST);
	60	return qtable[(int) q];
	61	}
	62
	63	extern qual qual_createMetaState (annotationInfo info)
	64	{
	65	qual res;
	66
	67	res = (qual) dmalloc (sizeof (*res));
	68	res->kind = QU_USERANNOT;
15b3d2b2	69	res->info = info;
28bf4b0b	70
15b3d2b2	71	sfreeEventually (res); /* Memory leak */
15b3d2b2	72	return res;
28bf4b0b	73	}
	74
	75	static bool quenum_isValid (int q)
	76	{
	77	return ((quenum) q >= QU_UNKNOWN
	78	&& ((quenum) q < QU_LAST));
616915dd	79	}
	80
	81	qual qual_fromInt (int q)
	82	{
28bf4b0b	83	llassertprint (quenum_isValid (q), ("Invalid qual: %d", q));
28bf4b0b	84	return (qual_createPlain ((quenum) q));
616915dd	85	}
	86
	87	cstring qual_unparse (qual q)
	88	{
495af944	89	if (q->kind == QU_USERANNOT) {
	90	return (annotationInfo_unparse (q->info));
	91	} else {
	92	switch (q->kind)
	93	{
	94	case QU_UNKNOWN: return cstring_makeLiteralTemp ("unknown");
	95	case QU_ABSTRACT: return cstring_makeLiteralTemp ("abstract");
	96	case QU_CONCRETE: return cstring_makeLiteralTemp ("concrete");
	97	case QU_MUTABLE: return cstring_makeLiteralTemp ("mutable");
	98	case QU_IMMUTABLE: return cstring_makeLiteralTemp ("immutable");
	99	case QU_SHORT: return cstring_makeLiteralTemp ("short");
	100	case QU_LONG: return cstring_makeLiteralTemp ("long");
	101	case QU_SIGNED: return cstring_makeLiteralTemp ("signed");
	102	case QU_UNSIGNED: return cstring_makeLiteralTemp ("unsigned");
	103	case QU_CONST: return cstring_makeLiteralTemp ("const");
	104	case QU_VOLATILE: return cstring_makeLiteralTemp ("volatile");
	105	case QU_INLINE: return cstring_makeLiteralTemp ("inline");
	106	case QU_EXTERN: return cstring_makeLiteralTemp ("extern");
	107	case QU_STATIC: return cstring_makeLiteralTemp ("static");
	108	case QU_AUTO: return cstring_makeLiteralTemp ("auto");
	109	case QU_REGISTER: return cstring_makeLiteralTemp ("register");
	110	case QU_OUT: return cstring_makeLiteralTemp ("out");
	111	case QU_IN: return cstring_makeLiteralTemp ("in");
	112	case QU_RELDEF: return cstring_makeLiteralTemp ("reldef");
	113	case QU_ONLY: return cstring_makeLiteralTemp ("only");
	114	case QU_IMPONLY: return cstring_makeLiteralTemp ("only");
	115	case QU_PARTIAL: return cstring_makeLiteralTemp ("partial");
	116	case QU_SPECIAL: return cstring_makeLiteralTemp ("special");
	117	case QU_KEEP: return cstring_makeLiteralTemp ("keep");
	118	case QU_KEPT: return cstring_makeLiteralTemp ("kept");
	119	case QU_YIELD: return cstring_makeLiteralTemp ("yield");
	120	case QU_TEMP: return cstring_makeLiteralTemp ("temp");
	121	case QU_SHARED: return cstring_makeLiteralTemp ("shared");
	122	case QU_UNIQUE: return cstring_makeLiteralTemp ("unique");
	123	case QU_UNCHECKED: return cstring_makeLiteralTemp ("unchecked");
	124	case QU_CHECKED: return cstring_makeLiteralTemp ("checked");
	125	case QU_CHECKMOD: return cstring_makeLiteralTemp ("checkmod");
	126	case QU_CHECKEDSTRICT: return cstring_makeLiteralTemp ("checkedstrict");
	127	case QU_TRUENULL: return cstring_makeLiteralTemp ("truenull");
	128	case QU_FALSENULL: return cstring_makeLiteralTemp ("falsenull");
	129	case QU_NULL: return cstring_makeLiteralTemp ("null");
	130	case QU_ISNULL: return cstring_makeLiteralTemp ("isnull");
	131	case QU_RELNULL: return cstring_makeLiteralTemp ("relnull");
	132	case QU_NOTNULL: return cstring_makeLiteralTemp ("notnull");
	133	case QU_NULLTERMINATED: return cstring_makeLiteralTemp ("nullterminated");
	134	case QU_RETURNED: return cstring_makeLiteralTemp ("returned");
	135	case QU_EXPOSED: return cstring_makeLiteralTemp ("exposed");
	136	case QU_EXITS: return cstring_makeLiteralTemp ("noreturn");
	137	case QU_MAYEXIT: return cstring_makeLiteralTemp ("maynotreturn");
	138	case QU_UNUSED: return cstring_makeLiteralTemp ("unused");
	139	case QU_EXTERNAL: return cstring_makeLiteralTemp ("external");
	140	case QU_SEF: return cstring_makeLiteralTemp ("sef");
	141	case QU_OBSERVER: return cstring_makeLiteralTemp ("observer");
	142	case QU_REFCOUNTED: return cstring_makeLiteralTemp ("refcounted");
	143	case QU_REFS: return cstring_makeLiteralTemp ("refs");
	144	case QU_NEWREF: return cstring_makeLiteralTemp ("newref");
	145	case QU_KILLREF: return cstring_makeLiteralTemp ("killref");
	146	case QU_TEMPREF: return cstring_makeLiteralTemp ("tempref");
	147	case QU_OWNED: return cstring_makeLiteralTemp ("owned");
	148	case QU_DEPENDENT: return cstring_makeLiteralTemp ("dependent");
	149	case QU_NEVEREXIT: return cstring_makeLiteralTemp ("alwaysreturns");
	150	case QU_TRUEEXIT: return cstring_makeLiteralTemp ("noreturnwhentrue");
	151	case QU_FALSEEXIT: return cstring_makeLiteralTemp ("noreturnwhenfalse");
	152	case QU_UNDEF: return cstring_makeLiteralTemp ("undef");
153	case QU_KILLED: return cstring_makeLiteralTemp ("killed");
154	case QU_PRINTFLIKE: return cstring_makeLiteralTemp ("printflike");
155	case QU_SCANFLIKE: return cstring_makeLiteralTemp ("scanflike");
156	case QU_MESSAGELIKE:return cstring_makeLiteralTemp ("messagelike");
157	case QU_SETBUFFERSIZE: return cstring_makeLiteralTemp("<qsetbuffersize>");
158	case QU_LAST: return cstring_makeLiteralTemp ("< last >");
159	case QU_USERANNOT: return cstring_makeLiteralTemp ("<user>");
160	case QU_INNERCONST: return cstring_makeLiteralTemp ("");
161	}
162	}
163
28bf4b0b	164	BADEXIT;
	165	}
	166
	167	extern bool qual_match (qual q1, qual q2)
	168	{
	169	if (q1->kind == q2->kind) {
	170	if (q1->kind == QU_USERANNOT) {
	171	return (annotationInfo_equal (q1->info, q2->info));
	172	} else {
	173	return TRUE;
	174	}
	175	}
	176
	177	return FALSE;
	178	}
	179
	180	extern annotationInfo qual_getAnnotationInfo (qual q)
	181	{
	182	llassert (qual_isMetaState (q));
	183	return q->info;
	184	}
	185
	186	/* Cannot call qual_create after this... */
	187
15b3d2b2	188	# if 0
15b3d2b2	189	static void qual_free (qual q)
28bf4b0b	190	{
	191	llassert (FALSE);
	192	sfree (q);
	193	}
15b3d2b2	194	# endif
28bf4b0b	195
	196	extern cstring qual_dump (qual q)
	197	{
	198	if (q->kind == QU_USERANNOT)
616915dd	199	{
28bf4b0b	200	return message ("%d.%s",
	201	(int) q->kind,
	202	annotationInfo_dump (q->info));
616915dd	203	}
28bf4b0b	204	else
	205	{
	206	return message ("%d", (int) q->kind);
	207	}
	208	}
616915dd	209
28bf4b0b	210
	211	extern qual qual_undump (char **s)
	212	{
	213	quenum q = (quenum) reader_getInt (s);
	214
	215	if (q == QU_USERANNOT)
	216	{
	217	annotationInfo ai;
	218
	219	reader_checkChar (s, '.');
	220	ai = annotationInfo_undump (s);
	221
	222	return qual_createMetaState (ai);
	223	}
	224	else
	225	{
	226	return qual_createPlain (q);
	227	}
616915dd	228	}
495af944	229	/drl added 04-26-2002/
	230	static bool innerConstQual = FALSE;
	231
	232	extern void setInnerConstQual ()
	233	{
	234	innerConstQual = TRUE;
	235	}
	236	/drl added 04-26-2002/
	237	extern void resetInnerConstQual ()
	238	{
	239	innerConstQual = FALSE;
	240	}
	241	/drl added 04-26-2002/
	242	bool hasInnerConstQual()
	243	{
	244	return innerConstQual;
	245	}
	246	/drl added 04-26-2002/
	247	/assume fullId is something like type * id */
	248	cstring insertInnerConstQual(/@only@/cstring fullId)
	249	{
	250	cstring tmp, tmp2, tmp3, ret;
	251
	252	tmp = cstring_afterChar (fullId, '*');
	253
	254	DPRINTF( (message("insertInnerConstQual: %s", tmp) ));
	255
	256	tmp2 = cstring_copy ( (tmp + 1) );
	257	if (cstring_isUndefined(tmp2) )
	258	{
	259	llassert(FALSE);
	260	return fullId;
	261	}
	262
	263
	264	tmp3 = cstring_beforeChar (fullId, '*');
616915dd	265
495af944	266	ret = cstring_concatChars(tmp3, " * const ");
	267
	268	ret = cstring_concat(ret, tmp2);
	269
	270	return ret;
	271	}
28bf4b0b	272