Kantha said:
Hi all,
I have declared an Union as follows
typedef union
{
struct interrupt_bits
{
unsigned char c_int_hs_fs_status : 1,
c_setup_intflag : 1,
c_hs_fs_state : 1,
c_int_suspend : 1,
c_int_resume : 1,
c_bus_reset : 1,
c_int_setup : 1,
c_int_ep0tx : 1,
c_int_ep0rx : 1,
c_int_ep2tx : 1,
c_int_ep2rx : 1;
} BITS;
short s_interrupt_flags;
}USB;
USB Usb;
Now when I compile the program , I get the a warning message saying
that
" warning: nonstandard type for a bit field". I am using a Texas
Instruments Cross Compiler(Code Composer Studio). Can anybody suggest
how to eliminate the warining message ??
Thanks in advance,
Srikanth
A bit picky. The data type for bit fields should be:
"A bit-field shall have a type that is a qualified or unqualified version of
_Bool, signed int, unsigned int, or some other implementation-defined type."
The ANSI/ISO C standard says (more fully):
©ISO/IEC ISO/IEC 9899:1999 (E)
Forward references: enumeration specifiers (6.7.2.2), structure and union
specifiers
(6.7.2.1), tags (6.7.2.3), type definitions (6.7.7).
6.7.2.1 Structure and union specifiers
Syntax
1 struct-or-union-specifier:
struct-or-union identifieropt { struct-declaration-list }
struct-or-union identifier
struct-or-union:
struct
union
struct-declaration-list:
struct-declaration
struct-declaration-list struct-declaration
struct-declaration:
specifier-qualifier-list struct-declarator-list ;
specifier-qualifier-list:
type-specifier specifier-qualifier-listopt
type-qualifier specifier-qualifier-listopt
struct-declarator-list:
struct-declarator
struct-declarator-list , struct-declarator
struct-declarator:
declarator
declaratoropt : constant-expression
Constraints
2 A structure or union shall not contain a member with incomplete or
function type (hence, a structure shall not contain an instance of itself,
but may contain a pointer to an instance of itself), except that the last
member of a structure with more than one named member may have incomplete
array type; such a structure (and any union containing, possibly
recursively, a member that is such a structure) shall not be a member of a
structure or an element of an array.
3 The expression that specifies the width of a bit-field shall be an integer
constant expression that has nonnegative value that shall not exceed the
number of bits in an object of the type that is specified if the colon and
expression are omitted. If the value is zero, the declaration shall have no
declarator.
4 A bit-field shall have a type that is a qualified or unqualified version
of _Bool, signed int, unsigned int, or some other implementation-defined
type.
Semantics
5 As discussed in 6.2.5, a structure is a type consisting of a sequence of
members, whose storage is allocated in an ordered sequence, and a union is a
type consisting of a sequence of members whose storage overlap.
6 Structure and union specifiers have the same form.
7 The presence of a struct-declaration-list in a struct-or-union-specifier
declares a new type, within a translation unit. The struct-declaration-list
is a sequence of declarations for the members of the structure or union. If
the struct-declaration-list contains no named members, the behavior is
undefined. The type is incomplete until after the } that terminates the
list.
8 A member of a structure or union may have any object type other than a
variably modified type.102) In addition, a member may be declared to consist
of a specified number of bits (including a sign bit, if any). Such a member
is called a bit-field;103) its width is preceded by a colon.
9 A bit-field is interpreted as a signed or unsigned integer type consisting
of the specified number of bits.104) If the value 0 or 1 is stored into a
nonzero-width bit-field of type _Bool, the value of the bit-field shall
compare equal to the value stored.
10 An implementation may allocate any addressable storage unit large enough
to hold a bitfield. If enough space remains, a bit-field that immediately
follows another bit-field in a structure shall be packed into adjacent bits
of the same unit. If insufficient space remains, whether a bit-field that
does not fit is put into the next unit or overlaps adjacent units is
implementation-defined. The order of allocation of bit-fields within a unit
(high-order to low-order or low-order to high-order) is
implementation-defined. The alignment of the addressable storage unit is
unspecified.
11 A bit-field declaration with no declarator, but only a colon and a width,
indicates an unnamed bit-field.105) As a special case, a bit-field structure
member with a width of 0 indicates that no further bit-field is to be packed
into the unit in which the previous bit-field, if any, was placed.
12 Each non-bit-field member of a structure or union object is aligned in an
implementationdefined manner appropriate to its type.
13 Within a structure object, the non-bit-field members and the units in
which bit-fields reside have addresses that increase in the order in which
they are declared. A pointer to a structure object, suitably converted,
points to its initial member (or if that member is a bit-field, then to the
unit in which it resides), and vice versa. There may be unnamed padding
within a structure object, but not at its beginning.
14 The size of a union is sufficient to contain the largest of its members.
The value of at most one of the members can be stored in a union object at
any time. A pointer to a union object, suitably converted, points to each of
its members (or if a member is a bitfield, then to the unit in which it
resides), and vice versa.
15 There may be unnamed padding at the end of a structure or union.
16 As a special case, the last element of a structure with more than one
named member may have an incomplete array type; this is called a flexible
array member. With two exceptions, the flexible array member is ignored.
First, the size of the structure shall be equal to the offset of the last
element of an otherwise identical structure that replaces the flexible array
member with an array of unspecified length.106) Second, when a . (or ->)
operator has a left operand that is (a pointer to) a structure with a
flexible array member and the right operand names that member, it behaves as
if that member were replaced with the longest array (with the same element
type) that would not make the structure larger than the object being
accessed; the offset of the array shall remain that of the flexible array
member, even if this would differ from that of the replacement array. If
this array would have no elements, it behaves as if it had one element but
the behavior is undefined if any attempt is made to access that element or
to generate a pointer one past it.
17 EXAMPLE Assuming that all array members are aligned the same, after the
declarations:
struct s { int n; double d[]; };
struct ss { int n; double d[1]; };
the three expressions:
sizeof (struct s)
offsetof(struct s, d)
offsetof(struct ss, d)
have the same value. The structure struct s has a flexible array member d.
18 If sizeof (double) is 8, then after the following code is executed:
struct s *s1;
struct s *s2;
s1 = malloc(sizeof (struct s) + 64);
s2 = malloc(sizeof (struct s) + 46);
and assuming that the calls to malloc succeed, the objects pointed to by s1
and s2 behave as if the
identifiers had been declared as:
struct { int n; double d[8]; } *s1;
struct { int n; double d[5]; } *s2;
19 Following the further successful assignments:
s1 = malloc(sizeof (struct s) + 10);
s2 = malloc(sizeof (struct s) + 6);
they then behave as if the declarations were:
struct { int n; double d[1]; } *s1, *s2;
and:
double *dp;
dp = &(s1->d[0]); // valid
*dp = 42; // valid
dp = &(s2->d[0]); // valid
*dp = 42; // undefined behavior
20 The assignment:
*s1 = *s2;
only copies the member n and not any of the array elements. Similarly:
struct s t1 = { 0 }; // valid
struct s t2 = { 2 }; // valid
struct ss tt = { 1, { 4.2 }}; // valid
struct s t3 = { 1, { 4.2 }}; // invalid: there is nothing for the 4.2 to
initialize
t1.n = 4; // valid
t1.d[0] = 4.2; // undefined behavior
Forward references: tags (6.7.2.3).
102) A structure or union can not contain a member with a variably modified
type because member names are not ordinary identifiers as defined in 6.2.3.
103) The unary & (address-of) operator cannot be applied to a bit-field
object; thus, there are no pointers to or arrays of bit-field objects.
104) As specified in 6.7.2 above, if the actual type specifier used is int
or a typedef-name defined as int, then it is implementation-defined whether
the bit-field is signed or unsigned.
105) An unnamed bit-field structure member is useful for padding to conform
to externally imposed layouts.
106) The length is unspecified to allow for the fact that implementations
may give array members different alignments according to their lengths.
, I