git.delta.rocks / jrsonnet / refs/commits / 686e5cc6bf11

1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val, ValType};5use thiserror::Error;67#[derive(Debug, Clone, Error)]8pub enum FormatError {9	#[error("truncated format code")]10	TruncatedFormatCode,11	#[error("unrecognized conversion type: {0}")]12	UnrecognizedConversionType(char),1314	#[error("not enough values")]15	NotEnoughValues,1617	#[error("cannot use * width with object")]18	CannotUseStarWidthWithObject,19	#[error("mapping keys required")]20	MappingKeysRequired,21	#[error("no such format field: {0}")]22	NoSuchFormatField(Rc<str>),23}2425impl From<FormatError> for LocError {26	fn from(e: FormatError) -> Self {27		Self::new(Format(e))28	}29}3031use std::rc::Rc;32use FormatError::*;3334type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;3536pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {37	if str.is_empty() {38		return Err(TruncatedFormatCode);39	}40	let bytes = str.as_bytes();41	if bytes[0] == b'(' {42		let mut i = 1;43		while i < bytes.len() {44			if bytes[i] == b')' {45				return Ok((&str[1..i as usize], &str[i as usize + 1..]));46			}47			i += 1;48		}49		Err(TruncatedFormatCode)50	} else {51		Ok(("", str))52	}53}5455#[cfg(test)]56pub mod tests_key {57	use super::*;5859	#[test]60	fn parse_key() {61		assert_eq!(62			try_parse_mapping_key("(hello ) world").unwrap(),63			("hello ", " world")64		);65		assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));66		assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));67		assert_eq!(68			try_parse_mapping_key(" () world").unwrap(),69			("", " () world")70		);71	}7273	#[test]74	#[should_panic]75	fn parse_key_missing_start() {76		try_parse_mapping_key("").unwrap();77	}7879	#[test]80	#[should_panic]81	fn parse_key_missing_end() {82		try_parse_mapping_key("(   ").unwrap();83	}84}8586#[derive(Default, Debug)]87pub struct CFlags {88	pub alt: bool,89	pub zero: bool,90	pub left: bool,91	pub blank: bool,92	pub sign: bool,93}9495pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {96	if str.is_empty() {97		return Err(TruncatedFormatCode);98	}99	let bytes = str.as_bytes();100	let mut i = 0;101	let mut out = CFlags::default();102	loop {103		if bytes.len() == i {104			return Err(TruncatedFormatCode);105		}106		match bytes[i] {107			b'#' => out.alt = true,108			b'0' => out.zero = true,109			b'-' => out.left = true,110			b' ' => out.blank = true,111			b'+' => out.sign = true,112			_ => break,113		}114		i += 1;115	}116	Ok((out, &str[i..]))117}118119#[derive(Debug, PartialEq)]120pub enum Width {121	Star,122	Fixed(usize),123}124pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {125	if str.is_empty() {126		return Err(TruncatedFormatCode);127	}128	let bytes = str.as_bytes();129	if bytes[0] == b'*' {130		return Ok((Width::Star, &str[1..]));131	}132	let mut out: usize = 0;133	let mut digits = 0;134	while let Some(digit) = (bytes[digits] as char).to_digit(10) {135		out *= 10;136		out += digit as usize;137		digits += 1;138		if digits == bytes.len() {139			return Err(TruncatedFormatCode);140		}141	}142	Ok((Width::Fixed(out), &str[digits..]))143}144145pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {146	if str.is_empty() {147		return Err(TruncatedFormatCode);148	}149	let bytes = str.as_bytes();150	if bytes[0] == b'.' {151		try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))152	} else {153		Ok((None, str))154	}155}156157// Only skips158pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {159	if str.is_empty() {160		return Err(TruncatedFormatCode);161	}162	let bytes = str.as_bytes();163	let mut idx = 0;164	while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {165		idx += 1;166		if bytes.len() == idx {167			return Err(TruncatedFormatCode);168		}169	}170	Ok(((), &str[idx..]))171}172173#[derive(Debug, PartialEq)]174pub enum ConvTypeV {175	Decimal,176	Octal,177	Hexadecimal,178	Scientific,179	Float,180	Shorter,181	Char,182	String,183	Percent,184}185pub struct ConvType {186	v: ConvTypeV,187	caps: bool,188}189190pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {191	if str.is_empty() {192		return Err(TruncatedFormatCode);193	}194195	let code = str.as_bytes()[0];196	let v: (ConvTypeV, bool) = match code {197		b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),198		b'o' => (ConvTypeV::Octal, false),199		b'x' => (ConvTypeV::Hexadecimal, false),200		b'X' => (ConvTypeV::Hexadecimal, true),201		b'e' => (ConvTypeV::Scientific, false),202		b'E' => (ConvTypeV::Scientific, true),203		b'f' => (ConvTypeV::Float, false),204		b'F' => (ConvTypeV::Float, true),205		b'g' => (ConvTypeV::Shorter, false),206		b'G' => (ConvTypeV::Shorter, true),207		b'c' => (ConvTypeV::Char, false),208		b's' => (ConvTypeV::String, false),209		b'%' => (ConvTypeV::Percent, false),210		c => return Err(UnrecognizedConversionType(c as char)),211	};212213	Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))214}215216#[derive(Debug)]217pub struct Code<'s> {218	mkey: &'s str,219	cflags: CFlags,220	width: Width,221	precision: Option<Width>,222	convtype: ConvTypeV,223	caps: bool,224}225pub fn parse_code(str: &str) -> ParseResult<Code> {226	if str.is_empty() {227		return Err(TruncatedFormatCode);228	}229	let (mkey, str) = try_parse_mapping_key(str)?;230	let (cflags, str) = try_parse_cflags(str)?;231	let (width, str) = try_parse_field_width(str)?;232	let (precision, str) = try_parse_precision(str)?;233	let (_, str) = try_parse_length_modifier(str)?;234	let (convtype, str) = parse_conversion_type(str)?;235236	Ok((237		Code {238			mkey,239			cflags,240			width,241			precision,242			convtype: convtype.v,243			caps: convtype.caps,244		},245		str,246	))247}248249#[derive(Debug)]250pub enum Element<'s> {251	String(&'s str),252	Code(Code<'s>),253}254pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {255	let mut bytes = str.as_bytes();256	let mut out = vec![];257	let mut offset = 0;258259	loop {260		while offset != bytes.len() && bytes[offset] != b'%' {261			offset += 1;262		}263		if offset != 0 {264			out.push(Element::String(&str[0..offset]));265		}266		if offset == bytes.len() {267			return Ok(out);268		}269		str = &str[offset + 1..];270		let (code, nstr) = parse_code(str)?;271		str = nstr;272		bytes = str.as_bytes();273		offset = 0;274275		out.push(Element::Code(code))276	}277}278279const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";280281#[inline]282pub fn render_integer(283	out: &mut String,284	iv: i64,285	padding: usize,286	precision: usize,287	blank: bool,288	sign: bool,289	radix: i64,290	prefix: &str,291	caps: bool,292) {293	// Digit char indexes in reverse order, i.e294	// for radix = 16 and n = 12f: [15, 2, 1]295	let digits = if iv == 0 {296		vec![0u8]297	} else {298		let mut v = iv.abs();299		let mut nums = Vec::with_capacity(1);300		while v > 0 {301			nums.push((v % radix) as u8);302			v /= radix;303		}304		nums305	};306	let neg = iv < 0;307	let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });308	let zp2 = zp309		.max(precision)310		.saturating_sub(prefix.len() + digits.len());311312	if neg {313		out.push('-')314	} else if sign {315		out.push('+');316	} else if blank {317		out.push(' ');318	}319320	out.reserve(zp2);321	for _ in 0..zp2 {322		out.push('0');323	}324	out.push_str(prefix);325326	for digit in digits.into_iter().rev() {327		let ch = NUMBERS[digit as usize] as char;328		out.push(if caps { ch.to_ascii_uppercase() } else { ch });329	}330}331332pub fn render_decimal(333	out: &mut String,334	iv: i64,335	padding: usize,336	precision: usize,337	blank: bool,338	sign: bool,339) {340	render_integer(out, iv, padding, precision, blank, sign, 10, "", false)341}342pub fn render_octal(343	out: &mut String,344	iv: i64,345	padding: usize,346	precision: usize,347	alt: bool,348	blank: bool,349	sign: bool,350) {351	render_integer(352		out,353		iv,354		padding,355		precision,356		blank,357		sign,358		8,359		if alt && iv != 0 { "0" } else { "" },360		false,361	)362}363pub fn render_hexadecimal(364	out: &mut String,365	iv: i64,366	padding: usize,367	precision: usize,368	alt: bool,369	blank: bool,370	sign: bool,371	caps: bool,372) {373	render_integer(374		out,375		iv,376		padding,377		precision,378		blank,379		sign,380		16,381		match (alt, caps) {382			(true, true) => "0X",383			(true, false) => "0x",384			(false, _) => "",385		},386		caps,387	)388}389390pub fn render_float(391	out: &mut String,392	n: f64,393	mut padding: usize,394	precision: usize,395	blank: bool,396	sign: bool,397	ensure_pt: bool,398	trailing: bool,399) {400	let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };401	padding = padding.saturating_sub(dot_size + precision);402	render_decimal(out, n.floor() as i64, padding, 0, blank, sign);403	if precision == 0 {404		if ensure_pt {405			out.push('.');406		}407		return;408	}409	let frac = n410		.fract()411		.mul_add(10.0_f64.powf(precision as f64), 0.5)412		.floor();413	if trailing || frac > 0.0 {414		out.push('.');415		let mut frac_str = String::new();416		render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);417		let mut trim = frac_str.len();418		if !trailing {419			for b in frac_str.as_bytes().iter().rev() {420				if *b == b'0' {421					trim -= 1;422				}423			}424		}425		out.push_str(&frac_str[..trim]);426	} else if ensure_pt {427		out.push('.');428	}429}430431pub fn render_float_sci(432	out: &mut String,433	n: f64,434	mut padding: usize,435	precision: usize,436	blank: bool,437	sign: bool,438	ensure_pt: bool,439	trailing: bool,440	caps: bool,441) {442	let exponent = n.log10().floor();443	let mantissa = if exponent as i16 == -324 {444		n * 10.0 / 10.0_f64.powf(exponent + 1.0)445	} else {446		n / 10.0_f64.powf(exponent)447	};448	let mut exponent_str = String::new();449	render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);450451	// +1 for e452	padding = padding.saturating_sub(exponent_str.len() + 1);453454	render_float(455		out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,456	);457	out.push(if caps { 'E' } else { 'e' });458	out.push_str(&exponent_str);459}460461pub fn format_code(462	out: &mut String,463	value: &Val,464	code: &Code,465	width: usize,466	precision: Option<usize>,467) -> Result<()> {468	let clfags = &code.cflags;469	let (fpprec, iprec) = match precision {470		Some(v) => (v, v),471		None => (6, 0),472	};473	let padding = if clfags.zero && !clfags.left {474		width475	} else {476		0477	};478479	// TODO: If left padded, can optimize by writing directly to out480	let mut tmp_out = String::new();481482	match code.convtype {483		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),484		ConvTypeV::Decimal => {485			let value = value.clone().try_cast_num("%d/%u/%i requires number")?;486			render_decimal(487				&mut tmp_out,488				value as i64,489				padding,490				iprec,491				clfags.blank,492				clfags.sign,493			);494		}495		ConvTypeV::Octal => {496			let value = value.clone().try_cast_num("%o requires number")?;497			render_octal(498				&mut tmp_out,499				value as i64,500				padding,501				iprec,502				clfags.alt,503				clfags.blank,504				clfags.sign,505			);506		}507		ConvTypeV::Hexadecimal => {508			let value = value.clone().try_cast_num("%x/%X requires number")?;509			render_hexadecimal(510				&mut tmp_out,511				value as i64,512				padding,513				iprec,514				clfags.alt,515				clfags.blank,516				clfags.sign,517				code.caps,518			);519		}520		ConvTypeV::Scientific => {521			let value = value.clone().try_cast_num("%e/%E requires number")?;522			render_float_sci(523				&mut tmp_out,524				value,525				padding,526				fpprec,527				clfags.blank,528				clfags.sign,529				clfags.alt,530				true,531				code.caps,532			);533		}534		ConvTypeV::Float => {535			let value = value.clone().try_cast_num("%e/%E requires number")?;536			render_float(537				&mut tmp_out,538				value,539				padding,540				fpprec,541				clfags.blank,542				clfags.sign,543				clfags.alt,544				true,545			);546		}547		ConvTypeV::Shorter => {548			let value = value.clone().try_cast_num("%g/%G requires number")?;549			let exponent = value.log10().floor();550			if exponent < -4.0 || exponent >= fpprec as f64 {551				render_float_sci(552					&mut tmp_out,553					value,554					padding,555					fpprec - 1,556					clfags.blank,557					clfags.sign,558					clfags.alt,559					clfags.alt,560					code.caps,561				);562			} else {563				let digits_before_pt = 1.max(exponent as usize + 1);564				render_float(565					&mut tmp_out,566					value,567					padding,568					fpprec - digits_before_pt,569					clfags.blank,570					clfags.sign,571					clfags.alt,572					clfags.alt,573				);574			}575		}576		ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {577			Val::Num(n) => tmp_out.push(578				std::char::from_u32(n as u32)579					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,580			),581			Val::Str(s) => {582				if s.chars().count() != 1 {583					throw!(RuntimeError(584						format!("%c expected 1 char string, got {}", s.chars().count()).into(),585					));586				}587				tmp_out.push_str(&s);588			}589			_ => {590				throw!(TypeMismatch(591					"%c requires number/string",592					vec![ValType::Num, ValType::Str],593					value.value_type()?,594				));595			}596		},597		ConvTypeV::Percent => tmp_out.push('%'),598	};599600	let padding = width.saturating_sub(tmp_out.len());601602	if !clfags.left {603		for _ in 0..padding {604			out.push(' ');605		}606	}607	out.push_str(&tmp_out);608	if clfags.left {609		for _ in 0..padding {610			out.push(' ');611		}612	}613614	Ok(())615}616617pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {618	let codes = parse_codes(str)?;619	let mut out = String::new();620621	for code in codes {622		match code {623			Element::String(s) => {624				out.push_str(s);625			}626			Element::Code(c) => {627				let width = match c.width {628					Width::Star => {629						if values.is_empty() {630							throw!(NotEnoughValues);631						}632						let value = &values[0];633						values = &values[1..];634						value.clone().try_cast_num("field width")? as usize635					}636					Width::Fixed(n) => n,637				};638				let precision = match c.precision {639					Some(Width::Star) => {640						if values.is_empty() {641							throw!(NotEnoughValues);642						}643						let value = &values[0];644						values = &values[1..];645						Some(value.clone().try_cast_num("field precision")? as usize)646					}647					Some(Width::Fixed(n)) => Some(n),648					None => None,649				};650651				// %% should not consume a value652				let value = if c.convtype == ConvTypeV::Percent {653					&Val::Null654				} else {655					if values.is_empty() {656						throw!(NotEnoughValues);657					}658					let value = &values[0];659					values = &values[1..];660					value661				};662663				format_code(&mut out, value, &c, width, precision)?;664			}665		}666	}667668	Ok(out)669}670671pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {672	let codes = parse_codes(str)?;673	let mut out = String::new();674675	for code in codes {676		match code {677			Element::String(s) => {678				out.push_str(s);679			}680			Element::Code(c) => {681				// TODO: Operate on ref682				let f: Rc<str> = c.mkey.into();683				let width = match c.width {684					Width::Star => {685						throw!(CannotUseStarWidthWithObject);686					}687					Width::Fixed(n) => n,688				};689				let precision = match c.precision {690					Some(Width::Star) => {691						throw!(CannotUseStarWidthWithObject);692					}693					Some(Width::Fixed(n)) => Some(n),694					None => None,695				};696697				let value = if c.convtype == ConvTypeV::Percent {698					Val::Null699				} else {700					if f.is_empty() {701						throw!(MappingKeysRequired);702					}703					if let Some(v) = values.get(f.clone())? {704						v705					} else {706						throw!(NoSuchFormatField(f));707					}708				};709710				format_code(&mut out, &value, &c, width, precision)?;711			}712		}713	}714715	Ok(out)716}717718#[cfg(test)]719pub mod test_format {720	use super::*;721722	#[test]723	fn parse() {724		assert_eq!(725			parse_codes(726				"How much error budget is left looking at our %.3f%% availability gurantees?"727			)728			.unwrap()729			.len(),730			4731		);732	}733734	#[test]735	fn octals() {736		assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");737		assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");738		assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), "  10");739		assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");740		assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");741		assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");742		assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10  ");743		assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");744		assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");745	}746747	#[test]748	fn percent_doesnt_consumes_values() {749		assert_eq!(750			format_arr(751				"How much error budget is left looking at our %.3f%% availability gurantees?",752				&[Val::Num(4.0)]753			)754			.unwrap(),755			"How much error budget is left looking at our 4.000% availability gurantees?"756		);757	}758}