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

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::Error::*, throw, typed::Typed, LocError, ObjValue, Result, State, 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 LocError {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 as usize], &str[i as usize + 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: i64,289	padding: usize,290	precision: usize,291	blank: bool,292	sign: bool,293	radix: i64,294	prefix: &str,295	caps: bool,296) {297	// Digit char indexes in reverse order, i.e298	// for radix = 16 and n = 12f: [15, 2, 1]299	let digits = if iv == 0 {300		vec![0u8]301	} else {302		let mut v = iv.abs();303		let mut nums = Vec::with_capacity(1);304		while v > 0 {305			nums.push((v % radix) as u8);306			v /= radix;307		}308		nums309	};310	let neg = iv < 0;311	let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });312	let zp2 = zp313		.max(precision)314		.saturating_sub(prefix.len() + digits.len());315316	if neg {317		out.push('-');318	} else if sign {319		out.push('+');320	} else if blank {321		out.push(' ');322	}323324	out.reserve(zp2);325	for _ in 0..zp2 {326		out.push('0');327	}328	out.push_str(prefix);329330	for digit in digits.into_iter().rev() {331		let ch = NUMBERS[digit as usize] as char;332		out.push(if caps { ch.to_ascii_uppercase() } else { ch });333	}334}335336pub fn render_decimal(337	out: &mut String,338	iv: i64,339	padding: usize,340	precision: usize,341	blank: bool,342	sign: bool,343) {344	render_integer(out, iv, padding, precision, blank, sign, 10, "", false);345}346pub fn render_octal(347	out: &mut String,348	iv: i64,349	padding: usize,350	precision: usize,351	alt: bool,352	blank: bool,353	sign: bool,354) {355	render_integer(356		out,357		iv,358		padding,359		precision,360		blank,361		sign,362		8,363		if alt && iv != 0 { "0" } else { "" },364		false,365	);366}367368#[allow(clippy::fn_params_excessive_bools)]369pub fn render_hexadecimal(370	out: &mut String,371	iv: i64,372	padding: usize,373	precision: usize,374	alt: bool,375	blank: bool,376	sign: bool,377	caps: bool,378) {379	render_integer(380		out,381		iv,382		padding,383		precision,384		blank,385		sign,386		16,387		match (alt, caps) {388			(true, true) => "0X",389			(true, false) => "0x",390			(false, _) => "",391		},392		caps,393	);394}395396#[allow(clippy::fn_params_excessive_bools)]397pub fn render_float(398	out: &mut String,399	n: f64,400	mut padding: usize,401	precision: usize,402	blank: bool,403	sign: bool,404	ensure_pt: bool,405	trailing: bool,406) {407	let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };408	padding = padding.saturating_sub(dot_size + precision);409	render_decimal(out, n.floor() as i64, padding, 0, blank, sign);410	if precision == 0 {411		if ensure_pt {412			out.push('.');413		}414		return;415	}416	let frac = n417		.fract()418		.mul_add(10.0_f64.powf(precision as f64), 0.5)419		.floor();420	if trailing || frac > 0.0 {421		out.push('.');422		let mut frac_str = String::new();423		render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);424		let mut trim = frac_str.len();425		if !trailing {426			for b in frac_str.as_bytes().iter().rev() {427				if *b == b'0' {428					trim -= 1;429				}430			}431		}432		out.push_str(&frac_str[..trim]);433	} else if ensure_pt {434		out.push('.');435	}436}437438#[allow(clippy::fn_params_excessive_bools)]439pub fn render_float_sci(440	out: &mut String,441	n: f64,442	mut padding: usize,443	precision: usize,444	blank: bool,445	sign: bool,446	ensure_pt: bool,447	trailing: bool,448	caps: bool,449) {450	let exponent = n.log10().floor();451	let mantissa = if exponent as i16 == -324 {452		n * 10.0 / 10.0_f64.powf(exponent + 1.0)453	} else {454		n / 10.0_f64.powf(exponent)455	};456	let mut exponent_str = String::new();457	render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);458459	// +1 for e460	padding = padding.saturating_sub(exponent_str.len() + 1);461462	render_float(463		out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,464	);465	out.push(if caps { 'E' } else { 'e' });466	out.push_str(&exponent_str);467}468469#[allow(clippy::too_many_lines)]470pub fn format_code(471	s: State,472	out: &mut String,473	value: &Val,474	code: &Code,475	width: usize,476	precision: Option<usize>,477) -> Result<()> {478	let clfags = &code.cflags;479	let (fpprec, iprec) = match precision {480		Some(v) => (v, v),481		None => (6, 0),482	};483	let padding = if clfags.zero && !clfags.left {484		width485	} else {486		0487	};488489	// TODO: If left padded, can optimize by writing directly to out490	let mut tmp_out = String::new();491492	match code.convtype {493		ConvTypeV::String => tmp_out.push_str(&value.clone().to_string(s)?),494		ConvTypeV::Decimal => {495			let value = f64::from_untyped(value.clone(), s)?;496			render_decimal(497				&mut tmp_out,498				value as i64,499				padding,500				iprec,501				clfags.blank,502				clfags.sign,503			);504		}505		ConvTypeV::Octal => {506			let value = f64::from_untyped(value.clone(), s)?;507			render_octal(508				&mut tmp_out,509				value as i64,510				padding,511				iprec,512				clfags.alt,513				clfags.blank,514				clfags.sign,515			);516		}517		ConvTypeV::Hexadecimal => {518			let value = f64::from_untyped(value.clone(), s)?;519			render_hexadecimal(520				&mut tmp_out,521				value as i64,522				padding,523				iprec,524				clfags.alt,525				clfags.blank,526				clfags.sign,527				code.caps,528			);529		}530		ConvTypeV::Scientific => {531			let value = f64::from_untyped(value.clone(), s)?;532			render_float_sci(533				&mut tmp_out,534				value,535				padding,536				fpprec,537				clfags.blank,538				clfags.sign,539				clfags.alt,540				true,541				code.caps,542			);543		}544		ConvTypeV::Float => {545			let value = f64::from_untyped(value.clone(), s)?;546			render_float(547				&mut tmp_out,548				value,549				padding,550				fpprec,551				clfags.blank,552				clfags.sign,553				clfags.alt,554				true,555			);556		}557		ConvTypeV::Shorter => {558			let value = f64::from_untyped(value.clone(), s)?;559			let exponent = value.log10().floor();560			if exponent < -4.0 || exponent >= fpprec as f64 {561				render_float_sci(562					&mut tmp_out,563					value,564					padding,565					fpprec - 1,566					clfags.blank,567					clfags.sign,568					clfags.alt,569					clfags.alt,570					code.caps,571				);572			} else {573				let digits_before_pt = 1.max(exponent as usize + 1);574				render_float(575					&mut tmp_out,576					value,577					padding,578					fpprec - digits_before_pt,579					clfags.blank,580					clfags.sign,581					clfags.alt,582					clfags.alt,583				);584			}585		}586		ConvTypeV::Char => match value.clone() {587			Val::Num(n) => tmp_out588				.push(std::char::from_u32(n as u32).ok_or(InvalidUnicodeCodepointGot(n as u32))?),589			Val::Str(s) => {590				if s.chars().count() != 1 {591					throw!(RuntimeError(592						format!("%c expected 1 char string, got {}", s.chars().count()).into(),593					));594				}595				tmp_out.push_str(&s);596			}597			_ => {598				throw!(TypeMismatch(599					"%c requires number/string",600					vec![ValType::Num, ValType::Str],601					value.value_type(),602				));603			}604		},605		ConvTypeV::Percent => tmp_out.push('%'),606	};607608	let padding = width.saturating_sub(tmp_out.len());609610	if !clfags.left {611		for _ in 0..padding {612			out.push(' ');613		}614	}615	out.push_str(&tmp_out);616	if clfags.left {617		for _ in 0..padding {618			out.push(' ');619		}620	}621622	Ok(())623}624625pub fn format_arr(s: State, str: &str, mut values: &[Val]) -> Result<String> {626	let codes = parse_codes(str)?;627	let mut out = String::new();628629	for code in codes {630		match code {631			Element::String(s) => {632				out.push_str(s);633			}634			Element::Code(c) => {635				let width = match c.width {636					Width::Star => {637						if values.is_empty() {638							throw!(NotEnoughValues);639						}640						let value = &values[0];641						values = &values[1..];642						usize::from_untyped(value.clone(), s.clone())?643					}644					Width::Fixed(n) => n,645				};646				let precision = match c.precision {647					Some(Width::Star) => {648						if values.is_empty() {649							throw!(NotEnoughValues);650						}651						let value = &values[0];652						values = &values[1..];653						Some(usize::from_untyped(value.clone(), s.clone())?)654					}655					Some(Width::Fixed(n)) => Some(n),656					None => None,657				};658659				// %% should not consume a value660				let value = if c.convtype == ConvTypeV::Percent {661					&Val::Null662				} else {663					if values.is_empty() {664						throw!(NotEnoughValues);665					}666					let value = &values[0];667					values = &values[1..];668					value669				};670671				format_code(s.clone(), &mut out, value, &c, width, precision)?;672			}673		}674	}675676	Ok(out)677}678679pub fn format_obj(s: State, str: &str, values: &ObjValue) -> Result<String> {680	let codes = parse_codes(str)?;681	let mut out = String::new();682683	for code in codes {684		match code {685			Element::String(s) => {686				out.push_str(s);687			}688			Element::Code(c) => {689				// TODO: Operate on ref690				let f: IStr = c.mkey.into();691				let width = match c.width {692					Width::Star => {693						throw!(CannotUseStarWidthWithObject);694					}695					Width::Fixed(n) => n,696				};697				let precision = match c.precision {698					Some(Width::Star) => {699						throw!(CannotUseStarWidthWithObject);700					}701					Some(Width::Fixed(n)) => Some(n),702					None => None,703				};704705				let value = if c.convtype == ConvTypeV::Percent {706					Val::Null707				} else {708					if f.is_empty() {709						throw!(MappingKeysRequired);710					}711					if let Some(v) = values.get(s.clone(), f.clone())? {712						v713					} else {714						throw!(NoSuchFormatField(f));715					}716				};717718				format_code(s.clone(), &mut out, &value, &c, width, precision)?;719			}720		}721	}722723	Ok(out)724}725726#[cfg(test)]727pub mod test_format {728	use super::*;729730	#[test]731	fn parse() {732		assert_eq!(733			parse_codes(734				"How much error budget is left looking at our %.3f%% availability gurantees?"735			)736			.unwrap()737			.len(),738			4739		);740	}741742	#[test]743	fn octals() {744		let s = State::default();745		assert_eq!(746			format_arr(s.clone(), "%#o", &[Val::Num(8.0)]).unwrap(),747			"010"748		);749		assert_eq!(750			format_arr(s.clone(), "%#4o", &[Val::Num(8.0)]).unwrap(),751			" 010"752		);753		assert_eq!(754			format_arr(s.clone(), "%4o", &[Val::Num(8.0)]).unwrap(),755			"  10"756		);757		assert_eq!(758			format_arr(s.clone(), "%04o", &[Val::Num(8.0)]).unwrap(),759			"0010"760		);761		assert_eq!(762			format_arr(s.clone(), "%+4o", &[Val::Num(8.0)]).unwrap(),763			" +10"764		);765		assert_eq!(766			format_arr(s.clone(), "%+04o", &[Val::Num(8.0)]).unwrap(),767			"+010"768		);769		assert_eq!(770			format_arr(s.clone(), "%-4o", &[Val::Num(8.0)]).unwrap(),771			"10  "772		);773		assert_eq!(774			format_arr(s.clone(), "%+-4o", &[Val::Num(8.0)]).unwrap(),775			"+10 "776		);777		assert_eq!(778			format_arr(s.clone(), "%+-04o", &[Val::Num(8.0)]).unwrap(),779			"+10 "780		);781	}782783	#[test]784	fn percent_doesnt_consumes_values() {785		let s = State::default();786		assert_eq!(787			format_arr(788				s,789				"How much error budget is left looking at our %.3f%% availability gurantees?",790				&[Val::Num(4.0)]791			)792			.unwrap(),793			"How much error budget is left looking at our 4.000% availability gurantees?"794		);795	}796}