difftreelog
fix int rendering in format should operate floats
in: master
1 file changed
crates/jrsonnet-evaluator/src/stdlib/format.rsdiffbeforeafterboth1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use jrsonnet_gcmodule::Trace;5use jrsonnet_interner::IStr;6use jrsonnet_types::ValType;7use thiserror::Error;89use crate::{error::Error::*, throw, typed::Typed, LocError, ObjValue, Result, State, Val};1011#[derive(Debug, Clone, Error, Trace)]12pub enum FormatError {13 #[error("truncated format code")]14 TruncatedFormatCode,15 #[error("unrecognized conversion type: {0}")]16 UnrecognizedConversionType(char),1718 #[error("not enough values")]19 NotEnoughValues,2021 #[error("cannot use * width with object")]22 CannotUseStarWidthWithObject,23 #[error("mapping keys required")]24 MappingKeysRequired,25 #[error("no such format field: {0}")]26 NoSuchFormatField(IStr),27}2829impl From<FormatError> for LocError {30 fn from(e: FormatError) -> Self {31 Self::new(Format(e))32 }33}3435use FormatError::*;3637type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;3839pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {40 if str.is_empty() {41 return Err(TruncatedFormatCode);42 }43 let bytes = str.as_bytes();44 if bytes[0] == b'(' {45 let mut i = 1;46 while i < bytes.len() {47 if bytes[i] == b')' {48 return Ok((&str[1..i as usize], &str[i as usize + 1..]));49 }50 i += 1;51 }52 Err(TruncatedFormatCode)53 } else {54 Ok(("", str))55 }56}5758#[cfg(test)]59pub mod tests_key {60 use super::*;6162 #[test]63 fn parse_key() {64 assert_eq!(65 try_parse_mapping_key("(hello ) world").unwrap(),66 ("hello ", " world")67 );68 assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));69 assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));70 assert_eq!(71 try_parse_mapping_key(" () world").unwrap(),72 ("", " () world")73 );74 }7576 #[test]77 #[should_panic]78 fn parse_key_missing_start() {79 try_parse_mapping_key("").unwrap();80 }8182 #[test]83 #[should_panic]84 fn parse_key_missing_end() {85 try_parse_mapping_key("( ").unwrap();86 }87}8889#[allow(clippy::struct_excessive_bools)]90#[derive(Default, Debug)]91pub struct CFlags {92 pub alt: bool,93 pub zero: bool,94 pub left: bool,95 pub blank: bool,96 pub sign: bool,97}9899pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {100 if str.is_empty() {101 return Err(TruncatedFormatCode);102 }103 let bytes = str.as_bytes();104 let mut i = 0;105 let mut out = CFlags::default();106 loop {107 if bytes.len() == i {108 return Err(TruncatedFormatCode);109 }110 match bytes[i] {111 b'#' => out.alt = true,112 b'0' => out.zero = true,113 b'-' => out.left = true,114 b' ' => out.blank = true,115 b'+' => out.sign = true,116 _ => break,117 }118 i += 1;119 }120 Ok((out, &str[i..]))121}122123#[derive(Debug, PartialEq, Eq)]124pub enum Width {125 Star,126 Fixed(usize),127}128pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {129 if str.is_empty() {130 return Err(TruncatedFormatCode);131 }132 let bytes = str.as_bytes();133 if bytes[0] == b'*' {134 return Ok((Width::Star, &str[1..]));135 }136 let mut out: usize = 0;137 let mut digits = 0;138 while let Some(digit) = (bytes[digits] as char).to_digit(10) {139 out *= 10;140 out += digit as usize;141 digits += 1;142 if digits == bytes.len() {143 return Err(TruncatedFormatCode);144 }145 }146 Ok((Width::Fixed(out), &str[digits..]))147}148149pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {150 if str.is_empty() {151 return Err(TruncatedFormatCode);152 }153 let bytes = str.as_bytes();154 if bytes[0] == b'.' {155 try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))156 } else {157 Ok((None, str))158 }159}160161// Only skips162pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {163 if str.is_empty() {164 return Err(TruncatedFormatCode);165 }166 let bytes = str.as_bytes();167 let mut idx = 0;168 while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {169 idx += 1;170 if bytes.len() == idx {171 return Err(TruncatedFormatCode);172 }173 }174 Ok(((), &str[idx..]))175}176177#[derive(Debug, PartialEq, Eq)]178pub enum ConvTypeV {179 Decimal,180 Octal,181 Hexadecimal,182 Scientific,183 Float,184 Shorter,185 Char,186 String,187 Percent,188}189pub struct ConvType {190 v: ConvTypeV,191 caps: bool,192}193194pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {195 if str.is_empty() {196 return Err(TruncatedFormatCode);197 }198199 let code = str.as_bytes()[0];200 let v: (ConvTypeV, bool) = match code {201 b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),202 b'o' => (ConvTypeV::Octal, false),203 b'x' => (ConvTypeV::Hexadecimal, false),204 b'X' => (ConvTypeV::Hexadecimal, true),205 b'e' => (ConvTypeV::Scientific, false),206 b'E' => (ConvTypeV::Scientific, true),207 b'f' => (ConvTypeV::Float, false),208 b'F' => (ConvTypeV::Float, true),209 b'g' => (ConvTypeV::Shorter, false),210 b'G' => (ConvTypeV::Shorter, true),211 b'c' => (ConvTypeV::Char, false),212 b's' => (ConvTypeV::String, false),213 b'%' => (ConvTypeV::Percent, false),214 c => return Err(UnrecognizedConversionType(c as char)),215 };216217 Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))218}219220#[derive(Debug)]221pub struct Code<'s> {222 mkey: &'s str,223 cflags: CFlags,224 width: Width,225 precision: Option<Width>,226 convtype: ConvTypeV,227 caps: bool,228}229pub fn parse_code(str: &str) -> ParseResult<Code> {230 if str.is_empty() {231 return Err(TruncatedFormatCode);232 }233 let (mkey, str) = try_parse_mapping_key(str)?;234 let (cflags, str) = try_parse_cflags(str)?;235 let (width, str) = try_parse_field_width(str)?;236 let (precision, str) = try_parse_precision(str)?;237 let (_, str) = try_parse_length_modifier(str)?;238 let (convtype, str) = parse_conversion_type(str)?;239240 Ok((241 Code {242 mkey,243 cflags,244 width,245 precision,246 convtype: convtype.v,247 caps: convtype.caps,248 },249 str,250 ))251}252253#[derive(Debug)]254pub enum Element<'s> {255 String(&'s str),256 Code(Code<'s>),257}258pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {259 let mut bytes = str.as_bytes();260 let mut out = vec![];261 let mut offset = 0;262263 loop {264 while offset != bytes.len() && bytes[offset] != b'%' {265 offset += 1;266 }267 if offset != 0 {268 out.push(Element::String(&str[0..offset]));269 }270 if offset == bytes.len() {271 return Ok(out);272 }273 str = &str[offset + 1..];274 let code;275 (code, str) = parse_code(str)?;276 bytes = str.as_bytes();277 offset = 0;278279 out.push(Element::Code(code));280 }281}282283const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";284285#[inline]286pub fn render_integer(287 out: &mut String,288 iv: i64,289 padding: usize,290 precision: usize,291 blank: bool,292 sign: bool,293 radix: i64,294 prefix: &str,295 caps: bool,296) {297 // Digit char indexes in reverse order, i.e298 // for radix = 16 and n = 12f: [15, 2, 1]299 let digits = if iv == 0 {300 vec![0u8]301 } else {302 let mut v = iv.abs();303 let mut nums = Vec::with_capacity(1);304 while v > 0 {305 nums.push((v % radix) as u8);306 v /= radix;307 }308 nums309 };310 let neg = iv < 0;311 let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });312 let zp2 = zp313 .max(precision)314 .saturating_sub(prefix.len() + digits.len());315316 if neg {317 out.push('-');318 } else if sign {319 out.push('+');320 } else if blank {321 out.push(' ');322 }323324 out.reserve(zp2);325 for _ in 0..zp2 {326 out.push('0');327 }328 out.push_str(prefix);329330 for digit in digits.into_iter().rev() {331 let ch = NUMBERS[digit as usize] as char;332 out.push(if caps { ch.to_ascii_uppercase() } else { ch });333 }334}335336pub fn render_decimal(337 out: &mut String,338 iv: i64,339 padding: usize,340 precision: usize,341 blank: bool,342 sign: bool,343) {344 render_integer(out, iv, padding, precision, blank, sign, 10, "", false);345}346pub fn render_octal(347 out: &mut String,348 iv: i64,349 padding: usize,350 precision: usize,351 alt: bool,352 blank: bool,353 sign: bool,354) {355 render_integer(356 out,357 iv,358 padding,359 precision,360 blank,361 sign,362 8,363 if alt && iv != 0 { "0" } else { "" },364 false,365 );366}367368#[allow(clippy::fn_params_excessive_bools)]369pub fn render_hexadecimal(370 out: &mut String,371 iv: i64,372 padding: usize,373 precision: usize,374 alt: bool,375 blank: bool,376 sign: bool,377 caps: bool,378) {379 render_integer(380 out,381 iv,382 padding,383 precision,384 blank,385 sign,386 16,387 match (alt, caps) {388 (true, true) => "0X",389 (true, false) => "0x",390 (false, _) => "",391 },392 caps,393 );394}395396#[allow(clippy::fn_params_excessive_bools)]397pub fn render_float(398 out: &mut String,399 n: f64,400 mut padding: usize,401 precision: usize,402 blank: bool,403 sign: bool,404 ensure_pt: bool,405 trailing: bool,406) {407 let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };408 padding = padding.saturating_sub(dot_size + precision);409 render_decimal(out, n.floor() as i64, padding, 0, blank, sign);410 if precision == 0 {411 if ensure_pt {412 out.push('.');413 }414 return;415 }416 let frac = n417 .fract()418 .mul_add(10.0_f64.powf(precision as f64), 0.5)419 .floor();420 if trailing || frac > 0.0 {421 out.push('.');422 let mut frac_str = String::new();423 render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);424 let mut trim = frac_str.len();425 if !trailing {426 for b in frac_str.as_bytes().iter().rev() {427 if *b == b'0' {428 trim -= 1;429 }430 }431 }432 out.push_str(&frac_str[..trim]);433 } else if ensure_pt {434 out.push('.');435 }436}437438#[allow(clippy::fn_params_excessive_bools)]439pub fn render_float_sci(440 out: &mut String,441 n: f64,442 mut padding: usize,443 precision: usize,444 blank: bool,445 sign: bool,446 ensure_pt: bool,447 trailing: bool,448 caps: bool,449) {450 let exponent = n.log10().floor();451 let mantissa = if exponent as i16 == -324 {452 n * 10.0 / 10.0_f64.powf(exponent + 1.0)453 } else {454 n / 10.0_f64.powf(exponent)455 };456 let mut exponent_str = String::new();457 render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);458459 // +1 for e460 padding = padding.saturating_sub(exponent_str.len() + 1);461462 render_float(463 out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,464 );465 out.push(if caps { 'E' } else { 'e' });466 out.push_str(&exponent_str);467}468469#[allow(clippy::too_many_lines)]470pub fn format_code(471 s: State,472 out: &mut String,473 value: &Val,474 code: &Code,475 width: usize,476 precision: Option<usize>,477) -> Result<()> {478 let clfags = &code.cflags;479 let (fpprec, iprec) = match precision {480 Some(v) => (v, v),481 None => (6, 0),482 };483 let padding = if clfags.zero && !clfags.left {484 width485 } else {486 0487 };488489 // TODO: If left padded, can optimize by writing directly to out490 let mut tmp_out = String::new();491492 match code.convtype {493 ConvTypeV::String => tmp_out.push_str(&value.clone().to_string(s)?),494 ConvTypeV::Decimal => {495 let value = f64::from_untyped(value.clone(), s)?;496 render_decimal(497 &mut tmp_out,498 value as i64,499 padding,500 iprec,501 clfags.blank,502 clfags.sign,503 );504 }505 ConvTypeV::Octal => {506 let value = f64::from_untyped(value.clone(), s)?;507 render_octal(508 &mut tmp_out,509 value as i64,510 padding,511 iprec,512 clfags.alt,513 clfags.blank,514 clfags.sign,515 );516 }517 ConvTypeV::Hexadecimal => {518 let value = f64::from_untyped(value.clone(), s)?;519 render_hexadecimal(520 &mut tmp_out,521 value as i64,522 padding,523 iprec,524 clfags.alt,525 clfags.blank,526 clfags.sign,527 code.caps,528 );529 }530 ConvTypeV::Scientific => {531 let value = f64::from_untyped(value.clone(), s)?;532 render_float_sci(533 &mut tmp_out,534 value,535 padding,536 fpprec,537 clfags.blank,538 clfags.sign,539 clfags.alt,540 true,541 code.caps,542 );543 }544 ConvTypeV::Float => {545 let value = f64::from_untyped(value.clone(), s)?;546 render_float(547 &mut tmp_out,548 value,549 padding,550 fpprec,551 clfags.blank,552 clfags.sign,553 clfags.alt,554 true,555 );556 }557 ConvTypeV::Shorter => {558 let value = f64::from_untyped(value.clone(), s)?;559 let exponent = value.log10().floor();560 if exponent < -4.0 || exponent >= fpprec as f64 {561 render_float_sci(562 &mut tmp_out,563 value,564 padding,565 fpprec - 1,566 clfags.blank,567 clfags.sign,568 clfags.alt,569 clfags.alt,570 code.caps,571 );572 } else {573 let digits_before_pt = 1.max(exponent as usize + 1);574 render_float(575 &mut tmp_out,576 value,577 padding,578 fpprec - digits_before_pt,579 clfags.blank,580 clfags.sign,581 clfags.alt,582 clfags.alt,583 );584 }585 }586 ConvTypeV::Char => match value.clone() {587 Val::Num(n) => tmp_out588 .push(std::char::from_u32(n as u32).ok_or(InvalidUnicodeCodepointGot(n as u32))?),589 Val::Str(s) => {590 if s.chars().count() != 1 {591 throw!(RuntimeError(592 format!("%c expected 1 char string, got {}", s.chars().count()).into(),593 ));594 }595 tmp_out.push_str(&s);596 }597 _ => {598 throw!(TypeMismatch(599 "%c requires number/string",600 vec![ValType::Num, ValType::Str],601 value.value_type(),602 ));603 }604 },605 ConvTypeV::Percent => tmp_out.push('%'),606 };607608 let padding = width.saturating_sub(tmp_out.len());609610 if !clfags.left {611 for _ in 0..padding {612 out.push(' ');613 }614 }615 out.push_str(&tmp_out);616 if clfags.left {617 for _ in 0..padding {618 out.push(' ');619 }620 }621622 Ok(())623}624625pub fn format_arr(s: State, str: &str, mut values: &[Val]) -> Result<String> {626 let codes = parse_codes(str)?;627 let mut out = String::new();628629 for code in codes {630 match code {631 Element::String(s) => {632 out.push_str(s);633 }634 Element::Code(c) => {635 let width = match c.width {636 Width::Star => {637 if values.is_empty() {638 throw!(NotEnoughValues);639 }640 let value = &values[0];641 values = &values[1..];642 usize::from_untyped(value.clone(), s.clone())?643 }644 Width::Fixed(n) => n,645 };646 let precision = match c.precision {647 Some(Width::Star) => {648 if values.is_empty() {649 throw!(NotEnoughValues);650 }651 let value = &values[0];652 values = &values[1..];653 Some(usize::from_untyped(value.clone(), s.clone())?)654 }655 Some(Width::Fixed(n)) => Some(n),656 None => None,657 };658659 // %% should not consume a value660 let value = if c.convtype == ConvTypeV::Percent {661 &Val::Null662 } else {663 if values.is_empty() {664 throw!(NotEnoughValues);665 }666 let value = &values[0];667 values = &values[1..];668 value669 };670671 format_code(s.clone(), &mut out, value, &c, width, precision)?;672 }673 }674 }675676 Ok(out)677}678679pub fn format_obj(s: State, str: &str, values: &ObjValue) -> Result<String> {680 let codes = parse_codes(str)?;681 let mut out = String::new();682683 for code in codes {684 match code {685 Element::String(s) => {686 out.push_str(s);687 }688 Element::Code(c) => {689 // TODO: Operate on ref690 let f: IStr = c.mkey.into();691 let width = match c.width {692 Width::Star => {693 throw!(CannotUseStarWidthWithObject);694 }695 Width::Fixed(n) => n,696 };697 let precision = match c.precision {698 Some(Width::Star) => {699 throw!(CannotUseStarWidthWithObject);700 }701 Some(Width::Fixed(n)) => Some(n),702 None => None,703 };704705 let value = if c.convtype == ConvTypeV::Percent {706 Val::Null707 } else {708 if f.is_empty() {709 throw!(MappingKeysRequired);710 }711 if let Some(v) = values.get(s.clone(), f.clone())? {712 v713 } else {714 throw!(NoSuchFormatField(f));715 }716 };717718 format_code(s.clone(), &mut out, &value, &c, width, precision)?;719 }720 }721 }722723 Ok(out)724}725726#[cfg(test)]727pub mod test_format {728 use super::*;729730 #[test]731 fn parse() {732 assert_eq!(733 parse_codes(734 "How much error budget is left looking at our %.3f%% availability gurantees?"735 )736 .unwrap()737 .len(),738 4739 );740 }741742 #[test]743 fn octals() {744 let s = State::default();745 assert_eq!(746 format_arr(s.clone(), "%#o", &[Val::Num(8.0)]).unwrap(),747 "010"748 );749 assert_eq!(750 format_arr(s.clone(), "%#4o", &[Val::Num(8.0)]).unwrap(),751 " 010"752 );753 assert_eq!(754 format_arr(s.clone(), "%4o", &[Val::Num(8.0)]).unwrap(),755 " 10"756 );757 assert_eq!(758 format_arr(s.clone(), "%04o", &[Val::Num(8.0)]).unwrap(),759 "0010"760 );761 assert_eq!(762 format_arr(s.clone(), "%+4o", &[Val::Num(8.0)]).unwrap(),763 " +10"764 );765 assert_eq!(766 format_arr(s.clone(), "%+04o", &[Val::Num(8.0)]).unwrap(),767 "+010"768 );769 assert_eq!(770 format_arr(s.clone(), "%-4o", &[Val::Num(8.0)]).unwrap(),771 "10 "772 );773 assert_eq!(774 format_arr(s.clone(), "%+-4o", &[Val::Num(8.0)]).unwrap(),775 "+10 "776 );777 assert_eq!(format_arr(s, "%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");778 }779780 #[test]781 fn percent_doesnt_consumes_values() {782 let s = State::default();783 assert_eq!(784 format_arr(785 s,786 "How much error budget is left looking at our %.3f%% availability gurantees?",787 &[Val::Num(4.0)]788 )789 .unwrap(),790 "How much error budget is left looking at our 4.000% availability gurantees?"791 );792 }793}1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use jrsonnet_gcmodule::Trace;5use jrsonnet_interner::IStr;6use jrsonnet_types::ValType;7use thiserror::Error;89use crate::{error::Error::*, throw, typed::Typed, LocError, ObjValue, Result, State, Val};1011#[derive(Debug, Clone, Error, Trace)]12pub enum FormatError {13 #[error("truncated format code")]14 TruncatedFormatCode,15 #[error("unrecognized conversion type: {0}")]16 UnrecognizedConversionType(char),1718 #[error("not enough values")]19 NotEnoughValues,2021 #[error("cannot use * width with object")]22 CannotUseStarWidthWithObject,23 #[error("mapping keys required")]24 MappingKeysRequired,25 #[error("no such format field: {0}")]26 NoSuchFormatField(IStr),27}2829impl From<FormatError> for LocError {30 fn from(e: FormatError) -> Self {31 Self::new(Format(e))32 }33}3435use FormatError::*;3637type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;3839pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {40 if str.is_empty() {41 return Err(TruncatedFormatCode);42 }43 let bytes = str.as_bytes();44 if bytes[0] == b'(' {45 let mut i = 1;46 while i < bytes.len() {47 if bytes[i] == b')' {48 return Ok((&str[1..i as usize], &str[i as usize + 1..]));49 }50 i += 1;51 }52 Err(TruncatedFormatCode)53 } else {54 Ok(("", str))55 }56}5758#[cfg(test)]59pub mod tests_key {60 use super::*;6162 #[test]63 fn parse_key() {64 assert_eq!(65 try_parse_mapping_key("(hello ) world").unwrap(),66 ("hello ", " world")67 );68 assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));69 assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));70 assert_eq!(71 try_parse_mapping_key(" () world").unwrap(),72 ("", " () world")73 );74 }7576 #[test]77 #[should_panic]78 fn parse_key_missing_start() {79 try_parse_mapping_key("").unwrap();80 }8182 #[test]83 #[should_panic]84 fn parse_key_missing_end() {85 try_parse_mapping_key("( ").unwrap();86 }87}8889#[allow(clippy::struct_excessive_bools)]90#[derive(Default, Debug)]91pub struct CFlags {92 pub alt: bool,93 pub zero: bool,94 pub left: bool,95 pub blank: bool,96 pub sign: bool,97}9899pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {100 if str.is_empty() {101 return Err(TruncatedFormatCode);102 }103 let bytes = str.as_bytes();104 let mut i = 0;105 let mut out = CFlags::default();106 loop {107 if bytes.len() == i {108 return Err(TruncatedFormatCode);109 }110 match bytes[i] {111 b'#' => out.alt = true,112 b'0' => out.zero = true,113 b'-' => out.left = true,114 b' ' => out.blank = true,115 b'+' => out.sign = true,116 _ => break,117 }118 i += 1;119 }120 Ok((out, &str[i..]))121}122123#[derive(Debug, PartialEq, Eq)]124pub enum Width {125 Star,126 Fixed(usize),127}128pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {129 if str.is_empty() {130 return Err(TruncatedFormatCode);131 }132 let bytes = str.as_bytes();133 if bytes[0] == b'*' {134 return Ok((Width::Star, &str[1..]));135 }136 let mut out: usize = 0;137 let mut digits = 0;138 while let Some(digit) = (bytes[digits] as char).to_digit(10) {139 out *= 10;140 out += digit as usize;141 digits += 1;142 if digits == bytes.len() {143 return Err(TruncatedFormatCode);144 }145 }146 Ok((Width::Fixed(out), &str[digits..]))147}148149pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {150 if str.is_empty() {151 return Err(TruncatedFormatCode);152 }153 let bytes = str.as_bytes();154 if bytes[0] == b'.' {155 try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))156 } else {157 Ok((None, str))158 }159}160161// Only skips162pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {163 if str.is_empty() {164 return Err(TruncatedFormatCode);165 }166 let bytes = str.as_bytes();167 let mut idx = 0;168 while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {169 idx += 1;170 if bytes.len() == idx {171 return Err(TruncatedFormatCode);172 }173 }174 Ok(((), &str[idx..]))175}176177#[derive(Debug, PartialEq, Eq)]178pub enum ConvTypeV {179 Decimal,180 Octal,181 Hexadecimal,182 Scientific,183 Float,184 Shorter,185 Char,186 String,187 Percent,188}189pub struct ConvType {190 v: ConvTypeV,191 caps: bool,192}193194pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {195 if str.is_empty() {196 return Err(TruncatedFormatCode);197 }198199 let code = str.as_bytes()[0];200 let v: (ConvTypeV, bool) = match code {201 b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),202 b'o' => (ConvTypeV::Octal, false),203 b'x' => (ConvTypeV::Hexadecimal, false),204 b'X' => (ConvTypeV::Hexadecimal, true),205 b'e' => (ConvTypeV::Scientific, false),206 b'E' => (ConvTypeV::Scientific, true),207 b'f' => (ConvTypeV::Float, false),208 b'F' => (ConvTypeV::Float, true),209 b'g' => (ConvTypeV::Shorter, false),210 b'G' => (ConvTypeV::Shorter, true),211 b'c' => (ConvTypeV::Char, false),212 b's' => (ConvTypeV::String, false),213 b'%' => (ConvTypeV::Percent, false),214 c => return Err(UnrecognizedConversionType(c as char)),215 };216217 Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))218}219220#[derive(Debug)]221pub struct Code<'s> {222 mkey: &'s str,223 cflags: CFlags,224 width: Width,225 precision: Option<Width>,226 convtype: ConvTypeV,227 caps: bool,228}229pub fn parse_code(str: &str) -> ParseResult<Code> {230 if str.is_empty() {231 return Err(TruncatedFormatCode);232 }233 let (mkey, str) = try_parse_mapping_key(str)?;234 let (cflags, str) = try_parse_cflags(str)?;235 let (width, str) = try_parse_field_width(str)?;236 let (precision, str) = try_parse_precision(str)?;237 let (_, str) = try_parse_length_modifier(str)?;238 let (convtype, str) = parse_conversion_type(str)?;239240 Ok((241 Code {242 mkey,243 cflags,244 width,245 precision,246 convtype: convtype.v,247 caps: convtype.caps,248 },249 str,250 ))251}252253#[derive(Debug)]254pub enum Element<'s> {255 String(&'s str),256 Code(Code<'s>),257}258pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {259 let mut bytes = str.as_bytes();260 let mut out = vec![];261 let mut offset = 0;262263 loop {264 while offset != bytes.len() && bytes[offset] != b'%' {265 offset += 1;266 }267 if offset != 0 {268 out.push(Element::String(&str[0..offset]));269 }270 if offset == bytes.len() {271 return Ok(out);272 }273 str = &str[offset + 1..];274 let code;275 (code, str) = parse_code(str)?;276 bytes = str.as_bytes();277 offset = 0;278279 out.push(Element::Code(code));280 }281}282283const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";284285#[inline]286pub fn render_integer(287 out: &mut String,288 iv: f64,289 padding: usize,290 precision: usize,291 blank: bool,292 sign: bool,293 radix: i64,294 prefix: &str,295 caps: bool,296) {297 let radix = radix as f64;298 let iv = iv.floor();299 // Digit char indexes in reverse order, i.e300 // for radix = 16 and n = 12f: [15, 2, 1]301 let digits = if iv == 0.0 {302 vec![0u8]303 } else {304 let mut v = iv.abs();305 let mut nums = Vec::with_capacity(1);306 while v != 0.0 {307 nums.push((v % radix) as u8);308 v = (v / radix).floor();309 }310 nums311 };312 let neg = iv < 0.0;313 let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });314 let zp2 = zp315 .max(precision)316 .saturating_sub(prefix.len() + digits.len());317318 if neg {319 out.push('-');320 } else if sign {321 out.push('+');322 } else if blank {323 out.push(' ');324 }325326 out.reserve(zp2);327 for _ in 0..zp2 {328 out.push('0');329 }330 out.push_str(prefix);331332 for digit in digits.into_iter().rev() {333 let ch = NUMBERS[digit as usize] as char;334 out.push(if caps { ch.to_ascii_uppercase() } else { ch });335 }336}337338pub fn render_decimal(339 out: &mut String,340 iv: f64,341 padding: usize,342 precision: usize,343 blank: bool,344 sign: bool,345) {346 render_integer(out, iv, padding, precision, blank, sign, 10, "", false);347}348pub fn render_octal(349 out: &mut String,350 iv: f64,351 padding: usize,352 precision: usize,353 alt: bool,354 blank: bool,355 sign: bool,356) {357 render_integer(358 out,359 iv,360 padding,361 precision,362 blank,363 sign,364 8,365 if alt && iv != 0.0 { "0" } else { "" },366 false,367 );368}369370#[allow(clippy::fn_params_excessive_bools)]371pub fn render_hexadecimal(372 out: &mut String,373 iv: f64,374 padding: usize,375 precision: usize,376 alt: bool,377 blank: bool,378 sign: bool,379 caps: bool,380) {381 render_integer(382 out,383 iv,384 padding,385 precision,386 blank,387 sign,388 16,389 match (alt, caps) {390 (true, true) => "0X",391 (true, false) => "0x",392 (false, _) => "",393 },394 caps,395 );396}397398#[allow(clippy::fn_params_excessive_bools)]399pub fn render_float(400 out: &mut String,401 n: f64,402 mut padding: usize,403 precision: usize,404 blank: bool,405 sign: bool,406 ensure_pt: bool,407 trailing: bool,408) {409 let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };410 padding = padding.saturating_sub(dot_size + precision);411 render_decimal(out, n.floor(), padding, 0, blank, sign);412 if precision == 0 {413 if ensure_pt {414 out.push('.');415 }416 return;417 }418 let frac = n419 .fract()420 .mul_add(10.0_f64.powf(precision as f64), 0.5)421 .floor();422 if trailing || frac > 0.0 {423 out.push('.');424 let mut frac_str = String::new();425 render_decimal(&mut frac_str, frac, precision, 0, false, false);426 let mut trim = frac_str.len();427 if !trailing {428 for b in frac_str.as_bytes().iter().rev() {429 if *b == b'0' {430 trim -= 1;431 }432 }433 }434 out.push_str(&frac_str[..trim]);435 } else if ensure_pt {436 out.push('.');437 }438}439440#[allow(clippy::fn_params_excessive_bools)]441pub fn render_float_sci(442 out: &mut String,443 n: f64,444 mut padding: usize,445 precision: usize,446 blank: bool,447 sign: bool,448 ensure_pt: bool,449 trailing: bool,450 caps: bool,451) {452 let exponent = n.log10().floor();453 let mantissa = if exponent as i16 == -324 {454 n * 10.0 / 10.0_f64.powf(exponent + 1.0)455 } else {456 n / 10.0_f64.powf(exponent)457 };458 let mut exponent_str = String::new();459 render_decimal(&mut exponent_str, exponent, 3, 0, false, true);460461 // +1 for e462 padding = padding.saturating_sub(exponent_str.len() + 1);463464 render_float(465 out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,466 );467 out.push(if caps { 'E' } else { 'e' });468 out.push_str(&exponent_str);469}470471#[allow(clippy::too_many_lines)]472pub fn format_code(473 s: State,474 out: &mut String,475 value: &Val,476 code: &Code,477 width: usize,478 precision: Option<usize>,479) -> Result<()> {480 let clfags = &code.cflags;481 let (fpprec, iprec) = match precision {482 Some(v) => (v, v),483 None => (6, 0),484 };485 let padding = if clfags.zero && !clfags.left {486 width487 } else {488 0489 };490491 // TODO: If left padded, can optimize by writing directly to out492 let mut tmp_out = String::new();493494 match code.convtype {495 ConvTypeV::String => tmp_out.push_str(&value.clone().to_string(s)?),496 ConvTypeV::Decimal => {497 let value = f64::from_untyped(value.clone(), s)?;498 render_decimal(499 &mut tmp_out,500 value,501 padding,502 iprec,503 clfags.blank,504 clfags.sign,505 );506 }507 ConvTypeV::Octal => {508 let value = f64::from_untyped(value.clone(), s)?;509 render_octal(510 &mut tmp_out,511 value,512 padding,513 iprec,514 clfags.alt,515 clfags.blank,516 clfags.sign,517 );518 }519 ConvTypeV::Hexadecimal => {520 let value = f64::from_untyped(value.clone(), s)?;521 render_hexadecimal(522 &mut tmp_out,523 value,524 padding,525 iprec,526 clfags.alt,527 clfags.blank,528 clfags.sign,529 code.caps,530 );531 }532 ConvTypeV::Scientific => {533 let value = f64::from_untyped(value.clone(), s)?;534 render_float_sci(535 &mut tmp_out,536 value,537 padding,538 fpprec,539 clfags.blank,540 clfags.sign,541 clfags.alt,542 true,543 code.caps,544 );545 }546 ConvTypeV::Float => {547 let value = f64::from_untyped(value.clone(), s)?;548 render_float(549 &mut tmp_out,550 value,551 padding,552 fpprec,553 clfags.blank,554 clfags.sign,555 clfags.alt,556 true,557 );558 }559 ConvTypeV::Shorter => {560 let value = f64::from_untyped(value.clone(), s)?;561 let exponent = value.log10().floor();562 if exponent < -4.0 || exponent >= fpprec as f64 {563 render_float_sci(564 &mut tmp_out,565 value,566 padding,567 fpprec - 1,568 clfags.blank,569 clfags.sign,570 clfags.alt,571 clfags.alt,572 code.caps,573 );574 } else {575 let digits_before_pt = 1.max(exponent as usize + 1);576 render_float(577 &mut tmp_out,578 value,579 padding,580 fpprec - digits_before_pt,581 clfags.blank,582 clfags.sign,583 clfags.alt,584 clfags.alt,585 );586 }587 }588 ConvTypeV::Char => match value.clone() {589 Val::Num(n) => tmp_out590 .push(std::char::from_u32(n as u32).ok_or(InvalidUnicodeCodepointGot(n as u32))?),591 Val::Str(s) => {592 if s.chars().count() != 1 {593 throw!(RuntimeError(594 format!("%c expected 1 char string, got {}", s.chars().count()).into(),595 ));596 }597 tmp_out.push_str(&s);598 }599 _ => {600 throw!(TypeMismatch(601 "%c requires number/string",602 vec![ValType::Num, ValType::Str],603 value.value_type(),604 ));605 }606 },607 ConvTypeV::Percent => tmp_out.push('%'),608 };609610 let padding = width.saturating_sub(tmp_out.len());611612 if !clfags.left {613 for _ in 0..padding {614 out.push(' ');615 }616 }617 out.push_str(&tmp_out);618 if clfags.left {619 for _ in 0..padding {620 out.push(' ');621 }622 }623624 Ok(())625}626627pub fn format_arr(s: State, str: &str, mut values: &[Val]) -> Result<String> {628 let codes = parse_codes(str)?;629 let mut out = String::new();630631 for code in codes {632 match code {633 Element::String(s) => {634 out.push_str(s);635 }636 Element::Code(c) => {637 let width = match c.width {638 Width::Star => {639 if values.is_empty() {640 throw!(NotEnoughValues);641 }642 let value = &values[0];643 values = &values[1..];644 usize::from_untyped(value.clone(), s.clone())?645 }646 Width::Fixed(n) => n,647 };648 let precision = match c.precision {649 Some(Width::Star) => {650 if values.is_empty() {651 throw!(NotEnoughValues);652 }653 let value = &values[0];654 values = &values[1..];655 Some(usize::from_untyped(value.clone(), s.clone())?)656 }657 Some(Width::Fixed(n)) => Some(n),658 None => None,659 };660661 // %% should not consume a value662 let value = if c.convtype == ConvTypeV::Percent {663 &Val::Null664 } else {665 if values.is_empty() {666 throw!(NotEnoughValues);667 }668 let value = &values[0];669 values = &values[1..];670 value671 };672673 format_code(s.clone(), &mut out, value, &c, width, precision)?;674 }675 }676 }677678 Ok(out)679}680681pub fn format_obj(s: State, str: &str, values: &ObjValue) -> Result<String> {682 let codes = parse_codes(str)?;683 let mut out = String::new();684685 for code in codes {686 match code {687 Element::String(s) => {688 out.push_str(s);689 }690 Element::Code(c) => {691 // TODO: Operate on ref692 let f: IStr = c.mkey.into();693 let width = match c.width {694 Width::Star => {695 throw!(CannotUseStarWidthWithObject);696 }697 Width::Fixed(n) => n,698 };699 let precision = match c.precision {700 Some(Width::Star) => {701 throw!(CannotUseStarWidthWithObject);702 }703 Some(Width::Fixed(n)) => Some(n),704 None => None,705 };706707 let value = if c.convtype == ConvTypeV::Percent {708 Val::Null709 } else {710 if f.is_empty() {711 throw!(MappingKeysRequired);712 }713 if let Some(v) = values.get(s.clone(), f.clone())? {714 v715 } else {716 throw!(NoSuchFormatField(f));717 }718 };719720 format_code(s.clone(), &mut out, &value, &c, width, precision)?;721 }722 }723 }724725 Ok(out)726}727728#[cfg(test)]729pub mod test_format {730 use super::*;731732 #[test]733 fn parse() {734 assert_eq!(735 parse_codes(736 "How much error budget is left looking at our %.3f%% availability gurantees?"737 )738 .unwrap()739 .len(),740 4741 );742 }743744 #[test]745 fn octals() {746 let s = State::default();747 assert_eq!(748 format_arr(s.clone(), "%#o", &[Val::Num(8.0)]).unwrap(),749 "010"750 );751 assert_eq!(752 format_arr(s.clone(), "%#4o", &[Val::Num(8.0)]).unwrap(),753 " 010"754 );755 assert_eq!(756 format_arr(s.clone(), "%4o", &[Val::Num(8.0)]).unwrap(),757 " 10"758 );759 assert_eq!(760 format_arr(s.clone(), "%04o", &[Val::Num(8.0)]).unwrap(),761 "0010"762 );763 assert_eq!(764 format_arr(s.clone(), "%+4o", &[Val::Num(8.0)]).unwrap(),765 " +10"766 );767 assert_eq!(768 format_arr(s.clone(), "%+04o", &[Val::Num(8.0)]).unwrap(),769 "+010"770 );771 assert_eq!(772 format_arr(s.clone(), "%-4o", &[Val::Num(8.0)]).unwrap(),773 "10 "774 );775 assert_eq!(776 format_arr(s.clone(), "%+-4o", &[Val::Num(8.0)]).unwrap(),777 "+10 "778 );779 assert_eq!(format_arr(s, "%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");780 }781782 #[test]783 fn percent_doesnt_consumes_values() {784 let s = State::default();785 assert_eq!(786 format_arr(787 s,788 "How much error budget is left looking at our %.3f%% availability gurantees?",789 &[Val::Num(4.0)]790 )791 .unwrap(),792 "How much error budget is left looking at our 4.000% availability gurantees?"793 );794 }795}