difftreelog
fix faster format consumes value for %%
in: master
1 file changed
crates/jrsonnet-evaluator/src/builtin/format.rsdiffbeforeafterboth1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use crate::{5 create_error, create_error_result, to_string, Error, LocError, ObjValue, Val, ValType,6};78#[derive(Debug)]9pub enum FormatError {10 TruncatedFormatCode,11 UnrecognizedConversionType(char),12 ValueError(LocError),1314 NotEnoughValues,1516 CannotUseStarWidthWithObject,17 MappingKeysRequired,18 NoSuchField(Rc<str>),19}20impl From<LocError> for FormatError {21 fn from(e: LocError) -> Self {22 Self::ValueError(e)23 }24}25use std::rc::Rc;26use FormatError::*;2728pub fn try_parse_mapping_key(str: &str) -> Result<(&str, &str), FormatError> {29 if str.is_empty() {30 return Err(TruncatedFormatCode);31 }32 let bytes = str.as_bytes();33 if bytes[0] == b'(' {34 let mut i = 1;35 while i < bytes.len() {36 if bytes[i] == b')' {37 return Ok((&str[1..i as usize], &str[i as usize + 1..]));38 }39 i += 1;40 }41 Err(TruncatedFormatCode)42 } else {43 Ok(("", str))44 }45}4647#[cfg(test)]48pub mod tests_key {49 use super::*;5051 #[test]52 fn parse_key() {53 assert_eq!(54 try_parse_mapping_key("(hello ) world").unwrap(),55 ("hello ", " world")56 );57 assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));58 assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));59 assert_eq!(60 try_parse_mapping_key(" () world").unwrap(),61 ("", " () world")62 );63 }6465 #[test]66 #[should_panic]67 fn parse_key_missing_start() {68 try_parse_mapping_key("").unwrap();69 }7071 #[test]72 #[should_panic]73 fn parse_key_missing_end() {74 try_parse_mapping_key("( ").unwrap();75 }76}7778#[derive(Default, Debug)]79pub struct CFlags {80 pub alt: bool,81 pub zero: bool,82 pub left: bool,83 pub blank: bool,84 pub sign: bool,85}8687pub fn try_parse_cflags(str: &str) -> Result<(CFlags, &str), FormatError> {88 if str.is_empty() {89 return Err(TruncatedFormatCode);90 }91 let bytes = str.as_bytes();92 let mut i = 0;93 let mut out = CFlags::default();94 loop {95 if bytes.len() == i {96 return Err(TruncatedFormatCode);97 }98 match bytes[i] {99 b'#' => out.alt = true,100 b'0' => out.zero = true,101 b'-' => out.left = true,102 b' ' => out.blank = true,103 b'+' => out.sign = true,104 _ => break,105 }106 i += 1;107 }108 Ok((out, &str[i..]))109}110111#[derive(Debug, PartialEq)]112pub enum Width {113 Star,114 Fixed(usize),115}116pub fn try_parse_field_width(str: &str) -> Result<(Width, &str), FormatError> {117 if str.is_empty() {118 return Err(TruncatedFormatCode);119 }120 let bytes = str.as_bytes();121 if bytes[0] == b'*' {122 return Ok((Width::Star, &str[1..]));123 }124 let mut out: usize = 0;125 let mut digits = 0;126 while let Some(digit) = (bytes[digits] as char).to_digit(10) {127 out *= 10;128 out += digit as usize;129 digits += 1;130 if digits == bytes.len() {131 return Err(TruncatedFormatCode);132 }133 }134 Ok((Width::Fixed(out), &str[digits..]))135}136137pub fn try_parse_precision(str: &str) -> Result<(Option<Width>, &str), FormatError> {138 if str.is_empty() {139 return Err(TruncatedFormatCode);140 }141 let bytes = str.as_bytes();142 if bytes[0] == b'.' {143 try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))144 } else {145 Ok((None, str))146 }147}148149// Only skips150pub fn try_parse_length_modifier(str: &str) -> Result<&str, FormatError> {151 if str.is_empty() {152 return Err(TruncatedFormatCode);153 }154 let bytes = str.as_bytes();155 let mut idx = 0;156 while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {157 idx += 1;158 if bytes.len() == idx {159 return Err(TruncatedFormatCode);160 }161 }162 Ok(&str[idx..])163}164165#[derive(Debug)]166pub enum ConvTypeV {167 Decimal,168 Octal,169 Hexadecimal,170 Scientific,171 Float,172 Shorter,173 Char,174 String,175 Percent,176}177pub struct ConvType {178 v: ConvTypeV,179 caps: bool,180}181182pub fn parse_conversion_type(str: &str) -> Result<(ConvType, &str), FormatError> {183 if str.is_empty() {184 return Err(TruncatedFormatCode);185 }186187 let code = str.as_bytes()[0];188 let v: (ConvTypeV, bool) = match code {189 b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),190 b'o' => (ConvTypeV::Octal, false),191 b'x' => (ConvTypeV::Hexadecimal, false),192 b'X' => (ConvTypeV::Hexadecimal, true),193 b'e' => (ConvTypeV::Scientific, false),194 b'E' => (ConvTypeV::Scientific, true),195 b'f' => (ConvTypeV::Float, false),196 b'F' => (ConvTypeV::Float, true),197 b'g' => (ConvTypeV::Shorter, false),198 b'G' => (ConvTypeV::Shorter, true),199 b'c' => (ConvTypeV::Char, false),200 b's' => (ConvTypeV::String, false),201 b'%' => (ConvTypeV::Percent, false),202 c => return Err(UnrecognizedConversionType(c as char)),203 };204205 Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))206}207208#[derive(Debug)]209pub struct Code<'s> {210 mkey: &'s str,211 cflags: CFlags,212 width: Width,213 precision: Option<Width>,214 convtype: ConvTypeV,215 caps: bool,216}217pub fn parse_code(str: &str) -> Result<(Code, &str), FormatError> {218 if str.is_empty() {219 return Err(TruncatedFormatCode);220 }221 let (mkey, str) = try_parse_mapping_key(str)?;222 let (cflags, str) = try_parse_cflags(str)?;223 let (width, str) = try_parse_field_width(str)?;224 let (precision, str) = try_parse_precision(str)?;225 let str = try_parse_length_modifier(str)?;226 let (convtype, str) = parse_conversion_type(str)?;227228 Ok((229 Code {230 mkey,231 cflags,232 width,233 precision,234 convtype: convtype.v,235 caps: convtype.caps,236 },237 str,238 ))239}240241#[derive(Debug)]242pub enum Element<'s> {243 String(&'s str),244 Code(Code<'s>),245}246pub fn parse_codes(mut str: &str) -> Result<Vec<Element>, FormatError> {247 let mut bytes = str.as_bytes();248 let mut out = vec![];249 let mut offset = 0;250251 loop {252 while offset != bytes.len() && bytes[offset] != b'%' {253 offset += 1;254 }255 if offset != 0 {256 out.push(Element::String(&str[0..offset]));257 }258 if offset == bytes.len() {259 return Ok(out);260 }261 str = &str[offset + 1..];262 let (code, nstr) = parse_code(str)?;263 str = nstr;264 bytes = str.as_bytes();265 offset = 0;266267 out.push(Element::Code(code))268 }269}270271const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";272273#[inline]274pub fn render_integer(275 out: &mut String,276 iv: i64,277 padding: usize,278 precision: usize,279 blank: bool,280 sign: bool,281 radix: i64,282 prefix: &str,283 caps: bool,284) {285 // Digit char indexes in reverse order, i.e286 // for radix = 16 and n = 12f: [15, 2, 1]287 let digits = if iv == 0 {288 vec![0u8]289 } else {290 let mut v = iv.abs();291 let mut nums = Vec::with_capacity(1);292 while v > 0 {293 nums.push((v % radix) as u8);294 v /= radix;295 }296 nums297 };298 let neg = iv < 0;299 let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });300 let zp2 = zp301 .max(precision)302 .saturating_sub(prefix.len() + digits.len());303304 if neg {305 out.push('-')306 } else if sign {307 out.push('+');308 } else if blank {309 out.push(' ');310 }311312 out.reserve(zp2);313 for _ in 0..zp2 {314 out.push('0');315 }316 out.push_str(&prefix);317318 for digit in digits.into_iter().rev() {319 let ch = NUMBERS[digit as usize] as char;320 out.push(if caps { ch.to_ascii_uppercase() } else { ch });321 }322}323324pub fn render_decimal(325 out: &mut String,326 iv: i64,327 padding: usize,328 precision: usize,329 blank: bool,330 sign: bool,331) {332 render_integer(out, iv, padding, precision, blank, sign, 10, "", false)333}334pub fn render_octal(335 out: &mut String,336 iv: i64,337 padding: usize,338 precision: usize,339 alt: bool,340 blank: bool,341 sign: bool,342) {343 render_integer(344 out,345 iv,346 padding,347 precision,348 blank,349 sign,350 8,351 if alt && iv != 0 { "0" } else { "" },352 false,353 )354}355pub fn render_hexadecimal(356 out: &mut String,357 iv: i64,358 padding: usize,359 precision: usize,360 alt: bool,361 blank: bool,362 sign: bool,363 caps: bool,364) {365 render_integer(366 out,367 iv,368 padding,369 precision,370 blank,371 sign,372 16,373 match (alt, caps) {374 (true, true) => "0X",375 (true, false) => "0x",376 (false, _) => "",377 },378 caps,379 )380}381382pub fn render_float(383 out: &mut String,384 n: f64,385 mut padding: usize,386 precision: usize,387 blank: bool,388 sign: bool,389 ensure_pt: bool,390 trailing: bool,391) {392 let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };393 padding = padding.saturating_sub(dot_size + precision);394 render_decimal(out, n.floor() as i64, padding, 0, blank, sign);395 if precision == 0 {396 if ensure_pt {397 out.push('.');398 }399 return;400 }401 let frac = (n.fract() * 10.0_f64.powf(precision as f64) + 0.5).floor();402 if trailing || frac > 0.0 {403 out.push('.');404 let mut frac_str = String::new();405 render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);406 let mut trim = frac_str.len();407 if !trailing {408 for b in frac_str.as_bytes().iter().rev() {409 if *b == b'0' {410 trim -= 1;411 }412 }413 }414 out.push_str(&frac_str[..trim]);415 } else if ensure_pt {416 out.push('.');417 }418}419420pub fn render_float_sci(421 out: &mut String,422 n: f64,423 mut padding: usize,424 precision: usize,425 blank: bool,426 sign: bool,427 ensure_pt: bool,428 trailing: bool,429 caps: bool,430) {431 let exponent = n.log10().floor();432 let mantissa = if exponent as i16 == -324 {433 n * 10.0 / 10.0_f64.powf(exponent + 1.0)434 } else {435 n / 10.0_f64.powf(exponent)436 };437 let mut exponent_str = String::new();438 render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);439440 // +1 for e441 padding = padding.saturating_sub(exponent_str.len() + 1);442443 render_float(444 out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,445 );446 out.push(if caps { 'E' } else { 'e' });447 out.push_str(&exponent_str);448}449450pub fn format_code(451 out: &mut String,452 value: &Val,453 code: &Code,454 width: usize,455 precision: Option<usize>,456) -> Result<(), FormatError> {457 let clfags = &code.cflags;458 let (fpprec, iprec) = match precision {459 Some(v) => (v, v),460 None => (6, 0),461 };462 let padding = if clfags.zero && !clfags.left {463 width464 } else {465 0466 };467468 // TODO: If left padded, can optimize by writing directly to out469 let mut tmp_out = String::new();470471 match code.convtype {472 ConvTypeV::String => tmp_out.push_str(&to_string(value)?),473 ConvTypeV::Decimal => {474 let value = value.clone().try_cast_num("%d/%u/%i requires number")?;475 render_decimal(476 &mut tmp_out,477 value as i64,478 padding,479 iprec,480 clfags.blank,481 clfags.sign,482 );483 }484 ConvTypeV::Octal => {485 let value = value.clone().try_cast_num("%o requires number")?;486 render_octal(487 &mut tmp_out,488 value as i64,489 padding,490 iprec,491 clfags.alt,492 clfags.blank,493 clfags.sign,494 );495 }496 ConvTypeV::Hexadecimal => {497 let value = value.clone().try_cast_num("%x/%X requires number")?;498 render_hexadecimal(499 &mut tmp_out,500 value as i64,501 padding,502 iprec,503 clfags.alt,504 clfags.blank,505 clfags.sign,506 code.caps,507 );508 }509 ConvTypeV::Scientific => {510 let value = value.clone().try_cast_num("%e/%E requires number")?;511 render_float_sci(512 &mut tmp_out,513 value,514 padding,515 fpprec,516 clfags.blank,517 clfags.sign,518 clfags.alt,519 true,520 code.caps,521 );522 }523 ConvTypeV::Float => {524 let value = value.clone().try_cast_num("%e/%E requires number")?;525 render_float(526 &mut tmp_out,527 value,528 padding,529 fpprec,530 clfags.blank,531 clfags.sign,532 clfags.alt,533 true,534 );535 }536 ConvTypeV::Shorter => {537 let value = value.clone().try_cast_num("%g/%G requires number")?;538 let exponent = value.log10().floor();539 if exponent < -4.0 || exponent >= fpprec as f64 {540 render_float_sci(541 &mut tmp_out,542 value,543 padding,544 fpprec - 1,545 clfags.blank,546 clfags.sign,547 clfags.alt,548 clfags.alt,549 code.caps,550 );551 } else {552 let digits_before_pt = 1.max(exponent as usize + 1);553 render_float(554 &mut tmp_out,555 value,556 padding,557 fpprec - digits_before_pt,558 clfags.blank,559 clfags.sign,560 clfags.alt,561 clfags.alt,562 );563 }564 }565 ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {566 Val::Num(n) => tmp_out.push(567 std::char::from_u32(n as u32)568 .ok_or_else(|| create_error(Error::InvalidUnicodeCodepointGot(n as u32)))?,569 ),570 Val::Str(s) => {571 if s.chars().count() != 1 {572 create_error_result(Error::RuntimeError(573 format!("%c expected 1 char string, got {}", s.chars().count()).into(),574 ))?;575 }576 tmp_out.push_str(&s);577 }578 _ => {579 create_error_result(Error::TypeMismatch(580 "%c requires number/string",581 vec![ValType::Num, ValType::Str],582 value.value_type()?,583 ))?;584 }585 },586 ConvTypeV::Percent => tmp_out.push('%'),587 };588589 let padding = width.saturating_sub(tmp_out.len());590591 if !clfags.left {592 for _ in 0..padding {593 out.push(' ');594 }595 }596 out.push_str(&tmp_out);597 if clfags.left {598 for _ in 0..padding {599 out.push(' ');600 }601 }602603 Ok(())604}605606pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String, FormatError> {607 let codes = parse_codes(&str)?;608 let mut out = String::new();609610 for code in codes {611 match code {612 Element::String(s) => {613 out.push_str(s);614 }615 Element::Code(c) => {616 let width = match c.width {617 Width::Star => {618 if values.is_empty() {619 return Err(FormatError::NotEnoughValues);620 }621 let value = &values[0];622 values = &values[1..];623 value.clone().try_cast_num("field width")? as usize624 }625 Width::Fixed(n) => n,626 };627 let precision = match c.precision {628 Some(Width::Star) => {629 if values.is_empty() {630 return Err(FormatError::NotEnoughValues);631 }632 let value = &values[0];633 values = &values[1..];634 Some(value.clone().try_cast_num("field precision")? as usize)635 }636 Some(Width::Fixed(n)) => Some(n),637 None => None,638 };639 if values.is_empty() {640 return Err(FormatError::NotEnoughValues);641 }642 let value = &values[0];643 values = &values[1..];644645 format_code(&mut out, value, &c, width, precision)?;646 }647 }648 }649650 Ok(out)651}652653pub fn format_obj(str: &str, values: &ObjValue) -> Result<String, FormatError> {654 let codes = parse_codes(&str)?;655 let mut out = String::new();656657 for code in codes {658 match code {659 Element::String(s) => {660 out.push_str(s);661 }662 Element::Code(c) => {663 // TODO: Operate on ref664 let f: Rc<str> = c.mkey.into();665 if f.is_empty() {666 return Err(FormatError::MappingKeysRequired);667 }668 let width = match c.width {669 Width::Star => {670 return Err(FormatError::CannotUseStarWidthWithObject);671 }672 Width::Fixed(n) => n,673 };674 let precision = match c.precision {675 Some(Width::Star) => {676 return Err(FormatError::CannotUseStarWidthWithObject);677 }678 Some(Width::Fixed(n)) => Some(n),679 None => None,680 };681 let value = if let Some(v) = values.get(f.clone())? {682 v683 } else {684 return Err(FormatError::NoSuchField(f));685 };686687 format_code(&mut out, &value, &c, width, precision)?;688 }689 }690 }691692 Ok(out)693}694695#[cfg(test)]696pub mod test_format {697 use super::*;698699 #[test]700 fn parse() {701 assert_eq!(702 parse_codes(703 "How much error budget is left looking at our %.3f%% availability gurantees?"704 )705 .unwrap()706 .len(),707 4708 );709 }710711 #[test]712 fn octals() {713 assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");714 assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");715 assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), " 10");716 assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");717 assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");718 assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");719 assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10 ");720 assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");721 assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");722 }723}