difftreelog
perf faster format
in: master
6 files changed
crates/jrsonnet-evaluator/build.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/build.rs
+++ b/crates/jrsonnet-evaluator/build.rs
@@ -39,7 +39,7 @@
if **name == *"join" || **name == *"manifestJsonEx" ||
**name == *"escapeStringJson" || **name == *"equals" ||
**name == *"base64" || **name == *"foldl" || **name == *"foldr" ||
- **name == *"sortImpl" || **name == *"range"
+ **name == *"sortImpl" || **name == *"format" || **name == *"range"
)
})
.collect(),
crates/jrsonnet-evaluator/src/builtin/format.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -0,0 +1,714 @@
+//! faster std.format impl
+#![allow(clippy::too_many_arguments)]
+
+use crate::{
+ create_error, create_error_result, to_string, Error, LocError, ObjValue, Val, ValType,
+};
+
+#[derive(Debug)]
+pub enum FormatError {
+ TruncatedFormatCode,
+ UnrecognizedConversionType(char),
+ ValueError(LocError),
+
+ NotEnoughValues,
+
+ CannotUseStarWidthWithObject,
+ MappingKeysRequired,
+ NoSuchField(Rc<str>),
+}
+impl From<LocError> for FormatError {
+ fn from(e: LocError) -> Self {
+ Self::ValueError(e)
+ }
+}
+use std::rc::Rc;
+use FormatError::*;
+
+pub fn try_parse_mapping_key(str: &str) -> Result<(&str, &str), FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+ let bytes = str.as_bytes();
+ if bytes[0] == b'(' {
+ let mut i = 1;
+ while i < bytes.len() {
+ if bytes[i] == b')' {
+ return Ok((&str[1..i as usize], &str[i as usize + 1..]));
+ }
+ i += 1;
+ }
+ Err(TruncatedFormatCode)
+ } else {
+ Ok(("", str))
+ }
+}
+
+#[cfg(test)]
+pub mod tests_key {
+ use super::*;
+
+ #[test]
+ fn parse_key() {
+ assert_eq!(
+ try_parse_mapping_key("(hello ) world").unwrap(),
+ ("hello ", " world")
+ );
+ assert_eq!(try_parse_mapping_key("() world").unwrap(), ("", " world"));
+ assert_eq!(try_parse_mapping_key(" world").unwrap(), ("", " world"));
+ assert_eq!(
+ try_parse_mapping_key(" () world").unwrap(),
+ ("", " () world")
+ );
+ }
+
+ #[test]
+ #[should_panic]
+ fn parse_key_missing_start() {
+ try_parse_mapping_key("").unwrap();
+ }
+
+ #[test]
+ #[should_panic]
+ fn parse_key_missing_end() {
+ try_parse_mapping_key("( ").unwrap();
+ }
+}
+
+#[derive(Default, Debug)]
+pub struct CFlags {
+ pub alt: bool,
+ pub zero: bool,
+ pub left: bool,
+ pub blank: bool,
+ pub sign: bool,
+}
+
+pub fn try_parse_cflags(str: &str) -> Result<(CFlags, &str), FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+ let bytes = str.as_bytes();
+ let mut i = 0;
+ let mut out = CFlags::default();
+ loop {
+ if bytes.len() == i {
+ return Err(TruncatedFormatCode);
+ }
+ match bytes[i] {
+ b'#' => out.alt = true,
+ b'0' => out.zero = true,
+ b'-' => out.left = true,
+ b' ' => out.blank = true,
+ b'+' => out.sign = true,
+ _ => break,
+ }
+ i += 1;
+ }
+ Ok((out, &str[i..]))
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Width {
+ Star,
+ Fixed(usize),
+}
+pub fn try_parse_field_width(str: &str) -> Result<(Width, &str), FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+ let bytes = str.as_bytes();
+ if bytes[0] == b'*' {
+ return Ok((Width::Star, &str[1..]));
+ }
+ let mut out: usize = 0;
+ let mut digits = 0;
+ while let Some(digit) = (bytes[digits] as char).to_digit(10) {
+ out *= 10;
+ out += digit as usize;
+ digits += 1;
+ if digits == bytes.len() {
+ return Err(TruncatedFormatCode);
+ }
+ }
+ Ok((Width::Fixed(out), &str[digits..]))
+}
+
+pub fn try_parse_precision(str: &str) -> Result<(Option<Width>, &str), FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+ let bytes = str.as_bytes();
+ if bytes[0] == b'.' {
+ try_parse_field_width(&str[1..]).map(|(r, s)| (Some(r), s))
+ } else {
+ Ok((None, str))
+ }
+}
+
+// Only skips
+pub fn try_parse_length_modifier(str: &str) -> Result<&str, FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+ let bytes = str.as_bytes();
+ let mut idx = 0;
+ while bytes[idx] == b'h' || bytes[idx] == b'l' || bytes[idx] == b'L' {
+ idx += 1;
+ if bytes.len() == idx {
+ return Err(TruncatedFormatCode);
+ }
+ }
+ Ok(&str[idx..])
+}
+
+#[derive(Debug)]
+pub enum ConvTypeV {
+ Decimal,
+ Octal,
+ Hexadecimal,
+ Scientific,
+ Float,
+ Shorter,
+ Char,
+ String,
+ Percent,
+}
+pub struct ConvType {
+ v: ConvTypeV,
+ caps: bool,
+}
+
+pub fn parse_conversion_type(str: &str) -> Result<(ConvType, &str), FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+
+ let code = str.as_bytes()[0];
+ let v: (ConvTypeV, bool) = match code {
+ b'd' | b'i' | b'u' => (ConvTypeV::Decimal, false),
+ b'o' => (ConvTypeV::Octal, false),
+ b'x' => (ConvTypeV::Hexadecimal, false),
+ b'X' => (ConvTypeV::Hexadecimal, true),
+ b'e' => (ConvTypeV::Scientific, false),
+ b'E' => (ConvTypeV::Scientific, true),
+ b'f' => (ConvTypeV::Float, false),
+ b'F' => (ConvTypeV::Float, true),
+ b'g' => (ConvTypeV::Shorter, false),
+ b'G' => (ConvTypeV::Shorter, true),
+ b'c' => (ConvTypeV::Char, false),
+ b's' => (ConvTypeV::String, false),
+ b'%' => (ConvTypeV::Percent, false),
+ c => return Err(UnrecognizedConversionType(c as char)),
+ };
+
+ Ok((ConvType { v: v.0, caps: v.1 }, &str[1..]))
+}
+
+#[derive(Debug)]
+pub struct Code<'s> {
+ mkey: &'s str,
+ cflags: CFlags,
+ width: Width,
+ precision: Option<Width>,
+ convtype: ConvTypeV,
+ caps: bool,
+}
+pub fn parse_code(str: &str) -> Result<(Code, &str), FormatError> {
+ if str.is_empty() {
+ return Err(TruncatedFormatCode);
+ }
+ let (mkey, str) = try_parse_mapping_key(str)?;
+ let (cflags, str) = try_parse_cflags(str)?;
+ let (width, str) = try_parse_field_width(str)?;
+ let (precision, str) = try_parse_precision(str)?;
+ let str = try_parse_length_modifier(str)?;
+ let (convtype, str) = parse_conversion_type(str)?;
+
+ Ok((
+ Code {
+ mkey,
+ cflags,
+ width,
+ precision,
+ convtype: convtype.v,
+ caps: convtype.caps,
+ },
+ str,
+ ))
+}
+
+#[derive(Debug)]
+pub enum Element<'s> {
+ String(&'s str),
+ Code(Code<'s>),
+}
+pub fn parse_codes(mut str: &str) -> Result<Vec<Element>, FormatError> {
+ let mut bytes = str.as_bytes();
+ let mut out = vec![];
+ let mut offset = 0;
+
+ loop {
+ while offset != bytes.len() && bytes[offset] != b'%' {
+ offset += 1;
+ }
+ if offset == bytes.len() {
+ return Ok(out);
+ }
+ out.push(Element::String(&str[0..offset]));
+ str = &str[offset + 1..];
+ let (code, nstr) = parse_code(str)?;
+ str = nstr;
+ bytes = str.as_bytes();
+ offset = 0;
+
+ out.push(Element::Code(code))
+ }
+}
+
+const NUMBERS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
+
+#[inline]
+pub fn render_integer(
+ out: &mut String,
+ iv: i64,
+ padding: usize,
+ precision: usize,
+ blank: bool,
+ sign: bool,
+ radix: i64,
+ prefix: &str,
+ caps: bool,
+) {
+ // Digit char indexes in reverse order, i.e
+ // for radix = 16 and n = 12f: [15, 2, 1]
+ let digits = if iv == 0 {
+ vec![0u8]
+ } else {
+ let mut v = iv.abs();
+ let mut nums = Vec::with_capacity(1);
+ while v > 0 {
+ nums.push((v % radix) as u8);
+ v /= radix;
+ }
+ nums
+ };
+ let neg = iv < 0;
+ let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });
+ let zp2 = zp
+ .max(precision)
+ .saturating_sub(prefix.len() + digits.len());
+
+ if neg {
+ out.push('-')
+ } else if sign {
+ out.push('+');
+ } else if blank {
+ out.push(' ');
+ }
+
+ out.reserve(zp2);
+ for _ in 0..zp2 {
+ out.push('0');
+ }
+ out.push_str(&prefix);
+
+ for digit in digits.into_iter().rev() {
+ let ch = NUMBERS[digit as usize] as char;
+ out.push(if caps { ch.to_ascii_uppercase() } else { ch });
+ }
+}
+
+pub fn render_decimal(
+ out: &mut String,
+ iv: i64,
+ padding: usize,
+ precision: usize,
+ blank: bool,
+ sign: bool,
+) {
+ render_integer(out, iv, padding, precision, blank, sign, 10, "", false)
+}
+pub fn render_octal(
+ out: &mut String,
+ iv: i64,
+ padding: usize,
+ precision: usize,
+ alt: bool,
+ blank: bool,
+ sign: bool,
+) {
+ render_integer(
+ out,
+ iv,
+ padding,
+ precision,
+ blank,
+ sign,
+ 8,
+ if alt && iv != 0 { "0" } else { "" },
+ false,
+ )
+}
+pub fn render_hexadecimal(
+ out: &mut String,
+ iv: i64,
+ padding: usize,
+ precision: usize,
+ alt: bool,
+ blank: bool,
+ sign: bool,
+ caps: bool,
+) {
+ render_integer(
+ out,
+ iv,
+ padding,
+ precision,
+ blank,
+ sign,
+ 16,
+ match (alt, caps) {
+ (true, true) => "0X",
+ (true, false) => "0x",
+ (false, _) => "",
+ },
+ caps,
+ )
+}
+
+pub fn render_float(
+ out: &mut String,
+ n: f64,
+ mut padding: usize,
+ precision: usize,
+ blank: bool,
+ sign: bool,
+ ensure_pt: bool,
+ trailing: bool,
+) {
+ let dot_size = if precision == 0 && !ensure_pt { 0 } else { 1 };
+ padding = padding.saturating_sub(dot_size + precision);
+ render_decimal(out, n.floor() as i64, padding, 0, blank, sign);
+ if precision == 0 {
+ if ensure_pt {
+ out.push('.');
+ }
+ return;
+ }
+ let frac = (n.fract() * 10.0_f64.powf(precision as f64) + 0.5).floor();
+ if trailing || frac > 0.0 {
+ out.push('.');
+ let mut frac_str = String::new();
+ render_decimal(&mut frac_str, frac as i64, precision, 0, false, false);
+ let mut trim = frac_str.len();
+ if !trailing {
+ for b in frac_str.as_bytes().iter().rev() {
+ if *b == b'0' {
+ trim -= 1;
+ }
+ }
+ }
+ out.push_str(&frac_str[..trim]);
+ } else if ensure_pt {
+ out.push('.');
+ }
+}
+
+pub fn render_float_sci(
+ out: &mut String,
+ n: f64,
+ mut padding: usize,
+ precision: usize,
+ blank: bool,
+ sign: bool,
+ ensure_pt: bool,
+ trailing: bool,
+ caps: bool,
+) {
+ let exponent = n.log10().floor();
+ let mantissa = if exponent as i16 == -324 {
+ n * 10.0 / 10.0_f64.powf(exponent + 1.0)
+ } else {
+ n / 10.0_f64.powf(exponent)
+ };
+ let mut exponent_str = String::new();
+ render_decimal(&mut exponent_str, exponent as i64, 3, 0, false, true);
+
+ // +1 for e
+ padding = padding.saturating_sub(exponent_str.len() + 1);
+
+ render_float(
+ out, mantissa, padding, precision, blank, sign, ensure_pt, trailing,
+ );
+ out.push(if caps { 'E' } else { 'e' });
+ out.push_str(&exponent_str);
+}
+
+pub fn format_code(
+ out: &mut String,
+ value: &Val,
+ code: &Code,
+ width: usize,
+ precision: Option<usize>,
+) -> Result<(), FormatError> {
+ let clfags = &code.cflags;
+ let (fpprec, iprec) = match precision {
+ Some(v) => (v, v),
+ None => (6, 0),
+ };
+ let padding = if clfags.zero && !clfags.left {
+ width
+ } else {
+ 0
+ };
+
+ // TODO: If left padded, can optimize by writing directly to out
+ let mut tmp_out = String::new();
+
+ match code.convtype {
+ ConvTypeV::String => tmp_out.push_str(&to_string(value)?),
+ ConvTypeV::Decimal => {
+ let value = value.clone().try_cast_num("%d/%u/%i requires number")?;
+ render_decimal(
+ &mut tmp_out,
+ value as i64,
+ padding,
+ iprec,
+ clfags.blank,
+ clfags.sign,
+ );
+ }
+ ConvTypeV::Octal => {
+ let value = value.clone().try_cast_num("%o requires number")?;
+ render_octal(
+ &mut tmp_out,
+ value as i64,
+ padding,
+ iprec,
+ clfags.alt,
+ clfags.blank,
+ clfags.sign,
+ );
+ }
+ ConvTypeV::Hexadecimal => {
+ let value = value.clone().try_cast_num("%x/%X requires number")?;
+ render_hexadecimal(
+ &mut tmp_out,
+ value as i64,
+ padding,
+ iprec,
+ clfags.alt,
+ clfags.blank,
+ clfags.sign,
+ code.caps,
+ );
+ }
+ ConvTypeV::Scientific => {
+ let value = value.clone().try_cast_num("%e/%E requires number")?;
+ render_float_sci(
+ &mut tmp_out,
+ value,
+ padding,
+ fpprec,
+ clfags.blank,
+ clfags.sign,
+ clfags.alt,
+ true,
+ code.caps,
+ );
+ }
+ ConvTypeV::Float => {
+ let value = value.clone().try_cast_num("%e/%E requires number")?;
+ render_float(
+ &mut tmp_out,
+ value,
+ padding,
+ fpprec,
+ clfags.blank,
+ clfags.sign,
+ clfags.alt,
+ true,
+ );
+ }
+ ConvTypeV::Shorter => {
+ let value = value.clone().try_cast_num("%g/%G requires number")?;
+ let exponent = value.log10().floor();
+ if exponent < -4.0 || exponent >= fpprec as f64 {
+ render_float_sci(
+ &mut tmp_out,
+ value,
+ padding,
+ fpprec - 1,
+ clfags.blank,
+ clfags.sign,
+ clfags.alt,
+ clfags.alt,
+ code.caps,
+ );
+ } else {
+ let digits_before_pt = 1.max(exponent as usize + 1);
+ render_float(
+ &mut tmp_out,
+ value,
+ padding,
+ fpprec - digits_before_pt,
+ clfags.blank,
+ clfags.sign,
+ clfags.alt,
+ clfags.alt,
+ );
+ }
+ }
+ ConvTypeV::Char => match value.clone().unwrap_if_lazy()? {
+ Val::Num(n) => tmp_out.push(
+ std::char::from_u32(n as u32)
+ .ok_or_else(|| create_error(Error::InvalidUnicodeCodepointGot(n as u32)))?,
+ ),
+ Val::Str(s) => {
+ if s.chars().count() != 1 {
+ create_error_result(Error::RuntimeError(
+ format!("%c expected 1 char string, got {}", s.chars().count()).into(),
+ ))?;
+ }
+ tmp_out.push_str(&s);
+ }
+ _ => {
+ create_error_result(Error::TypeMismatch(
+ "%c requires number/string",
+ vec![ValType::Num, ValType::Str],
+ value.value_type()?,
+ ))?;
+ }
+ },
+ ConvTypeV::Percent => tmp_out.push('%'),
+ };
+
+ let padding = width.saturating_sub(tmp_out.len());
+
+ if !clfags.left {
+ for _ in 0..padding {
+ out.push(' ');
+ }
+ }
+ out.push_str(&tmp_out);
+ if clfags.left {
+ for _ in 0..padding {
+ out.push(' ');
+ }
+ }
+
+ Ok(())
+}
+
+pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String, FormatError> {
+ let codes = parse_codes(&str)?;
+ let mut out = String::new();
+
+ for code in codes {
+ match code {
+ Element::String(s) => {
+ out.push_str(s);
+ }
+ Element::Code(c) => {
+ let width = match c.width {
+ Width::Star => {
+ if values.is_empty() {
+ return Err(FormatError::NotEnoughValues);
+ }
+ let value = &values[0];
+ values = &values[1..];
+ value.clone().try_cast_num("field width")? as usize
+ }
+ Width::Fixed(n) => n,
+ };
+ let precision = match c.precision {
+ Some(Width::Star) => {
+ if values.is_empty() {
+ return Err(FormatError::NotEnoughValues);
+ }
+ let value = &values[0];
+ values = &values[1..];
+ Some(value.clone().try_cast_num("field precision")? as usize)
+ }
+ Some(Width::Fixed(n)) => Some(n),
+ None => None,
+ };
+ if values.is_empty() {
+ return Err(FormatError::NotEnoughValues);
+ }
+ let value = &values[0];
+ values = &values[1..];
+
+ format_code(&mut out, value, &c, width, precision)?;
+ }
+ }
+ }
+
+ Ok(out)
+}
+
+pub fn format_obj(str: &str, values: &ObjValue) -> Result<String, FormatError> {
+ let codes = parse_codes(&str)?;
+ let mut out = String::new();
+
+ for code in codes {
+ match code {
+ Element::String(s) => {
+ out.push_str(s);
+ }
+ Element::Code(c) => {
+ // TODO: Operate on ref
+ let f: Rc<str> = c.mkey.into();
+ if f.is_empty() {
+ return Err(FormatError::MappingKeysRequired);
+ }
+ let width = match c.width {
+ Width::Star => {
+ return Err(FormatError::CannotUseStarWidthWithObject);
+ }
+ Width::Fixed(n) => n,
+ };
+ let precision = match c.precision {
+ Some(Width::Star) => {
+ return Err(FormatError::CannotUseStarWidthWithObject);
+ }
+ Some(Width::Fixed(n)) => Some(n),
+ None => None,
+ };
+ let value = if let Some(v) = values.get(f.clone())? {
+ v
+ } else {
+ return Err(FormatError::NoSuchField(f));
+ };
+
+ format_code(&mut out, &value, &c, width, precision)?;
+ }
+ }
+ }
+
+ Ok(out)
+}
+
+#[cfg(test)]
+pub mod test_format {
+ use super::*;
+
+ #[test]
+ fn parse() {
+ println!("{:?}", parse_codes("Hello %s world!!! %s %(aaa)s ww"));
+ }
+
+ #[test]
+ fn octals() {
+ assert_eq!(format_arr("%#o", &[Val::Num(8.0)]).unwrap(), "010");
+ assert_eq!(format_arr("%#4o", &[Val::Num(8.0)]).unwrap(), " 010");
+ assert_eq!(format_arr("%4o", &[Val::Num(8.0)]).unwrap(), " 10");
+ assert_eq!(format_arr("%04o", &[Val::Num(8.0)]).unwrap(), "0010");
+ assert_eq!(format_arr("%+4o", &[Val::Num(8.0)]).unwrap(), " +10");
+ assert_eq!(format_arr("%+04o", &[Val::Num(8.0)]).unwrap(), "+010");
+ assert_eq!(format_arr("%-4o", &[Val::Num(8.0)]).unwrap(), "10 ");
+ assert_eq!(format_arr("%+-4o", &[Val::Num(8.0)]).unwrap(), "+10 ");
+ assert_eq!(format_arr("%+-04o", &[Val::Num(8.0)]).unwrap(), "+10 ");
+ }
+}
crates/jrsonnet-evaluator/src/builtin/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/builtin/mod.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/mod.rs
@@ -1,2 +1,4 @@
pub mod stdlib;
pub use stdlib::*;
+
+pub mod format;
crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -60,6 +60,7 @@
StringManifestOutputIsNotAString,
ImportCallbackError(String),
+ InvalidUnicodeCodepointGot(u32),
}
#[derive(Clone, Debug)]
crates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth1use crate::{2 builtin::format::{format_arr, format_obj},3 context_creator, create_error, create_error_result, equals, escape_string_json, future_wrapper,4 lazy_val, manifest_json_ex, parse_args, primitive_equals, push, with_state, Context,5 ContextCreator, Error, FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,6 ValType,7};8use closure::closure;9use jrsonnet_parser::{10 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,11 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,12 Visibility,13};14use std::{cmp::Ordering, collections::HashMap, rc::Rc};1516pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {17 let b = b.clone();18 if let Some(params) = &b.params {19 let params = params.clone();20 (21 b.name.clone(),22 LazyBinding::Bindable(Rc::new(move |this, super_obj| {23 Ok(lazy_val!(24 closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(25 context_creator.0(this.clone(), super_obj.clone())?,26 b.name.clone(),27 params.clone(),28 b.value.clone(),29 )))30 ))31 })),32 )33 } else {34 (35 b.name.clone(),36 LazyBinding::Bindable(Rc::new(move |this, super_obj| {37 Ok(lazy_val!(closure!(clone context_creator, clone b, ||38 evaluate_named(39 context_creator.0(this.clone(), super_obj.clone())?,40 &b.value,41 b.name.clone()42 )43 )))44 })),45 )46 }47}4849pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {50 Val::Func(Rc::new(FuncDesc {51 name,52 ctx,53 params,54 body,55 }))56}5758pub fn evaluate_field_name(59 context: Context,60 field_name: &jrsonnet_parser::FieldName,61) -> Result<Option<Rc<str>>> {62 Ok(match field_name {63 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),64 jrsonnet_parser::FieldName::Dyn(expr) => {65 let lazy = evaluate(context, expr)?;66 let value = lazy.unwrap_if_lazy()?;67 if matches!(value, Val::Null) {68 None69 } else {70 Some(value.try_cast_str("dynamic field name")?)71 }72 }73 })74}7576pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {77 Ok(match (op, b) {78 (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,79 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),80 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),81 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),82 (op, o) => create_error_result(Error::UnaryOperatorDoesNotOperateOnType(83 op,84 o.value_type()?,85 ))?,86 })87}8889pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {90 Ok(match (a, b) {91 (Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),9293 // Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)94 (Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),95 (Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),9697 (Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),98 (o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),99100 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),101 (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),102 (Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,103 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(104 BinaryOpType::Add,105 a.value_type()?,106 b.value_type()?,107 ))?,108 })109}110111pub fn evaluate_binary_op_special(112 context: Context,113 a: &LocExpr,114 op: BinaryOpType,115 b: &LocExpr,116) -> Result<Val> {117 Ok(118 match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {119 (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),120 (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),121 (a, op, eb) => {122 evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?123 }124 },125 )126}127128pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {129 Ok(match (a, op, b) {130 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,131132 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),133134 // Bool X Bool135 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),136 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),137138 // Str X Str139 (Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),140 (Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),141 (Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),142 (Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),143144 // Num X Num145 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,146 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {147 if *v2 <= f64::EPSILON {148 create_error_result(crate::Error::DivisionByZero)?149 }150 Val::new_checked_num(v1 / v2)?151 }152153 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,154155 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),156 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),157 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),158 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),159160 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {161 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)162 }163 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {164 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)165 }166 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {167 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)168 }169 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {170 if *v2 < 0.0 {171 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?172 }173 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)174 }175 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {176 if *v2 < 0.0 {177 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?178 }179 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)180 }181182 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(183 op,184 a.value_type()?,185 b.value_type()?,186 ))?,187 })188}189190future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);191future_wrapper!(ObjValue, FutureObjValue);192193pub fn evaluate_comp<T>(194 context: Context,195 value: &impl Fn(Context) -> Result<T>,196 specs: &[CompSpec],197) -> Result<Option<Vec<T>>> {198 Ok(match specs.get(0) {199 None => Some(vec![value(context)?]),200 Some(CompSpec::IfSpec(IfSpecData(cond))) => {201 if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {202 evaluate_comp(context, value, &specs[1..])?203 } else {204 None205 }206 }207 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {208 match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {209 Val::Arr(list) => {210 let mut out = Vec::new();211 for item in list.iter() {212 let item = item.unwrap_if_lazy()?;213 out.push(evaluate_comp(214 context.with_var(var.clone(), item.clone())?,215 value,216 &specs[1..],217 )?);218 }219 Some(out.into_iter().flatten().flatten().collect())220 }221 _ => create_error_result(Error::InComprehensionCanOnlyIterateOverArray)?,222 }223 }224 })225}226227pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {228 let new_bindings = FutureNewBindings::new();229 let future_this = FutureObjValue::new();230 let context_creator = context_creator!(231 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {232 Ok(context.extend_unbound(233 new_bindings.clone().unwrap(),234 context.dollar().clone().or_else(||this.clone()),235 Some(this.unwrap()),236 super_obj237 )?)238 })239 );240 {241 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();242 for (n, b) in members243 .iter()244 .filter_map(|m| match m {245 Member::BindStmt(b) => Some(b.clone()),246 _ => None,247 })248 .map(|b| evaluate_binding(&b, context_creator.clone()))249 {250 bindings.insert(n, b);251 }252 new_bindings.fill(bindings);253 }254255 let mut new_members = HashMap::new();256 for member in members.iter() {257 match member {258 Member::Field(FieldMember {259 name,260 plus,261 params: None,262 visibility,263 value,264 }) => {265 let name = evaluate_field_name(context.clone(), &name)?;266 if name.is_none() {267 continue;268 }269 let name = name.unwrap();270 new_members.insert(271 name.clone(),272 ObjMember {273 add: *plus,274 visibility: *visibility,275 invoke: LazyBinding::Bindable(Rc::new(276 closure!(clone name, clone value, clone context_creator, |this, super_obj| {277 Ok(LazyVal::new_resolved(evaluate(278 context_creator.0(this, super_obj)?,279 &value,280 )?))281 }),282 )),283 location: value.1.clone(),284 },285 );286 }287 Member::Field(FieldMember {288 name,289 params: Some(params),290 value,291 ..292 }) => {293 let name = evaluate_field_name(context.clone(), &name)?;294 if name.is_none() {295 continue;296 }297 let name = name.unwrap();298 new_members.insert(299 name.clone(),300 ObjMember {301 add: false,302 visibility: Visibility::Hidden,303 invoke: LazyBinding::Bindable(Rc::new(304 closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {305 // TODO: Assert306 Ok(LazyVal::new_resolved(evaluate_method(307 context_creator.0(this, super_obj)?,308 name.clone(),309 params.clone(),310 value.clone(),311 )))312 }),313 )),314 location: value.1.clone(),315 },316 );317 }318 Member::BindStmt(_) => {}319 Member::AssertStmt(_) => {}320 }321 }322 Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))323}324325pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {326 Ok(match object {327 ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,328 ObjBody::ObjComp(obj) => {329 let future_this = FutureObjValue::new();330 let mut new_members = HashMap::new();331 for (k, v) in evaluate_comp(332 context.clone(),333 &|ctx| {334 let new_bindings = FutureNewBindings::new();335 let context_creator = context_creator!(336 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {337 Ok(context.extend_unbound(338 new_bindings.clone().unwrap(),339 context.dollar().clone().or_else(||this.clone()),340 None,341 super_obj342 )?)343 })344 );345 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();346 for (n, b) in obj347 .pre_locals348 .iter()349 .chain(obj.post_locals.iter())350 .map(|b| evaluate_binding(b, context_creator.clone()))351 {352 bindings.insert(n, b);353 }354 let bindings = new_bindings.fill(bindings);355 let ctx = ctx.extend_unbound(bindings, None, None, None)?;356 let key = evaluate(ctx.clone(), &obj.key)?;357 let value = LazyBinding::Bindable(Rc::new(358 closure!(clone ctx, clone obj.value, |this, _super_obj| {359 Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))360 }),361 ));362363 Ok((key, value))364 },365 &obj.compspecs,366 )?367 .unwrap()368 {369 match k {370 Val::Null => {}371 Val::Str(n) => {372 new_members.insert(373 n,374 ObjMember {375 add: false,376 visibility: Visibility::Normal,377 invoke: v,378 location: obj.value.1.clone(),379 },380 );381 }382 v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,383 }384 }385386 future_this.fill(ObjValue::new(None, Rc::new(new_members)))387 }388 })389}390391/// Extracts code block and disables inlining for them392/// Fixes WASM to java bytecode compilation failing because of very large method393macro_rules! noinline {394 ($e:expr) => {395 (#[inline(never)]396 move || $e)()397 };398}399400pub fn evaluate_apply(401 context: Context,402 value: &LocExpr,403 args: &ArgsDesc,404 loc: &Option<ExprLocation>,405 tailstrict: bool,406) -> Result<Val> {407 let lazy = evaluate(context.clone(), value)?;408 let value = lazy.unwrap_if_lazy()?;409 Ok(match value {410 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {411 // arr/string/function412 ("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [413 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];414 ], {415 Ok(match x {416 Val::Str(n) => Val::Num(n.chars().count() as f64),417 Val::Arr(i) => Val::Num(i.len() as f64),418 Val::Obj(o) => Val::Num(419 o.fields_visibility()420 .into_iter()421 .filter(|(_k, v)| *v)422 .count() as f64,423 ),424 _ => unreachable!(),425 })426 }))?,427 // any428 ("std", "type") => parse_args!(context, "std.type", args, 1, [429 0, x, vec![];430 ], {431 Val::Str(x.value_type()?.name().into())432 }),433 // length, idx=>any434 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [435 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];436 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];437 ], {438 if sz < 0.0 {439 create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;440 }441 let mut out = Vec::with_capacity(sz as usize);442 for i in 0..sz as usize {443 out.push(func.evaluate_values(444 Context::new(),445 &[Val::Num(i as f64)]446 )?)447 }448 Ok(Val::Arr(Rc::new(out)))449 }))?,450 // string451 ("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [452 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];453 ], {454 assert!(455 str.chars().count() == 1,456 "std.codepoint should receive single char string"457 );458 Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)459 }),460 // object, includeHidden461 ("std", "objectFieldsEx") => {462 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [463 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];464 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];465 ], {466 let mut out = obj.fields_visibility()467 .into_iter()468 .filter(|(_k, v)| *v || inc_hidden)469 .map(|(k, _v)|k)470 .collect::<Vec<_>>();471 out.sort();472 Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))473 }))?474 }475 // object, field, includeHidden476 ("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [477 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];478 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];479 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];480 ], {481 Val::Bool(482 obj.fields_visibility()483 .into_iter()484 .filter(|(_k, v)| *v || inc_hidden)485 .any(|(k, _v)| *k == *f),486 )487 }),488 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [489 0, a, vec![];490 1, b, vec![];491 ], {492 Val::Bool(primitive_equals(&a, &b)?)493 }),494 // faster495 ("std", "equals") => parse_args!(context, "std.equals", args, 2, [496 0, a, vec![];497 1, b, vec![];498 ], {499 Val::Bool(equals(&a, &b)?)500 }),501 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [502 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];503 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];504 ], {505 Val::Num(a % b)506 }),507 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [508 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];509 ], {510 Val::Num(x.floor())511 }),512 ("std", "log") => parse_args!(context, "std.log", args, 2, [513 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];514 ], {515 Val::Num(n.ln())516 }),517 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [518 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];519 1, rest, vec![];520 ], {521 eprint!("TRACE:");522 if let Some(loc) = loc {523 with_state(|s|{524 let locs = s.map_source_locations(&loc.0, &[loc.1]);525 eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);526 });527 }528 eprintln!(" {}", str);529 rest530 }),531 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [532 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];533 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];534 ], {535 Val::Num(x.powf(n))536 }),537 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [538 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];539 ], {540 with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(541 || create_error(crate::Error::UndefinedExternalVariable(x)),542 )?543 }),544 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [545 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];546 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];547 ], {548 Ok(Val::Arr(Rc::new(549 arr.iter()550 .cloned()551 .filter(|e| {552 func553 .evaluate_values(context.clone(), &[e.clone()])554 .unwrap()555 .try_cast_bool("filter predicate")556 .unwrap()557 })558 .collect(),559 )))560 }))?,561 // faster562 ("std", "foldl") => noinline!(parse_args!(context, "std.foldl", args, 3, [563 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];564 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];565 2, init, vec![];566 ], {567 let mut acc = init;568 for i in arr.iter().cloned() {569 acc = func.evaluate_values(context.clone(), &[acc, i])?;570 }571 Ok(acc)572 }))?,573 // faster574 ("std", "foldr") => noinline!(parse_args!(context, "std.foldr", args, 3, [575 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];576 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];577 2, init, vec![];578 ], {579 let mut acc = init;580 for i in arr.iter().rev().cloned() {581 acc = func.evaluate_values(context.clone(), &[acc, i])?;582 }583 Ok(acc)584 }))?,585 // faster586 ("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [587 0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];588 1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];589 ], {590 if arr.len() <= 1 {591 return Ok(Val::Arr(arr))592 }593 let mut new_arr = arr.iter().cloned().collect::<Vec<_>>();594 match keyF.evaluate_values(context.clone(), &[new_arr[0].clone()])? {595 Val::Str(_) => {596 let mut err = None;597 new_arr.sort_by_cached_key(|k| {598 match keyF.evaluate_values(context.clone(), &[k.clone()]) {599 Ok(Val::Str(v)) => v,600 Ok(_) => {601 err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));602 "".into()603 }604 Err(e) => {605 err = Some(e);606 "".into()607 }608 }609 });610 if let Some(e) = err {611 return Err(e);612 }613 },614 Val::Num(_) => {615 let mut err = None;616 new_arr.sort_unstable_by(|a, b| {617 match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {618 (Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),619 (Ok(_a), Ok(_b)) => {620 err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));621 Ordering::Equal622 }623 (Err(e), _) | (_, Err(e)) => {624 err = Some(e);625 Ordering::Equal626 }627 }628 });629 if let Some(e) = err {630 return Err(e);631 }632 },633 _ => return Err(create_error(crate::error::Error::RuntimeError("keys should be number or string".into())))634 }635 Ok(Val::Arr(Rc::new(new_arr)))636 }))?,637 // faster638 ("std", "format") => parse_args!(context, "std.format", args, 2, [639 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];640 1, vals: [Val::Arr|Val::Obj], vec![ValType::Arr, ValType::Obj];641 ], {642 match vals {643 Val::Arr(vals) => Val::Str(format_arr(&str, &vals).unwrap().into()),644 Val::Obj(obj) => Val::Str(format_obj(&str, &obj).unwrap().into()),645 _ => unreachable!()646 }647 }),648 // faster649 ("std", "range") => parse_args!(context, "std.range", args, 2, [650 0, from: [Val::Num]!!Val::Num, vec![ValType::Num];651 0, to: [Val::Num]!!Val::Num, vec![ValType::Num];652 ], {653 let mut out = Vec::with_capacity((1+to as usize-from as usize).max(0));654 for i in from as usize..=to as usize {655 out.push(Val::Num(i as f64));656 }657 Val::Arr(Rc::new(out))658 }),659 ("std", "char") => parse_args!(context, "std.char", args, 1, [660 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];661 ], {662 let mut out = String::new();663 out.push(std::char::from_u32(n as u32).ok_or_else(||664 create_error(crate::error::Error::InvalidUnicodeCodepointGot(n as u32))665 )?);666 Ok(Val::Str(out.into()))667 })?,668 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [669 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];670 ], {671 Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))672 }),673 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [674 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];675 ], {676 Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))677 }))?,678 // faster679 ("std", "base64") => parse_args!(context, "std.base64", args, 1, [680 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];681 ], {682 Val::Str(match input {683 Val::Str(s) => {684 base64::encode(s.bytes().collect::<Vec<_>>()).into()685 },686 Val::Arr(a) => {687 base64::encode(a.iter().map(|v| {688 Ok(v.clone().try_cast_num("base64 array")? as u8)689 }).collect::<Result<Vec<_>>>()?).into()690 },691 _ => unreachable!()692 })693 }),694 // faster695 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [696 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];697 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];698 ], {699 Ok(match sep {700 Val::Arr(joiner_items) => {701 let mut out = Vec::new();702703 let mut first = true;704 for item in arr.iter().cloned() {705 if let Val::Arr(items) = item.unwrap_if_lazy()? {706 if !first {707 out.reserve(joiner_items.len());708 out.extend(joiner_items.iter().cloned());709 }710 first = false;711 out.reserve(items.len());712 out.extend(items.iter().cloned());713 } else {714 create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;715 }716 }717718 Val::Arr(Rc::new(out))719 },720 Val::Str(sep) => {721 let mut out = String::new();722723 let mut first = true;724 for item in arr.iter().cloned() {725 if let Val::Str(item) = item.unwrap_if_lazy()? {726 if !first {727 out += &sep;728 }729 first = false;730 out += &item;731 } else {732 create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;733 }734 }735736 Val::Str(out.into())737 },738 _ => unreachable!()739 })740 }))?,741 // Faster742 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [743 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];744 ], {745 Val::Str(escape_string_json(&str_).into())746 }),747 // Faster748 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [749 0, value, vec![];750 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];751 ], {752 Val::Str(manifest_json_ex(&value, &indent)?.into())753 }),754 (ns, name) => {755 create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?756 }757 },758 Val::Func(f) => {759 let body = || f.evaluate(context, args, tailstrict);760 if tailstrict {761 body()?762 } else {763 push(loc, || format!("function <{}> call", f.name), body)?764 }765 }766 v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,767 })768}769770pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: Rc<str>) -> Result<Val> {771 use Expr::*;772 let LocExpr(expr, _loc) = lexpr;773 Ok(match &**expr {774 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),775 _ => evaluate(context, lexpr)?,776 })777}778779pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {780 use Expr::*;781 let LocExpr(expr, loc) = expr;782 Ok(match &**expr {783 Literal(LiteralType::This) => Val::Obj(784 context785 .this()786 .clone()787 .ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,788 ),789 Literal(LiteralType::Dollar) => Val::Obj(790 context791 .dollar()792 .clone()793 .ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,794 ),795 Literal(LiteralType::True) => Val::Bool(true),796 Literal(LiteralType::False) => Val::Bool(false),797 Literal(LiteralType::Null) => Val::Null,798 Parened(e) => evaluate(context, e)?,799 Str(v) => Val::Str(v.clone()),800 Num(v) => Val::new_checked_num(*v)?,801 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,802 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,803 Var(name) => push(804 loc,805 || format!("variable <{}>", name),806 || Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),807 )?,808 Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {809 let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;810 context811 .super_obj()812 .clone()813 .expect("no super found")814 .get_raw(name, &context.this().clone().expect("no this found"))?815 .expect("value not found")816 }817 Index(value, index) => {818 match (819 evaluate(context.clone(), value)?.unwrap_if_lazy()?,820 evaluate(context, index)?,821 ) {822 (Val::Obj(v), Val::Str(s)) => {823 if let Some(v) = v.get(s.clone())? {824 v.unwrap_if_lazy()?825 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {826 Val::Intristic(n, s)827 } else {828 create_error_result(crate::Error::NoSuchField(s))?829 }830 }831 (Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(832 ValType::Obj,833 ValType::Str,834 n.value_type()?,835 ))?,836837 (Val::Arr(v), Val::Num(n)) => {838 if n.fract() > f64::EPSILON {839 create_error_result(crate::Error::FractionalIndex)?840 }841 v.get(n as usize)842 .ok_or_else(|| {843 create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))844 })?845 .clone()846 .unwrap_if_lazy()?847 }848 (Val::Arr(_), Val::Str(n)) => {849 create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?850 }851 (Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(852 ValType::Arr,853 ValType::Num,854 n.value_type()?,855 ))?,856857 (Val::Str(s), Val::Num(n)) => Val::Str(858 s.chars()859 .skip(n as usize)860 .take(1)861 .collect::<String>()862 .into(),863 ),864 (Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(865 ValType::Str,866 ValType::Num,867 n.value_type()?,868 ))?,869870 (v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,871 }872 }873 LocalExpr(bindings, returned) => {874 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();875 let future_context = Context::new_future();876877 let context_creator = context_creator!(878 closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))879 );880881 for (k, v) in bindings882 .iter()883 .map(|b| evaluate_binding(b, context_creator.clone()))884 {885 new_bindings.insert(k, v);886 }887888 let context = context889 .extend_unbound(new_bindings, None, None, None)?890 .into_future(future_context);891 evaluate(context, &returned.clone())?892 }893 Arr(items) => {894 let mut out = Vec::with_capacity(items.len());895 for item in items {896 out.push(Val::Lazy(lazy_val!(897 closure!(clone context, clone item, || {898 evaluate(context.clone(), &item)899 })900 )));901 }902 Val::Arr(Rc::new(out))903 }904 ArrComp(expr, compspecs) => Val::Arr(905 // First compspec should be forspec, so no "None" possible here906 Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),907 ),908 Obj(body) => Val::Obj(evaluate_object(context, body)?),909 ObjExtend(s, t) => evaluate_add_op(910 &evaluate(context.clone(), s)?,911 &Val::Obj(evaluate_object(context, t)?),912 )?,913 Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,914 Function(params, body) => {915 evaluate_method(context, "anonymous".into(), params.clone(), body.clone())916 }917 AssertExpr(AssertStmt(value, msg), returned) => {918 let assertion_result = push(919 &value.1,920 || "assertion condition".to_owned(),921 || {922 evaluate(context.clone(), &value)?923 .try_cast_bool("assertion condition should be boolean")924 },925 )?;926 if assertion_result {927 evaluate(context, returned)?928 } else if let Some(msg) = msg {929 create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?930 } else {931 create_error_result(crate::Error::AssertionFailed(Val::Null))?932 }933 }934 Error(e) => push(935 &loc,936 || "error statement".to_owned(),937 || {938 create_error_result(crate::Error::RuntimeError(939 evaluate(context, e)?.try_cast_str("error text should be string")?,940 ))?941 },942 )?,943 IfElse {944 cond,945 cond_then,946 cond_else,947 } => {948 if evaluate(context.clone(), &cond.0)?949 .try_cast_bool("if condition should be boolean")?950 {951 evaluate(context, cond_then)?952 } else {953 match cond_else {954 Some(v) => evaluate(context, v)?,955 None => Val::Null,956 }957 }958 }959 Import(path) => {960 let mut tmp = loc961 .clone()962 .expect("imports can't be used without loc_data")963 .0;964 let import_location = Rc::make_mut(&mut tmp);965 import_location.pop();966 push(967 loc,968 || format!("import {:?}", path),969 || with_state(|s| s.import_file(&import_location, path)),970 )?971 }972 ImportStr(path) => {973 let mut tmp = loc974 .clone()975 .expect("imports can't be used without loc_data")976 .0;977 let import_location = Rc::make_mut(&mut tmp);978 import_location.pop();979 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)980 }981 Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),982 })983}crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -405,6 +405,15 @@
out
}
+pub fn to_string(val: &Val) -> Result<Rc<str>> {
+ Ok(match val {
+ Val::Bool(true) => "true".into(),
+ Val::Null => "null".into(),
+ Val::Str(s) => s.clone(),
+ v => v.clone().into_json(0)?,
+ })
+}
+
#[test]
fn json_test() {
assert_eq!(escape_string_json("\u{001f}"), "\"\\u001f\"")