use crate::alphabet::{char_to_value, donors, ALPHABET_VALUE, DEC_BASE, DEC_INVALID};
use crate::constants::{DP_SIGNAL_BASE, FILL_SIGNAL_BASE, FUTURE_SIGNAL_BASE, TAIL_SIGNAL_BASE};
use crate::digits::{chars_to_value, value_to_5chars_32, POW85_2, POW85_3, POW85_4};
use crate::error::DecodeError;
fn is_ignorable_ws(c: u8) -> bool {
c == b' ' || c == b'\t' || c == b'\n' || c == b'\r'
}
#[inline]
fn split_dp_payload(payload: u64) -> (usize, u16, usize) {
let length = (payload & 0x7FF) as usize + 1;
let mask = ((payload >> 11) & 0x1FFF) as u16;
let profile = ((payload >> 24) & 0x7) as usize;
(profile, mask, length)
}
#[inline]
fn split_fill_payload(payload: u64) -> (u8, usize) {
let length = (payload & 0x7FF) as usize + 1;
let byte = ((payload >> 11) & 0xFF) as u8;
(byte, length)
}
#[inline]
fn split_tail_payload(payload: u64) -> (usize, u8, [u8; 2]) {
let zeros = ((payload >> 16) & 0x1F) as usize + 1;
let order = ((payload >> 21) & 1) as u8;
let lit = [((payload >> 8) & 0xFF) as u8, (payload & 0xFF) as u8];
(zeros, order, lit)
}
fn dp_table(profile: usize, mask: u16) -> [u16; 256] {
let mut table = DEC_BASE;
let (pairs, k) = donors(profile, mask);
for &(rset, donor) in &pairs[..k] {
table[donor as usize] = rset as u16;
}
table
}
#[inline]
fn reserve(out: &mut Vec<u8>, w: usize, need: usize) {
if need > out.len() - w {
let want = w + need;
out.resize(want + want / 4, 0);
}
}
fn scan(src: &[u8], out: &mut Vec<u8>) -> Option<usize> {
let n = src.len();
let mut pos = 0usize;
let mut w = 0usize;
let mut table = DEC_BASE;
let mut table_key = u32::MAX;
while pos < n {
let remaining = n - pos;
if remaining >= 5 {
let run = ((n - pos) / 5).min((out.len() - w) / 4);
if run > 0 {
let (ins, _) = src[pos..pos + 5 * run].as_chunks::<5>();
let (outs, _) = out[w..w + 4 * run].as_chunks_mut::<4>();
let mut done = 0usize;
for (g, o) in ins.iter().zip(outs.iter_mut()) {
let v0 = ALPHABET_VALUE[g[0] as usize] as u8;
let v1 = ALPHABET_VALUE[g[1] as usize] as u8;
let v2 = ALPHABET_VALUE[g[2] as usize] as u8;
let v3 = ALPHABET_VALUE[g[3] as usize] as u8;
let v4 = ALPHABET_VALUE[g[4] as usize] as u8;
if (v0 | v1 | v2 | v3 | v4) & 0x80 != 0 {
return None;
}
let value = v0 as u64 * POW85_4
+ (v1 as u32 * POW85_3 + v2 as u32 * POW85_2 + v3 as u32 * 85 + v4 as u32)
as u64;
if value >= DP_SIGNAL_BASE {
break; }
*o = (value as u32).to_be_bytes();
done += 1;
}
if done > 0 {
pos += 5 * done;
w += 4 * done;
continue;
}
}
let g: &[u8; 5] = src[pos..pos + 5].try_into().expect("five bytes");
let v0 = ALPHABET_VALUE[g[0] as usize] as u8;
let v1 = ALPHABET_VALUE[g[1] as usize] as u8;
let v2 = ALPHABET_VALUE[g[2] as usize] as u8;
let v3 = ALPHABET_VALUE[g[3] as usize] as u8;
let v4 = ALPHABET_VALUE[g[4] as usize] as u8;
if (v0 | v1 | v2 | v3 | v4) & 0x80 != 0 {
return None;
}
let decoded_value = v0 as u64 * POW85_4
+ (v1 as u32 * POW85_3 + v2 as u32 * POW85_2 + v3 as u32 * 85 + v4 as u32) as u64;
pos += 5;
if decoded_value < DP_SIGNAL_BASE {
reserve(out, w, 4);
out[w..w + 4].copy_from_slice(&(decoded_value as u32).to_be_bytes());
w += 4;
continue;
}
if decoded_value >= FUTURE_SIGNAL_BASE {
return None; }
if decoded_value >= TAIL_SIGNAL_BASE {
let (zeros, order, lit) = split_tail_payload(decoded_value - TAIL_SIGNAL_BASE);
reserve(out, w, zeros + 2);
let (first, second) = if order == 0 { (zeros, 0) } else { (0, zeros) };
out[w..w + first].fill(0);
out[w + first..w + first + 2].copy_from_slice(&lit);
out[w + first + 2..w + first + 2 + second].fill(0);
w += zeros + 2;
continue;
}
if decoded_value >= FILL_SIGNAL_BASE {
let (byte, length) = split_fill_payload(decoded_value - FILL_SIGNAL_BASE);
reserve(out, w, length);
out[w..w + length].fill(byte);
w += length;
continue;
}
let (profile, mask, length) = split_dp_payload(decoded_value - DP_SIGNAL_BASE);
if n - pos < length {
return None; }
reserve(out, w, length);
let key = ((profile as u32) << 16) | mask as u32;
if table_key != key {
table = dp_table(profile, mask);
table_key = key;
}
let seg = &src[pos..pos + length];
let out_seg = &mut out[w..w + length];
for (o, &c) in out_seg.iter_mut().zip(seg.iter()) {
let t = table[c as usize];
if t & DEC_INVALID != 0 {
return None;
}
*o = t as u8;
}
pos += length;
w += length;
continue;
}
if remaining == 1 {
return None;
}
let mut digits = [84u8; 5]; for (d, &c) in digits.iter_mut().zip(&src[pos..pos + remaining]) {
let v = ALPHABET_VALUE[c as usize];
if v < 0 {
return None;
}
*d = v as u8;
}
let value = crate::digits::digits_to_value(&digits);
if value >= DP_SIGNAL_BASE {
return None;
}
let produced = remaining - 1;
let bytes = (value as u32).to_be_bytes();
let mut padded = [0u8; 4];
padded[..produced].copy_from_slice(&bytes[..produced]);
let canonical = value_to_5chars_32(u32::from_be_bytes(padded));
if canonical[..remaining] != src[pos..pos + remaining] {
return None;
}
reserve(out, w, produced);
out[w..w + produced].copy_from_slice(&bytes[..produced]);
w += produced;
pos += remaining;
}
Some(w)
}
pub fn decode(s: &str) -> Result<Vec<u8>, DecodeError> {
let bytes = s.as_bytes();
let mut out = vec![0u8; bytes.len()];
if let Some(produced) = scan(bytes, &mut out) {
out.truncate(produced);
return Ok(out);
}
if bytes.iter().any(|&c| is_ignorable_ws(c)) {
let filtered: Vec<u8> = bytes.iter().copied().filter(|&c| !is_ignorable_ws(c)).collect();
debug_assert!(filtered.len() <= out.len());
if let Some(produced) = scan(&filtered, &mut out) {
out.truncate(produced);
return Ok(out);
}
}
Err(report_error(s))
}
#[derive(Clone, Copy)]
struct PosChar {
c: char,
pos: usize,
}
fn report_error(s: &str) -> DecodeError {
let mut chars = s
.char_indices()
.filter(|&(_, c)| !matches!(c, ' ' | '\t' | '\n' | '\r'))
.map(|(pos, c)| PosChar { c, pos });
loop {
let mut group = [PosChar { c: '\0', pos: 0 }; 5];
let mut have = 0usize;
for slot in group.iter_mut() {
match chars.next() {
Some(pc) => {
*slot = pc;
have += 1;
}
None => break,
}
}
if have == 0 {
break;
}
if have == 5 {
let decoded_value = match value_of_group(&group) {
Ok(v) => v,
Err(e) => return e,
};
if decoded_value >= FUTURE_SIGNAL_BASE {
return DecodeError::UndefinedSignal { value: decoded_value };
}
if decoded_value >= FILL_SIGNAL_BASE {
continue; }
if decoded_value >= DP_SIGNAL_BASE {
let (_profile, _mask, length) = split_dp_payload(decoded_value - DP_SIGNAL_BASE);
let mut invalid = None;
for _ in 0..length {
let Some(pc) = chars.next() else {
return DecodeError::UnexpectedEndOfStream;
};
if invalid.is_none() && char_to_value(pc.c).is_none() {
invalid = Some(DecodeError::InvalidCharacter {
character: pc.c,
position: pc.pos,
});
}
}
if let Some(e) = invalid {
return e;
}
}
continue;
}
if have == 1 {
let pc = group[0];
if char_to_value(pc.c).is_none() {
return DecodeError::InvalidCharacter { character: pc.c, position: pc.pos };
}
return DecodeError::InvalidFinalBlock { length: have };
}
let mut digits = [84u8; 5]; for (k, pc) in group[..have].iter().enumerate() {
match char_to_value(pc.c) {
Some(v) => digits[k] = v,
None => {
return DecodeError::InvalidCharacter { character: pc.c, position: pc.pos }
}
}
}
let value = crate::digits::digits_to_value(&digits);
if value >= DP_SIGNAL_BASE {
return DecodeError::InvalidFinalBlock { length: have };
}
let produced = have - 1;
let bytes = (value as u32).to_be_bytes();
let mut padded = [0u8; 4];
padded[..produced].copy_from_slice(&bytes[..produced]);
let canonical = value_to_5chars_32(u32::from_be_bytes(padded));
if canonical[..have].iter().zip(&group[..have]).any(|(&want, got)| want as char != got.c) {
return DecodeError::InvalidFinalBlock { length: have };
}
break;
}
debug_assert!(false, "the decoder rejected an input its error reporter accepts");
DecodeError::UnexpectedEndOfStream
}
fn first_invalid(group: &[PosChar]) -> Option<DecodeError> {
group.iter().find_map(|pc| {
if char_to_value(pc.c).is_none() {
Some(DecodeError::InvalidCharacter {
character: pc.c,
position: pc.pos,
})
} else {
None
}
})
}
fn value_of_group(group: &[PosChar; 5]) -> Result<u64, DecodeError> {
let cs = [group[0].c, group[1].c, group[2].c, group[3].c, group[4].c];
match chars_to_value(&cs) {
Some(v) => Ok(v),
None => {
Err(first_invalid(group).expect("chars_to_value failed but no invalid character found"))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::alphabet::RSET_LEN;
use crate::constants::{MAX_DP_SEGMENT_CHARS, MAX_FILL_BYTES};
#[test]
fn payload_fields_are_masked_to_their_widths() {
let payload = (7u64 << 24) | (0x1FFF << 11) | 0x7FF;
assert_eq!(split_dp_payload(payload), (7, 0x1FFF, MAX_DP_SEGMENT_CHARS));
assert_eq!(split_dp_payload(0), (0, 0, 1));
assert_eq!(split_fill_payload(0), (0, 1));
assert_eq!(
split_fill_payload((0xFFu64 << 11) | 0x7FF),
(0xFF, MAX_FILL_BYTES)
);
assert_eq!(RSET_LEN, 13);
}
}