@@ -19,15 +19,15 @@ void print_bitfield(bitfield bfield)
19
19
Bindgen creates a set of field getters and setters for interacting with the bitset. For example,
20
20
21
21
```rust
22
- let mut bfield = unsafe{create_bitfield()};
22
+ let mut bfield = unsafe{ create_bitfield() };
23
23
24
24
bfield.set_a(1);
25
25
println!("a set to {}", bfield.a());
26
26
bfield.set_b(1);
27
27
println!("b set to {}", bfield.b());
28
28
bfield.set_c(3);
29
29
println!("c set to {}", bfield.c());
30
- unsafe{print_bitfield(bfield)};
30
+ unsafe{ print_bitfield(bfield) };
31
31
```
32
32
33
33
will print out
@@ -42,12 +42,12 @@ bitfield: a:1, b:1, c:3
42
42
Overflowing a bitfield will result in the same behavior as in C/C++: the bitfield will be set to 0.
43
43
44
44
``` rust
45
- let mut bfield = unsafe {create_bitfield ()};
45
+ let mut bfield = unsafe { create_bitfield () };
46
46
bfield . set_a (1 );
47
47
bfield . set_b (1 );
48
48
bfield . set_c (12 );
49
49
println! (" c set to {} due to overflow" , bfield . c ());
50
- unsafe {print_bitfield (bfield )};
50
+ unsafe { print_bitfield (bfield ) };
51
51
```
52
52
53
53
will print out
@@ -60,10 +60,10 @@ bitfield: a:1, b:1, c:0
60
60
To create a new bitfield in Rust, use mem::zeroed.
61
61
62
62
``` rust
63
- let mut bfield = unsafe {mem :: zeroed :: <bitfield >()};
63
+ let mut bfield = unsafe { mem :: zeroed :: <bitfield >() };
64
64
bfield . set_a (1 );
65
65
bfield . set_c (2 );
66
- unsafe {print_bitfield (bfield )};
66
+ unsafe { print_bitfield (bfield ) };
67
67
```
68
68
69
69
This will print out
@@ -112,24 +112,24 @@ void walk_bitfield() {
112
112
113
113
``` rust
114
114
fn walk_bitfield () {
115
- let mut bfield = unsafe {mem :: zeroed :: <bitfield >()};
116
- unsafe {print_bitfield (bfield )};
115
+ let mut bfield = unsafe { mem :: zeroed :: <bitfield >() };
116
+ unsafe { print_bitfield (bfield ) };
117
117
bfield . set_c (1 );
118
- unsafe {print_bitfield (bfield )};
118
+ unsafe { print_bitfield (bfield ) };
119
119
bfield . set_c (2 );
120
- unsafe {print_bitfield (bfield )};
120
+ unsafe { print_bitfield (bfield ) };
121
121
bfield . set_c (3 );
122
- unsafe {print_bitfield (bfield )};
122
+ unsafe { print_bitfield (bfield ) };
123
123
bfield . set_c (4 );
124
- unsafe {print_bitfield (bfield )};
124
+ unsafe { print_bitfield (bfield ) };
125
125
bfield . set_c (- 1 );
126
- unsafe {print_bitfield (bfield )};
126
+ unsafe { print_bitfield (bfield ) };
127
127
bfield . set_c (- 2 );
128
- unsafe {print_bitfield (bfield )};
128
+ unsafe { print_bitfield (bfield ) };
129
129
bfield . set_c (- 3 );
130
- unsafe {print_bitfield (bfield )};
130
+ unsafe { print_bitfield (bfield ) };
131
131
bfield . set_c (- 4 );
132
- unsafe {print_bitfield (bfield )};
132
+ unsafe { print_bitfield (bfield ) };
133
133
}
134
134
```
135
135
@@ -162,7 +162,7 @@ However, Bindgen's getter provides different results:
162
162
163
163
``` rust
164
164
fn getter_walk_bitfield () {
165
- let mut bfield = unsafe {mem :: zeroed :: <bitfield >()};
165
+ let mut bfield = unsafe { mem :: zeroed :: <bitfield >() };
166
166
println! (" c set to {}" , bfield . c ());
167
167
bfield . set_c (1 );
168
168
println! (" c set to {}" , bfield . c ());
0 commit comments