if (type->is_slice_type())
{
Type* element_type = type->array_type()->element_type()->forwarded();
- bool is_byte = element_type == Type::lookup_integer_type("uint8");
- bool is_int = element_type == Type::lookup_integer_type("int");
- if (is_byte || is_int)
+ bool is_byte = (element_type->integer_type() != NULL
+ && element_type->integer_type()->is_byte());
+ bool is_rune = (element_type->integer_type() != NULL
+ && element_type->integer_type()->is_rune());
+ if (is_byte || is_rune)
{
std::string s;
if (val->string_constant_value(&s))
tree len = a->length_tree(gogo, expr_tree);
len = fold_convert_loc(this->location().gcc_location(), integer_type_node,
len);
- if (e->integer_type()->is_unsigned()
- && e->integer_type()->bits() == 8)
+ if (e->integer_type()->is_byte())
{
static tree byte_array_to_string_fndecl;
ret = Gogo::call_builtin(&byte_array_to_string_fndecl,
}
else
{
- go_assert(e == Type::lookup_integer_type("int"));
+ go_assert(e->integer_type()->is_rune());
static tree int_array_to_string_fndecl;
ret = Gogo::call_builtin(&int_array_to_string_fndecl,
this->location(),
{
Type* e = type->array_type()->element_type()->forwarded();
go_assert(e->integer_type() != NULL);
- if (e->integer_type()->is_unsigned()
- && e->integer_type()->bits() == 8)
+ if (e->integer_type()->is_byte())
{
tree string_to_byte_array_fndecl = NULL_TREE;
ret = Gogo::call_builtin(&string_to_byte_array_fndecl,
}
else
{
- go_assert(e == Type::lookup_integer_type("int"));
+ go_assert(e->integer_type()->is_rune());
tree string_to_int_array_fndecl = NULL_TREE;
ret = Gogo::call_builtin(&string_to_int_array_fndecl,
this->location(),
break;
}
- Type* e2;
if (arg2_type->is_slice_type())
- e2 = arg2_type->array_type()->element_type();
+ {
+ Type* e2 = arg2_type->array_type()->element_type();
+ if (!Type::are_identical(e1, e2, true, NULL))
+ this->report_error(_("element types must be the same"));
+ }
else if (arg2_type->is_string_type())
- e2 = Type::lookup_integer_type("uint8");
- else
{
- this->report_error(_("right argument must be a slice or a string"));
- break;
+ if (e1->integer_type() == NULL || !e1->integer_type()->is_byte())
+ this->report_error(_("first argument must be []byte"));
}
-
- if (!Type::are_identical(e1, e2, true, NULL))
- this->report_error(_("element types must be the same"));
+ else
+ this->report_error(_("second argument must be slice or string"));
}
break;
{
const Array_type* at = args->front()->type()->array_type();
const Type* e = at->element_type()->forwarded();
- if (e == Type::lookup_integer_type("uint8"))
+ if (e->integer_type() != NULL && e->integer_type()->is_byte())
break;
}
tree arg2_len;
tree element_size;
if (arg2->type()->is_string_type()
- && element_type == Type::lookup_integer_type("uint8"))
+ && element_type->integer_type() != NULL
+ && element_type->integer_type()->is_byte())
{
arg2_tree = save_expr(arg2_tree);
arg2_val = String_type::bytes_tree(gogo, arg2_tree);
if (lhs->complex_type() != NULL && rhs->complex_type() != NULL)
return true;
- // An integer, or []byte, or []int, may be converted to a string.
+ // An integer, or []byte, or []rune, may be converted to a string.
if (lhs->is_string_type())
{
if (rhs->integer_type() != NULL)
{
const Type* e = rhs->array_type()->element_type()->forwarded();
if (e->integer_type() != NULL
- && (e == Type::lookup_integer_type("uint8")
- || e == Type::lookup_integer_type("int")))
+ && (e->integer_type()->is_byte()
+ || e->integer_type()->is_rune()))
return true;
}
}
- // A string may be converted to []byte or []int.
+ // A string may be converted to []byte or []rune.
if (rhs->is_string_type() && lhs->is_slice_type())
{
const Type* e = lhs->array_type()->element_type()->forwarded();
if (e->integer_type() != NULL
- && (e == Type::lookup_integer_type("uint8")
- || e == Type::lookup_integer_type("int")))
+ && (e->integer_type()->is_byte() || e->integer_type()->is_rune()))
return true;
}
bool
is_identical(const Integer_type* t) const;
- protected:
+ // Whether this is the type "byte" or another name for "byte".
+ bool
+ is_byte() const
+ { return this->is_byte_; }
+
+ // Mark this as the "byte" type.
+ void
+ set_is_byte()
+ { this->is_byte_ = true; }
+
+ // Whether this is the type "rune" or another name for "rune".
+ bool
+ is_rune() const
+ { return this->is_rune_; }
+
+ // Mark this as the "rune" type.
+ void
+ set_is_rune()
+ { this->is_rune_ = true; }
+
+protected:
bool
do_compare_is_identity(Gogo*) const
{ return true; }
Integer_type(bool is_abstract, bool is_unsigned, int bits,
int runtime_type_kind)
: Type(TYPE_INTEGER),
- is_abstract_(is_abstract), is_unsigned_(is_unsigned), bits_(bits),
- runtime_type_kind_(runtime_type_kind)
+ is_abstract_(is_abstract), is_unsigned_(is_unsigned), is_byte_(false),
+ is_rune_(false), bits_(bits), runtime_type_kind_(runtime_type_kind)
{ }
// Map names of integer types to the types themselves.
bool is_abstract_;
// True if this is an unsigned type.
bool is_unsigned_;
+ // True if this is the byte type.
+ bool is_byte_;
+ // True if this is the rune type.
+ bool is_rune_;
// The number of bits.
int bits_;
// The runtime type code used in the type descriptor for this type.