git.delta.rocks / jrsonnet / refs/commits / 2afd5ff0dd7a

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				}434			}435		}436		out.push_str(&frac_str[..trim]);437	} else if ensure_pt {438		out.push('.');439	}440}441442#[allow(clippy::fn_params_excessive_bools)]443pub fn render_float_sci(444	out: &mut String,445	n: f64,446	mut padding: usize,447	precision: usize,448	blank: bool,449	sign: bool,450	ensure_pt: bool,451	trailing: bool,452	caps: bool,453) {454	let exponent = n.log10().floor();455	let mantissa = if exponent as i16 == -324 {456		n * 10.0 / 10.0_f64.powf(exponent + 1.0)457	} else {458		n / 10.0_f64.powf(exponent)459	};460	let mut exponent_str = String::new();461	render_decimal(&mut exponent_str, exponent, 3, 0, false, true);462463	// +1 for e464	padding = padding.saturating_sub(exponent_str.len() + 1);465466	render_float(467		out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,468	);469	out.push(if caps { 'E' } else { 'e' });470	out.push_str(&exponent_str);471}472473#[allow(clippy::too_many_lines)]474pub fn format_code(475	out: &mut String,476	value: &Val,477	code: &Code<'_>,478	width: usize,479	precision: Option<usize>,480) -> Result<()> {481	let clfags = &code.cflags;482	let (fpprec, iprec) = precision.map_or((6, 0), |v| (v, v));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()?),494		ConvTypeV::Decimal => {495			let value = f64::from_untyped(value.clone())?;496			render_decimal(497				&mut tmp_out,498				value,499				padding,500				iprec,501				clfags.blank,502				clfags.sign,503			);504		}505		ConvTypeV::Octal => {506			let value = f64::from_untyped(value.clone())?;507			render_octal(508				&mut tmp_out,509				value,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())?;519			render_hexadecimal(520				&mut tmp_out,521				value,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())?;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())?;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())?;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_out.push(588				std::char::from_u32(n as u32)589					.ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?,590			),591			Val::Str(s) => {592				let s = s.into_flat();593				if s.chars().count() != 1 {594					throw!("%c expected 1 char string, got {}", s.chars().count(),);595				}596				tmp_out.push_str(&s);597			}598			_ => {599				throw!(TypeMismatch(600					"%c requires number/string",601					vec![ValType::Num, ValType::Str],602					value.value_type(),603				));604			}605		},606		ConvTypeV::Percent => tmp_out.push('%'),607	};608609	let padding = width.saturating_sub(tmp_out.len());610611	if !clfags.left {612		for _ in 0..padding {613			out.push(' ');614		}615	}616	out.push_str(&tmp_out);617	if clfags.left {618		for _ in 0..padding {619			out.push(' ');620		}621	}622623	Ok(())624}625626pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {627	let codes = parse_codes(str)?;628	let mut out = String::new();629	let value_count = values.len();630631	for code in codes {632		match code {633			Element::String(s) => {634				out.push_str(s);635			}636			Element::Code(c) => {637				let width = match c.width {638					Width::Star => {639						if values.is_empty() {640							throw!(NotEnoughValues);641						}642						let value = &values[0];643						values = &values[1..];644						usize::from_untyped(value.clone())?645					}646					Width::Fixed(n) => n,647				};648				let precision = match c.precision {649					Some(Width::Star) => {650						if values.is_empty() {651							throw!(NotEnoughValues);652						}653						let value = &values[0];654						values = &values[1..];655						Some(usize::from_untyped(value.clone())?)656					}657					Some(Width::Fixed(n)) => Some(n),658					None => None,659				};660661				// %% should not consume a value662				let value = if c.convtype == ConvTypeV::Percent {663					&Val::Null664				} else {665					if values.is_empty() {666						throw!(NotEnoughValues);667					}668					let value = &values[0];669					values = &values[1..];670					value671				};672673				format_code(&mut out, value, &c, width, precision)?;674			}675		}676	}677678	if !values.is_empty() {679		throw!(680			"too many values to format, expected {value_count}, got {}",681			value_count + values.len()682		)683	}684685	Ok(out)686}687688pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {689	let codes = parse_codes(str)?;690	let mut out = String::new();691692	for code in codes {693		match code {694			Element::String(s) => {695				out.push_str(s);696			}697			Element::Code(c) => {698				// TODO: Operate on ref699				let f: IStr = c.mkey.into();700				let width = match c.width {701					Width::Star => {702						throw!(CannotUseStarWidthWithObject);703					}704					Width::Fixed(n) => n,705				};706				let precision = match c.precision {707					Some(Width::Star) => {708						throw!(CannotUseStarWidthWithObject);709					}710					Some(Width::Fixed(n)) => Some(n),711					None => None,712				};713714				let value = if c.convtype == ConvTypeV::Percent {715					Val::Null716				} else {717					if f.is_empty() {718						throw!(MappingKeysRequired);719					}720					if let Some(v) = values.get(f.clone())? {721						v722					} else {723						throw!(NoSuchFormatField(f));724					}725				};726727				format_code(&mut out, &value, &c, width, precision)?;728			}729		}730	}731732	Ok(out)733}734735#[cfg(test)]736pub mod test_format {737	use super::*;738739	#[test]740	fn parse() {741		assert_eq!(742			parse_codes(743				"How much error budget is left looking at our %.3f%% availability gurantees?"744			)745			.unwrap()746			.len(),747			4748		);749	}750751	#[test]752	fn octals() {753		assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");754		assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");755		assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), "  10");756		assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");757		assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");758		assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");759		assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10  ");760		assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");761		assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");762	}763764	#[test]765	fn percent_doesnt_consumes_values() {766		assert_eq!(767			format_arr(768				"How much error budget is left looking at our %.3f%% availability gurantees?",769				&[Val::Num(4.0)]770			)771			.unwrap(),772			"How much error budget is left looking at our 4.000% availability gurantees?"773		);774	}775}