use core::fmt;
use core::fmt::Write as _;
use crate::address::PcRead;
use crate::tokens::{Hex, OperandIndex, TokenKind, TokenSink};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Form {
Hex,
Signed,
Decimal,
}
pub struct SignedHex {
pub value: i64,
pub negative: bool,
}
impl fmt::Display for SignedHex {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.negative || self.value < 0 {
true => write!(f, "-0x{:x}", self.value.unsigned_abs()),
false => write!(f, "0x{:x}", self.value),
}
}
}
pub fn float_from_bits(bits: u64, width: u32) -> f64 {
match width {
16 => {
let half = bits as u16;
let sign = if half >> 15 == 1 { -1.0 } else { 1.0 };
let exponent = (half >> 10) & 0x1f;
let fraction = f64::from(half & 0x3ff);
match exponent {
0 => sign * fraction * power_of_two(-24),
0x1f if fraction == 0.0 => sign * f64::INFINITY,
0x1f => f64::NAN,
_ => sign * (1.0 + fraction / 1024.0) * power_of_two(i32::from(exponent) - 15),
}
}
32 => f64::from(f32::from_bits(bits as u32)),
_ => f64::from_bits(bits),
}
}
const fn power_of_two(exponent: i32) -> f64 {
debug_assert!(-1022 <= exponent && exponent <= 1023);
f64::from_bits(((exponent + 1023) as u64) << 52)
}
pub struct Float<T>(pub T);
impl<T: fmt::Display> fmt::Display for Float<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut out = DetectDecimalPoint { f, found: false };
write!(out, "{}", self.0)?;
match out.found {
true => Ok(()),
false => f.write_str(".0"),
}
}
}
struct DetectDecimalPoint<'a, 'b> {
f: &'a mut fmt::Formatter<'b>,
found: bool,
}
impl fmt::Write for DetectDecimalPoint<'_, '_> {
fn write_str(&mut self, s: &str) -> fmt::Result {
self.found |= s.contains(['.', 'e', 'E']);
self.f.write_str(s)
}
}
pub struct Writer<'a> {
sink: &'a mut dyn TokenSink,
name: &'static str,
address: u64,
bits: u32,
operand: OperandIndex,
}
impl<'a> Writer<'a> {
pub fn new(sink: &'a mut dyn TokenSink, name: &'static str, address: u64, bits: u32) -> Self {
Writer {
sink,
name,
address,
bits,
operand: None,
}
}
#[inline]
pub fn operand(&mut self, operand: OperandIndex) {
self.operand = operand;
}
#[inline(never)]
pub fn name(&mut self) -> fmt::Result {
self.sink.text(TokenKind::Mnemonic, self.operand, self.name)
}
#[inline(never)]
pub fn mnemonic(&mut self, text: &str) -> fmt::Result {
self.sink.text(TokenKind::Mnemonic, self.operand, text)
}
#[inline(never)]
pub fn text(&mut self, text: &str) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, text)
}
#[inline(never)]
pub fn separator(&mut self) -> fmt::Result {
self.operand = None;
self.sink.text(TokenKind::Separator, None, ", ")
}
#[inline(never)]
pub fn inner_separator(&mut self) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, ", ")
}
#[inline(never)]
pub fn bracket(&mut self, text: &str) -> fmt::Result {
self.sink.text(TokenKind::Bracket, self.operand, text)
}
#[inline(never)]
pub fn number(&mut self, value: i64, form: Form) -> fmt::Result {
match form {
Form::Hex => {
self.sink.text(TokenKind::Text, self.operand, "#")?;
self.sink.value(
TokenKind::Immediate(value),
self.operand,
&Hex(value as u64),
)
}
Form::Signed => self.signed(value, false),
Form::Decimal => {
self.sink
.value(TokenKind::Integer(value as u64), self.operand, &value)
}
}
}
#[inline(never)]
pub fn float(&mut self, value: impl fmt::Display) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, "#")?;
self.sink
.value(TokenKind::Float, self.operand, &Float(value))
}
#[inline(never)]
pub fn register(&mut self, reg: &dyn fmt::Display) -> fmt::Result {
self.sink.value(TokenKind::Register, self.operand, reg)
}
#[inline(never)]
pub fn some_register<R: fmt::Display>(&mut self, reg: Option<R>) -> fmt::Result {
self.register(®.ok_or(fmt::Error)?)
}
#[inline(never)]
pub fn some_number(&mut self, value: Option<i64>, form: Form) -> fmt::Result {
self.number(value.ok_or(fmt::Error)?, form)
}
#[inline(never)]
pub fn symbol(&mut self, name: &dyn fmt::Display) -> fmt::Result {
self.sink.value(TokenKind::Symbol, self.operand, name)
}
#[inline(never)]
pub fn token(&mut self, kind: TokenKind, text: &str) -> fmt::Result {
self.sink.text(kind, self.operand, text)
}
#[inline(never)]
pub fn valued(&mut self, kind: TokenKind, value: &dyn fmt::Display) -> fmt::Result {
self.sink.value(kind, self.operand, value)
}
#[inline(never)]
pub fn signed(&mut self, value: i64, negative: bool) -> fmt::Result {
self.sink.text(TokenKind::Text, self.operand, "#")?;
self.sink.value(
TokenKind::Immediate(value),
self.operand,
&SignedHex { value, negative },
)
}
#[inline(never)]
pub fn address(&mut self, target: u64) -> fmt::Result {
self.sink
.value(TokenKind::Address(target), self.operand, &Hex(target))
}
#[inline(never)]
pub fn label(&mut self, offset: i64, pc: PcRead) -> fmt::Result {
self.address(pc.target(self.address, offset, self.bits))
}
}
#[macro_export]
macro_rules! rendering_writer {
($(#[$doc:meta])* $name:ident, $bits:literal) => {
$(#[$doc])*
pub struct $name<'a> {
out: $crate::write::Writer<'a>,
}
impl<'a> ::core::ops::Deref for $name<'a> {
type Target = $crate::write::Writer<'a>;
fn deref(&self) -> &Self::Target {
&self.out
}
}
impl<'a> ::core::ops::DerefMut for $name<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.out
}
}
impl<'a> $name<'a> {
pub fn new(
sink: &'a mut dyn $crate::tokens::TokenSink,
name: &'static str,
address: u64,
) -> Self {
$name {
out: $crate::write::Writer::new(sink, name, address, $bits),
}
}
}
};
}
#[cfg(all(test, feature = "alloc"))]
mod tests {
use super::{Float, Form, Writer, float_from_bits};
use crate::address::PcRead;
use crate::tokens::{Token, TokenKind};
use alloc::string::{String, ToString};
use alloc::vec;
use alloc::vec::Vec;
use core::fmt;
fn written(
at: u64,
bits: u32,
write: impl FnOnce(&mut Writer) -> fmt::Result,
) -> (Vec<Token>, String) {
let mut sink: Vec<Token> = Vec::new();
let mut writer = Writer::new(&mut sink, "b", at, bits);
write(&mut writer).expect("a Vec sink cannot fail");
let text = sink.iter().map(|t| t.text.as_str()).collect();
(sink, text)
}
#[test]
fn a_decimal_is_written_bare() {
let (tokens, text) = written(0, 64, |w| w.number(3, Form::Decimal));
assert_eq!(text, "3");
assert_eq!(tokens.len(), 1);
assert_eq!(tokens[0].kind, TokenKind::Integer(3));
}
#[test]
fn a_subtracted_zero_keeps_its_sign() {
assert_eq!(written(0, 64, |w| w.signed(0, true)).1, "#-0x0");
assert_eq!(written(0, 64, |w| w.signed(0, false)).1, "#0x0");
assert_eq!(written(0, 64, |w| w.signed(16, true)).1, "#-0x10");
}
#[test]
fn a_signed_form_writes_the_value_it_has() {
assert_eq!(written(0, 64, |w| w.number(-16, Form::Signed)).1, "#-0x10");
}
#[test]
fn a_target_wraps_within_the_instruction_set_s_reach() {
let pc = PcRead { ahead: 0, align: 1 };
assert_eq!(
written(0xffff_fffc, 32, |w| w.label(0x10, pc)).1,
"0xc",
"a 32-bit target past the end wraps to the bottom"
);
assert_eq!(written(0x10, 32, |w| w.label(-0x20, pc)).1, "0xfffffff0");
}
#[test]
fn each_piece_carries_its_kind() {
let (tokens, text) = written(0, 64, |w| {
w.name()?;
w.text("\t")?;
w.register(&"x0")?;
w.separator()?;
w.operand(Some(1));
w.bracket("[")?;
w.register(&"x1")?;
w.inner_separator()?;
w.symbol(&"lsl")?;
w.bracket("]")
});
assert_eq!(text, "b\tx0, [x1, lsl]");
let kinds: Vec<(TokenKind, Option<u8>)> =
tokens.iter().map(|t| (t.kind, t.operand)).collect();
assert_eq!(
kinds,
vec![
(TokenKind::Mnemonic, None),
(TokenKind::Text, None),
(TokenKind::Register, None),
(TokenKind::Separator, None),
(TokenKind::Bracket, Some(1)),
(TokenKind::Register, Some(1)),
(TokenKind::Text, Some(1)),
(TokenKind::Symbol, Some(1)),
(TokenKind::Bracket, Some(1)),
]
);
}
#[test]
fn a_whole_number_keeps_its_point() {
assert_eq!(Float(2.0).to_string(), "2.0");
assert_eq!(Float(-0.125).to_string(), "-0.125");
}
#[test]
fn a_long_number_is_written_whole() {
let written = Float(1e100).to_string();
assert_eq!(written.len(), 103);
assert!(written.starts_with('1') && written.ends_with("0.0"));
}
#[test]
fn denormal() {
assert_eq!(float_from_bits(0x0001, 16), 2f64.powi(-24));
assert_eq!(float_from_bits(0x0000_0001, 32), 2f64.powi(-149));
assert_eq!(
float_from_bits(0x0000_0000_0000_0001, 64),
f64::from_bits(1)
);
}
#[test]
fn infinity() {
assert_eq!(float_from_bits(0x7c00, 16), f64::INFINITY);
assert_eq!(float_from_bits(0xfc00, 16), f64::NEG_INFINITY);
assert_eq!(float_from_bits(0x7f80_0000, 32), f64::INFINITY);
assert_eq!(float_from_bits(0x7ff0_0000_0000_0000, 64), f64::INFINITY);
}
#[test]
fn nan() {
assert!(float_from_bits(0x7e00, 16).is_nan());
assert!(float_from_bits(0x7fc0_0000, 32).is_nan());
assert!(float_from_bits(0x7ff8_0000_0000_0000, 64).is_nan());
}
}