Import upstream sources.

[cparse] / number.c

#include "cparse.h"
#include "platform.h"
#include <float.h>
#include <endian.h>

/* order is important. */
static const struct {
  unsigned type;
  unsigned long long max;
} int_info[] = {
  { TS_INT, P_INT_MAX },
  { TS_UNSIGNED, P_UINT_MAX },
  { TS_LONG, P_LONG_MAX },
  { TS_UNSIGNED|TS_LONG, P_ULONG_MAX },
  { TS_LONGLONG, P_LLONG_MAX },
  { TS_UNSIGNED|TS_LONGLONG, P_ULLONG_MAX },
  /* XXX other built-in integral types should maybe go here too */
};

#define N_INT_INFO (sizeof int_info / sizeof *int_info)

/* Throw away the bottom few bits of a floating point number.
 * Makes rather free assumptions about representation!
 * XXX only tested on i386 linux
 *
 * Why on earth do we need this ridiculous thing?
 *
 * gcc's FLT_MAX is defined as 3.40282347e+38F
 * which its strtold converts to xxxx407effffff048ff9eb4e
 * but gcc converts it to        xxxx407effffff0000000000
 *                               ----EEEEMMMMMMMMMMMMMMMM
 * so we end up with 3.40282347e+38 > FLT_MAX being true and getting
 * an error.
 *
 * Really gcc should have written it as e.g. 3.4028234663852885982e+38
 * which strtold converts to the exact answer.
 *
 * At least potentially the same problem might exist for DBL_MAX (I've
 * not checked).
 */
static void massage_float(long double *ld,
			  unsigned bits) {
  unsigned char *ptr = (unsigned char *)ld;
  size_t n;
  unsigned left;

#if BYTE_ORDER == BIG_ENDIAN
  memset(ptr + sizeof (long double) - bits / 8, 0, bits / 8);
  n = sizeof (long double) - bits / 8 - 1;
#else
  memset(ptr, 0, bits / 8);
  n = bits / 8;
#endif
  if((left = bits & 7))
    ptr[n] &= 0xFFFFFFFF << left;
}

struct declarator *numbertype(const struct expression *e) {
  unsigned long long u;
  long double ld;
  int hex, f_l = 0, f_u = 0, f_f = 0;
  char *rest;
  struct declarator *d;
  unsigned ts;
  size_t n;

  /* . always means a floating constant
   * E/e but no 0x means a floating constant
   * 0x and P/p means a floating constant
   * anything else is some kind of integer
   */
  hex = !strncmp(e->u.constant, "0x", 2);
  if(strchr(e->u.constant, '.')
     || (hex ? strchr(e->u.constant, 'p') || strchr(e->u.constant, 'P')
	     : strchr(e->u.constant, 'e') || strchr(e->u.constant, 'E'))) {
    /* long double had better be as big as the target's long double */
    errno = 0;
    ld = strtold(e->u.constant, &rest);
    if(errno) {
      inputerror(&e->where, "floating constant '%s' out of range",
		 e->u.constant);
      return 0;
    }
    while(*rest) {
      switch(*rest++) {
      case 'f': case 'F': f_f++; break;
      case 'l': case 'L': f_l++; break;
      default:
	inputerror(&e->where, "invalid suffix on floating constant '%s'",
		   e->u.constant);
	return 0;
      }
    }
    if(f_f + f_l > 1) {
      inputerror(&e->where, "too many suffixes on floating constant '%s'",
		 e->u.constant);
      return 0;
    }
    if(f_f) {
      massage_float(&ld, LDBL_MANT_DIG - P_FLT_MANT_DIG);
      if(ld > P_FLT_MAX) {
	inputerror(&e->where, "float constant '%s' out of range",
		   e->u.constant);
	return 0;
      }
      ts = TS_FLOAT;
    } else if(!f_l) {
      massage_float(&ld, LDBL_MANT_DIG - P_DBL_MANT_DIG);
      if(ld > P_DBL_MAX) {
	inputerror(&e->where, "double constant '%s' out of range",
		   e->u.constant);
	return 0;
      }
      ts = TS_DOUBLE;
    } else {
      massage_float(&ld, LDBL_MANT_DIG - P_LDBL_MANT_DIG);
      if(ld > P_LDBL_MAX) {
	inputerror(&e->where, "double constant '%s' out of range",
		   e->u.constant);
	return 0;
      }
      ts = TS_LONG|TS_DOUBLE;
    }
    NEW(d);
    NEW(d->declaration_specifiers);
    d->declaration_specifiers->type_specifiers = ts;
    return d;
  } else {
    errno = 0;
    u = strtoull(e->u.constant, &rest, 0);
    if(errno) {
      inputerror(&e->where, "integral constant '%s' out of range",
		 e->u.constant);
      return 0;
    }
    while(*rest) {
      switch(*rest++) {
      case 'u': case 'U': f_u++; break;
      case 'l': case 'L': f_l++; break;
      default:
	inputerror(&e->where, "invalid suffix on integral constant '%s'",
		   e->u.constant);
	return 0;
      }
    }
    if(f_u > 1 || f_l > 2) {
      inputerror(&e->where, "too many suffixes on integral constant '%s'",
		 e->u.constant);
      return 0;
    }
    if(hex || e->u.constant[0] == '0') {
      /* hex or octal - first type that fits */
      for(n = 2 * f_l; n < N_INT_INFO; ++n)
	if(u <= int_info[n].max)
	  break;
    } else {
      /* decimal - unsigned only allowed if u/U specified */
      for(n = 2 * f_l; n < N_INT_INFO; ++n)
	if(u <= int_info[n].max)
	  if(f_u || !(int_info[n].type & TS_UNSIGNED))
	    break;
    }
    if(n >= N_INT_INFO) {
      inputerror(&e->where, "integral constant '%s' out of range",
		 e->u.constant);
      return 0;
    }
    NEW(d);
    NEW(d->declaration_specifiers);
    d->declaration_specifiers->type_specifiers = int_info[n].type;
    return d;
  }
}

/*
Local Variables:
c-basic-offset:2
comment-column:40
End:
*/