feat: add display UI with splash screen, dashboard, and RSSI sparkline
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
17624 files changed
+4564928
-38
No files matched your search
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"files":{".cargo_vcs_info.json":"7776adac9941b94ba0cfcaba6cef6b503360bbf5facfc2e2e8f0280e709dbbf0","CHANGELOG.md":"9666c9deb88d3e438f1e2e28a039d9a88a4392cb0b7f2fc9df51f17ba1804518","Cargo.lock":"d4f011179426432214ca495e1b9147203bbfe0043a1a1b67c649782da3cf68c6","Cargo.toml":"3ecceec32dd196024b9fe1ba69f0f4a36a2ebaa77f6c4590fcc4b699facebf15","Cargo.toml.orig":"07d851e1a6ddacd76d281d5894ac9aa77cc894d59e08167355dcd32e55fdd683","LICENSE-APACHE":"c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08","LICENSE-MIT":"af6b8d2c7ab89b819e3c2db77b572f145d14c8578dbd25015d739b30d4cc92f7","README.md":"304b671dd302959f80bfacfaf66880a0697865546ab242e5a2703a38e9752020","examples/bits_position.rs":"11262f58fefb2664175183fe4ac8997897c06a113841367ef4f3b7f79f7f7ae9","examples/ipv4.rs":"d5e8eb84b9768fec7abb83ee6722bb544c5cd16cef06af6c91d648deb2c44bd7","multitest.toml":"b29b8501990c193b71446ce98121c59d6983f7fb530b132167a384cf63df8a4c","src/lib.rs":"9468c45ba4a0f7394619a71848fad8eaa5a72c1ed770cc36acfbf45bfa0db292","tests/lib.rs":"c3680e96248869f1298bcb65b88238da2e14dd64581c9ef9ac85803fed159207"},"package":"f798d2d157e547aa99aab0967df39edd0b70307312b6f8bd2848e6abe40896e0"}
|
||||
Vendored
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"git": {
|
||||
"sha1": "1386eb34c2e73b5c38b984ae8a405901e141de64"
|
||||
},
|
||||
"path_in_vcs": ""
|
||||
}
|
||||
Vendored
+63
@@ -0,0 +1,63 @@
|
||||
# Changelog
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [0.17.0] - 2024-09-08
|
||||
|
||||
### Breaking Changes
|
||||
- Changes published as 0.16.2 (version now yanked) was breaking
|
||||
|
||||
## [0.16.2] - 2024-09-07
|
||||
|
||||
### Added
|
||||
- Allow creating bitfield structs with arbitrary visibilities, thanks to @ADSteele916
|
||||
|
||||
## [0.16.1] - 2024-07-25
|
||||
|
||||
### Added
|
||||
- Implement bitwise operations for all array-Like inner types, using `AsRef`/`AsMut`, thanks to @PokeJofeJr4th
|
||||
- Allow to derive constructors, thanks to @PokeJofeJr4th
|
||||
|
||||
## [0.16.0] - 2024-07-22
|
||||
|
||||
### Added
|
||||
- Easily Derive Bitwise Operations, thanks to @PokeJofeJr4th
|
||||
|
||||
### Breaking Changes
|
||||
- The minimum rustc version is now 1.79.0
|
||||
|
||||
## [0.15.0] - 2024-04-09
|
||||
|
||||
### Added
|
||||
- Allow to generate mask for a field
|
||||
|
||||
### Breaking Changes
|
||||
- The minimum rustc version is now 1.46.0
|
||||
|
||||
## [0.14.0] - 2022-07-11
|
||||
|
||||
### Added
|
||||
- Getters work with immutable Data
|
||||
|
||||
### Breaking Changes
|
||||
- The minimum rustc version is now 1.31.0
|
||||
- The setters of the `BitRange` and `Bit` has been separated in the `BitRangeMut` and `BitMut` traits.
|
||||
|
||||
## [0.13.2] - 2019-05-28
|
||||
|
||||
### Added
|
||||
- `from into` can be used in place of `from` to change the input type of the setter. Thanks to @roblabla
|
||||
|
||||
[Unreleased]: https://github.com/dzamlo/rust-bitfield/compare/v0.17.0...HEAD
|
||||
[0.17.0]: https://github.com/dzamlo/rust-bitfield/compare/v0.16.2...v0.17.0
|
||||
[0.16.2]: https://github.com/dzamlo/rust-bitfield/compare/v0.16.0...v0.16.2
|
||||
[0.16.1]: https://github.com/dzamlo/rust-bitfield/compare/v0.16.0...v0.16.1
|
||||
[0.16.0]: https://github.com/dzamlo/rust-bitfield/compare/v0.15.0...v0.16.0
|
||||
[0.15.0]: https://github.com/dzamlo/rust-bitfield/compare/v0.14.0...v0.15.0
|
||||
[0.14.0]: https://github.com/dzamlo/rust-bitfield/compare/v0.13.2...v0.14.0
|
||||
[0.13.2]: https://github.com/dzamlo/rust-bitfield/compare/v0.13.1...v0.13.2
|
||||
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "bitfield"
|
||||
version = "0.17.0"
|
||||
Vendored
+43
@@ -0,0 +1,43 @@
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies.
|
||||
#
|
||||
# If you are reading this file be aware that the original Cargo.toml
|
||||
# will likely look very different (and much more reasonable).
|
||||
# See Cargo.toml.orig for the original contents.
|
||||
|
||||
[package]
|
||||
name = "bitfield"
|
||||
version = "0.17.0"
|
||||
authors = ["Loïc Damien <loic.damien@dzamlo.ch>"]
|
||||
build = false
|
||||
autobins = false
|
||||
autoexamples = false
|
||||
autotests = false
|
||||
autobenches = false
|
||||
description = "This crate provides macros to generate bitfield-like struct."
|
||||
documentation = "https://docs.rs/bitfield"
|
||||
readme = "README.md"
|
||||
license = "MIT OR Apache-2.0"
|
||||
repository = "https://github.com/dzamlo/rust-bitfield"
|
||||
|
||||
[lib]
|
||||
name = "bitfield"
|
||||
path = "src/lib.rs"
|
||||
|
||||
[[example]]
|
||||
name = "bits_position"
|
||||
path = "examples/bits_position.rs"
|
||||
|
||||
[[example]]
|
||||
name = "ipv4"
|
||||
path = "examples/ipv4.rs"
|
||||
|
||||
[[test]]
|
||||
name = "lib"
|
||||
path = "tests/lib.rs"
|
||||
|
||||
[dependencies]
|
||||
Vendored
+202
@@ -0,0 +1,202 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright {yyyy} {name of copyright owner}
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
|
||||
Vendored
+19
@@ -0,0 +1,19 @@
|
||||
Copyright (c) 2017 Loïc Damien
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
Vendored
+57
@@ -0,0 +1,57 @@
|
||||
rust-bitfield
|
||||
=============
|
||||
|
||||
This crate provides macros to generate bitfield-like struct.
|
||||
|
||||
This a complete rewrite of the `bitfield` crate.
|
||||
You can find the previous version in the [rust-bitfield-legacy](https://github.com/dzamlo/rust-bitfield-legacy) repository. This version works on the stable version of rustc and use a different syntax with different possibility.
|
||||
|
||||
|
||||
## Example
|
||||
|
||||
An IPv4 header could be described like that:
|
||||
|
||||
```rust
|
||||
bitfield!{
|
||||
struct IpV4Header(MSB0 [u8]);
|
||||
u32;
|
||||
get_version, _: 3, 0;
|
||||
get_ihl, _: 7, 4;
|
||||
get_dscp, _: 13, 8;
|
||||
get_ecn, _: 15, 14;
|
||||
get_total_length, _: 31, 16;
|
||||
get_identification, _: 47, 32;
|
||||
get_df, _: 49;
|
||||
get_mf, _: 50;
|
||||
get_fragment_offset, _: 63, 51;
|
||||
get_time_to_live, _: 71, 64;
|
||||
get_protocol, _: 79, 72;
|
||||
get_header_checksum, _: 95, 79;
|
||||
get_source_address, _: 127, 96;
|
||||
get_destination_address, _: 159, 128;
|
||||
}
|
||||
```
|
||||
|
||||
In this example, all the fields are read-only, the _ as setter name signals to skip the setter method.
|
||||
The range at the end (e.g. 3, 0) defines the bit range where the information is encoded.
|
||||
|
||||
## Documentation
|
||||
|
||||
The documentation of the released version is available on [doc.rs](https://docs.rs/bitfield).
|
||||
|
||||
|
||||
## License
|
||||
|
||||
Licensed under either of
|
||||
|
||||
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
|
||||
* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
|
||||
|
||||
at your option.
|
||||
|
||||
### Contribution
|
||||
|
||||
Unless you explicitly state otherwise, any contribution intentionally
|
||||
submitted for inclusion in the work by you, as defined in the Apache-2.0
|
||||
license, shall be dual licensed as above, without any additional terms or
|
||||
conditions.
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
#[macro_use]
|
||||
extern crate bitfield;
|
||||
|
||||
use bitfield::BitMut;
|
||||
use bitfield::BitRangeMut;
|
||||
|
||||
bitfield! {
|
||||
struct BitsLocations([u8]);
|
||||
}
|
||||
|
||||
bitfield! {
|
||||
struct BitsLocationsMsb0(MSB0 [u8]);
|
||||
}
|
||||
|
||||
fn println_slice_bits(slice: &[u8]) {
|
||||
if slice.is_empty() {
|
||||
println!("[]");
|
||||
} else {
|
||||
print!("[{:08b}", slice[0]);
|
||||
|
||||
for byte in &slice[1..] {
|
||||
print!(", {:08b}", byte);
|
||||
}
|
||||
|
||||
println!("]");
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let mut bits_locations = BitsLocations([0; 3]);
|
||||
let mut bits_locations_msb0 = BitsLocationsMsb0([0; 3]);
|
||||
|
||||
println!("Default version:");
|
||||
for i in 0..(3 * 8) {
|
||||
bits_locations.set_bit(i, true);
|
||||
print!("{:2}: ", i);
|
||||
println_slice_bits(&bits_locations.0);
|
||||
bits_locations.set_bit(i, false);
|
||||
}
|
||||
|
||||
for i in 0..(3 * 8 - 3) {
|
||||
let msb = i + 3;
|
||||
let lsb = i;
|
||||
for value in &[0b1111u8, 0b0001, 0b1000] {
|
||||
bits_locations.set_bit_range(msb, lsb, *value);
|
||||
print!("{:2} - {:2} ({:04b}): ", msb, lsb, value);
|
||||
println_slice_bits(&bits_locations.0);
|
||||
}
|
||||
println!();
|
||||
bits_locations.set_bit_range(msb, lsb, 0u8);
|
||||
}
|
||||
|
||||
println!("MSB0 version:");
|
||||
|
||||
for i in 0..(3 * 8) {
|
||||
bits_locations_msb0.set_bit(i, true);
|
||||
print!("{:2}: ", i);
|
||||
println_slice_bits(&bits_locations_msb0.0);
|
||||
|
||||
bits_locations_msb0.set_bit(i, false);
|
||||
}
|
||||
|
||||
for i in 0..(3 * 8 - 3) {
|
||||
let msb = i + 3;
|
||||
let lsb = i;
|
||||
for value in &[0b1111u8, 0b0001, 0b1000] {
|
||||
bits_locations_msb0.set_bit_range(msb, lsb, *value);
|
||||
print!("{:2} - {:2} ({:04b}): ", msb, lsb, value);
|
||||
println_slice_bits(&bits_locations_msb0.0);
|
||||
}
|
||||
println!();
|
||||
|
||||
bits_locations_msb0.set_bit_range(msb, lsb, 0u8);
|
||||
}
|
||||
}
|
||||
Vendored
+60
@@ -0,0 +1,60 @@
|
||||
#![allow(dead_code)]
|
||||
|
||||
#[macro_use]
|
||||
extern crate bitfield;
|
||||
|
||||
use std::net::Ipv4Addr;
|
||||
|
||||
bitfield! {
|
||||
struct IpV4Header(MSB0 [u8]);
|
||||
impl Debug;
|
||||
u32;
|
||||
get_version, _: 3, 0;
|
||||
get_ihl, _: 7, 4;
|
||||
get_dscp, _: 13, 8;
|
||||
get_ecn, _: 15, 14;
|
||||
get_total_length, _: 31, 16;
|
||||
get_identification, _: 47, 32;
|
||||
get_df, _: 49;
|
||||
get_mf, _: 50;
|
||||
get_fragment_offset, _: 63, 51;
|
||||
get_time_to_live, _: 71, 64;
|
||||
get_protocol, _: 79, 72;
|
||||
get_header_checksum, _: 95, 80;
|
||||
u8, get_source_address, _: 103, 96, 4;
|
||||
u32, into Ipv4Addr, get_destination_address, _: 159, 128;
|
||||
}
|
||||
|
||||
impl<T: AsRef<[u8]>> IpV4Header<T> {
|
||||
fn get_source_as_ip_addr(&self) -> Ipv4Addr {
|
||||
let mut src = [0; 4];
|
||||
for (i, src) in src.iter_mut().enumerate() {
|
||||
*src = self.get_source_address(i);
|
||||
}
|
||||
src.into()
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let data = [
|
||||
0x45, 0x00, 0x00, 0x40, 0x69, 0x27, 0x40, 0x00, 0x40, 0x11, 0x4d, 0x0d, 0xc0, 0xa8, 0x01,
|
||||
0x2a, 0xc0, 0xa8, 0x01, 0xfe,
|
||||
];
|
||||
|
||||
let header = IpV4Header(data);
|
||||
|
||||
assert_eq!(header.get_version(), 4);
|
||||
assert_eq!(header.get_total_length(), 64);
|
||||
assert_eq!(header.get_identification(), 0x6927);
|
||||
assert!(header.get_df());
|
||||
assert!(!header.get_mf());
|
||||
assert_eq!(header.get_fragment_offset(), 0);
|
||||
assert_eq!(header.get_protocol(), 0x11);
|
||||
println!(
|
||||
"from {} to {}",
|
||||
header.get_source_as_ip_addr(),
|
||||
header.get_destination_address()
|
||||
);
|
||||
|
||||
println!("{:#?}", header);
|
||||
}
|
||||
Vendored
+22
@@ -0,0 +1,22 @@
|
||||
[[tests]]
|
||||
name = "cargo-test-{{toolchain}}"
|
||||
command = ["cargo", "+{{toolchain}}", "test", "--all", "--frozen"]
|
||||
|
||||
[[tests.env]]
|
||||
name = "CARGO_TARGET_DIR"
|
||||
value = "target/{{name}}"
|
||||
|
||||
[tests.variables]
|
||||
toolchain = ["stable", "beta", "nightly", "1.79.0"]
|
||||
|
||||
[[tests]]
|
||||
name = "cargo-clippy"
|
||||
command = ["cargo", "+stable", "clippy", "--all", "--frozen", "--all-targets", "--", "-D", "warnings"]
|
||||
|
||||
[[tests.env]]
|
||||
name = "CARGO_TARGET_DIR"
|
||||
value = "target/cargo-test-nightly"
|
||||
|
||||
[[tests]]
|
||||
name = "cargo-fmt"
|
||||
command = ["cargo", "fmt", "--all", "--", "--check"]
|
||||
Vendored
+986
@@ -0,0 +1,986 @@
|
||||
#![no_std]
|
||||
#![deny(
|
||||
missing_docs,
|
||||
unused_extern_crates,
|
||||
unused_import_braces,
|
||||
unused_qualifications
|
||||
)]
|
||||
//! This crate provides macros to generate bitfield-like struct.
|
||||
//!
|
||||
//! See the documentation of the macros for how to use them.
|
||||
//!
|
||||
//! Examples and tests are also a great way to understand how to use these macros.
|
||||
|
||||
/// Generates and dispatches trait implementations for a struct
|
||||
///
|
||||
/// This must be called outside of any `impl` block.
|
||||
///
|
||||
/// The syntax is `TheNameOfTheTrait for struct TheNameOfTheStruct(TheInnerType);` followed by the syntax of bitfield_fields.
|
||||
///
|
||||
/// Supported traits:
|
||||
/// * Debug
|
||||
/// * BitAnd
|
||||
/// * BitOr
|
||||
/// * BitXor
|
||||
///
|
||||
/// Additional derivations:
|
||||
/// * new
|
||||
/// * Creates a constructor, including parameters for all fields with a setter
|
||||
/// * new{constructor_name(setter_name: setter_type, ...)}
|
||||
/// * Creates a constructor using the given name and parameters. In order to compile correctly, each `setter_name`
|
||||
/// must be the setter of a field of type `setter_type` specified later in the macro.
|
||||
#[macro_export(local_inner_macros)]
|
||||
macro_rules! bitfield_impl {
|
||||
(Debug for struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
impl<T: AsRef<[$t]> + $crate::fmt::Debug> $crate::fmt::Debug for $name<T> {
|
||||
bitfield_debug!{struct $name; $($rest)*}
|
||||
}
|
||||
};
|
||||
(Debug for struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
impl $crate::fmt::Debug for $name {
|
||||
bitfield_debug!{struct $name; $($rest)*}
|
||||
}
|
||||
};
|
||||
(BitAnd for struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
bitfield_impl!{@bitwise BitAnd bitand BitAndAssign bitand_assign $name([$t]) &=}
|
||||
};
|
||||
(BitAnd for struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
bitfield_impl!{@bitwise BitAnd bitand BitAndAssign bitand_assign $name($t) &=}
|
||||
};
|
||||
(BitOr for struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
bitfield_impl!{@bitwise BitOr bitor BitOrAssign bitor_assign $name([$t]) |=}
|
||||
};
|
||||
(BitOr for struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
bitfield_impl!{@bitwise BitOr bitor BitOrAssign bitor_assign $name($t) |=}
|
||||
};
|
||||
(BitXor for struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
bitfield_impl!{@bitwise BitXor bitxor BitXorAssign bitxor_assign $name([$t]) ^=}
|
||||
};
|
||||
(BitXor for struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
bitfield_impl!{@bitwise BitXor bitxor BitXorAssign bitxor_assign $name($t) ^=}
|
||||
};
|
||||
(@bitwise $bitwise:ident $func:ident $bitwise_assign:ident $func_assign:ident $name:ident([$t:ty]) $op:tt) => {
|
||||
impl<T: AsMut<[$t]> + AsRef<[$t]>> $crate::ops::$bitwise for $name<T> {
|
||||
type Output = Self;
|
||||
fn $func(mut self, rhs: Self) -> Self {
|
||||
bitfield_impl!(@mutate self rhs $op);
|
||||
self
|
||||
}
|
||||
}
|
||||
impl<T: AsMut<[$t]> + AsRef<[$t]>> $crate::ops::$bitwise_assign for $name<T> {
|
||||
fn $func_assign(&mut self, rhs: Self) {
|
||||
bitfield_impl!(@mutate self rhs $op);
|
||||
}
|
||||
}
|
||||
};
|
||||
(@bitwise $bitwise:ident $func:ident $bitwise_assign:ident $func_assign:ident $name:ident($t:ty) $op:tt) => {
|
||||
impl $crate::ops::$bitwise for $name {
|
||||
type Output = Self;
|
||||
fn $func(mut self, rhs: Self) -> Self {
|
||||
self.0 $op rhs.0;
|
||||
self
|
||||
}
|
||||
}
|
||||
impl $crate::ops::$bitwise_assign for $name {
|
||||
fn $func_assign(&mut self, rhs: Self) {
|
||||
self.0 $op rhs.0;
|
||||
}
|
||||
}
|
||||
};
|
||||
(@mutate $self:ident $rhs:ident $op:tt) => {{
|
||||
let as_mut = AsMut::<[_]>::as_mut(&mut $self.0);
|
||||
let rhs = AsRef::<[_]>::as_ref(&$rhs.0);
|
||||
for i in 0..as_mut.len() {
|
||||
as_mut[i] $op rhs[i];
|
||||
}
|
||||
}};
|
||||
(new for struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
impl<T: AsMut<[$t]> + Default> $name<T> {
|
||||
bitfield_constructor!{() -> {}; $($rest)*}
|
||||
}
|
||||
};
|
||||
(new for struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
impl $name {
|
||||
bitfield_constructor!{() -> {}; $($rest)*}
|
||||
}
|
||||
};
|
||||
(new{$new:ident ($($setter_name:ident: $setter_type:ty),*$(,)?)} for struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
impl<T: AsMut<[$t]> + Default> $name<T> {
|
||||
pub fn $new($($setter_name: $setter_type),*) -> Self {
|
||||
let mut value = Self(T::default());
|
||||
$(
|
||||
value.$setter_name($setter_name);
|
||||
)*
|
||||
value
|
||||
}
|
||||
}
|
||||
};
|
||||
(new{$new:ident ($($setter_name:ident: $setter_type:ty),*$(,)?)} for struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
impl $name {
|
||||
pub fn $new($($setter_name: $setter_type),*) -> Self {
|
||||
let mut value = Self($t::default());
|
||||
$(
|
||||
value.$setter_name($setter_name);
|
||||
)*
|
||||
value
|
||||
}
|
||||
}
|
||||
};
|
||||
// display a more friendly error message when someone tries to use `impl <Trait>;` syntax when not supported
|
||||
($macro:ident for struct $name:ident $($rest:tt)*) => {
|
||||
::std::compile_error!(::std::stringify!(Unsupported impl $macro for struct $name));
|
||||
};
|
||||
}
|
||||
|
||||
/// Declares the fields of struct.
|
||||
///
|
||||
/// This macro will generate the methods to access the fields of a bitfield. It must be called
|
||||
/// from an `impl` block for a type that implements the `BitRange` and/or the `Bit` traits
|
||||
/// (which traits are required depending on what type of fields are used).
|
||||
///
|
||||
/// The syntax of this macro is composed of declarations ended by semicolons. There are two types
|
||||
/// of declarations: default type, and fields.
|
||||
///
|
||||
/// A default type is just a type followed by a semicolon. This will affect all the following field
|
||||
/// declarations.
|
||||
///
|
||||
/// A field declaration is composed of the following:
|
||||
///
|
||||
/// * Optional attributes (`#[...]`), documentation comments (`///`) are attributes;
|
||||
/// * An optional pub keyword to make the methods public
|
||||
/// * An optional type followed by a comma
|
||||
/// * Optionally, the word `into` followed by a type, followed by a comma
|
||||
/// * The getter and setter idents, separated by a comma
|
||||
/// * A colon
|
||||
/// * One to three expressions of type `usize`
|
||||
///
|
||||
/// The attributes and pub will be applied to the two methods generated.
|
||||
///
|
||||
/// If the `into` part is used, the getter will convert the field after reading it.
|
||||
///
|
||||
/// The getter and setter idents can be `_` to not generate one of the two. For example, if the
|
||||
/// setter is `_`, the field will be read-only.
|
||||
///
|
||||
/// The expressions at the end are the bit positions. Their meaning depends on the number of
|
||||
/// expressions:
|
||||
///
|
||||
/// * One expression: the field is a single bit. The type is ignored and `bool` is used. The trait
|
||||
/// `Bit` is used.
|
||||
/// * Two expressions: `msb, lsb`, the field is composed of the bits from `msb` to `lsb`, included.
|
||||
/// * Three expressions: `msb, lsb, count`, the field is an array. The first element is composed of
|
||||
/// the bits from `msb` to `lsb`. The following elements are consecutive bits range of the same
|
||||
/// size.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # #[macro_use] extern crate bitfield;
|
||||
/// # fn main() {}
|
||||
/// # struct FooBar(u64);
|
||||
/// # bitfield_bitrange!{struct FooBar(u64)}
|
||||
/// # impl From<u32> for FooBar{ fn from(_: u32) -> FooBar {unimplemented!()}}
|
||||
/// # impl From<FooBar> for u32{ fn from(_: FooBar) -> u32 {unimplemented!()}}
|
||||
/// # impl FooBar {
|
||||
/// bitfield_fields!{
|
||||
/// // The default type will be `u64
|
||||
/// u64;
|
||||
/// // filed1 is read-write, public, the methods are inline
|
||||
/// #[inline]
|
||||
/// pub field1, set_field1: 10, 0;
|
||||
/// // `field2` is read-only, private, and of type bool.
|
||||
/// field2, _ : 0;
|
||||
/// // `field3` will be read as an `u32` and then converted to `FooBar`.
|
||||
/// // The setter is not affected, it still need an `u32` value.
|
||||
/// u32, into FooBar, field3, set_field3: 10, 0;
|
||||
/// // `field4` will be read as an `u32` and then converted to `FooBar`.
|
||||
/// // The setter will take a `FooBar`, and converted back to an `u32`.
|
||||
/// u32, from into FooBar, field4, set_field4: 10, 0;
|
||||
/// // `field5` will be read as an `u32` and then converted to `FooBar`.
|
||||
/// // The setter will take a `FooBar`, and converted back to an `u32`.
|
||||
/// // The struct will have an associated constant `FIELD5_MASK` of type u64
|
||||
/// //with the bits of field5 set
|
||||
/// u32, mask FIELD5_MASK(u64), from into FooBar, field5, set_field5: 10, 0;
|
||||
/// }
|
||||
/// # }
|
||||
/// ```
|
||||
#[macro_export(local_inner_macros)]
|
||||
macro_rules! bitfield_fields {
|
||||
(only mask; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, _, $setter:ident: $($exprs:expr),*) => {
|
||||
bitfield_fields!(only mask; @field $(#[$attribute])* ($($vis)*) $t, $mask($mask_t): $($exprs),*);
|
||||
};
|
||||
(only mask; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, $getter:ident, _: $($exprs:expr),*) => {
|
||||
bitfield_fields!(only mask; @field $(#[$attribute])* ($($vis)*) $t, $mask($mask_t): $($exprs),*);
|
||||
};
|
||||
(only mask; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, __NO_MASK_FOR_FIELD($mask_t:ty): $($exprs:expr),*) => {};
|
||||
(only mask; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty): $bit:expr) => {
|
||||
$($vis)* const $mask: $mask_t = 1 << $bit;
|
||||
};
|
||||
(only mask; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty): $msb:expr, $lsb:expr) => {
|
||||
$($vis)* const $mask: $mask_t = {
|
||||
let msb = $msb;
|
||||
let lsb = $lsb;
|
||||
let mut i = lsb;
|
||||
let mut acc = 0;
|
||||
while i <= msb {
|
||||
acc |= 1<<i;
|
||||
i += 1;
|
||||
}
|
||||
acc
|
||||
};
|
||||
};
|
||||
(only mask; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty): $msb:expr, $lsb:expr, $count:expr) => {
|
||||
$($vis)* const $mask: $mask_t = {
|
||||
let msb = $msb;
|
||||
let lsb = $lsb;
|
||||
let width = msb - lsb;
|
||||
let full_msb = msb + width * $count;
|
||||
let mut i = lsb;
|
||||
let mut acc = 0;
|
||||
while i <= full_msb {
|
||||
acc |= 1<<i;
|
||||
i += 1;
|
||||
}
|
||||
acc
|
||||
};
|
||||
};
|
||||
(only setter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, _, $setter:ident: $msb:expr,
|
||||
$lsb:expr, $count:expr) => {
|
||||
$(#[$attribute])*
|
||||
#[allow(unknown_lints)]
|
||||
#[allow(eq_op)]
|
||||
$($vis)* fn $setter(&mut self, index: usize, value: $from) {
|
||||
use $crate::BitRangeMut;
|
||||
__bitfield_debug_assert!(index < $count);
|
||||
let width = $msb - $lsb + 1;
|
||||
let lsb = $lsb + index*width;
|
||||
let msb = lsb + width - 1;
|
||||
self.set_bit_range(msb, lsb, $crate::Into::<$t>::into(value));
|
||||
}
|
||||
};
|
||||
(only setter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, _, $setter:ident: $msb:expr,
|
||||
$lsb:expr) => {
|
||||
$(#[$attribute])*
|
||||
$($vis)* fn $setter(&mut self, value: $from) {
|
||||
use $crate::BitRangeMut;
|
||||
self.set_bit_range($msb, $lsb, $crate::Into::<$t>::into(value));
|
||||
}
|
||||
};
|
||||
(only setter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, _, $setter:ident: $bit:expr) => {
|
||||
$(#[$attribute])*
|
||||
$($vis)* fn $setter(&mut self, value: bool) {
|
||||
use $crate::BitMut;
|
||||
self.set_bit($bit, value);
|
||||
}
|
||||
};
|
||||
(only getter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, _, $setter:ident: $($exprs:expr),*) => {};
|
||||
|
||||
(only getter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, $getter:ident, _: $msb:expr, $lsb:expr, $count:expr) => {
|
||||
$(#[$attribute])*
|
||||
#[allow(unknown_lints)]
|
||||
#[allow(eq_op)]
|
||||
$($vis)* fn $getter(&self, index: usize) -> $into {
|
||||
use $crate::BitRange;
|
||||
__bitfield_debug_assert!(index < $count);
|
||||
let width = $msb - $lsb + 1;
|
||||
let lsb = $lsb + index*width;
|
||||
let msb = lsb + width - 1;
|
||||
let raw_value: $t = self.bit_range(msb, lsb);
|
||||
$crate::Into::into(raw_value)
|
||||
}
|
||||
};
|
||||
(only getter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, $getter:ident, _: $msb:expr,
|
||||
$lsb:expr) => {
|
||||
$(#[$attribute])*
|
||||
$($vis)* fn $getter(&self) -> $into {
|
||||
use $crate::BitRange;
|
||||
let raw_value: $t = self.bit_range($msb, $lsb);
|
||||
$crate::Into::into(raw_value)
|
||||
}
|
||||
};
|
||||
(only getter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, $getter:ident, _: $bit:expr) => {
|
||||
$(#[$attribute])*
|
||||
$($vis)* fn $getter(&self) -> bool {
|
||||
use $crate::Bit;
|
||||
self.bit($bit)
|
||||
}
|
||||
};
|
||||
(only setter; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, $getter:ident, _: $($exprs:expr),*) => {};
|
||||
|
||||
(only $only:tt; @field $(#[$attribute:meta])* ($($vis:tt)*) $t:ty, $mask:ident($mask_t:ty), $from:ty, $into:ty, $getter:ident, $setter:ident:
|
||||
$($exprs:expr),*) => {
|
||||
bitfield_fields!(only $only; @field $(#[$attribute])* ($($vis)*) $t, $mask($mask_t), $from, $into, $getter, _: $($exprs),*);
|
||||
bitfield_fields!(only $only; @field $(#[$attribute])* ($($vis)*) $t, __NO_MASK_FOR_FIELD(u8), $from, $into, _, $setter: $($exprs),*);
|
||||
};
|
||||
|
||||
(only $only:tt; $t:ty;) => {};
|
||||
(only $only:tt; $default_ty:ty; pub $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; $default_ty; () pub $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; #[$attribute:meta] $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; $default_ty; (#[$attribute]) $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attributes:meta])*) #[$attribute:meta] $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; $default_ty; ($(#[$attributes])* #[$attribute]) $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $t:ty, mask $mask:ident($mask_t:ty), from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $t, $mask($mask_t), $into, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $t:ty, mask $mask:ident($mask_t:ty), into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $t, $mask($mask_t), $t, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $t:ty, mask $mask:ident($mask_t:ty), $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $t, $mask($mask_t), $t, $t, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub mask $mask:ident($mask_t:ty), from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $default_ty, $mask($mask_t), $into, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub mask $mask:ident($mask_t:ty), into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $default_ty, $mask($mask_t), $default_ty, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub mask $mask:ident($mask_t:ty), $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $default_ty, $mask($mask_t), $default_ty, $default_ty, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $t:ty, from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $t, __NO_MASK_FOR_FIELD(u8), $into, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $t:ty, into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $t, __NO_MASK_FOR_FIELD(u8), $t, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $t:ty, $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $t, __NO_MASK_FOR_FIELD(u8), $t, $t, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $default_ty, __NO_MASK_FOR_FIELD(u8), $into, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $default_ty, __NO_MASK_FOR_FIELD(u8), $default_ty, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) pub $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* (pub) $default_ty, __NO_MASK_FOR_FIELD(u8), $default_ty, $default_ty, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $t:ty, mask $mask:ident($mask_t:ty), from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $t, $mask($mask_t), $into, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $t:ty, mask $mask:ident($mask_t:ty), into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $t, $mask($mask_t), $t, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $t:ty, mask $mask:ident($mask_t:ty), $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $t, $mask($mask_t), $t, $t, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) mask $mask:ident($mask_t:ty), from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $default_ty, $mask($mask_t), $into, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) mask $mask:ident($mask_t:ty), into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $default_ty, $mask($mask_t), $default_ty, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) mask $mask:ident($mask_t:ty), $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $default_ty, $mask($mask_t), $default_ty, $default_ty, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $t:ty, from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $t, __NO_MASK_FOR_FIELD(u8), $into, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $t:ty, into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $t, __NO_MASK_FOR_FIELD(u8), $t, $into, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $t:ty, $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $t, __NO_MASK_FOR_FIELD(u8), $t, $t, $getter, $setter: $($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) from into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $default_ty, __NO_MASK_FOR_FIELD(u8), $into, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) into $into:ty, $getter:tt, $setter:tt:
|
||||
$($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $default_ty, __NO_MASK_FOR_FIELD(u8), $default_ty, $into, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; ($(#[$attribute:meta])*) $getter:tt, $setter:tt: $($exprs:expr),*;
|
||||
$($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; @field $(#[$attribute])* () $default_ty, __NO_MASK_FOR_FIELD(u8), $default_ty, $default_ty, $getter, $setter:
|
||||
$($exprs),*}
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $previous_default_ty:ty; $default_ty:ty; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; $default_ty; $($rest)*}
|
||||
};
|
||||
(only $only:tt; $default_ty:ty; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; $default_ty; () $($rest)*}
|
||||
};
|
||||
(only $only:tt; $($rest:tt)*) => {
|
||||
bitfield_fields!{only $only; SET_A_DEFAULT_TYPE_OR_SPECIFY_THE_TYPE_FOR_EACH_FIELDS; $($rest)*}
|
||||
};
|
||||
($($rest:tt)*) => {
|
||||
bitfield_fields!{only getter; $($rest)*}
|
||||
bitfield_fields!{only setter; $($rest)*}
|
||||
bitfield_fields!{only mask; $($rest)*}
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates a `fmt::Debug` implementation.
|
||||
///
|
||||
/// This macros must be called from a `impl Debug for ...` block. It will generate the `fmt` method.
|
||||
///
|
||||
/// In most of the case, you will not directly call this macros, but use `bitfield`.
|
||||
///
|
||||
/// The syntax is `struct TheNameOfTheStruct` followed by the syntax of `bitfield_fields`.
|
||||
///
|
||||
/// The write-only fields are ignored.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # #[macro_use] extern crate bitfield;
|
||||
/// struct FooBar(u32);
|
||||
/// bitfield_bitrange!{struct FooBar(u32)}
|
||||
/// impl FooBar{
|
||||
/// bitfield_fields!{
|
||||
/// u32;
|
||||
/// field1, _: 7, 0;
|
||||
/// field2, _: 31, 24;
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// impl std::fmt::Debug for FooBar {
|
||||
/// bitfield_debug!{
|
||||
/// struct FooBar;
|
||||
/// field1, _: 7, 0;
|
||||
/// field2, _: 31, 24;
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// fn main() {
|
||||
/// let foobar = FooBar(0x11223344);
|
||||
/// println!("{:?}", foobar);
|
||||
|
||||
/// }
|
||||
/// ```
|
||||
#[macro_export(local_inner_macros)]
|
||||
macro_rules! bitfield_debug {
|
||||
(struct $name:ident; $($rest:tt)*) => {
|
||||
fn fmt(&self, f: &mut $crate::fmt::Formatter) -> $crate::fmt::Result {
|
||||
let mut debug_struct = f.debug_struct(__bitfield_stringify!($name));
|
||||
debug_struct.field(".0", &self.0);
|
||||
bitfield_debug!{debug_struct, self, $($rest)*}
|
||||
debug_struct.finish()
|
||||
}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, mask $mask:ident($mask_t:ty), $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, #[$attribute:meta] $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, pub $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, _, $setter:tt: $($exprs:expr),*; $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, $type:ty; $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, $getter:ident, $setter:tt: $msb:expr, $lsb:expr, $count:expr;
|
||||
$($rest:tt)*) => {
|
||||
let mut array = [$self.$getter(0); $count];
|
||||
for (i, e) in (&mut array).into_iter().enumerate() {
|
||||
*e = $self.$getter(i);
|
||||
}
|
||||
$debug_struct.field(__bitfield_stringify!($getter), &array);
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, $getter:ident, $setter:tt: $($exprs:expr),*; $($rest:tt)*)
|
||||
=> {
|
||||
$debug_struct.field(__bitfield_stringify!($getter), &$self.$getter());
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, from into $into:ty, $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, into $into:ty, $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, $type:ty, $($rest:tt)*) => {
|
||||
bitfield_debug!{$debug_struct, $self, $($rest)*}
|
||||
};
|
||||
($debug_struct:ident, $self:ident, ) => {};
|
||||
}
|
||||
|
||||
/// Implements an exhaustive constructor function for a bitfield. Should only be called by `bitfield!` when using `impl new;`
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rs
|
||||
/// bitfield_constructor {0; () -> {}; u8; foo1, set_foo1: 2,0; foo2, set_foo2: 7,2}
|
||||
/// ```
|
||||
/// Generates:
|
||||
/// ```rs
|
||||
/// pub fn new(set_foo1: u8, set_foo2: u8) -> Self {
|
||||
/// let mut value = Self(0);
|
||||
/// value.set_foo1(set_foo1);
|
||||
/// value.set_foo2(set_foo2);
|
||||
/// value
|
||||
/// }
|
||||
/// ```
|
||||
#[macro_export(local_inner_macros)]
|
||||
macro_rules! bitfield_constructor {
|
||||
(() -> {}; $($rest:tt)*) => {
|
||||
bitfield_constructor!{@value; () -> {let mut value = Self(Default::default());}; bool; $($rest)*}
|
||||
};
|
||||
(@$value:ident; ($($param:ident: $ty:ty,)*) -> {$($stmt:stmt;)*}; $old_ty:ty; impl $_trait:ident$({$($trait_arg:tt)*})?; $($rest:tt)*) => {
|
||||
bitfield_constructor!{@$value; ($($param: $ty,)*) -> {$($stmt;)*}; $old_ty; $($rest)*}
|
||||
};
|
||||
(@$value:ident; ($($param:ident: $ty:ty,)*) -> {$($stmt:stmt;)*}; $old_ty:ty; $new_ty:ty; $($rest:tt)*) => {
|
||||
bitfield_constructor!{@$value; ($($param: $ty,)*) -> {$($stmt;)*}; $new_ty; $($rest)*}
|
||||
};
|
||||
(@$value:ident; ($($param:ident: $ty:ty,)*) -> {$($stmt:stmt;)*}; $default_ty:ty;
|
||||
$(#[$_:meta])* $(pub)? $(into $_into:ty,)?
|
||||
$_getter:ident, $setter:ident: $($_expr:expr),*; $($rest:tt)* ) => {
|
||||
bitfield_constructor!{@$value;
|
||||
($($param: $ty,)* $setter: $default_ty,) -> {$($stmt;)* $value.$setter($setter);};
|
||||
$default_ty; $($rest)*}
|
||||
};
|
||||
(@$value:ident; ($($param:ident: $ty:ty,)*) -> {$($stmt:stmt;)*}; $default_ty:ty;
|
||||
$(#[$_:meta])* $(pub)? $field_type:ty, $(into $_into:ty,)?
|
||||
$_getter:ident, $setter:ident: $($_expr:expr),*; $($rest:tt)* ) => {
|
||||
bitfield_constructor!{@$value;
|
||||
($($param: $ty,)* $setter: $field_type,) -> {$($stmt;)* $value.$setter($setter);};
|
||||
$default_ty; $($rest)*}
|
||||
};
|
||||
(@$value:ident; ($($param:ident: $ty:ty,)*) -> {$($stmt:stmt;)*}; $_:ty;) => {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new($($param: $ty),*) -> Self {
|
||||
$($stmt;)*
|
||||
$value
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Implements `BitRange` and `BitRangeMut` for a tuple struct (or "newtype").
|
||||
///
|
||||
/// This macro will generate an implementation of the `BitRange` trait for an existing single
|
||||
/// element tuple struct.
|
||||
///
|
||||
/// The syntax is more or less the same as declaring a "newtype", **without** the attributes,
|
||||
/// documentation comments and pub keyword.
|
||||
///
|
||||
/// The difference with a normal "newtype" is the type in parentheses. If the type is `[t]` (where
|
||||
/// `t` is any of the unsigned integer type), the "newtype" will be generic and implement
|
||||
/// `BitRange` for `T: AsRef<[t]>` and `BitRangeMut` for `T: AsMut<[t]>` (for example a slice, an array or a `Vec`). You can
|
||||
/// also use `MSB0 [t]`. The difference will be the positions of the bit. You can use the
|
||||
/// `bits_positions` example to see where each bits is. If the type is neither of this two, the
|
||||
/// "newtype" will wrap a value of the specified type and implements `BitRange` the same ways as
|
||||
/// the wrapped type.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
/// # #[macro_use] extern crate bitfield;
|
||||
/// # fn main() {}
|
||||
/// struct BitField1(u32);
|
||||
/// bitfield_bitrange!{struct BitField1(u32)}
|
||||
///
|
||||
/// struct BitField2<T>(T);
|
||||
/// bitfield_bitrange!{struct BitField2([u8])}
|
||||
///
|
||||
/// struct BitField3<T>(T);
|
||||
/// bitfield_bitrange!{struct BitField3(MSB0 [u8])}
|
||||
/// ```
|
||||
///
|
||||
#[macro_export(local_inner_macros)]
|
||||
macro_rules! bitfield_bitrange {
|
||||
(@impl_bitrange_slice $name:ident, $slice_ty:ty, $bitrange_ty:ty) => {
|
||||
impl<T: AsRef<[$slice_ty]>> $crate::BitRange<$bitrange_ty>
|
||||
for $name<T> {
|
||||
fn bit_range(&self, msb: usize, lsb: usize) -> $bitrange_ty {
|
||||
let bit_len = $crate::size_of::<$slice_ty>()*8;
|
||||
let value_bit_len = $crate::size_of::<$bitrange_ty>()*8;
|
||||
let mut value = 0;
|
||||
for i in (lsb..=msb).rev() {
|
||||
value <<= 1;
|
||||
value |= ((self.0.as_ref()[i/bit_len] >> (i%bit_len)) & 1) as $bitrange_ty;
|
||||
}
|
||||
value << (value_bit_len - (msb - lsb + 1)) >> (value_bit_len - (msb - lsb + 1))
|
||||
}
|
||||
}
|
||||
impl<T: AsMut<[$slice_ty]>> $crate::BitRangeMut<$bitrange_ty>
|
||||
for $name<T> {
|
||||
|
||||
fn set_bit_range(&mut self, msb: usize, lsb: usize, value: $bitrange_ty) {
|
||||
let bit_len = $crate::size_of::<$slice_ty>()*8;
|
||||
let mut value = value;
|
||||
for i in lsb..=msb {
|
||||
self.0.as_mut()[i/bit_len] &= !(1 << (i%bit_len));
|
||||
self.0.as_mut()[i/bit_len] |= (value & 1) as $slice_ty << (i%bit_len);
|
||||
value >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
(@impl_bitrange_slice_msb0 $name:ident, $slice_ty:ty, $bitrange_ty:ty) => {
|
||||
impl<T: AsRef<[$slice_ty]>> $crate::BitRange<$bitrange_ty>
|
||||
for $name<T> {
|
||||
fn bit_range(&self, msb: usize, lsb: usize) -> $bitrange_ty {
|
||||
let bit_len = $crate::size_of::<$slice_ty>()*8;
|
||||
let value_bit_len = $crate::size_of::<$bitrange_ty>()*8;
|
||||
let mut value = 0;
|
||||
for i in lsb..=msb {
|
||||
value <<= 1;
|
||||
value |= ((self.0.as_ref()[i/bit_len] >> (bit_len - i%bit_len - 1)) & 1)
|
||||
as $bitrange_ty;
|
||||
}
|
||||
value << (value_bit_len - (msb - lsb + 1)) >> (value_bit_len - (msb - lsb + 1))
|
||||
}
|
||||
}
|
||||
impl<T: AsMut<[$slice_ty]>> $crate::BitRangeMut<$bitrange_ty>
|
||||
for $name<T> {
|
||||
fn set_bit_range(&mut self, msb: usize, lsb: usize, value: $bitrange_ty) {
|
||||
let bit_len = $crate::size_of::<$slice_ty>()*8;
|
||||
let mut value = value;
|
||||
for i in (lsb..=msb).rev() {
|
||||
self.0.as_mut()[i/bit_len] &= !(1 << (bit_len - i%bit_len - 1));
|
||||
self.0.as_mut()[i/bit_len] |= (value & 1) as $slice_ty
|
||||
<< (bit_len - i%bit_len - 1);
|
||||
value >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
(struct $name:ident([$t:ty])) => {
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, u8);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, u16);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, u32);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, u64);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, u128);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, i8);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, i16);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, i32);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, i64);
|
||||
bitfield_bitrange!(@impl_bitrange_slice $name, $t, i128);
|
||||
};
|
||||
(struct $name:ident(MSB0 [$t:ty])) => {
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, u8);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, u16);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, u32);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, u64);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, u128);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, i8);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, i16);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, i32);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, i64);
|
||||
bitfield_bitrange!(@impl_bitrange_slice_msb0 $name, $t, i128);
|
||||
};
|
||||
(struct $name:ident($t:ty)) => {
|
||||
impl<T> $crate::BitRange<T> for $name where $t: $crate::BitRange<T> {
|
||||
fn bit_range(&self, msb: usize, lsb: usize) -> T {
|
||||
self.0.bit_range(msb, lsb)
|
||||
}
|
||||
}
|
||||
impl<T> $crate::BitRangeMut<T> for $name where $t: $crate::BitRangeMut<T> {
|
||||
fn set_bit_range(&mut self, msb: usize, lsb: usize, value: T) {
|
||||
self.0.set_bit_range(msb, lsb, value);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Combines `bitfield_bitrange` and `bitfield_fields`.
|
||||
///
|
||||
/// The syntax of this macro is the syntax of a tuple struct, including attributes and
|
||||
/// documentation comments, followed by a semicolon, some optional elements, and finally the fields
|
||||
/// as described in the `bitfield_fields` documentation.
|
||||
///
|
||||
/// The first optional element is `no default BitRange;`. With that, no implementation of
|
||||
/// `BitRange` will be generated.
|
||||
///
|
||||
/// The second optional element is a set of lines of the form `impl <Trait>;`. The following traits are supported:
|
||||
/// * `Debug`; This will generate an implementation of `fmt::Debug` with the `bitfield_debug` macro.
|
||||
/// * `BitAnd`, `BitOr`, `BitXor`; These will generate implementations of the relevant `ops::Bit___` and `ops::Bit___Assign` traits.
|
||||
/// * `new`; This will generate a constructor that calls all of the bitfield's setter methods with an argument of the appropriate type
|
||||
/// * `new{constructor_name(setter_name: setter_type, ...)}`; This will generate a constructor that calls a given subset of the bitfield's setter methods
|
||||
///
|
||||
/// The difference with calling those macros separately is that `bitfield_fields` is called
|
||||
/// from an appropriate `impl` block. If you use the non-slice form of `bitfield_bitrange`, the
|
||||
/// default type for `bitfield_fields` will be set to the wrapped fields.
|
||||
///
|
||||
/// See the documentation of these macros for more information on their respective syntax.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # #[macro_use] extern crate bitfield;
|
||||
/// # fn main() {}
|
||||
/// bitfield!{
|
||||
/// pub struct BitField1(u16);
|
||||
/// impl Debug;
|
||||
/// // The fields default to u16
|
||||
/// field1, set_field1: 10, 0;
|
||||
/// pub field2, _ : 12, 3;
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// or with a custom `BitRange` and `BitRangeMut` implementation :
|
||||
/// ```rust
|
||||
/// # #[macro_use] extern crate bitfield;
|
||||
/// # use bitfield::{BitRange, BitRangeMut};
|
||||
/// # fn main() {}
|
||||
/// bitfield!{
|
||||
/// pub struct BitField1(u16);
|
||||
/// no default BitRange;
|
||||
/// impl Debug;
|
||||
/// impl BitAnd;
|
||||
/// u8;
|
||||
/// field1, set_field1: 10, 0;
|
||||
/// pub field2, _ : 12, 3;
|
||||
/// }
|
||||
/// impl BitRange<u8> for BitField1 {
|
||||
/// fn bit_range(&self, msb: usize, lsb: usize) -> u8 {
|
||||
/// let width = msb - lsb + 1;
|
||||
/// let mask = (1 << width) - 1;
|
||||
/// ((self.0 >> lsb) & mask) as u8
|
||||
/// }
|
||||
/// }
|
||||
/// impl BitRangeMut<u8> for BitField1 {
|
||||
/// fn set_bit_range(&mut self, msb: usize, lsb: usize, value: u8) {
|
||||
/// self.0 = (value as u16) << lsb;
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
#[macro_export(local_inner_macros)]
|
||||
macro_rules! bitfield {
|
||||
// Force `impl <Trait>` to always be after `no default BitRange` it the two are present.
|
||||
// This simplify the rest of the macro.
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident($($type:tt)*); $(impl $trait:ident$({$($trait_arg:tt)*})?;)+ no default BitRange; $($rest:tt)*) => {
|
||||
bitfield!{$(#[$attribute])* $vis struct $name($($type)*); no default BitRange; $(impl $trait$({$($trait_arg)*})?;)* $($rest)*}
|
||||
};
|
||||
|
||||
// If we have `impl <Trait>` without `no default BitRange`, we will still match, because when
|
||||
// we call `bitfield_bitrange`, we add `no default BitRange`.
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident([$t:ty]); no default BitRange; impl $trait:ident$({$($trait_arg:tt)*})?; $($rest:tt)*) => {
|
||||
bitfield_impl!{$trait$({$($trait_arg)*})? for struct $name([$t]); $($rest)*}
|
||||
|
||||
bitfield!{$(#[$attribute])* $vis struct $name([$t]); no default BitRange; $($rest)*}
|
||||
};
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident([$t:ty]); no default BitRange; $($rest:tt)*) => {
|
||||
$(#[$attribute])*
|
||||
$vis struct $name<T>(pub T);
|
||||
|
||||
//impl<T: AsMut<[$t]> + AsRef<[$t]>> $name<T> {
|
||||
// bitfield_fields!{$($rest)*}
|
||||
//}
|
||||
impl<T: AsRef<[$t]>> $name<T> {
|
||||
bitfield_fields!{only getter; $($rest)*}
|
||||
}
|
||||
impl<T: AsMut<[$t]>> $name<T> {
|
||||
bitfield_fields!{only setter; $($rest)*}
|
||||
}
|
||||
};
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident([$t:ty]); $($rest:tt)*) => {
|
||||
bitfield_bitrange!(struct $name([$t]));
|
||||
bitfield!{$(#[$attribute])* $vis struct $name([$t]); no default BitRange; $($rest)*}
|
||||
};
|
||||
|
||||
// The only difference between the MSB0 version anf the non-MSB0 version, is the BitRange
|
||||
// implementation. We delegate everything else to the non-MSB0 version of the macro.
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident(MSB0 [$t:ty]); no default BitRange; $($rest:tt)*) => {
|
||||
bitfield!{$(#[$attribute])* $vis struct $name([$t]); no default BitRange; $($rest)*}
|
||||
};
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident(MSB0 [$t:ty]); $($rest:tt)*) => {
|
||||
bitfield_bitrange!(struct $name(MSB0 [$t]));
|
||||
bitfield!{$(#[$attribute])* $vis struct $name([$t]); no default BitRange; $($rest)*}
|
||||
};
|
||||
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident($t:ty); no default BitRange; impl $trait:ident$({$($trait_arg:tt)*})?; $($rest:tt)*) => {
|
||||
bitfield_impl!{$trait$({$($trait_arg)*})? for struct $name($t); $($rest)*}
|
||||
|
||||
bitfield!{$(#[$attribute])* $vis struct $name($t); no default BitRange; $($rest)*}
|
||||
};
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident($t:ty); no default BitRange; $($rest:tt)*) => {
|
||||
$(#[$attribute])*
|
||||
$vis struct $name(pub $t);
|
||||
|
||||
impl $name {
|
||||
bitfield_fields!{$t; $($rest)*}
|
||||
}
|
||||
};
|
||||
($(#[$attribute:meta])* $vis:vis struct $name:ident($t:ty); $($rest:tt)*) => {
|
||||
bitfield_bitrange!(struct $name($t));
|
||||
bitfield!{$(#[$attribute])* $vis struct $name($t); no default BitRange; $($rest)*}
|
||||
};
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
pub use core::convert::Into;
|
||||
#[doc(hidden)]
|
||||
pub use core::fmt;
|
||||
#[doc(hidden)]
|
||||
pub use core::mem::size_of;
|
||||
#[doc(hidden)]
|
||||
pub use core::ops;
|
||||
|
||||
/// A trait to get ranges of bits.
|
||||
pub trait BitRange<T> {
|
||||
/// Get a range of bits.
|
||||
fn bit_range(&self, msb: usize, lsb: usize) -> T;
|
||||
}
|
||||
|
||||
/// A trait to set ranges of bits.
|
||||
pub trait BitRangeMut<T> {
|
||||
/// Set a range of bits.
|
||||
fn set_bit_range(&mut self, msb: usize, lsb: usize, value: T);
|
||||
}
|
||||
|
||||
/// A trait to get a single bit.
|
||||
///
|
||||
/// This trait is implemented for all type that implement `BitRange<u8>`.
|
||||
pub trait Bit {
|
||||
/// Get a single bit.
|
||||
fn bit(&self, bit: usize) -> bool;
|
||||
}
|
||||
|
||||
/// A trait to set a single bit.
|
||||
///
|
||||
/// This trait is implemented for all type that implement `BitRangeMut<u8>`.
|
||||
pub trait BitMut {
|
||||
/// Set a single bit.
|
||||
fn set_bit(&mut self, bit: usize, value: bool);
|
||||
}
|
||||
|
||||
impl<T: BitRange<u8>> Bit for T {
|
||||
fn bit(&self, bit: usize) -> bool {
|
||||
self.bit_range(bit, bit) != 0
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BitRangeMut<u8>> BitMut for T {
|
||||
fn set_bit(&mut self, bit: usize, value: bool) {
|
||||
self.set_bit_range(bit, bit, value as u8);
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_bitrange_for_u {
|
||||
($t:ty, $bitrange_ty:ty) => {
|
||||
impl BitRange<$bitrange_ty> for $t {
|
||||
#[inline]
|
||||
#[allow(clippy::cast_lossless)]
|
||||
#[allow(clippy::manual_bits)]
|
||||
fn bit_range(&self, msb: usize, lsb: usize) -> $bitrange_ty {
|
||||
let bit_len = size_of::<$t>()*8;
|
||||
let result_bit_len = size_of::<$bitrange_ty>()*8;
|
||||
let result = ((*self << (bit_len - msb - 1)) >> (bit_len - msb - 1 + lsb))
|
||||
as $bitrange_ty;
|
||||
result << (result_bit_len - (msb - lsb + 1)) >> (result_bit_len - (msb - lsb + 1))
|
||||
}
|
||||
}
|
||||
|
||||
impl BitRangeMut<$bitrange_ty> for $t {
|
||||
#[inline]
|
||||
#[allow(clippy::cast_lossless)]
|
||||
#[allow(clippy::manual_bits)]
|
||||
fn set_bit_range(&mut self, msb: usize, lsb: usize, value: $bitrange_ty) {
|
||||
let bit_len = size_of::<$t>()*8;
|
||||
let mask: $t = !(0 as $t)
|
||||
<< (bit_len - msb - 1)
|
||||
>> (bit_len - msb - 1 + lsb)
|
||||
<< (lsb);
|
||||
*self &= !mask;
|
||||
*self |= (value as $t << lsb) & mask;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_bitrange_for_u_combinations {
|
||||
((),($($bitrange_ty:ty),*)) => {
|
||||
|
||||
};
|
||||
(($t:ty),($($bitrange_ty:ty),*)) => {
|
||||
$(impl_bitrange_for_u!{$t, $bitrange_ty})*
|
||||
};
|
||||
(($t_head:ty, $($t_rest:ty),*),($($bitrange_ty:ty),*)) => {
|
||||
impl_bitrange_for_u_combinations!{($t_head), ($($bitrange_ty),*)}
|
||||
impl_bitrange_for_u_combinations!{($($t_rest),*), ($($bitrange_ty),*)}
|
||||
};
|
||||
}
|
||||
|
||||
impl_bitrange_for_u_combinations! {(u8, u16, u32, u64, u128), (u8, u16, u32, u64, u128)}
|
||||
impl_bitrange_for_u_combinations! {(u8, u16, u32, u64, u128), (i8, i16, i32, i64, i128)}
|
||||
|
||||
// Same as std::stringify but callable from local_inner_macros macros defined inside
|
||||
// this crate.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __bitfield_stringify {
|
||||
($s:ident) => {
|
||||
stringify!($s)
|
||||
};
|
||||
}
|
||||
|
||||
// Same as std::debug_assert but callable from local_inner_macros macros defined inside
|
||||
// this crate.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __bitfield_debug_assert {
|
||||
($e:expr) => {
|
||||
debug_assert!($e)
|
||||
};
|
||||
}
|
||||
Vendored
+1267
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user