git.delta.rocks / jrsonnet / refs/commits / 370c6155b374

1//! 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				};639640				// %% should not consume a value641				let value = if c.convtype == ConvTypeV::Percent {642					&Val::Null643				} else {644					if values.is_empty() {645						return Err(FormatError::NotEnoughValues);646					}647					let value = &values[0];648					values = &values[1..];649					value650				};651652				format_code(&mut out, value, &c, width, precision)?;653			}654		}655	}656657	Ok(out)658}659660pub fn format_obj(str: &str, values: &ObjValue) -> Result<String, FormatError> {661	let codes = parse_codes(&str)?;662	let mut out = String::new();663664	for code in codes {665		match code {666			Element::String(s) => {667				out.push_str(s);668			}669			Element::Code(c) => {670				// TODO: Operate on ref671				let f: Rc<str> = c.mkey.into();672				if f.is_empty() {673					return Err(FormatError::MappingKeysRequired);674				}675				let width = match c.width {676					Width::Star => {677						return Err(FormatError::CannotUseStarWidthWithObject);678					}679					Width::Fixed(n) => n,680				};681				let precision = match c.precision {682					Some(Width::Star) => {683						return Err(FormatError::CannotUseStarWidthWithObject);684					}685					Some(Width::Fixed(n)) => Some(n),686					None => None,687				};688				let value = if let Some(v) = values.get(f.clone())? {689					v690				} else {691					return Err(FormatError::NoSuchField(f));692				};693694				format_code(&mut out, &value, &c, width, precision)?;695			}696		}697	}698699	Ok(out)700}701702#[cfg(test)]703pub mod test_format {704	use super::*;705706	#[test]707	fn parse() {708		assert_eq!(709			parse_codes(710				"How much error budget is left looking at our %.3f%% availability gurantees?"711			)712			.unwrap()713			.len(),714			4715		);716	}717718	#[test]719	fn octals() {720		assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");721		assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");722		assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), "  10");723		assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");724		assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");725		assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");726		assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10  ");727		assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");728		assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");729	}730731	#[test]732	fn percent_doesnt_consumes_values() {733		assert_eq!(734			format_arr(735				"How much error budget is left looking at our %.3f%% availability gurantees?",736				&[Val::Num(4.0)]737			)738			.unwrap(),739			"How much error budget is left looking at our 4.000% availability gurantees?"740		);741	}742}