git.delta.rocks / jrsonnet / refs/commits / bbe146ee2257

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::ErrorKind::*, throw, typed::Typed, Error, ObjValue, Result, 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 Error {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], &str[i + 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	#[allow(clippy::bool_to_int_with_if)]314	let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });315	let zp2 = zp316		.max(precision)317		.saturating_sub(prefix.len() + digits.len());318319	if neg {320		out.push('-');321	} else if sign {322		out.push('+');323	} else if blank {324		out.push(' ');325	}326327	out.reserve(zp2);328	for _ in 0..zp2 {329		out.push('0');330	}331	out.push_str(prefix);332333	for digit in digits.into_iter().rev() {334		let ch = NUMBERS[digit as usize] as char;335		out.push(if caps { ch.to_ascii_uppercase() } else { ch });336	}337}338339pub fn render_decimal(340	out: &mut String,341	iv: f64,342	padding: usize,343	precision: usize,344	blank: bool,345	sign: bool,346) {347	render_integer(out, iv, padding, precision, blank, sign, 10, "", false);348}349pub fn render_octal(350	out: &mut String,351	iv: f64,352	padding: usize,353	precision: usize,354	alt: bool,355	blank: bool,356	sign: bool,357) {358	render_integer(359		out,360		iv,361		padding,362		precision,363		blank,364		sign,365		8,366		if alt && iv != 0.0 { "0" } else { "" },367		false,368	);369}370371#[allow(clippy::fn_params_excessive_bools)]372pub fn render_hexadecimal(373	out: &mut String,374	iv: f64,375	padding: usize,376	precision: usize,377	alt: bool,378	blank: bool,379	sign: bool,380	caps: bool,381) {382	render_integer(383		out,384		iv,385		padding,386		precision,387		blank,388		sign,389		16,390		match (alt, caps) {391			(true, true) => "0X",392			(true, false) => "0x",393			(false, _) => "",394		},395		caps,396	);397}398399#[allow(clippy::fn_params_excessive_bools)]400pub fn render_float(401	out: &mut String,402	n: f64,403	mut padding: usize,404	precision: usize,405	blank: bool,406	sign: bool,407	ensure_pt: bool,408	trailing: bool,409) {410	#[allow(clippy::bool_to_int_with_if)]411	let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };412	padding = padding.saturating_sub(dot_size + precision);413	render_decimal(out, n.floor(), padding, 0, blank, sign);414	if precision == 0 {415		if ensure_pt {416			out.push('.');417		}418		return;419	}420	let frac = n421		.fract()422		.mul_add(10.0_f64.powf(precision as f64), 0.5)423		.floor();424	if trailing || frac > 0.0 {425		out.push('.');426		let mut frac_str = String::new();427		render_decimal(&mut frac_str, frac, precision, 0, false, false);428		let mut trim = frac_str.len();429		if !trailing {430			for b in frac_str.as_bytes().iter().rev() {431				if *b == b'0' {432					trim -= 1;433				} else {434					break;435				}436			}437		}438		out.push_str(&frac_str[..trim]);439	} else if ensure_pt {440		out.push('.');441	}442}443444#[allow(clippy::fn_params_excessive_bools)]445pub fn render_float_sci(446	out: &mut String,447	n: f64,448	mut padding: usize,449	precision: usize,450	blank: bool,451	sign: bool,452	ensure_pt: bool,453	trailing: bool,454	caps: bool,455) {456	let exponent = n.log10().floor();457	let mantissa = if exponent as i16 == -324 {458		n * 10.0 / 10.0_f64.powf(exponent + 1.0)459	} else {460		n / 10.0_f64.powf(exponent)461	};462	let mut exponent_str = String::new();463	render_decimal(&mut exponent_str, exponent, 3, 0, false, true);464465	// +1 for e466	padding = padding.saturating_sub(exponent_str.len() + 1);467468	render_float(469		out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,470	);471	out.push(if caps { 'E' } else { 'e' });472	out.push_str(&exponent_str);473}474475#[allow(clippy::too_many_lines)]476pub fn format_code(477	out: &mut String,478	value: &Val,479	code: &Code<'_>,480	width: usize,481	precision: Option<usize>,482) -> Result<()> {483	let clfags = &code.cflags;484	let (fpprec, iprec) = precision.map_or((6, 0), |v| (v, v));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()?),496		ConvTypeV::Decimal => {497			let value = f64::from_untyped(value.clone())?;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())?;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())?;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())?;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())?;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())?;561			let exponent = if value == 0.0 {562				0.0563			} else {564				value.abs().log10().floor()565			};566			if exponent < -4.0 || exponent >= fpprec as f64 {567				render_float_sci(568					&mut tmp_out,569					value,570					padding,571					fpprec - 1,572					clfags.blank,573					clfags.sign,574					clfags.alt,575					clfags.alt,576					code.caps,577				);578			} else {579				let digits_before_pt = 1.max(exponent as usize + 1);580				render_float(581					&mut tmp_out,582					value,583					padding,584					fpprec - digits_before_pt,585					clfags.blank,586					clfags.sign,587					clfags.alt,588					clfags.alt,589				);590			}591		}592		ConvTypeV::Char => match value.clone() {593			Val::Num(n) => tmp_out.push(594				std::char::from_u32(n as u32)595					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,596			),597			Val::Str(s) => {598				let s = s.into_flat();599				if s.chars().count() != 1 {600					throw!("%c expected 1 char string, got {}", s.chars().count(),);601				}602				tmp_out.push_str(&s);603			}604			_ => {605				throw!(TypeMismatch(606					"%c requires number/string",607					vec![ValType::Num, ValType::Str],608					value.value_type(),609				));610			}611		},612		ConvTypeV::Percent => tmp_out.push('%'),613	};614615	let padding = width.saturating_sub(tmp_out.len());616617	if !clfags.left {618		for _ in 0..padding {619			out.push(' ');620		}621	}622	out.push_str(&tmp_out);623	if clfags.left {624		for _ in 0..padding {625			out.push(' ');626		}627	}628629	Ok(())630}631632pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {633	let codes = parse_codes(str)?;634	let mut out = String::new();635	let value_count = values.len();636637	for code in codes {638		match code {639			Element::String(s) => {640				out.push_str(s);641			}642			Element::Code(c) => {643				let width = match c.width {644					Width::Star => {645						if values.is_empty() {646							throw!(NotEnoughValues);647						}648						let value = &values[0];649						values = &values[1..];650						usize::from_untyped(value.clone())?651					}652					Width::Fixed(n) => n,653				};654				let precision = match c.precision {655					Some(Width::Star) => {656						if values.is_empty() {657							throw!(NotEnoughValues);658						}659						let value = &values[0];660						values = &values[1..];661						Some(usize::from_untyped(value.clone())?)662					}663					Some(Width::Fixed(n)) => Some(n),664					None => None,665				};666667				// %% should not consume a value668				let value = if c.convtype == ConvTypeV::Percent {669					&Val::Null670				} else {671					if values.is_empty() {672						throw!(NotEnoughValues);673					}674					let value = &values[0];675					values = &values[1..];676					value677				};678679				format_code(&mut out, value, &c, width, precision)?;680			}681		}682	}683684	if !values.is_empty() {685		throw!(686			"too many values to format, expected {value_count}, got {}",687			value_count + values.len()688		)689	}690691	Ok(out)692}693694pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {695	let codes = parse_codes(str)?;696	let mut out = String::new();697698	for code in codes {699		match code {700			Element::String(s) => {701				out.push_str(s);702			}703			Element::Code(c) => {704				// TODO: Operate on ref705				let f: IStr = c.mkey.into();706				let width = match c.width {707					Width::Star => {708						throw!(CannotUseStarWidthWithObject);709					}710					Width::Fixed(n) => n,711				};712				let precision = match c.precision {713					Some(Width::Star) => {714						throw!(CannotUseStarWidthWithObject);715					}716					Some(Width::Fixed(n)) => Some(n),717					None => None,718				};719720				let value = if c.convtype == ConvTypeV::Percent {721					Val::Null722				} else {723					if f.is_empty() {724						throw!(MappingKeysRequired);725					}726					if let Some(v) = values.get(f.clone())? {727						v728					} else {729						throw!(NoSuchFormatField(f));730					}731				};732733				format_code(&mut out, &value, &c, width, precision)?;734			}735		}736	}737738	Ok(out)739}740741#[cfg(test)]742pub mod test_format {743	use super::*;744745	#[test]746	fn parse() {747		assert_eq!(748			parse_codes(749				"How much error budget is left looking at our %.3f%% availability gurantees?"750			)751			.unwrap()752			.len(),753			4754		);755	}756757	#[test]758	fn octals() {759		assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");760		assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");761		assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), "  10");762		assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");763		assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");764		assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");765		assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10  ");766		assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");767		assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");768	}769770	#[test]771	fn percent_doesnt_consumes_values() {772		assert_eq!(773			format_arr(774				"How much error budget is left looking at our %.3f%% availability gurantees?",775				&[Val::Num(4.0)]776			)777			.unwrap(),778			"How much error budget is left looking at our 4.000% availability gurantees?"779		);780	}781}