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

1//! faster std.format impl2#![allow(clippy::too_many_arguments)]34use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};5use jrsonnet_interner::IStr;6use jrsonnet_types::ValType;7use thiserror::Error;89#[derive(Debug, Clone, Error)]10pub enum FormatError {11	#[error("truncated format code")]12	TruncatedFormatCode,13	#[error("unrecognized conversion type: {0}")]14	UnrecognizedConversionType(char),1516	#[error("not enough values")]17	NotEnoughValues,1819	#[error("cannot use * width with object")]20	CannotUseStarWidthWithObject,21	#[error("mapping keys required")]22	MappingKeysRequired,23	#[error("no such format field: {0}")]24	NoSuchFormatField(IStr),25}2627impl From<FormatError> for LocError {28	fn from(e: FormatError) -> Self {29		Self::new(Format(e))30	}31}3233use FormatError::*;3435type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;3637pub fn try_parse_mapping_key(str: &str) -> ParseResult<&str> {38	if str.is_empty() {39		return Err(TruncatedFormatCode);40	}41	let bytes = str.as_bytes();42	if bytes[0] == b'(' {43		let mut i = 1;44		while i < bytes.len() {45			if bytes[i] == b')' {46				return Ok((&str[1..i as usize], &str[i as usize + 1..]));47			}48			i += 1;49		}50		Err(TruncatedFormatCode)51	} else {52		Ok(("", str))53	}54}5556#[cfg(test)]57pub mod tests_key {58	use super::*;5960	#[test]61	fn parse_key() {62		assert_eq!(63			try_parse_mapping_key("(hello ) world").unwrap(),64			("hello ", " world")65		);66		assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));67		assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));68		assert_eq!(69			try_parse_mapping_key(" () world").unwrap(),70			("", " () world")71		);72	}7374	#[test]75	#[should_panic]76	fn parse_key_missing_start() {77		try_parse_mapping_key("").unwrap();78	}7980	#[test]81	#[should_panic]82	fn parse_key_missing_end() {83		try_parse_mapping_key("(   ").unwrap();84	}85}8687#[derive(Default, Debug)]88pub struct CFlags {89	pub alt: bool,90	pub zero: bool,91	pub left: bool,92	pub blank: bool,93	pub sign: bool,94}9596pub fn try_parse_cflags(str: &str) -> ParseResult<CFlags> {97	if str.is_empty() {98		return Err(TruncatedFormatCode);99	}100	let bytes = str.as_bytes();101	let mut i = 0;102	let mut out = CFlags::default();103	loop {104		if bytes.len() == i {105			return Err(TruncatedFormatCode);106		}107		match bytes[i] {108			b'#' => out.alt = true,109			b'0' => out.zero = true,110			b'-' => out.left = true,111			b' ' => out.blank = true,112			b'+' => out.sign = true,113			_ => break,114		}115		i += 1;116	}117	Ok((out, &str[i..]))118}119120#[derive(Debug, PartialEq)]121pub enum Width {122	Star,123	Fixed(usize),124}125pub fn try_parse_field_width(str: &str) -> ParseResult<Width> {126	if str.is_empty() {127		return Err(TruncatedFormatCode);128	}129	let bytes = str.as_bytes();130	if bytes[0] == b'*' {131		return Ok((Width::Star, &str[1..]));132	}133	let mut out: usize = 0;134	let mut digits = 0;135	while let Some(digit) = (bytes[digits] as char).to_digit(10) {136		out *= 10;137		out += digit as usize;138		digits += 1;139		if digits == bytes.len() {140			return Err(TruncatedFormatCode);141		}142	}143	Ok((Width::Fixed(out), &str[digits..]))144}145146pub fn try_parse_precision(str: &str) -> ParseResult<Option<Width>> {147	if str.is_empty() {148		return Err(TruncatedFormatCode);149	}150	let bytes = str.as_bytes();151	if bytes[0] == b'.' {152		try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))153	} else {154		Ok((None, str))155	}156}157158// Only skips159pub fn try_parse_length_modifier(str: &str) -> ParseResult<()> {160	if str.is_empty() {161		return Err(TruncatedFormatCode);162	}163	let bytes = str.as_bytes();164	let mut idx = 0;165	while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {166		idx += 1;167		if bytes.len() == idx {168			return Err(TruncatedFormatCode);169		}170	}171	Ok(((), &str[idx..]))172}173174#[derive(Debug, PartialEq)]175pub enum ConvTypeV {176	Decimal,177	Octal,178	Hexadecimal,179	Scientific,180	Float,181	Shorter,182	Char,183	String,184	Percent,185}186pub struct ConvType {187	v: ConvTypeV,188	caps: bool,189}190191pub fn parse_conversion_type(str: &str) -> ParseResult<ConvType> {192	if str.is_empty() {193		return Err(TruncatedFormatCode);194	}195196	let code = str.as_bytes()[0];197	let v: (ConvTypeV, bool) = match code {198		b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),199		b'o' => (ConvTypeV::Octal, false),200		b'x' => (ConvTypeV::Hexadecimal, false),201		b'X' => (ConvTypeV::Hexadecimal, true),202		b'e' => (ConvTypeV::Scientific, false),203		b'E' => (ConvTypeV::Scientific, true),204		b'f' => (ConvTypeV::Float, false),205		b'F' => (ConvTypeV::Float, true),206		b'g' => (ConvTypeV::Shorter, false),207		b'G' => (ConvTypeV::Shorter, true),208		b'c' => (ConvTypeV::Char, false),209		b's' => (ConvTypeV::String, false),210		b'%' => (ConvTypeV::Percent, false),211		c => return Err(UnrecognizedConversionType(c as char)),212	};213214	Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))215}216217#[derive(Debug)]218pub struct Code<'s> {219	mkey: &'s str,220	cflags: CFlags,221	width: Width,222	precision: Option<Width>,223	convtype: ConvTypeV,224	caps: bool,225}226pub fn parse_code(str: &str) -> ParseResult<Code> {227	if str.is_empty() {228		return Err(TruncatedFormatCode);229	}230	let (mkey, str) = try_parse_mapping_key(str)?;231	let (cflags, str) = try_parse_cflags(str)?;232	let (width, str) = try_parse_field_width(str)?;233	let (precision, str) = try_parse_precision(str)?;234	let (_, str) = try_parse_length_modifier(str)?;235	let (convtype, str) = parse_conversion_type(str)?;236237	Ok((238		Code {239			mkey,240			cflags,241			width,242			precision,243			convtype: convtype.v,244			caps: convtype.caps,245		},246		str,247	))248}249250#[derive(Debug)]251pub enum Element<'s> {252	String(&'s str),253	Code(Code<'s>),254}255pub fn parse_codes(mut str: &str) -> Result<Vec<Element>> {256	let mut bytes = str.as_bytes();257	let mut out = vec![];258	let mut offset = 0;259260	loop {261		while offset != bytes.len() && bytes[offset] != b'%' {262			offset += 1;263		}264		if offset != 0 {265			out.push(Element::String(&str[0..offset]));266		}267		if offset == bytes.len() {268			return Ok(out);269		}270		str = &str[offset + 1..];271		let (code, nstr) = parse_code(str)?;272		str = nstr;273		bytes = str.as_bytes();274		offset = 0;275276		out.push(Element::Code(code))277	}278}279280const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";281282#[inline]283pub fn render_integer(284	out: &mut String,285	iv: i64,286	padding: usize,287	precision: usize,288	blank: bool,289	sign: bool,290	radix: i64,291	prefix: &str,292	caps: bool,293) {294	// Digit char indexes in reverse order, i.e295	// for radix = 16 and n = 12f: [15, 2, 1]296	let digits = if iv == 0 {297		vec![0u8]298	} else {299		let mut v = iv.abs();300		let mut nums = Vec::with_capacity(1);301		while v > 0 {302			nums.push((v % radix) as u8);303			v /= radix;304		}305		nums306	};307	let neg = iv < 0;308	let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });309	let zp2 = zp310		.max(precision)311		.saturating_sub(prefix.len() + digits.len());312313	if neg {314		out.push('-')315	} else if sign {316		out.push('+');317	} else if blank {318		out.push(' ');319	}320321	out.reserve(zp2);322	for _ in 0..zp2 {323		out.push('0');324	}325	out.push_str(prefix);326327	for digit in digits.into_iter().rev() {328		let ch = NUMBERS[digit as usize] as char;329		out.push(if caps { ch.to_ascii_uppercase() } else { ch });330	}331}332333pub fn render_decimal(334	out: &mut String,335	iv: i64,336	padding: usize,337	precision: usize,338	blank: bool,339	sign: bool,340) {341	render_integer(out, iv, padding, precision, blank, sign, 10, "", false)342}343pub fn render_octal(344	out: &mut String,345	iv: i64,346	padding: usize,347	precision: usize,348	alt: bool,349	blank: bool,350	sign: bool,351) {352	render_integer(353		out,354		iv,355		padding,356		precision,357		blank,358		sign,359		8,360		if alt && iv != 0 { "0" } else { "" },361		false,362	)363}364pub fn render_hexadecimal(365	out: &mut String,366	iv: i64,367	padding: usize,368	precision: usize,369	alt: bool,370	blank: bool,371	sign: bool,372	caps: bool,373) {374	render_integer(375		out,376		iv,377		padding,378		precision,379		blank,380		sign,381		16,382		match (alt, caps) {383			(true, true) => "0X",384			(true, false) => "0x",385			(false, _) => "",386		},387		caps,388	)389}390391pub fn render_float(392	out: &mut String,393	n: f64,394	mut padding: usize,395	precision: usize,396	blank: bool,397	sign: bool,398	ensure_pt: bool,399	trailing: bool,400) {401	let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };402	padding = padding.saturating_sub(dot_size + precision);403	render_decimal(out, n.floor() as i64, padding, 0, blank, sign);404	if precision == 0 {405		if ensure_pt {406			out.push('.');407		}408		return;409	}410	let frac = n411		.fract()412		.mul_add(10.0_f64.powf(precision as f64), 0.5)413		.floor();414	if trailing || frac > 0.0 {415		out.push('.');416		let mut frac_str = String::new();417		render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);418		let mut trim = frac_str.len();419		if !trailing {420			for b in frac_str.as_bytes().iter().rev() {421				if *b == b'0' {422					trim -= 1;423				}424			}425		}426		out.push_str(&frac_str[..trim]);427	} else if ensure_pt {428		out.push('.');429	}430}431432pub fn render_float_sci(433	out: &mut String,434	n: f64,435	mut padding: usize,436	precision: usize,437	blank: bool,438	sign: bool,439	ensure_pt: bool,440	trailing: bool,441	caps: bool,442) {443	let exponent = n.log10().floor();444	let mantissa = if exponent as i16 == -324 {445		n * 10.0 / 10.0_f64.powf(exponent + 1.0)446	} else {447		n / 10.0_f64.powf(exponent)448	};449	let mut exponent_str = String::new();450	render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);451452	// +1 for e453	padding = padding.saturating_sub(exponent_str.len() + 1);454455	render_float(456		out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,457	);458	out.push(if caps { 'E' } else { 'e' });459	out.push_str(&exponent_str);460}461462pub fn format_code(463	out: &mut String,464	value: &Val,465	code: &Code,466	width: usize,467	precision: Option<usize>,468) -> Result<()> {469	let clfags = &code.cflags;470	let (fpprec, iprec) = match precision {471		Some(v) => (v, v),472		None => (6, 0),473	};474	let padding = if clfags.zero && !clfags.left {475		width476	} else {477		0478	};479480	// TODO: If left padded, can optimize by writing directly to out481	let mut tmp_out = String::new();482483	match code.convtype {484		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string()?),485		ConvTypeV::Decimal => {486			let value = value.clone().try_cast_num("%d/%u/%i requires number")?;487			render_decimal(488				&mut tmp_out,489				value as i64,490				padding,491				iprec,492				clfags.blank,493				clfags.sign,494			);495		}496		ConvTypeV::Octal => {497			let value = value.clone().try_cast_num("%o requires number")?;498			render_octal(499				&mut tmp_out,500				value as i64,501				padding,502				iprec,503				clfags.alt,504				clfags.blank,505				clfags.sign,506			);507		}508		ConvTypeV::Hexadecimal => {509			let value = value.clone().try_cast_num("%x/%X requires number")?;510			render_hexadecimal(511				&mut tmp_out,512				value as i64,513				padding,514				iprec,515				clfags.alt,516				clfags.blank,517				clfags.sign,518				code.caps,519			);520		}521		ConvTypeV::Scientific => {522			let value = value.clone().try_cast_num("%e/%E requires number")?;523			render_float_sci(524				&mut tmp_out,525				value,526				padding,527				fpprec,528				clfags.blank,529				clfags.sign,530				clfags.alt,531				true,532				code.caps,533			);534		}535		ConvTypeV::Float => {536			let value = value.clone().try_cast_num("%e/%E requires number")?;537			render_float(538				&mut tmp_out,539				value,540				padding,541				fpprec,542				clfags.blank,543				clfags.sign,544				clfags.alt,545				true,546			);547		}548		ConvTypeV::Shorter => {549			let value = value.clone().try_cast_num("%g/%G requires number")?;550			let exponent = value.log10().floor();551			if exponent < -4.0 || exponent >= fpprec as f64 {552				render_float_sci(553					&mut tmp_out,554					value,555					padding,556					fpprec - 1,557					clfags.blank,558					clfags.sign,559					clfags.alt,560					clfags.alt,561					code.caps,562				);563			} else {564				let digits_before_pt = 1.max(exponent as usize + 1);565				render_float(566					&mut tmp_out,567					value,568					padding,569					fpprec - digits_before_pt,570					clfags.blank,571					clfags.sign,572					clfags.alt,573					clfags.alt,574				);575			}576		}577		ConvTypeV::Char => match value.clone() {578			Val::Num(n) => tmp_out.push(579				std::char::from_u32(n as u32)580					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,581			),582			Val::Str(s) => {583				if s.chars().count() != 1 {584					throw!(RuntimeError(585						format!("%c expected 1 char string, got {}", s.chars().count()).into(),586					));587				}588				tmp_out.push_str(&s);589			}590			_ => {591				throw!(TypeMismatch(592					"%c requires number/string",593					vec![ValType::Num, ValType::Str],594					value.value_type(),595				));596			}597		},598		ConvTypeV::Percent => tmp_out.push('%'),599	};600601	let padding = width.saturating_sub(tmp_out.len());602603	if !clfags.left {604		for _ in 0..padding {605			out.push(' ');606		}607	}608	out.push_str(&tmp_out);609	if clfags.left {610		for _ in 0..padding {611			out.push(' ');612		}613	}614615	Ok(())616}617618pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {619	let codes = parse_codes(str)?;620	let mut out = String::new();621622	for code in codes {623		match code {624			Element::String(s) => {625				out.push_str(s);626			}627			Element::Code(c) => {628				let width = match c.width {629					Width::Star => {630						if values.is_empty() {631							throw!(NotEnoughValues);632						}633						let value = &values[0];634						values = &values[1..];635						value.clone().try_cast_num("field width")? as usize636					}637					Width::Fixed(n) => n,638				};639				let precision = match c.precision {640					Some(Width::Star) => {641						if values.is_empty() {642							throw!(NotEnoughValues);643						}644						let value = &values[0];645						values = &values[1..];646						Some(value.clone().try_cast_num("field precision")? as usize)647					}648					Some(Width::Fixed(n)) => Some(n),649					None => None,650				};651652				// %% should not consume a value653				let value = if c.convtype == ConvTypeV::Percent {654					&Val::Null655				} else {656					if values.is_empty() {657						throw!(NotEnoughValues);658					}659					let value = &values[0];660					values = &values[1..];661					value662				};663664				format_code(&mut out, value, &c, width, precision)?;665			}666		}667	}668669	Ok(out)670}671672pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {673	let codes = parse_codes(str)?;674	let mut out = String::new();675676	for code in codes {677		match code {678			Element::String(s) => {679				out.push_str(s);680			}681			Element::Code(c) => {682				// TODO: Operate on ref683				let f: IStr = c.mkey.into();684				let width = match c.width {685					Width::Star => {686						throw!(CannotUseStarWidthWithObject);687					}688					Width::Fixed(n) => n,689				};690				let precision = match c.precision {691					Some(Width::Star) => {692						throw!(CannotUseStarWidthWithObject);693					}694					Some(Width::Fixed(n)) => Some(n),695					None => None,696				};697698				let value = if c.convtype == ConvTypeV::Percent {699					Val::Null700				} else {701					if f.is_empty() {702						throw!(MappingKeysRequired);703					}704					if let Some(v) = values.get(f.clone())? {705						v706					} else {707						throw!(NoSuchFormatField(f));708					}709				};710711				format_code(&mut out, &value, &c, width, precision)?;712			}713		}714	}715716	Ok(out)717}718719#[cfg(test)]720pub mod test_format {721	use super::*;722723	#[test]724	fn parse() {725		assert_eq!(726			parse_codes(727				"How much error budget is left looking at our %.3f%% availability gurantees?"728			)729			.unwrap()730			.len(),731			4732		);733	}734735	#[test]736	fn octals() {737		assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");738		assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");739		assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), "  10");740		assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");741		assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");742		assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");743		assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10  ");744		assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");745		assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");746	}747748	#[test]749	fn percent_doesnt_consumes_values() {750		assert_eq!(751			format_arr(752				"How much error budget is left looking at our %.3f%% availability gurantees?",753				&[Val::Num(4.0)]754			)755			.unwrap(),756			"How much error budget is left looking at our 4.000% availability gurantees?"757		);758	}759}