[splint.git] / src / cprim.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
*/
/*
** cprim.c
*/

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

static bool cprim_isReal (cprim c)
{
  return (cprim_isAnyReal (c));
}

static bool cprim_isNumeric (cprim c)
{
  return (cprim_isReal (c) || cprim_isInt (c));
}

cprim
cprim_fromInt (int i)
{
  if (i < CTX_UNKNOWN || i > CTX_LAST)
    {
      llcontbug (message ("cprim_fromInt: out of range: %d", i));
      return CTX_UNKNOWN;
    }
  return (cprim) i;
}


/*
** not symmetric:  c1 := c2 or c2 is passed as c1
**    (if RELAXQUALS, c1 must be "bigger" than c2)
*/

static bool cprim_closeEnoughAux (cprim p_c1, cprim p_c2, bool p_deep);

bool
cprim_closeEnoughDeep (cprim c1, cprim c2) 
{
  /*
  ** If * c2 is passed as * c1
  ** Comparison is slightly different since it is safe to pass int as long,
  ** but not to pass int * as long *!
  **
  ** For deep comparisons, +relaxquals does not permit the long/int break.
  */

  return cprim_closeEnoughAux (c1, c2, TRUE);
}

bool
cprim_closeEnough (cprim c1, cprim c2)
{
  return cprim_closeEnoughAux (c1, c2, FALSE);
}

static bool
cprim_closeEnoughAux (cprim c1, cprim c2, bool deep)
{
  if (c1 == c2) return TRUE;

  DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));

  if (c1 == CTX_ANYINTEGRAL)
    {
      if (context_getFlag (FLG_MATCHANYINTEGRAL)
	  || context_getFlag (FLG_IGNOREQUALS))
	{
	  return (cprim_isAnyInt (c2)
		  || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	}
      else if (context_getFlag (FLG_LONGINTEGRAL))
	{
	  return (cprim_closeEnough (CTX_LINT, c2));
	}
      else if (context_getFlag (FLG_LONGUNSIGNEDINTEGRAL))
	{
	  return (cprim_closeEnough (CTX_ULINT, c2));
	}
      else
	{
	  return FALSE;
	}
    }

  if (c1 == CTX_UNSIGNEDINTEGRAL)
    {
      if (context_getFlag (FLG_MATCHANYINTEGRAL)
	  || context_getFlag (FLG_IGNOREQUALS))
	{
	  if (context_getFlag (FLG_IGNORESIGNS)) 
	    {
	      return (cprim_isAnyUnsignedInt (c2)
		      || (cprim_isUnsignedChar (c2) && context_msgCharInt ()));
	    }
	  else
	    {
	      return (cprim_isAnyInt (c2)
		      || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	    }
	}
      else if (context_getFlag (FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL))
	{
	  return (cprim_closeEnough (CTX_ULINT, c2));
	}
      else
	{
	  return FALSE;
	}
    }

  if (c1 == CTX_SIGNEDINTEGRAL)
    {
      if (context_getFlag (FLG_MATCHANYINTEGRAL)
	  || context_getFlag (FLG_IGNOREQUALS))
	{
	  return (cprim_isAnyInt (c2)
		  || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	}
      else if (context_getFlag (FLG_LONGSIGNEDINTEGRAL))
	{
	  return (cprim_closeEnough (CTX_LINT, c2));
	}
      else
	{
	  return FALSE;
	}
    }

  if (c2 == CTX_ANYINTEGRAL)
    {
      if (context_getFlag (FLG_MATCHANYINTEGRAL))
	{
	  return (cprim_isAnyInt (c1)
		  || (cprim_isAnyChar (c1) && context_msgCharInt ()));
	}
      else if (context_getFlag (FLG_LONGINTEGRAL))
	{
	  return (cprim_closeEnough (c1, CTX_LINT));
	}
      else if (context_getFlag (FLG_LONGUNSIGNEDINTEGRAL))
	{
	  return (cprim_closeEnough (c1, CTX_ULINT));
	}
      else
	{
	  return FALSE;
	}
    }

  if (c2 == CTX_UNSIGNEDINTEGRAL)
    {
      if (context_getFlag (FLG_MATCHANYINTEGRAL))
	{
	  return (cprim_isAnyInt (c1)
		  || (cprim_isAnyChar (c1) && context_msgCharInt ()));
	}
      else if (context_getFlag (FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL))
	{
	  return (cprim_closeEnough (c1, CTX_ULINT));
	}
      else
	{
	  return FALSE;
	}
    }

  if (c2 == CTX_SIGNEDINTEGRAL)
    {
      if (context_getFlag (FLG_MATCHANYINTEGRAL))
	{
	  return (cprim_isAnyInt (c2)
		  || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	}
      else if (context_getFlag (FLG_LONGSIGNEDINTEGRAL))
	{
	  return (cprim_closeEnough (c1, CTX_LINT));
	}
      else
	{
	  return FALSE;
	}
    }


  DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));

  if (context_getFlag (FLG_RELAXTYPES))
    {
      if (cprim_isNumeric (c1) && cprim_isNumeric (c2)) return TRUE;
    }

  if (context_getFlag (FLG_IGNOREQUALS))
    {
      switch (c1)
	{
	case CTX_CHAR:
	case CTX_UCHAR:
	  if (cprim_isAnyChar (c2) 
	      || (cprim_isAnyInt (c2) && (context_msgCharInt ()))) {
	    return TRUE;
	  } 
	  break;
	case CTX_DOUBLE:
	case CTX_FLOAT:
	case CTX_LDOUBLE:
	  if (c2 == CTX_DOUBLE || c2 == CTX_FLOAT || c2 == CTX_LDOUBLE) {
	    return TRUE;
	  }
	  break;
	case CTX_INT:
	case CTX_LINT:
	case CTX_LLINT:
	case CTX_ULLINT:
	case CTX_SINT:
	case CTX_UINT:
	case CTX_ULINT:
	case CTX_USINT:
	  if (cprim_isAnyInt (c2) 
	      || (cprim_isAnyChar (c2) && context_msgCharInt ())) {
	    return TRUE;
	  }
	default:
	  ;
	}
    }

  if (context_getFlag (FLG_IGNORESIGNS))
    {
      if (c1 == CTX_UCHAR)  
	{
	  c1 = CTX_CHAR;
	}
      else if (c1 == CTX_UINT)  
	{
	  c1 = CTX_INT;
	}
      else if (c1 == CTX_ULINT) 
	{
	  c1 = CTX_LINT;
	}
      /* 2001-06-10: This fix provided by Jim Zelenka: */
      else if (c1 == CTX_ULLINT) 
	{
	  c1 = CTX_LLINT;
	}
      /* End fix */
      else if (c1 == CTX_USINT)  
	{
	  c1 = CTX_SINT;
	}
      else
	{
	  ;
	}
      
      if (c2 == CTX_UCHAR)  
	{
	  c2 = CTX_CHAR;
	}
      else if (c2 == CTX_UINT)   
	{
	  c2 = CTX_INT;
	}
      else if (c2 == CTX_ULINT) 
	{
	  c2 = CTX_LINT;
	}
      /* 2001-06-10: This fix provided by Jim Zelenka: */
      else if (c2 == CTX_ULLINT)
	{
	  c2 = CTX_LLINT;
	}
      /* End fix */
      else if (c2 == CTX_USINT)  
	{
	  c2 = CTX_SINT;
	}
      else
	{
	  ;
	}
    }

  if (c1 == c2) return TRUE;
  
  if (context_getFlag (FLG_FLOATDOUBLE))
    {
      if (c1 == CTX_FLOAT && c2 == CTX_DOUBLE) 
	{
	  return TRUE;
	}
      if (c2 == CTX_FLOAT && c1 == CTX_DOUBLE)
	{
	  return TRUE;
	}
    }
  
  DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
  
  if (!deep && context_getFlag (FLG_RELAXQUALS))
    {
      switch (c1)
	{
	case CTX_DOUBLE:
	  return (c2 == CTX_FLOAT);
	case CTX_LDOUBLE:
	  return (c2 == CTX_DOUBLE || c2 == CTX_FLOAT);
	case CTX_SINT:
	  return ((c2 == CTX_CHAR && context_msgCharInt ()) 
		  || (c2 == CTX_INT && context_msgShortInt ())
		  || (c2 == CTX_LINT && context_msgShortInt () && context_msgLongInt ()));

	case CTX_INT:
	  return ((c2 == CTX_SINT
		   || (cprim_isAnyChar (c2) && context_msgCharInt ())
		   || (c2 == CTX_LINT && context_msgLongInt ())));

	case CTX_LLINT:
	  return (c2 == CTX_SINT
		  || c2 == CTX_INT 
		      || c2 == CTX_LINT
		  || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	case CTX_ULLINT:
	  return (c2 == CTX_USINT
		  || c2 == CTX_UINT 
		  || c2 == CTX_ULINT
		  /* 2001-06-10: This fix provided by Jim Zelenka: */
		  || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	case CTX_LINT:
	  return (c2 == CTX_SINT
		  || c2 == CTX_INT 
		  || (cprim_isAnyChar (c2) && context_msgCharInt ()));
	case CTX_UINT:
	  return (c2 == CTX_USINT 
		  || (c2 == CTX_UCHAR && context_msgCharInt ()));
	case CTX_USINT:
	  return (c2 == CTX_UCHAR && context_msgCharInt ());
	case CTX_ULINT:
	  /* 2001-06-10: This fix provided by Jim Zelenka: */
	  return (c2 == CTX_UINT || c2 == CTX_USINT
		  || (c2 == CTX_UCHAR && context_msgCharInt()));
	case CTX_UCHAR:
	  return (c2 == CTX_UINT && context_msgCharInt ());
	case CTX_CHAR:
	  return ((c2 == CTX_INT || c2 == CTX_SINT)
		  && context_msgCharInt ());
	default:
	  return FALSE;
	}
    }
  else
    {
      switch (c1)
	{
	case CTX_DOUBLE:
	case CTX_LDOUBLE:
	  return FALSE;
	case CTX_SINT:
	  if (c2 == CTX_INT && context_msgShortInt ()) {
	    return TRUE;
	  }
	  /*@fallthrough@*/
	case CTX_INT:
	  if (c2 == CTX_INT && context_msgLongInt ()) {
	    return TRUE;
	  }
	  
	  if (c2 == CTX_SINT && context_msgShortInt ()) {
	    return TRUE;
	  }
	  /*@fallthrough@*/
	case CTX_LINT:
	  if (c2 == CTX_INT && context_msgLongInt ()) {
	    return TRUE;
	  }
	  /*@fallthrough@*/
	case CTX_LLINT:
	  return (c2 == CTX_CHAR && context_msgCharInt ());
	case CTX_UINT:
	case CTX_USINT:
	case CTX_ULINT:
	case CTX_ULLINT:
	  return (c2 == CTX_UCHAR && context_msgCharInt ());
	case CTX_UCHAR:
	  return (c2 == CTX_UINT && context_msgCharInt ());
	case CTX_CHAR:
	  return ((c2 == CTX_INT || c2 == CTX_SINT)
		  && context_msgCharInt ());
	default:
	  return FALSE;
	}
    }
}

/*@only@*/ cstring
cprim_unparse (cprim c)
{
  switch (c)
    {
    case CTX_UNKNOWN:
      return cstring_makeLiteral ("-");
    case CTX_VOID:
      return cstring_makeLiteral ("void");
    case CTX_CHAR:
      return cstring_makeLiteral ("char");
    case CTX_UCHAR:
      return cstring_makeLiteral ("unsigned char");
   case CTX_DOUBLE:
      return cstring_makeLiteral ("double");
    case CTX_LDOUBLE:
      return cstring_makeLiteral ("long double");
    case CTX_FLOAT:
      return cstring_makeLiteral ("float");
    case CTX_INT:
      return cstring_makeLiteral ("int");
    case CTX_LINT:
      return cstring_makeLiteral ("long int");
    case CTX_LLINT:
      return cstring_makeLiteral ("long long");
    case CTX_ULLINT:
      return cstring_makeLiteral ("unsigned long long");
    case CTX_SINT:
      return cstring_makeLiteral ("short int");
    case CTX_UINT:
      return cstring_makeLiteral ("unsigned int");
    case CTX_ULINT:
      return cstring_makeLiteral ("unsigned long int");
    case CTX_USINT:
      return cstring_makeLiteral ("unsigned short int");
    case CTX_UNSIGNEDINTEGRAL:
      return cstring_makeLiteral ("arbitrary unsigned integral type");
    case CTX_SIGNEDINTEGRAL:
      return cstring_makeLiteral ("arbitrary signed integral type");
    case CTX_ANYINTEGRAL:
      return cstring_makeLiteral ("arbitrary integral type");
    default:
      return cstring_makeLiteral ("unknown prim");
    }
}

bool cprim_isInt (cprim c) 
{
  return (cprim_isAnyInt (c)
	  || (cprim_isAnyChar (c) && context_msgCharInt ()));
}
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	** cprim.c
	26	*/
	27
1b8ae690	28	# include "splintMacros.nf"
616915dd	29	# include "basic.h"
	30
	31	static bool cprim_isReal (cprim c)
	32	{
	33	return (cprim_isAnyReal (c));
	34	}
	35
	36	static bool cprim_isNumeric (cprim c)
	37	{
	38	return (cprim_isReal (c) \|\| cprim_isInt (c));
	39	}
	40
	41	cprim
	42	cprim_fromInt (int i)
	43	{
	44	if (i < CTX_UNKNOWN \|\| i > CTX_LAST)
	45	{
	46	llcontbug (message ("cprim_fromInt: out of range: %d", i));
	47	return CTX_UNKNOWN;
	48	}
	49	return (cprim) i;
	50	}
	51
	52
	53	/*
	54	** not symmetric: c1 := c2 or c2 is passed as c1
	55	** (if RELAXQUALS, c1 must be "bigger" than c2)
	56	*/
	57
	58	static bool cprim_closeEnoughAux (cprim p_c1, cprim p_c2, bool p_deep);
	59
	60	bool
	61	cprim_closeEnoughDeep (cprim c1, cprim c2)
	62	{
	63	/*
	64	** If * c2 is passed as * c1
	65	** Comparison is slightly different since it is safe to pass int as long,
	66	** but not to pass int * as long *!
	67	**
	68	** For deep comparisons, +relaxquals does not permit the long/int break.
	69	*/
	70
	71	return cprim_closeEnoughAux (c1, c2, TRUE);
	72	}
	73
	74	bool
	75	cprim_closeEnough (cprim c1, cprim c2)
	76	{
	77	return cprim_closeEnoughAux (c1, c2, FALSE);
	78	}
	79
	80	static bool
	81	cprim_closeEnoughAux (cprim c1, cprim c2, bool deep)
	82	{
	83	if (c1 == c2) return TRUE;
	84
81fc136a	85	DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
81fc136a	86
616915dd	87	if (c1 == CTX_ANYINTEGRAL)
	88	{
	89	if (context_getFlag (FLG_MATCHANYINTEGRAL)
	90	\|\| context_getFlag (FLG_IGNOREQUALS))
	91	{
	92	return (cprim_isAnyInt (c2)
	93	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
	94	}
	95	else if (context_getFlag (FLG_LONGINTEGRAL))
	96	{
	97	return (cprim_closeEnough (CTX_LINT, c2));
	98	}
	99	else if (context_getFlag (FLG_LONGUNSIGNEDINTEGRAL))
	100	{
	101	return (cprim_closeEnough (CTX_ULINT, c2));
	102	}
	103	else
	104	{
	105	return FALSE;
	106	}
	107	}
	108
	109	if (c1 == CTX_UNSIGNEDINTEGRAL)
	110	{
	111	if (context_getFlag (FLG_MATCHANYINTEGRAL)
	112	\|\| context_getFlag (FLG_IGNOREQUALS))
	113	{
6fcd0b1e	114	if (context_getFlag (FLG_IGNORESIGNS))
	115	{
	116	return (cprim_isAnyUnsignedInt (c2)
	117	\|\| (cprim_isUnsignedChar (c2) && context_msgCharInt ()));
	118	}
	119	else
	120	{
	121	return (cprim_isAnyInt (c2)
	122	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
	123	}
616915dd	124	}
	125	else if (context_getFlag (FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL))
	126	{
	127	return (cprim_closeEnough (CTX_ULINT, c2));
	128	}
	129	else
	130	{
	131	return FALSE;
	132	}
	133	}
	134
	135	if (c1 == CTX_SIGNEDINTEGRAL)
	136	{
	137	if (context_getFlag (FLG_MATCHANYINTEGRAL)
	138	\|\| context_getFlag (FLG_IGNOREQUALS))
	139	{
	140	return (cprim_isAnyInt (c2)
	141	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
	142	}
	143	else if (context_getFlag (FLG_LONGSIGNEDINTEGRAL))
	144	{
	145	return (cprim_closeEnough (CTX_LINT, c2));
	146	}
	147	else
	148	{
	149	return FALSE;
	150	}
	151	}
	152
	153	if (c2 == CTX_ANYINTEGRAL)
	154	{
	155	if (context_getFlag (FLG_MATCHANYINTEGRAL))
	156	{
	157	return (cprim_isAnyInt (c1)
	158	\|\| (cprim_isAnyChar (c1) && context_msgCharInt ()));
	159	}
	160	else if (context_getFlag (FLG_LONGINTEGRAL))
	161	{
	162	return (cprim_closeEnough (c1, CTX_LINT));
	163	}
	164	else if (context_getFlag (FLG_LONGUNSIGNEDINTEGRAL))
	165	{
	166	return (cprim_closeEnough (c1, CTX_ULINT));
	167	}
	168	else
	169	{
	170	return FALSE;
	171	}
	172	}
	173
	174	if (c2 == CTX_UNSIGNEDINTEGRAL)
	175	{
	176	if (context_getFlag (FLG_MATCHANYINTEGRAL))
	177	{
	178	return (cprim_isAnyInt (c1)
	179	\|\| (cprim_isAnyChar (c1) && context_msgCharInt ()));
	180	}
	181	else if (context_getFlag (FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL))
	182	{
	183	return (cprim_closeEnough (c1, CTX_ULINT));
	184	}
	185	else
	186	{
	187	return FALSE;
188	}
189	}
190
191	if (c2 == CTX_SIGNEDINTEGRAL)
192	{
193	if (context_getFlag (FLG_MATCHANYINTEGRAL))
194	{
195	return (cprim_isAnyInt (c2)
196	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
197	}
198	else if (context_getFlag (FLG_LONGSIGNEDINTEGRAL))
199	{
200	return (cprim_closeEnough (c1, CTX_LINT));
201	}
202	else
203	{
204	return FALSE;
205	}
206	}
207
81fc136a	208
	209	DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
	210
616915dd	211	if (context_getFlag (FLG_RELAXTYPES))
	212	{
	213	if (cprim_isNumeric (c1) && cprim_isNumeric (c2)) return TRUE;
	214	}
	215
	216	if (context_getFlag (FLG_IGNOREQUALS))
	217	{
	218	switch (c1)
	219	{
	220	case CTX_CHAR:
	221	case CTX_UCHAR:
81fc136a	222	if (cprim_isAnyChar (c2)
	223	\|\| (cprim_isAnyInt (c2) && (context_msgCharInt ()))) {
	224	return TRUE;
	225	}
	226	break;
616915dd	227	case CTX_DOUBLE:
	228	case CTX_FLOAT:
	229	case CTX_LDOUBLE:
81fc136a	230	if (c2 == CTX_DOUBLE \|\| c2 == CTX_FLOAT \|\| c2 == CTX_LDOUBLE) {
	231	return TRUE;
	232	}
	233	break;
616915dd	234	case CTX_INT:
	235	case CTX_LINT:
	236	case CTX_LLINT:
	237	case CTX_ULLINT:
	238	case CTX_SINT:
	239	case CTX_UINT:
	240	case CTX_ULINT:
	241	case CTX_USINT:
81fc136a	242	if (cprim_isAnyInt (c2)
	243	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ())) {
	244	return TRUE;
	245	}
616915dd	246	default:
81fc136a	247	;
616915dd	248	}
616915dd	249	}
81fc136a	250
81fc136a	251	if (context_getFlag (FLG_IGNORESIGNS))
616915dd	252	{
81fc136a	253	if (c1 == CTX_UCHAR)
616915dd	254	{
81fc136a	255	c1 = CTX_CHAR;
616915dd	256	}
81fc136a	257	else if (c1 == CTX_UINT)
616915dd	258	{
81fc136a	259	c1 = CTX_INT;
	260	}
	261	else if (c1 == CTX_ULINT)
	262	{
	263	c1 = CTX_LINT;
	264	}
	265	/* 2001-06-10: This fix provided by Jim Zelenka: */
	266	else if (c1 == CTX_ULLINT)
	267	{
	268	c1 = CTX_LLINT;
	269	}
	270	/* End fix */
	271	else if (c1 == CTX_USINT)
	272	{
	273	c1 = CTX_SINT;
	274	}
	275	else
	276	{
	277	;
	278	}
	279
	280	if (c2 == CTX_UCHAR)
	281	{
	282	c2 = CTX_CHAR;
	283	}
	284	else if (c2 == CTX_UINT)
	285	{
	286	c2 = CTX_INT;
	287	}
	288	else if (c2 == CTX_ULINT)
	289	{
	290	c2 = CTX_LINT;
	291	}
	292	/* 2001-06-10: This fix provided by Jim Zelenka: */
	293	else if (c2 == CTX_ULLINT)
	294	{
	295	c2 = CTX_LLINT;
	296	}
	297	/* End fix */
	298	else if (c2 == CTX_USINT)
	299	{
	300	c2 = CTX_SINT;
616915dd	301	}
81fc136a	302	else
	303	{
	304	;
	305	}
	306	}
616915dd	307
81fc136a	308	if (c1 == c2) return TRUE;
	309
	310	if (context_getFlag (FLG_FLOATDOUBLE))
	311	{
	312	if (c1 == CTX_FLOAT && c2 == CTX_DOUBLE)
616915dd	313	{
81fc136a	314	return TRUE;
	315	}
	316	if (c2 == CTX_FLOAT && c1 == CTX_DOUBLE)
	317	{
	318	return TRUE;
	319	}
	320	}
	321
	322	DPRINTF (("cprim close: %s / %s", cprim_unparse (c1), cprim_unparse (c2)));
	323
	324	if (!deep && context_getFlag (FLG_RELAXQUALS))
	325	{
	326	switch (c1)
	327	{
	328	case CTX_DOUBLE:
	329	return (c2 == CTX_FLOAT);
	330	case CTX_LDOUBLE:
	331	return (c2 == CTX_DOUBLE \|\| c2 == CTX_FLOAT);
	332	case CTX_SINT:
	333	return ((c2 == CTX_CHAR && context_msgCharInt ())
	334	\|\| (c2 == CTX_INT && context_msgShortInt ())
	335	\|\| (c2 == CTX_LINT && context_msgShortInt () && context_msgLongInt ()));
	336
	337	case CTX_INT:
	338	return ((c2 == CTX_SINT
	339	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ())
	340	\|\| (c2 == CTX_LINT && context_msgLongInt ())));
	341
	342	case CTX_LLINT:
	343	return (c2 == CTX_SINT
	344	\|\| c2 == CTX_INT
616915dd	345	\|\| c2 == CTX_LINT
81fc136a	346	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
	347	case CTX_ULLINT:
	348	return (c2 == CTX_USINT
	349	\|\| c2 == CTX_UINT
	350	\|\| c2 == CTX_ULINT
	351	/* 2001-06-10: This fix provided by Jim Zelenka: */
	352	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
	353	case CTX_LINT:
	354	return (c2 == CTX_SINT
	355	\|\| c2 == CTX_INT
	356	\|\| (cprim_isAnyChar (c2) && context_msgCharInt ()));
	357	case CTX_UINT:
	358	return (c2 == CTX_USINT
	359	\|\| (c2 == CTX_UCHAR && context_msgCharInt ()));
	360	case CTX_USINT:
	361	return (c2 == CTX_UCHAR && context_msgCharInt ());
	362	case CTX_ULINT:
	363	/* 2001-06-10: This fix provided by Jim Zelenka: */
	364	return (c2 == CTX_UINT \|\| c2 == CTX_USINT
	365	\|\| (c2 == CTX_UCHAR && context_msgCharInt()));
	366	case CTX_UCHAR:
	367	return (c2 == CTX_UINT && context_msgCharInt ());
	368	case CTX_CHAR:
	369	return ((c2 == CTX_INT \|\| c2 == CTX_SINT)
	370	&& context_msgCharInt ());
	371	default:
	372	return FALSE;
616915dd	373	}
81fc136a	374	}
	375	else
	376	{
	377	switch (c1)
616915dd	378	{
81fc136a	379	case CTX_DOUBLE:
	380	case CTX_LDOUBLE:
	381	return FALSE;
	382	case CTX_SINT:
	383	if (c2 == CTX_INT && context_msgShortInt ()) {
	384	return TRUE;
	385	}
	386	/@fallthrough@/
	387	case CTX_INT:
	388	if (c2 == CTX_INT && context_msgLongInt ()) {
	389	return TRUE;
	390	}
	391
	392	if (c2 == CTX_SINT && context_msgShortInt ()) {
	393	return TRUE;
	394	}
	395	/@fallthrough@/
	396	case CTX_LINT:
	397	if (c2 == CTX_INT && context_msgLongInt ()) {
	398	return TRUE;
	399	}
	400	/@fallthrough@/
	401	case CTX_LLINT:
	402	return (c2 == CTX_CHAR && context_msgCharInt ());
	403	case CTX_UINT:
	404	case CTX_USINT:
	405	case CTX_ULINT:
	406	case CTX_ULLINT:
	407	return (c2 == CTX_UCHAR && context_msgCharInt ());
	408	case CTX_UCHAR:
	409	return (c2 == CTX_UINT && context_msgCharInt ());
	410	case CTX_CHAR:
	411	return ((c2 == CTX_INT \|\| c2 == CTX_SINT)
	412	&& context_msgCharInt ());
	413	default:
	414	return FALSE;
616915dd	415	}
	416	}
	417	}
	418
	419	/@only@/ cstring
	420	cprim_unparse (cprim c)
	421	{
	422	switch (c)
	423	{
	424	case CTX_UNKNOWN:
	425	return cstring_makeLiteral ("-");
	426	case CTX_VOID:
	427	return cstring_makeLiteral ("void");
	428	case CTX_CHAR:
	429	return cstring_makeLiteral ("char");
	430	case CTX_UCHAR:
	431	return cstring_makeLiteral ("unsigned char");
	432	case CTX_DOUBLE:
	433	return cstring_makeLiteral ("double");
	434	case CTX_LDOUBLE:
	435	return cstring_makeLiteral ("long double");
	436	case CTX_FLOAT:
	437	return cstring_makeLiteral ("float");
	438	case CTX_INT:
	439	return cstring_makeLiteral ("int");
	440	case CTX_LINT:
	441	return cstring_makeLiteral ("long int");
	442	case CTX_LLINT:
	443	return cstring_makeLiteral ("long long");
	444	case CTX_ULLINT:
	445	return cstring_makeLiteral ("unsigned long long");
	446	case CTX_SINT:
	447	return cstring_makeLiteral ("short int");
	448	case CTX_UINT:
	449	return cstring_makeLiteral ("unsigned int");
	450	case CTX_ULINT:
	451	return cstring_makeLiteral ("unsigned long int");
	452	case CTX_USINT:
	453	return cstring_makeLiteral ("unsigned short int");
	454	case CTX_UNSIGNEDINTEGRAL:
	455	return cstring_makeLiteral ("arbitrary unsigned integral type");
	456	case CTX_SIGNEDINTEGRAL:
	457	return cstring_makeLiteral ("arbitrary signed integral type");
	458	case CTX_ANYINTEGRAL:
	459	return cstring_makeLiteral ("arbitrary integral type");
	460	default:
	461	return cstring_makeLiteral ("unknown prim");
	462	}
	463	}
	464
	465	bool cprim_isInt (cprim c)
	466	{
	467	return (cprim_isAnyInt (c)
	468	\|\| (cprim_isAnyChar (c) && context_msgCharInt ()));
	469	}
	470
	471
	472
	473