bool clang_c_convertert::convert_float_literal(
const clang::FloatingLiteral &floating_literal,
exprt &dest)
{
if(!config.ansi_c.use_fixed_for_float)
{
std::cerr << "floatbv unsupported, sorry" << std::endl;
return false;
}
typet type;
if(get_type(floating_literal.getType(), type))
return true;
llvm::APFloat val = floating_literal.getValue();
llvm::SmallVector<char, 32> string;
val.toString(string, 32, 0);
unsigned width = bv_width(type);
mp_integer value;
std::string float_string;
if(!val.isInfinity())
{
mp_integer significand;
mp_integer exponent;
float_string = parse_float(string, significand, exponent);
unsigned fraction_bits;
const std::string &integer_bits = type.integer_bits().as_string();
if (integer_bits == "")
fraction_bits = width / 2;
else
fraction_bits = width - atoi(integer_bits.c_str());
mp_integer factor = mp_integer(1) << fraction_bits;
value = significand * factor;
if(exponent < 0)
value /= power(10, -exponent);
else
{
value *= power(10, exponent);
if(value <= -power(2, width - 1) - 1)
{
// saturate: use "smallest value"
value = -power(2, width - 1);
}
}
}
else
{
// saturate: use "biggest value"
value = power(2, width - 1) - 1;
float_string = "2147483647.99999999976716935634613037109375";
}
dest =
constant_exprt(
integer2binary(value, bv_width(type)),
float_string,
type);
return false;
}
static bool parse_gsa(const uint8_t *msg, size_t msg_size,
struct nmea_gpgsa_t *dst, struct gps_msg_status_t *status)
{
unsigned fields_nb;
unsigned i;
struct nmea_gpgsa_t gpgsa;
const char *fields[18];
char buf[NMEA_MAX];
assert(msg_size <= sizeof(buf));
fields_nb = split_nmea_str(msg, msg_size, fields, sizeof(fields)/sizeof(fields[0]), buf);
if (fields_nb < 18)
return set_nmea_error(status, msg, msg_size, "Invalid field count %u", fields_nb);
/* Field 1. Fix mode */
gpgsa.fix_mode = (int)fields[1];
/* Field 2. Fix type */
if (fields[2][0] == '\0')
gpgsa.fix_type = -1;
else {
char *endptr;
unsigned long type;
errno = 0;
type = strtoul(fields[2], &endptr, 10);
if ((errno == ERANGE && type == ULONG_MAX)
|| (errno != 0 && type == 0)
|| *endptr != '\0') {
return set_nmea_error(status, msg, msg_size, "Invalid fix type");
}
gpgsa.fix_type = (int)type;
}
/* Field 3-14 PRN's of Satellite Vechicles */
for (i=0; i<12; ++i) {
if (fields[3+i][0] == '\0')
gpgsa.prn[0] = 0;
else {
char *endptr;
unsigned long prn;
errno = 0;
prn = strtoul(fields[3+i], &endptr, 10);
if ((errno == ERANGE && prn == ULONG_MAX)
|| (errno != 0 && prn == 0)
|| *endptr != '\0') {
return set_nmea_error(status, msg, msg_size, "Invalid PRN");
}
gpgsa.prn[i] = (unsigned)prn;
}
}
/* Field 15. PDOP */
if (!parse_float(fields[15], &gpgsa.pdop, &gpgsa.has_pdop))
return set_nmea_error(status, msg, msg_size, "Invalid PDOP");
/* Field 16. HDOP */
if (!parse_float(fields[16], &gpgsa.hdop, &gpgsa.has_hdop))
return set_nmea_error(status, msg, msg_size, "Invalid HDOP");
/* Field 17. VDOP */
if (!parse_float(fields[17], &gpgsa.vdop, &gpgsa.has_vdop))
return set_nmea_error(status, msg, msg_size, "Invalid VDOP");
*dst = gpgsa;
status->is_valid = true;
status->err[0] = '\0';
return status->is_valid;
}
static void option_do_set(option_t *option, char *value)
{
char expand[FILENAME_MAX+1];
int val;
double val2;
char c;
char *ptr;
char *temp;
/* Handle comments after the value */
ptr = strchr(value,';');
if ( ptr )
*ptr = 0;
if ( option->type & OPT_ARRAY ) {
switch ( option->type & ~OPT_ARRAY ) {
case OPT_INT:
val = parse_int(value);
*(int **)option->value = realloc(*(int **)option->value, (*option->count + 1) * sizeof(int));
(*(int **)(option->value))[*option->count] = val;
(*option->count)++;
break;
case OPT_STR:
case OPT_FILENAME:
strip_ws(value);
if ( (option->type & ~OPT_ARRAY) == OPT_FILENAME ) {
filename_expand(value,expand,sizeof(expand),NULL,NULL);
temp = strdup(expand);
} else {
temp = strdup(value);
}
*(char **)option->value = realloc(*(char **)option->value, (*option->count + 1) * sizeof(char *));
(*(char ***)(option->value))[*option->count] = temp;
(*option->count)++;
break;
case OPT_FLOAT:
val2 = parse_float(value);
*(double **)option->value = realloc(*(double **)option->value, (*option->count + 1) * sizeof(double));
(*(double **)(option->value))[*option->count] = val2;
(*option->count)++;
break;
}
return;
}
switch ( option->type ) {
case OPT_INT:
val = parse_int(value);
*(int *)(option->value) = val;
return;
case OPT_STR:
case OPT_FILENAME:
strip_ws(value);
if ( option->type == OPT_FILENAME ) {
filename_expand(value,expand,sizeof(expand),NULL,NULL);
temp = strdup(expand);
} else {
temp = strdup(value);
}
*(char **)(option->value) = temp;
return;
case OPT_BOOL:
c = toupper(value[0]);
val = 0;
switch (c) {
case 'Y':
case 'T':
case '1':
val = 1;
}
*(char *)(option->value) = val;
return;
case OPT_FLOAT:
val2 = parse_float(value);
*(double *)(option->value) = val2;
return;
}
}
static bool parse_gga(const uint8_t *msg, size_t msg_size,
struct nmea_gpgga_t *dst, struct gps_msg_status_t *status)
{
unsigned fields_nb;
struct nmea_gpgga_t gpgga;
const char *fields[15];
char buf[NMEA_MAX];
assert(msg_size <= sizeof(buf));
fields_nb = split_nmea_str(msg, msg_size, fields, sizeof(fields)/sizeof(fields[0]), buf);
if (fields_nb < 15) {
return set_nmea_error(status, msg, msg_size,
"Invalid field count %u", fields_nb);
}
/* Field 1. Time of fix */
if (parse_nmea_fix_time(fields[1], &gpgga.fix_time) != FIELD_VALID)
return set_nmea_error(status, msg, msg_size, "Invalid NMEA fix time");
/* Fields 2,3 latitude */
if (!parse_nmea_latitude(fields[2], fields[3], &gpgga.latitude, &gpgga.has_latitude))
return set_nmea_error(status, msg, msg_size,
"Invalid latitude '%s:%s'", fields[2], fields[3]);
/* Fields 4,5 longitude */
if (!parse_nmea_longitude(fields[4], fields[5], &gpgga.longitude, &gpgga.has_longitude))
return set_nmea_error(status, msg, msg_size,
"Invalid longitude '%s:%s'", fields[4], fields[5]);
/* Field 6 fix quality */
if (fields[6][0] == '\0') {
return set_nmea_error(status, msg, msg_size,
"Undefined fix quality");
}else {
char *endptr;
unsigned long fixq;
errno = 0;
fixq = strtoul(fields[6], &endptr, 10);
if ((errno == ERANGE && fixq == ULONG_MAX)
|| (errno != 0 && fixq == 0)
|| *endptr != '\0') {
return set_nmea_error(status, msg, msg_size,
"Invalid fix quality");
}
gpgga.fix_quality = fixq;
}
/* Field 7. Number of satellites being tracked */
if ( (gpgga.has_sattelites_nb = (fields[7][0] != '\0'))) {
unsigned long sat_nb;
char *endptr;
errno = 0;
sat_nb = strtoul(fields[7], &endptr, 10);
if ((errno == ERANGE && sat_nb == LONG_MAX)
|| (errno != 0 && sat_nb == 0)
|| *endptr != '\0') {
return set_nmea_error(status, msg, msg_size,
"Invalid number of satellites");
}
gpgga.sattelites_nb = (int)sat_nb;
}
/* Field 8. HDOP */
if (!parse_float(fields[8], &gpgga.hdop, &gpgga.has_hdop))
return set_nmea_error(status, msg, msg_size, "Invalid HDOP");
/* Field 9. Altitude above mean sea level */
if ( (gpgga.has_altitude = (fields[9][0] != '\0'))) {
char *endptr;
errno = 0;
gpgga.altitude = strtod(fields[9], &endptr);
if ((errno == ERANGE && (gpgga.altitude == HUGE_VAL || gpgga.altitude == -HUGE_VAL))
|| (errno != 0 && gpgga.altitude == 0)
|| (*endptr != '\0')
) {
return set_nmea_error(status, msg, msg_size, "Invalid altitude");
}
}
/* Field 11. Geoid height */
if ( (gpgga.has_geoid_height = (fields[11][0] != '\0'))) {
char *endptr;
errno = 0;
gpgga.geoid_height = strtod(fields[11], &endptr);
if ((errno == ERANGE && (gpgga.geoid_height == HUGE_VAL || gpgga.geoid_height == -HUGE_VAL))
|| (errno != 0 && gpgga.geoid_height == 0)
|| (*endptr != '\0')
) {
return set_nmea_error(status, msg, msg_size, "Invalid geoid height");
}
}
status->is_valid = true;
status->err[0] = '\0';
*dst = gpgga;
return status->is_valid;
}
void convert_float_literal(const std::string &src, exprt &dest)
{
mp_integer significand;
mp_integer exponent;
bool is_float, is_long;
unsigned base;
parse_float(src, significand, exponent, base, is_float, is_long);
dest = exprt("constant");
dest.cformat(src);
if(is_float)
{
dest.type() = float_type();
dest.type().set("#cpp_type", "float");
}
else if(is_long)
{
dest.type() = long_double_type();
dest.type().set("#cpp_type", "long_double");
}
else
{
dest.type() = double_type();
dest.type().set("#cpp_type", "double");
}
if(config.ansi_c.use_fixed_for_float)
{
unsigned width = atoi(dest.type().width().c_str());
unsigned fraction_bits;
const std::string &integer_bits = dest.type().integer_bits().as_string();
if(integer_bits == "")
fraction_bits = width / 2;
else
fraction_bits = width - atoi(integer_bits.c_str());
mp_integer factor = mp_integer(1) << fraction_bits;
mp_integer value = significand * factor;
if(value != 0)
{
if(exponent < 0)
value /= power(base, -exponent);
else
{
value *= power(base, exponent);
if(value >= power(2, width - 1))
{
// saturate: use "biggest value"
value = power(2, width - 1) - 1;
}
else if(value <= -power(2, width - 1) - 1)
{
// saturate: use "smallest value"
value = -power(2, width - 1);
}
}
}
dest.value(integer2binary(value, width));
}
else
{
ieee_floatt a;
a.spec = to_floatbv_type(dest.type());
if(base == 10)
a.from_base10(significand, exponent);
else if(base == 2) // hex
a.build(significand, exponent);
else
assert(false);
dest.value(integer2binary(a.pack(), a.spec.width()));
}
}
Value *Parser::parse_value(void) {
int c;
Value *value;
c = read_byte();
switch (c) {
case trace::TYPE_NULL:
value = new Null;
break;
case trace::TYPE_FALSE:
value = new Bool(false);
break;
case trace::TYPE_TRUE:
value = new Bool(true);
break;
case trace::TYPE_SINT:
value = parse_sint();
break;
case trace::TYPE_UINT:
value = parse_uint();
break;
case trace::TYPE_FLOAT:
value = parse_float();
break;
case trace::TYPE_DOUBLE:
value = parse_double();
break;
case trace::TYPE_STRING:
value = parse_string();
break;
case trace::TYPE_ENUM:
value = parse_enum();
break;
case trace::TYPE_BITMASK:
value = parse_bitmask();
break;
case trace::TYPE_ARRAY:
value = parse_array();
break;
case trace::TYPE_STRUCT:
value = parse_struct();
break;
case trace::TYPE_BLOB:
value = parse_blob();
break;
case trace::TYPE_OPAQUE:
value = parse_opaque();
break;
case trace::TYPE_REPR:
value = parse_repr();
break;
default:
std::cerr << "error: unknown type " << c << "\n";
exit(1);
case -1:
value = NULL;
break;
}
#if TRACE_VERBOSE
if (value) {
std::cerr << "\tVALUE ";
trace::dump(value, std::cerr);
std::cerr << "\n";
}
#endif
return value;
}
// prints out specified matches formatted by their Match type
// args: limit: number of entries to print IN TOTAL (default is 100)
void Memscan::printMatches(size_t limit) {
cout << "Printing first " << limit << " matches (" << matches.size() << " matches total)... FORMAT: [base address: offset: value: float]" << endl;
ostringstream b, w, d, q;
size_t num_entries = 0;
for (Match* m : matches) {
if (num_entries >= limit) {
break;
}
if (1 == m->size) { // size is BYTE
b << hex << uppercase << DWORD64(m->address) << nouppercase << dec << ": " << m->offset << ": " << m->value << ": " << parse_float(m->value, m->size) << endl;
} else if (2 == m->size) { // size is WORD
w << hex << uppercase << DWORD64(m->address) << nouppercase << dec << ": " << m->offset << ": " << m->value << ": " << parse_float(m->value, m->size) << endl;
} else if (4 == m->size) { // size is DWORD
d << hex << uppercase << DWORD64(m->address) << nouppercase << dec << ": " << m->offset << ": " << m->value << ": " << parse_float(m->value, m->size) << endl;
} else if (8 == m->size) { // size is QUADWORD
q << hex << uppercase << DWORD64(m->address) << nouppercase << dec << ": " << m->offset << ": " << m->value << ": " << parse_float(m->value, m->size) << endl;
} else {
cout << "Error: size not specified." << endl;
exit(1);
}
num_entries++;
}
if (b.str().length() != 0) {
cout << "BYTE" << endl;
cout << b.str();
}
if (w.str().length() != 0) {
cout << "WORD" << endl;
cout << w.str();
}
if (d.str().length() != 0) {
cout << "DWORD" << endl;
cout << d.str();
}
if (q.str().length() != 0) {
cout << "QUADWORD" << endl;
cout << q.str();
}
}
/* FIXME: This function does not handle LONG_LONG */
int _pSLang_sscanf (void)
{
int num;
unsigned int num_refs;
char *format;
char *input_string, *input_string_max;
SLFUTURE_CONST char *f, *s;
unsigned char map8[256], map10[256], map16[256];
if (SLang_Num_Function_Args < 2)
{
_pSLang_verror (SL_INVALID_PARM, "Int_Type sscanf (str, format, ...)");
return -1;
}
num_refs = (unsigned int) SLang_Num_Function_Args;
if (-1 == SLreverse_stack (num_refs))
return -1;
num_refs -= 2;
if (-1 == SLang_pop_slstring (&input_string))
return -1;
if (-1 == SLang_pop_slstring (&format))
{
SLang_free_slstring (input_string);
return -1;
}
f = format;
s = input_string;
input_string_max = input_string + strlen (input_string);
init_map (map8, 8);
init_map (map10, 10);
init_map (map16, 16);
num = 0;
while (num_refs != 0)
{
SLang_Object_Type obj;
SLang_Ref_Type *ref;
SLFUTURE_CONST char *smax;
unsigned char *map;
int base;
int no_assign;
int is_short;
int is_long;
int status;
char chf;
unsigned int width;
int has_width;
chf = *f++;
if (chf == 0)
{
/* Hmmm.... what is the most useful thing to do?? */
#if 1
break;
#else
_pSLang_verror (SL_INVALID_PARM, "sscanf: format not big enough for output list");
goto return_error;
#endif
}
if (isspace (chf))
{
char *s1 = _pSLskip_whitespace (s);
if (s1 == s)
break;
s = s1;
continue;
}
if ((chf != '%')
|| ((chf = *f++) == '%'))
{
if (*s != chf)
break;
s++;
continue;
}
no_assign = 0;
is_short = 0;
is_long = 0;
width = 0;
smax = input_string_max;
/* Look for the flag character */
if (chf == '*')
{
no_assign = 1;
chf = *f++;
}
/* Width */
has_width = isdigit (chf);
if (has_width)
{
f--;
(void) parse_uint (&f, f + strlen(f), &width, 10, map10);
chf = *f++;
}
/* Now the type modifier */
switch (chf)
{
case 'h':
is_short = 1;
chf = *f++;
break;
case 'L': /* not implemented */
case 'l':
is_long = 1;
chf = *f++;
break;
}
status = -1;
if ((chf != 'c') && (chf != '['))
{
s = _pSLskip_whitespace (s);
if (*s == 0)
break;
}
if (has_width)
{
if (width > (unsigned int) (input_string_max - s))
width = (unsigned int) (input_string_max - s);
smax = s + width;
}
/* Now the format descriptor */
map = map10;
base = 10;
try_again: /* used by i, x, and o, conversions */
switch (chf)
{
case 0:
_pSLang_verror (SL_INVALID_PARM, "sscanf: Unexpected end of format");
goto return_error;
case 'D':
is_long = 1;
case 'd':
if (is_short)
{
obj.o_data_type = SLANG_SHORT_TYPE;
status = parse_short (&s, smax, &obj.v.short_val, base, map);
}
else if (is_long)
{
obj.o_data_type = SLANG_LONG_TYPE;
status = parse_long (&s, smax, &obj.v.long_val, base, map);
}
else
{
obj.o_data_type = SLANG_INT_TYPE;
status = parse_int (&s, smax, &obj.v.int_val, base, map);
}
break;
case 'U':
is_long = 1;
case 'u':
if (is_short)
{
obj.o_data_type = SLANG_USHORT_TYPE;
status = parse_ushort (&s, smax, &obj.v.ushort_val, base, map);
}
else if (is_long)
{
obj.o_data_type = SLANG_ULONG_TYPE;
status = parse_ulong (&s, smax, &obj.v.ulong_val, base, map);
}
else
{
obj.o_data_type = SLANG_INT_TYPE;
status = parse_uint (&s, smax, &obj.v.uint_val, base, map);
}
break;
case 'I':
is_long = 1;
case 'i':
if ((s + 1 >= smax)
|| (*s != 0))
chf = 'd';
else if (((s[1] == 'x') || (s[1] == 'X'))
&& (s + 2 < smax))
{
s += 2;
chf = 'x';
}
else chf = 'o';
goto try_again;
case 'O':
is_long = 1;
case 'o':
map = map8;
base = 8;
chf = 'd';
goto try_again;
case 'X':
is_long = 1;
case 'x':
base = 16;
map = map16;
chf = 'd';
goto try_again;
case 'E':
case 'F':
is_long = 1;
case 'e':
case 'f':
case 'g':
#if SLANG_HAS_FLOAT
if (is_long)
{
obj.o_data_type = SLANG_DOUBLE_TYPE;
status = parse_double (&s, smax, &obj.v.double_val);
}
else
{
obj.o_data_type = SLANG_FLOAT_TYPE;
status = parse_float (&s, smax, &obj.v.float_val);
}
#else
_pSLang_verror (SL_NOT_IMPLEMENTED,
"This version of the S-Lang does not support floating point");
status = -1;
#endif
break;
case 's':
obj.o_data_type = SLANG_STRING_TYPE;
status = parse_string (&s, smax, &obj.v.s_val);
break;
case 'c':
if (has_width == 0)
{
obj.o_data_type = SLANG_UCHAR_TYPE;
obj.v.uchar_val = *s++;
status = 1;
break;
}
obj.o_data_type = SLANG_STRING_TYPE;
status = parse_bstring (&s, smax, &obj.v.s_val);
break;
case '[':
obj.o_data_type = SLANG_STRING_TYPE;
status = parse_range (&s, smax, &f, &obj.v.s_val);
break;
case 'n':
obj.o_data_type = SLANG_UINT_TYPE;
obj.v.uint_val = (unsigned int) (s - input_string);
status = 1;
break;
default:
status = -1;
_pSLang_verror (SL_NOT_IMPLEMENTED, "format specifier '%c' is not supported", chf);
break;
}
if (status == 0)
break;
if (status == -1)
goto return_error;
if (no_assign)
{
SLang_free_object (&obj);
continue;
}
if (-1 == SLang_pop_ref (&ref))
{
SLang_free_object (&obj);
goto return_error;
}
if (-1 == SLang_push (&obj))
{
SLang_free_object (&obj);
SLang_free_ref (ref);
goto return_error;
}
if (-1 == _pSLang_deref_assign (ref))
{
SLang_free_ref (ref);
goto return_error;
}
SLang_free_ref (ref);
num++;
num_refs--;
}
if (-1 == SLdo_pop_n (num_refs))
goto return_error;
SLang_free_slstring (format);
SLang_free_slstring (input_string);
return num;
return_error:
/* NULLS ok */
SLang_free_slstring (format);
SLang_free_slstring (input_string);
return -1;
}
