void c_typecastt::implicit_typecast_arithmetic(
exprt &expr,
c_typet c_type)
{
typet new_type;
const typet &expr_type=ns.follow(expr.type());
switch(c_type)
{
case PTR:
if(expr_type.id()==ID_array)
{
new_type.id(ID_pointer);
new_type.subtype()=expr_type.subtype();
break;
}
return;
case BOOL: new_type=bool_typet(); break;
case CHAR: assert(false); // should always be promoted to int
case UCHAR: assert(false); // should always be promoted to int
case SHORT: assert(false); // should always be promoted to int
case USHORT: assert(false); // should always be promoted to int
case INT: new_type=int_type(); break;
case UINT: new_type=uint_type(); break;
case LONG: new_type=long_int_type(); break;
case ULONG: new_type=long_uint_type(); break;
case LONGLONG: new_type=long_long_int_type(); break;
case ULONGLONG: new_type=long_long_uint_type(); break;
case SINGLE: new_type=float_type(); break;
case DOUBLE: new_type=double_type(); break;
case LONGDOUBLE: new_type=long_double_type(); break;
case RATIONAL: new_type=rational_typet(); break;
case REAL: new_type=real_typet(); break;
case INTEGER: new_type=integer_typet(); break;
case COMPLEX: return; // do nothing
default: return;
}
if(new_type!=expr_type)
{
if(new_type.id()==ID_pointer &&
expr_type.id()==ID_array)
{
exprt index_expr(ID_index, expr_type.subtype());
index_expr.reserve_operands(2);
index_expr.move_to_operands(expr);
index_expr.copy_to_operands(gen_zero(index_type()));
expr=exprt(ID_address_of, new_type);
expr.move_to_operands(index_expr);
}
else
do_typecast(expr, new_type);
}
}
hdf5_iprimitive::read_hdf5_dataset
(
long double* t,
std::size_t data_count,
std::size_t object_number
)
{
hdf5_datatype double_type(H5T_NATIVE_LDOUBLE);
read_dataset_basic(t, data_count, double_type, object_number);
}
hdf5_oprimitive::write_hdf5_dataset
(
long double const* t,
std::size_t data_count,
std::size_t object_number
)
{
hdf5_datatype double_type(H5T_NATIVE_LDOUBLE);
write_dataset_basic(t, data_count, double_type, object_number);
}
BOOST_ARCHIVE_OR_WARCHIVE_DECL void
hdf5_oprimitive::write_hdf5_dataset
(
double const* t,
std::size_t data_count,
std::size_t object_number
)
{
hdf5_datatype double_type(H5T_NATIVE_DOUBLE);
write_dataset_basic(t, data_count, double_type, object_number);
}
double1 sqrt( const expression<E1>& a, double_type )
{
double1 w,x;
w = a();
x = native_sqrt(w,double_type());
x = 0.5*(x + w/x);
x = 0.5*(x + w/x);
return x;
}
VerificationType VerificationType::from_tag(u1 tag) {
switch (tag) {
case ITEM_Top: return bogus_type();
case ITEM_Integer: return integer_type();
case ITEM_Float: return float_type();
case ITEM_Double: return double_type();
case ITEM_Long: return long_type();
case ITEM_Null: return null_type();
default:
ShouldNotReachHere();
return bogus_type();
}
}
void c_typecastt::implicit_typecast_arithmetic(
exprt &expr,
c_typet c_type)
{
typet new_type;
const typet &expr_type=ns.follow(expr.type());
switch(c_type)
{
case PTR:
if(expr_type.id()==ID_array)
{
new_type.id(ID_pointer);
new_type.subtype()=expr_type.subtype();
break;
}
return;
case BOOL: assert(false); // should always be promoted to int
case CHAR: assert(false); // should always be promoted to int
case UCHAR: assert(false); // should always be promoted to int
case SHORT: assert(false); // should always be promoted to int
case USHORT: assert(false); // should always be promoted to int
case INT: new_type=signed_int_type(); break;
case UINT: new_type=unsigned_int_type(); break;
case LONG: new_type=signed_long_int_type(); break;
case ULONG: new_type=unsigned_long_int_type(); break;
case LONGLONG: new_type=signed_long_long_int_type(); break;
case ULONGLONG: new_type=unsigned_long_long_int_type(); break;
case SINGLE: new_type=float_type(); break;
case DOUBLE: new_type=double_type(); break;
case LONGDOUBLE: new_type=long_double_type(); break;
case FLOAT128: new_type=ieee_float_spect::quadruple_precision().to_type(); break;
case RATIONAL: new_type=rational_typet(); break;
case REAL: new_type=real_typet(); break;
case INTEGER: new_type=integer_typet(); break;
case COMPLEX: return; // do nothing
default: return;
}
if(new_type!=expr_type)
do_typecast(expr, new_type);
}
exprt convert_float_literal(const std::string &src)
{
mp_integer significand;
mp_integer exponent;
bool is_float, is_long, is_imaginary;
bool is_decimal, is_float80, is_float128; // GCC extensions
unsigned base;
parse_float(src, significand, exponent, base,
is_float, is_long, is_imaginary,
is_decimal, is_float80, is_float128);
exprt result=exprt(ID_constant);
result.set(ID_C_cformat, src);
// In ANSI-C, float literals are double by default,
// unless marked with 'f'.
// All of these can be complex as well.
// This can be overriden with
// config.ansi_c.single_precision_constant.
if(is_float)
result.type()=float_type();
else if(is_long)
result.type()=long_double_type();
else if(is_float80)
{
result.type()=ieee_float_spect(64, 15).to_type();
result.type().set(ID_C_c_type, ID_long_double);
}
else if(is_float128)
{
result.type()=ieee_float_spect::quadruple_precision().to_type();
result.type().set(ID_C_c_type, ID_gcc_float128);
}
else
{
// default
if(config.ansi_c.single_precision_constant)
result.type()=float_type(); // default
else
result.type()=double_type(); // default
}
if(is_decimal)
{
// TODO - should set ID_gcc_decimal32/ID_gcc_decimal64/ID_gcc_decimal128,
// but these aren't handled anywhere
}
if(config.ansi_c.use_fixed_for_float)
{
unsigned width=result.type().get_int(ID_width);
unsigned fraction_bits;
const irep_idt integer_bits=result.type().get(ID_integer_bits);
assert(width!=0);
if(integer_bits==irep_idt())
fraction_bits=width/2; // default
else
fraction_bits=width-safe_string2int(id2string(integer_bits));
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);
}
}
}
result.set(ID_value, integer2binary(value, width));
}
else
{
ieee_floatt a;
a.spec=to_floatbv_type(result.type());
if(base==10)
a.from_base10(significand, exponent);
else if(base==2) // hex
a.build(significand, exponent);
else
assert(false);
result.set(ID_value,
integer2binary(a.pack(), a.spec.width()));
}
if(is_imaginary)
{
complex_typet complex_type;
complex_type.subtype()=result.type();
exprt complex_expr(ID_complex, complex_type);
complex_expr.operands().resize(2);
complex_expr.op0()=gen_zero(result.type());
complex_expr.op1()=result;
return complex_expr;
}
return result;
}
double_literal::double_literal()
: string_(std::string()), type_(double_type()) {}
void printf_formattert::process_format(std::ostream &out)
{
exprt tmp;
format_constantt format_constant;
format_constant.precision=6;
format_constant.min_width=0;
format_constant.zero_padding=false;
char ch=next();
if(ch=='0') // leading zeros
{
format_constant.zero_padding=true;
ch=next();
}
while(isdigit(ch)) // width
{
format_constant.min_width*=10;
format_constant.min_width+=ch-'0';
ch=next();
}
if(ch=='.') // precision
{
format_constant.precision=0;
ch=next();
while(isdigit(ch))
{
format_constant.precision*=10;
format_constant.precision+=ch-'0';
ch=next();
}
}
switch(ch)
{
case '%':
out << ch;
break;
case 'e':
case 'E':
format_constant.style=format_spect::stylet::SCIENTIFIC;
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), double_type()));
break;
case 'f':
case 'F':
format_constant.style=format_spect::stylet::DECIMAL;
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), double_type()));
break;
case 'g':
case 'G':
format_constant.style=format_spect::stylet::AUTOMATIC;
if(format_constant.precision==0)
format_constant.precision=1;
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), double_type()));
break;
case 's':
{
if(next_operand==operands.end())
break;
// this is the address of a string
const exprt &op=*(next_operand++);
if(op.id()==ID_address_of &&
op.operands().size()==1 &&
op.op0().id()==ID_index &&
op.op0().operands().size()==2 &&
op.op0().op0().id()==ID_string_constant)
out << format_constant(op.op0().op0());
}
break;
case 'd':
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), signed_int_type()));
break;
case 'D':
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), signed_long_int_type()));
break;
case 'u':
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), unsigned_int_type()));
break;
case 'U':
if(next_operand==operands.end())
break;
out << format_constant(
make_type(*(next_operand++), unsigned_long_int_type()));
break;
default:
out << '%' << ch;
}
}
void c_typecheck_baset::typecheck_type(typet &type)
{
// we first convert, and then check
{
ansi_c_convert_typet ansi_c_convert_type(get_message_handler());
ansi_c_convert_type.read(type);
ansi_c_convert_type.write(type);
}
if(type.id()==ID_already_typechecked)
{
// need to preserve any qualifiers
c_qualifierst c_qualifiers(type);
c_qualifiers+=c_qualifierst(type.subtype());
bool packed=type.get_bool(ID_C_packed);
exprt alignment=static_cast<const exprt &>(type.find(ID_C_alignment));
irept _typedef=type.find(ID_C_typedef);
type=type.subtype();
c_qualifiers.write(type);
if(packed)
type.set(ID_C_packed, true);
if(alignment.is_not_nil())
type.add(ID_C_alignment, alignment);
if(_typedef.is_not_nil())
type.add(ID_C_typedef, _typedef);
return; // done
}
// do we have alignment?
if(type.find(ID_C_alignment).is_not_nil())
{
exprt &alignment=static_cast<exprt &>(type.add(ID_C_alignment));
if(alignment.id()!=ID_default)
{
typecheck_expr(alignment);
make_constant(alignment);
}
}
if(type.id()==ID_code)
typecheck_code_type(to_code_type(type));
else if(type.id()==ID_array)
typecheck_array_type(to_array_type(type));
else if(type.id()==ID_pointer)
typecheck_type(type.subtype());
else if(type.id()==ID_struct ||
type.id()==ID_union)
typecheck_compound_type(to_struct_union_type(type));
else if(type.id()==ID_c_enum)
typecheck_c_enum_type(type);
else if(type.id()==ID_c_enum_tag)
typecheck_c_enum_tag_type(to_c_enum_tag_type(type));
else if(type.id()==ID_c_bit_field)
typecheck_c_bit_field_type(to_c_bit_field_type(type));
else if(type.id()==ID_typeof)
typecheck_typeof_type(type);
else if(type.id()==ID_symbol)
typecheck_symbol_type(type);
else if(type.id()==ID_vector)
typecheck_vector_type(to_vector_type(type));
else if(type.id()==ID_custom_unsignedbv ||
type.id()==ID_custom_signedbv ||
type.id()==ID_custom_floatbv ||
type.id()==ID_custom_fixedbv)
typecheck_custom_type(type);
else if(type.id()==ID_gcc_attribute_mode)
{
// get that mode
irep_idt mode=type.get(ID_size);
// A list of all modes ist at
// http://www.delorie.com/gnu/docs/gcc/gccint_53.html
typecheck_type(type.subtype());
typet underlying_type=type.subtype();
// gcc allows this, but clang doesn't; it's a compiler hint only,
// but we'll try to interpret it the GCC way
if(underlying_type.id()==ID_c_enum_tag)
{
underlying_type=
follow_tag(to_c_enum_tag_type(underlying_type)).subtype();
assert(underlying_type.id()==ID_signedbv ||
underlying_type.id()==ID_unsignedbv);
}
if(underlying_type.id()==ID_signedbv ||
underlying_type.id()==ID_unsignedbv)
{
bool is_signed=underlying_type.id()==ID_signedbv;
typet result;
if(mode=="__QI__") // 8 bits
result=is_signed?signed_char_type():unsigned_char_type();
else if(mode=="__byte__") // 8 bits
result=is_signed?signed_char_type():unsigned_char_type();
else if(mode=="__HI__") // 16 bits
result=is_signed?signed_short_int_type():unsigned_short_int_type();
else if(mode=="__SI__") // 32 bits
result=is_signed?signed_int_type():unsigned_int_type();
else if(mode=="__word__") // long int, we think
result=is_signed?signed_long_int_type():unsigned_long_int_type();
else if(mode=="__pointer__") // we think this is size_t/ssize_t
result=is_signed?signed_size_type():size_type();
else if(mode=="__DI__") // 64 bits
{
if(config.ansi_c.long_int_width==64)
result=is_signed?signed_long_int_type():unsigned_long_int_type();
else
{
assert(config.ansi_c.long_long_int_width==64);
result=
is_signed?signed_long_long_int_type():unsigned_long_long_int_type();
}
}
else if(mode=="__TI__") // 128 bits
result=is_signed?gcc_signed_int128_type():gcc_unsigned_int128_type();
else if(mode=="__V2SI__") // vector of 2 ints, deprecated by gcc
result=
vector_typet(
is_signed?signed_int_type():unsigned_int_type(),
from_integer(2, size_type()));
else if(mode=="__V4SI__") // vector of 4 ints, deprecated by gcc
result=
vector_typet(
is_signed?signed_int_type():unsigned_int_type(),
from_integer(4, size_type()));
else // give up, just use subtype
result=type.subtype();
// save the location
result.add_source_location()=type.source_location();
if(type.subtype().id()==ID_c_enum_tag)
{
const irep_idt &tag_name=
to_c_enum_tag_type(type.subtype()).get_identifier();
symbol_tablet::symbolst::iterator entry=
symbol_table.symbols.find(tag_name);
assert(entry!=symbol_table.symbols.end());
entry->second.type.subtype()=result;
}
type=result;
}
else if(underlying_type.id()==ID_floatbv)
{
typet result;
if(mode=="__SF__") // 32 bits
result=float_type();
else if(mode=="__DF__") // 64 bits
result=double_type();
else if(mode=="__TF__") // 128 bits
result=gcc_float128_type();
else if(mode=="__V2SF__") // vector of 2 floats, deprecated by gcc
result=vector_typet(float_type(), from_integer(2, size_type()));
else if(mode=="__V2DF__") // vector of 2 doubles, deprecated by gcc
result=vector_typet(double_type(), from_integer(2, size_type()));
else if(mode=="__V4SF__") // vector of 4 floats, deprecated by gcc
result=vector_typet(float_type(), from_integer(4, size_type()));
else if(mode=="__V4DF__") // vector of 4 doubles, deprecated by gcc
result=vector_typet(double_type(), from_integer(4, size_type()));
else // give up, just use subtype
result=type.subtype();
// save the location
result.add_source_location()=type.source_location();
type=result;
}
else if(underlying_type.id()==ID_complex)
{
// gcc allows this, but clang doesn't -- see enums above
typet result;
if(mode=="__SC__") // 32 bits
result=float_type();
else if(mode=="__DC__") // 64 bits
result=double_type();
else if(mode=="__TC__") // 128 bits
result=gcc_float128_type();
else // give up, just use subtype
result=type.subtype();
// save the location
result.add_source_location()=type.source_location();
type=complex_typet(result);
}
else
{
error().source_location=type.source_location();
error() << "attribute mode `" << mode
<< "' applied to inappropriate type `"
<< to_string(type) << "'" << eom;
throw 0;
}
}
// do a mild bit of rule checking
if(type.get_bool(ID_C_restricted) &&
type.id()!=ID_pointer &&
type.id()!=ID_array)
{
error().source_location=type.source_location();
error() << "only a pointer can be 'restrict'" << eom;
throw 0;
}
}
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()));
}
}
double_literal::double_literal(double val)
: val_(val), string_(std::string()), type_(double_type()) {}
bool bare_expr_type::is_primitive() const {
return order_id() == int_type().oid() || order_id() == double_type().oid();
}
void ansi_c_convert_typet::write(typet &type)
{
type.clear();
// first, do "other"
if(!other.empty())
{
if(
double_cnt || float_cnt || signed_cnt || unsigned_cnt || int_cnt ||
bool_cnt || short_cnt || char_cnt || int8_cnt || int16_cnt || int32_cnt ||
int64_cnt || ptr32_cnt || ptr64_cnt || long_cnt)
{
err_location(location);
error("illegal type modifier for defined type");
throw 0;
}
if(other.size() != 1)
{
err_location(location);
error("illegal combination of defined types");
throw 0;
}
type.swap(other.front());
}
else if(double_cnt || float_cnt)
{
if(
signed_cnt || unsigned_cnt || int_cnt || bool_cnt || int8_cnt ||
int16_cnt || int32_cnt || int64_cnt || ptr32_cnt || ptr64_cnt ||
short_cnt || char_cnt)
{
err_location(location);
error("cannot conbine integer type with float");
throw 0;
}
if(double_cnt && float_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
if(long_cnt == 0)
{
if(double_cnt != 0)
type = double_type();
else
type = float_type();
}
else if(long_cnt == 1 || long_cnt == 2)
{
if(double_cnt != 0)
type = long_double_type();
else
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
}
else
{
err_location(location);
error("illegal type modifier for float");
throw 0;
}
}
else if(bool_cnt)
{
if(
signed_cnt || unsigned_cnt || int_cnt || short_cnt || int8_cnt ||
int16_cnt || int32_cnt || int64_cnt || ptr32_cnt || ptr64_cnt ||
char_cnt || long_cnt)
{
err_location(location);
error("illegal type modifier for boolean type");
throw 0;
}
type.id("bool");
}
else if(ptr32_cnt || ptr64_cnt)
{
type.id("pointer");
type.subtype() = typet("empty");
}
else
{
// it is integer -- signed or unsigned?
if(signed_cnt && unsigned_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
if(unsigned_cnt)
type.id("unsignedbv");
else if(signed_cnt)
type.id("signedbv");
else
{
if(char_cnt)
type.id(config.ansi_c.char_is_unsigned ? "unsignedbv" : "signedbv");
else
type.id("signedbv");
}
// get width
unsigned width;
if(int8_cnt || int16_cnt || int32_cnt || int64_cnt)
{
if(long_cnt || char_cnt || short_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
if(int8_cnt)
width = 1 * 8;
else if(int16_cnt)
width = 2 * 8;
else if(int32_cnt)
width = 4 * 8;
else if(int64_cnt)
width = 8 * 8;
else
abort();
}
else if(short_cnt)
{
if(long_cnt || char_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
width = config.ansi_c.short_int_width;
}
else if(char_cnt)
{
if(long_cnt)
{
err_location(location);
error("illegal type modifier for char type");
throw 0;
}
width = config.ansi_c.char_width;
}
else if(long_cnt == 0)
{
width = config.ansi_c.int_width;
}
else if(long_cnt == 1)
{
width = config.ansi_c.long_int_width;
}
else if(long_cnt == 2)
{
width = config.ansi_c.long_long_int_width;
}
else
{
err_location(location);
error("illegal type modifier for integer type");
throw 0;
}
type.width(width);
}
c_qualifiers.write(type);
}
exprt convert_float_literal(const std::string &src)
{
mp_integer significand;
mp_integer exponent;
bool is_float, is_long, is_fixed, is_accum;
unsigned base;
parse_float(src, significand, exponent, base, is_float, is_long, is_fixed, is_accum);
exprt result=exprt(ID_constant);
result.set(ID_C_cformat, src);
// In ANSI-C, float literals are double by default
// unless marked with 'f'.
if(is_float)
{
result.type()=float_type();
result.type().set(ID_C_cpp_type, ID_float);
}
else if(is_long)
{
result.type()=long_double_type();
result.type().set(ID_C_cpp_type, ID_long_double);
}
else if(is_fixed)
{
result.type()=fixed_type();
result.type().set(ID_C_cpp_type, ID_fixed);
}
else if(is_accum)
{
result.type()=accum_type();
result.type().set(ID_C_cpp_type, ID_accum);
}
else
{
result.type()=double_type(); // default
result.type().set(ID_C_cpp_type, ID_double);
}
if(config.ansi_c.use_fixed_for_float || is_fixed || is_accum)
{
unsigned width=result.type().get_int(ID_width);
unsigned fraction_bits;
const irep_idt integer_bits=result.type().get(ID_integer_bits);
assert(width!=0);
if(is_fixed)
{
fraction_bits = width - 1;
}
else if(is_accum)
{
fraction_bits = width - 9;
}
else if(integer_bits==irep_idt())
fraction_bits=width/2; // default
else
fraction_bits=width-safe_string2int(id2string(integer_bits));
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);
}
}
}
result.set(ID_value, integer2binary(value, width));
}
else
{
ieee_floatt a;
a.spec=to_floatbv_type(result.type());
if(base==10)
a.from_base10(significand, exponent);
else if(base==2) // hex
a.build(significand, exponent);
else
assert(false);
result.set(ID_value,
integer2binary(a.pack(), a.spec.width()));
}
return result;
}
static void
call(Iterator const& first, Iterator const& last, double& attr)
{
Iterator first_ = first;
qi::parse(first_, last, double_type(), attr);
}
bool bare_expr_type::is_double_type() const {
return order_id() == double_type().oid();
}
void ansi_c_convert_typet::write(typet &type)
{
type.clear();
// first, do "other"
if(!other.empty())
{
if(double_cnt || float_cnt || signed_cnt ||
unsigned_cnt || int_cnt || c_bool_cnt || proper_bool_cnt ||
short_cnt || char_cnt || complex_cnt || long_cnt ||
int8_cnt || int16_cnt || int32_cnt || int64_cnt ||
gcc_float128_cnt || gcc_int128_cnt || bv_cnt)
{
err_location(location);
error("illegal type modifier for defined type");
throw 0;
}
if(other.size()!=1)
{
err_location(location);
error("illegal combination of defined types");
throw 0;
}
type.swap(other.front());
}
else if(gcc_float128_cnt)
{
if(signed_cnt || unsigned_cnt || int_cnt || c_bool_cnt || proper_bool_cnt ||
int8_cnt || int16_cnt || int32_cnt || int64_cnt ||
gcc_int128_cnt || bv_cnt ||
short_cnt || char_cnt)
{
err_location(location);
error("cannot combine integer type with float");
throw 0;
}
if(long_cnt || double_cnt || float_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
type=long_double_type();
}
else if(double_cnt || float_cnt)
{
if(signed_cnt || unsigned_cnt || int_cnt || c_bool_cnt || proper_bool_cnt ||
int8_cnt || int16_cnt || int32_cnt || int64_cnt ||
gcc_int128_cnt|| bv_cnt ||
short_cnt || char_cnt)
{
err_location(location);
error("cannot combine integer type with float");
throw 0;
}
if(double_cnt && float_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
if(long_cnt==0)
{
if(double_cnt!=0)
type=double_type();
else
type=float_type();
}
else if(long_cnt==1 || long_cnt==2)
{
if(double_cnt!=0)
type=long_double_type();
else
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
}
else
{
err_location(location);
error("illegal type modifier for float");
throw 0;
}
}
else if(c_bool_cnt)
{
if(signed_cnt || unsigned_cnt || int_cnt || short_cnt ||
int8_cnt || int16_cnt || int32_cnt || int64_cnt ||
gcc_float128_cnt || bv_cnt || proper_bool_cnt ||
char_cnt || long_cnt)
{
err_location(location);
error("illegal type modifier for C boolean type");
throw 0;
}
type.id(ID_unsignedbv);
type.set(ID_width, config.ansi_c.bool_width);
type.set(ID_C_c_type, ID_bool);
}
else if(proper_bool_cnt)
{
if(signed_cnt || unsigned_cnt || int_cnt || short_cnt ||
int8_cnt || int16_cnt || int32_cnt || int64_cnt ||
gcc_float128_cnt || bv_cnt ||
char_cnt || long_cnt)
{
err_location(location);
error("illegal type modifier for proper boolean type");
throw 0;
}
type.id(ID_bool);
}
else if(complex_cnt && !char_cnt && !signed_cnt && !unsigned_cnt && !short_cnt && !gcc_int128_cnt)
{
// the "default" for complex is double
type=double_type();
}
else
{
// it is integer -- signed or unsigned?
if(signed_cnt && unsigned_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
else if(unsigned_cnt)
type.id(ID_unsignedbv);
else if(signed_cnt)
type.id(ID_signedbv);
else
{
if(char_cnt)
type.id(config.ansi_c.char_is_unsigned?ID_unsignedbv:ID_signedbv);
else
type.id(ID_signedbv);
}
// get width
unsigned width;
if(gcc_mode_QI || gcc_mode_HI || gcc_mode_SI || gcc_mode_DI)
{
if(gcc_mode_QI)
width=1*8;
else if(gcc_mode_HI)
width=2*8;
else if(gcc_mode_SI)
width=4*8;
else if(gcc_mode_DI)
width=8*8;
else
assert(false);
}
else if(int8_cnt || int16_cnt || int32_cnt || int64_cnt || gcc_int128_cnt || bv_cnt)
{
if(long_cnt || char_cnt || short_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
if(int8_cnt)
width=1*8;
else if(int16_cnt)
width=2*8;
else if(int32_cnt)
width=4*8;
else if(int64_cnt)
width=8*8;
else if(bv_cnt)
width=bv_width;
else if(gcc_int128_cnt)
width=128;
else
assert(false);
}
else if(short_cnt)
{
if(long_cnt || char_cnt)
{
err_location(location);
error("conflicting type modifiers");
throw 0;
}
width=config.ansi_c.short_int_width;
}
else if(char_cnt)
{
if(long_cnt)
{
err_location(location);
error("illegal type modifier for char type");
throw 0;
}
width=config.ansi_c.char_width;
}
else if(long_cnt==0)
{
width=config.ansi_c.int_width;
}
else if(long_cnt==1)
{
width=config.ansi_c.long_int_width;
}
else if(long_cnt==2)
{
width=config.ansi_c.long_long_int_width;
}
else
{
err_location(location);
error("illegal type modifier for integer type");
throw 0;
}
type.set(ID_width, width);
}
if(vector_size.is_not_nil())
{
vector_typet new_type;
new_type.size()=vector_size;
new_type.location()=vector_size.location();
new_type.subtype().swap(type);
type=new_type;
}
if(complex_cnt)
{
// These take more or less arbitrary subtypes.
complex_typet new_type;
new_type.location()=location;
new_type.subtype()=type;
type.swap(new_type);
}
c_qualifiers.write(type);
if(packed)
type.set(ID_C_packed, true);
if(aligned)
type.set(ID_C_alignment, alignment);
}
bare_expr_type::bare_expr_type(const double_type& x)
: bare_type_(double_type(x.is_data_)) {}
typet get_type(const format_tokent &token)
{
switch(token.type)
{
case format_tokent::INT:
switch(token.length_modifier)
{
case format_tokent::LEN_h:
if(token.representation==format_tokent::SIGNED_DEC)
return signed_char_type();
else
return unsigned_char_type();
case format_tokent::LEN_hh:
if(token.representation==format_tokent::SIGNED_DEC)
return signed_short_int_type();
else
return unsigned_short_int_type();
case format_tokent::LEN_l:
if(token.representation==format_tokent::SIGNED_DEC)
return signed_long_int_type();
else
return unsigned_long_int_type();
case format_tokent::LEN_ll:
if(token.representation==format_tokent::SIGNED_DEC)
return signed_long_long_int_type();
else
return unsigned_long_long_int_type();
default:
if(token.representation==format_tokent::SIGNED_DEC)
return signed_int_type();
else
return unsigned_int_type();
}
case format_tokent::FLOAT:
switch(token.length_modifier)
{
case format_tokent::LEN_l: return double_type();
case format_tokent::LEN_L: return long_double_type();
default: return float_type();
}
case format_tokent::CHAR:
switch(token.length_modifier)
{
case format_tokent::LEN_l: return wchar_t_type();
default: return char_type();
}
case format_tokent::POINTER:
return pointer_type(void_type());
case format_tokent::STRING:
switch(token.length_modifier)
{
case format_tokent::LEN_l: return array_typet(wchar_t_type(), nil_exprt());
default: return array_typet(char_type(), nil_exprt());
}
default:
return nil_typet();
}
}
