git.delta.rocks / jrsonnet / refs/commits / 11643ec5f009

86	}86	}
87}87}
8888
89#[allow(clippy::struct_excessive_bools)]
89#[derive(Default, Debug)]90#[derive(Default, Debug)]
90pub struct CFlags {91pub struct CFlags {
91	pub alt: bool,92	pub alt: bool,
270			return Ok(out);271			return Ok(out);
271		}272		}
272		str = &str[offset + 1..];273		str = &str[offset + 1..];
273		let (code, nstr) = parse_code(str)?;274		let code;
274		str = nstr;275		(code, str) = parse_code(str)?;
275		bytes = str.as_bytes();276		bytes = str.as_bytes();
276		offset = 0;277		offset = 0;
277278
278		out.push(Element::Code(code))279		out.push(Element::Code(code));
279	}280	}
280}281}
281282
313		.saturating_sub(prefix.len() + digits.len());314		.saturating_sub(prefix.len() + digits.len());
314315
315	if neg {316	if neg {
316		out.push('-')317		out.push('-');
317	} else if sign {318	} else if sign {
318		out.push('+');319		out.push('+');
319	} else if blank {320	} else if blank {
340	blank: bool,341	blank: bool,
341	sign: bool,342	sign: bool,
342) {343) {
343	render_integer(out, iv, padding, precision, blank, sign, 10, "", false)344	render_integer(out, iv, padding, precision, blank, sign, 10, "", false);
344}345}
345pub fn render_octal(346pub fn render_octal(
346	out: &mut String,347	out: &mut String,
361		8,362		8,
362		if alt && iv != 0 { "0" } else { "" },363		if alt && iv != 0 { "0" } else { "" },
363		false,364		false,
364	)365	);
365}366}
367
368#[allow(clippy::fn_params_excessive_bools)]
366pub fn render_hexadecimal(369pub fn render_hexadecimal(
367	out: &mut String,370	out: &mut String,
368	iv: i64,371	iv: i64,
387			(false, _) => "",390			(false, _) => "",
388		},391		},
389		caps,392		caps,
390	)393	);
391}394}
392395
396#[allow(clippy::fn_params_excessive_bools)]
393pub fn render_float(397pub fn render_float(
394	out: &mut String,398	out: &mut String,
395	n: f64,399	n: f64,
431	}435	}
432}436}
433437
438#[allow(clippy::fn_params_excessive_bools)]
434pub fn render_float_sci(439pub fn render_float_sci(
435	out: &mut String,440	out: &mut String,
436	n: f64,441	n: f64,
461	out.push_str(&exponent_str);466	out.push_str(&exponent_str);
462}467}
463468
469#[allow(clippy::too_many_lines)]
464pub fn format_code(470pub fn format_code(
465	s: State,471	s: State,
466	out: &mut String,472	out: &mut String,

158			'\r' => buf.push_str("\\r"),158			'\r' => buf.push_str("\\r"),
159			'\t' => buf.push_str("\\t"),159			'\t' => buf.push_str("\\t"),
160			c if c < 32 as char || (c >= 127 as char && c <= 159 as char) => {160			c if c < 32 as char || (c >= 127 as char && c <= 159 as char) => {
161				write!(buf, "\\u{:04x}", c as u32).unwrap()161				write!(buf, "\\u{:04x}", c as u32).unwrap();
162			}162			}
163			c => buf.push(c),163			c => buf.push(c),
164		}164		}
194	pub preserve_order: bool,194	pub preserve_order: bool,
195}195}
196196
197/// From https://github.com/chyh1990/yaml-rust/blob/da52a68615f2ecdd6b7e4567019f280c433c1521/src/emitter.rs#L289197/// From <https://github.com/chyh1990/yaml-rust/blob/da52a68615f2ecdd6b7e4567019f280c433c1521/src/emitter.rs#L289>
198/// With added date check198/// With added date check
199fn yaml_needs_quotes(string: &str) -> bool {199fn yaml_needs_quotes(string: &str) -> bool {
200	fn need_quotes_spaces(string: &str) -> bool {200	fn need_quotes_spaces(string: &str) -> bool {
228	Ok(out)228	Ok(out)
229}229}
230
231#[allow(clippy::too_many_lines)]
230fn manifest_yaml_ex_buf(232fn manifest_yaml_ex_buf(
231	s: State,233	s: State,
232	val: &Val,234	val: &Val,
238	match val {240	match val {
239		Val::Bool(v) => {241		Val::Bool(v) => {
240			if *v {242			if *v {
241				buf.push_str("true")243				buf.push_str("true");
242			} else {244			} else {
243				buf.push_str("false")245				buf.push_str("false");
244			}246			}
245		}247		}
246		Val::Null => buf.push_str("null"),248		Val::Null => buf.push_str("null"),

1// All builtins should return results
2#![allow(clippy::unnecessary_wraps)]
3
1use std::collections::HashMap;4use std::collections::HashMap;
25
173fn builtin_make_array(s: State, sz: usize, func: FuncVal) -> Result<VecVal> {176fn builtin_make_array(s: State, sz: usize, func: FuncVal) -> Result<VecVal> {
174	let mut out = Vec::with_capacity(sz);177	let mut out = Vec::with_capacity(sz);
175	for i in 0..sz {178	for i in 0..sz {
176		out.push(func.evaluate_simple(s.clone(), &[i as f64].as_slice())?)179		out.push(func.evaluate_simple(s.clone(), &[i as f64].as_slice())?);
177	}180	}
178	Ok(VecVal(Cc::new(out)))181	Ok(VecVal(Cc::new(out)))
179}182}
420				match func.evaluate_simple(s.clone(), &[Any(el)].as_slice())? {423				match func.evaluate_simple(s.clone(), &[Any(el)].as_slice())? {
421					Val::Arr(o) => {424					Val::Arr(o) => {
422						for oe in o.iter(s.clone()) {425						for oe in o.iter(s.clone()) {
423							out.push(oe?)426							out.push(oe?);
424						}427						}
425					}428					}
426					_ => throw!(RuntimeError(429					_ => throw!(RuntimeError(
707#[jrsonnet_macros::builtin]710#[jrsonnet_macros::builtin]
708fn builtin_count(s: State, arr: Vec<Any>, v: Any) -> Result<usize> {711fn builtin_count(s: State, arr: Vec<Any>, v: Any) -> Result<usize> {
709	let mut count = 0;712	let mut count = 0;
710	for item in arr.iter() {713	for item in &arr {
711		if equals(s.clone(), &item.0, &v.0)? {714		if equals(s.clone(), &item.0, &v.0)? {
712			count += 1;715			count += 1;
713		}716		}

53		match (i, sort_type) {53		match (i, sort_type) {
54			(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,54			(Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,
55			(Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,55			(Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,
56			(Val::Str(_), SortKeyType::String) => {}56			(Val::Str(_), SortKeyType::String) | (Val::Num(_), SortKeyType::Number) => {}
57			(Val::Str(_), _) => throw!(SortError::SortElementsShouldHaveEqualType),
58			(Val::Num(_), SortKeyType::Number) => {}
59			(Val::Num(_), _) => throw!(SortError::SortElementsShouldHaveEqualType),57			(Val::Str(_) | Val::Num(_), _) => {
58				throw!(SortError::SortElementsShouldHaveEqualType)
59			}
60			_ => throw!(SortError::SortKeyShouldBeStringOrNumber),60			_ => throw!(SortError::SortKeyShouldBeStringOrNumber),
61		}61		}
62	}62	}
91		Ok(Cc::new(vk.into_iter().map(|v| v.0).collect()))91		Ok(Cc::new(vk.into_iter().map(|v| v.0).collect()))
92	} else {92	} else {
93		// Fast path, identity key getter93		// Fast path, identity key getter
94		let mut mvalues = (*values).clone();94		let mut values = (*values).clone();
95		let sort_type = get_sort_type(&mut mvalues, |k| k)?;95		let sort_type = get_sort_type(&mut values, |k| k)?;
96		match sort_type {96		match sort_type {
97			SortKeyType::Number => mvalues.sort_unstable_by_key(|v| match v {97			SortKeyType::Number => values.sort_unstable_by_key(|v| match v {
98				Val::Num(n) => NonNaNf64(*n),98				Val::Num(n) => NonNaNf64(*n),
99				_ => unreachable!(),99				_ => unreachable!(),
100			}),100			}),
101			SortKeyType::String => mvalues.sort_unstable_by_key(|v| match v {101			SortKeyType::String => values.sort_unstable_by_key(|v| match v {
102				Val::Str(s) => s.clone(),102				Val::Str(s) => s.clone(),
103				_ => unreachable!(),103				_ => unreachable!(),
104			}),104			}),
105			SortKeyType::Unknown => unreachable!(),105			SortKeyType::Unknown => unreachable!(),
106		};106		};
107		Ok(Cc::new(mvalues))107		Ok(Cc::new(values))
108	}108	}
109}109}
110110

24}24}
2525
26pub fn get_parsed_stdlib() -> LocExpr {26pub fn get_parsed_stdlib() -> LocExpr {
27	PARSED_STDLIB.with(|t| t.clone())27	PARSED_STDLIB.with(Clone::clone)
28}28}
2929

79	pub fn contains_binding(&self, name: IStr) -> bool {79	pub fn contains_binding(&self, name: IStr) -> bool {
80		self.0.bindings.contains_key(&name)80		self.0.bindings.contains_key(&name)
81	}81	}
82	#[must_use]
82	pub fn into_future(self, ctx: FutureWrapper<Self>) -> Self {83	pub fn into_future(self, ctx: FutureWrapper<Self>) -> Self {
83		{84		{
84			ctx.0.borrow_mut().replace(self);85			ctx.0.borrow_mut().replace(self);
85		}86		}
86		ctx.unwrap()87		ctx.unwrap()
87	}88	}
8889
90	#[must_use]
89	pub fn with_var(self, name: IStr, value: Val) -> Self {91	pub fn with_var(self, name: IStr, value: Val) -> Self {
90		let mut new_bindings = GcHashMap::with_capacity(1);92		let mut new_bindings = GcHashMap::with_capacity(1);
91		new_bindings.insert(name, LazyVal::new_resolved(value));93		new_bindings.insert(name, LazyVal::new_resolved(value));
92		self.extend(new_bindings, None, None, None)94		self.extend(new_bindings, None, None, None)
93	}95	}
9496
97	#[must_use]
95	pub fn with_this_super(self, new_this: ObjValue, new_super_obj: Option<ObjValue>) -> Self {98	pub fn with_this_super(self, new_this: ObjValue, new_super_obj: Option<ObjValue>) -> Self {
96		self.extend(GcHashMap::new(), None, Some(new_this), new_super_obj)99		self.extend(GcHashMap::new(), None, Some(new_this), new_super_obj)
97	}100	}
98101
102	#[must_use]
99	pub fn extend(103	pub fn extend(
100		self,104		self,
101		new_bindings: GcHashMap<IStr, LazyVal>,105		new_bindings: GcHashMap<IStr, LazyVal>,
119			bindings,123			bindings,
120		}))124		}))
121	}125	}
126	#[must_use]
122	pub fn extend_bound(self, new_bindings: GcHashMap<IStr, LazyVal>) -> Self {127	pub fn extend_bound(self, new_bindings: GcHashMap<IStr, LazyVal>) -> Self {
123		let new_this = self.0.this.clone();128		let new_this = self.0.this.clone();
124		let new_super_obj = self.0.super_obj.clone();129		let new_super_obj = self.0.super_obj.clone();
135		let this = new_this.or_else(|| self.0.this.clone());140		let this = new_this.or_else(|| self.0.this.clone());
136		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());141		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());
137		let mut new = GcHashMap::with_capacity(new_bindings.len());142		let mut new = GcHashMap::with_capacity(new_bindings.len());
138		for (k, v) in new_bindings.0.into_iter() {143		for (k, v) in new_bindings.0 {
139			new.insert(k, v.evaluate(s.clone(), this.clone(), super_obj.clone())?);144			new.insert(k, v.evaluate(s.clone(), this.clone(), super_obj.clone())?);
140		}145		}
141		Ok(self.extend(new, new_dollar, this, super_obj))146		Ok(self.extend(new, new_dollar, this, super_obj))

8	pub fn new() -> Self {8	pub fn new() -> Self {
9		Self(Cc::new(RefCell::new(None)))9		Self(Cc::new(RefCell::new(None)))
10	}10	}
11	/// # Panics
12	/// If wrapper is filled already
11	pub fn fill(self, value: T) {13	pub fn fill(self, value: T) {
12		assert!(self.0.borrow().is_none(), "wrapper is filled already");14		assert!(self.0.borrow().is_none(), "wrapper is filled already");
13		self.0.borrow_mut().replace(value);15		self.0.borrow_mut().replace(value);
14	}16	}
15}17}
16impl<T: Clone + Trace + 'static> FutureWrapper<T> {18impl<T: Clone + Trace + 'static> FutureWrapper<T> {
19	/// # Panics
20	/// If wrapper is not yet filled
17	pub fn unwrap(&self) -> T {21	pub fn unwrap(&self) -> T {
18		self.0.borrow().as_ref().cloned().unwrap()22		self.0.borrow().as_ref().cloned().unwrap()
19	}23	}

96	#[error(96	#[error(
97		"syntax error: expected {}, got {:?}",97		"syntax error: expected {}, got {:?}",
98		.error.expected,98		.error.expected,
99		.source_code.chars().nth(error.location.offset).map(|c| c.to_string()).unwrap_or_else(|| "EOF".into())99		.source_code.chars().nth(error.location.offset)
100		.map_or_else(|| "EOF".into(), |c| c.to_string())
100	)]101	)]
101	ImportSyntaxError {102	ImportSyntaxError {
102		#[skip_trace]103		#[skip_trace]
190impl Debug for LocError {191impl Debug for LocError {
191	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {192	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
192		writeln!(f, "{}", self.0 .0)?;193		writeln!(f, "{}", self.0 .0)?;
193		for el in self.0 .1 .0.iter() {194		for el in &self.0 .1 .0 {
194			writeln!(f, "\t{:?}", el)?;195			writeln!(f, "\t{:?}", el)?;
195		}196		}
196		Ok(())197		Ok(())

23pub fn evaluate_binding_in_future(b: &BindSpec, fctx: FutureWrapper<Context>) -> LazyVal {23pub fn evaluate_binding_in_future(b: &BindSpec, fctx: FutureWrapper<Context>) -> LazyVal {
24	let b = b.clone();24	let b = b.clone();
25	if let Some(params) = &b.params {25	if let Some(params) = &b.params {
26		let params = params.clone();
27
28		#[derive(Trace)]26		#[derive(Trace)]
29		struct LazyMethodBinding {27		struct LazyMethodBinding {
43			}41			}
44		}42		}
43
44		let params = params.clone();
4545
46		LazyVal::new(TraceBox(Box::new(LazyMethodBinding {46		LazyVal::new(TraceBox(Box::new(LazyMethodBinding {
47			fctx,47			fctx,
69	}69	}
70}70}
7171
72#[allow(clippy::too_many_lines)]
72pub fn evaluate_binding(b: &BindSpec, cctx: ContextCreator) -> (IStr, LazyBinding) {73pub fn evaluate_binding(b: &BindSpec, cctx: ContextCreator) -> (IStr, LazyBinding) {
73	let b = b.clone();74	let b = b.clone();
74	if let Some(params) = &b.params {75	if let Some(params) = &b.params {
75		let params = params.clone();
76
77		#[derive(Trace)]76		#[derive(Trace)]
78		struct BindableMethodLazyVal {77		struct BindableMethodLazyVal {
121			}120			}
122		}121		}
122
123		let params = params.clone();
123124
124		(125		(
125			b.name.clone(),126			b.name.clone(),
227		None => callback(ctx)?,228		None => callback(ctx)?,
228		Some(CompSpec::IfSpec(IfSpecData(cond))) => {229		Some(CompSpec::IfSpec(IfSpecData(cond))) => {
229			if bool::from_untyped(evaluate(s.clone(), ctx.clone(), cond)?, s.clone())? {230			if bool::from_untyped(evaluate(s.clone(), ctx.clone(), cond)?, s.clone())? {
230				evaluate_comp(s, ctx, &specs[1..], callback)?231				evaluate_comp(s, ctx, &specs[1..], callback)?;
231			}232			}
232		}233		}
233		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {234		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {
239							ctx.clone().with_var(var.clone(), item?.clone()),240							ctx.clone().with_var(var.clone(), item?.clone()),
240							&specs[1..],241							&specs[1..],
241							callback,242							callback,
242						)?243						)?;
243					}244					}
244				}245				}
245				_ => throw!(InComprehensionCanOnlyIterateOverArray),246				_ => throw!(InComprehensionCanOnlyIterateOverArray),
249	Ok(())250	Ok(())
250}251}
251252
253#[allow(clippy::too_many_lines)]
252pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {254pub fn evaluate_member_list_object(s: State, ctx: Context, members: &[Member]) -> Result<ObjValue> {
253	let new_bindings = FutureWrapper::new();255	let new_bindings = FutureWrapper::new();
254	let future_this = FutureWrapper::new();256	let future_this = FutureWrapper::new();
278				visibility,280				visibility,
279				value,281				value,
280			}) => {282			}) => {
281				let name = evaluate_field_name(s.clone(), ctx.clone(), name)?;
282				if name.is_none() {
283					continue;
284				}
285				let name = name.unwrap();
286
287				#[derive(Trace)]283				#[derive(Trace)]
288				struct ObjMemberBinding {284				struct ObjMemberBinding {
306					}302					}
307				}303				}
304
305				let name = evaluate_field_name(s.clone(), ctx.clone(), name)?;
306				let name = if let Some(name) = name {
307					name
308				} else {
309					continue;
310				};
311
308				builder312				builder
309					.member(name.clone())313					.member(name.clone())
325				value,329				value,
326				..330				..
327			}) => {331			}) => {
328				let name = evaluate_field_name(s.clone(), ctx.clone(), name)?;
329				if name.is_none() {
330					continue;
331				}
332				let name = name.unwrap();
333				#[derive(Trace)]332				#[derive(Trace)]
334				struct ObjMemberBinding {333				struct ObjMemberBinding {
335					cctx: ContextCreator,334					cctx: ContextCreator,
353					}352					}
354				}353				}
354
355				let name = if let Some(name) = evaluate_field_name(s.clone(), ctx.clone(), name)? {
356					name
357				} else {
358					continue;
359				};
360
355				builder361				builder
356					.member(name.clone())362					.member(name.clone())
505					throw!(AssertionFailed(511					throw!(AssertionFailed(
506						evaluate(s.clone(), ctx, msg)?.to_string(s.clone())?512						evaluate(s.clone(), ctx, msg)?.to_string(s.clone())?
507					));513					));
508				} else {514				}
509					throw!(AssertionFailed(Val::Null.to_string(s.clone())?));515				throw!(AssertionFailed(Val::Null.to_string(s.clone())?));
510				}
511			},516			},
512		)?517		)?;
513	}518	}
514	Ok(())519	Ok(())
515}520}
516521
517pub fn evaluate_named(s: State, ctx: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {522pub fn evaluate_named(s: State, ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {
518	use Expr::*;523	use Expr::*;
519	let LocExpr(expr, _loc) = lexpr;524	let LocExpr(raw_expr, _loc) = expr;
520	Ok(match &**expr {525	Ok(match &**raw_expr {
521		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),526		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),
522		_ => evaluate(s, ctx, lexpr)?,527		_ => evaluate(s, ctx, expr)?,
523	})528	})
524}529}
525530
531#[allow(clippy::too_many_lines)]
526pub fn evaluate(s: State, ctx: Context, expr: &LocExpr) -> Result<Val> {532pub fn evaluate(s: State, ctx: Context, expr: &LocExpr) -> Result<Val> {
527	use Expr::*;533	use Expr::*;
528	let LocExpr(expr, loc) = expr;534	let LocExpr(expr, loc) = expr;
535			ctx.super_obj()541			ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(
536				.clone()
537				.ok_or(NoSuperFound)?
538				.with_this(ctx.this().clone().unwrap()),542				ctx.this()
543					.clone()
544					.expect("if super exists - then this should to"),
545			),
539		),546		),
540		Literal(LiteralType::Dollar) => {547		Literal(LiteralType::Dollar) => {
699			}706			}
700		}707		}
701		Slice(value, desc) => {708		Slice(value, desc) => {
702			let indexable = evaluate(s.clone(), ctx.clone(), value)?;
703			let loc = CallLocation::new(loc);
704
705			fn parse_idx<T: Typed>(709			fn parse_idx<T: Typed>(
706				loc: CallLocation,710				loc: CallLocation,
720				}724				}
721			}725			}
726
727			let indexable = evaluate(s.clone(), ctx.clone(), value)?;
728			let loc = CallLocation::new(loc);
722729
723			let start = parse_idx(loc, s.clone(), &ctx, &desc.start, "start")?;730			let start = parse_idx(loc, s.clone(), &ctx, &desc.start, "start")?;
724			let end = parse_idx(loc, s.clone(), &ctx, &desc.end, "end")?;731			let end = parse_idx(loc, s.clone(), &ctx, &desc.end, "end")?;

1use std::cmp::Ordering;
2
1use jrsonnet_parser::{BinaryOpType, LocExpr, UnaryOpType};3use jrsonnet_parser::{BinaryOpType, LocExpr, UnaryOpType};
24
11	Ok(match (op, b) {13	Ok(match (op, b) {
12		(Not, Bool(v)) => Bool(!v),14		(Not, Bool(v)) => Bool(!v),
13		(Minus, Num(n)) => Num(-*n),15		(Minus, Num(n)) => Num(-*n),
14		(BitNot, Num(n)) => Num(!(*n as i32) as f64),16		(BitNot, Num(n)) => Num(f64::from(!(*n as i32))),
15		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),17		(op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type())),
16	})18	})
17}19}
22		(Str(v1), Str(v2)) => Str(((**v1).to_owned() + v2).into()),24		(Str(v1), Str(v2)) => Str(((**v1).to_owned() + v2).into()),
2325
24		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)26		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)
25		(Num(n), Str(o)) => Str(format!("{}{}", n, o).into()),27		(Num(a), Str(b)) => Str(format!("{a}{b}").into()),
26		(Str(o), Num(n)) => Str(format!("{}{}", o, n).into()),28		(Str(a), Num(b)) => Str(format!("{a}{b}").into()),
2729
28		(Str(a), o) => Str(format!("{}{}", a, o.clone().to_string(s)?).into()),30		(Str(a), o) => Str(format!("{}{}", a, o.clone().to_string(s)?).into()),
29		(o, Str(a)) => Str(format!("{}{}", o.clone().to_string(s)?, a).into()),31		(o, Str(a)) => Str(format!("{}{}", o.clone().to_string(s)?, a).into()),
47pub fn evaluate_mod_op(s: State, a: &Val, b: &Val) -> Result<Val> {49pub fn evaluate_mod_op(s: State, a: &Val, b: &Val) -> Result<Val> {
48	use Val::*;50	use Val::*;
49	match (a, b) {51	match (a, b) {
50		(Num(a), Num(b)) => Ok(Num(a % b)),52		(Num(a), Num(b)) => {
53			if *b == 0.0 {
54				throw!(DivisionByZero)
55			}
56			Ok(Num(a % b))
57		}
51		(Str(str), vals) => {58		(Str(str), vals) => {
52			String::into_untyped(std_format(s.clone(), str.clone(), vals.clone())?, s)59			String::into_untyped(std_format(s.clone(), str.clone(), vals.clone())?, s)
53		}60		}
75	})82	})
76}83}
84
85pub fn evaluate_compare_op(s: State, a: &Val, op: BinaryOpType, b: &Val) -> Result<Ordering> {
86	use Val::*;
87	Ok(match (a, b) {
88		(Str(a), Str(b)) => a.cmp(b),
89		(Num(a), Num(b)) => a.partial_cmp(b).expect("jsonnet numbers are non NaN"),
90		(Arr(a), Arr(b)) => {
91			let ai = a.iter(s.clone());
92			let bi = b.iter(s.clone());
93
94			for (a, b) in ai.zip(bi) {
95				let ord = evaluate_compare_op(s.clone(), &a?, op, &b?)?;
96				if !ord.is_eq() {
97					return Ok(ord);
98				}
99			}
100
101			a.len().cmp(&b.len())
102		}
103		(_, _) => throw!(BinaryOperatorDoesNotOperateOnValues(
104			op,
105			a.value_type(),
106			b.value_type()
107		)),
108	})
109}
77110
78pub fn evaluate_binary_op_normal(s: State, a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {111pub fn evaluate_binary_op_normal(s: State, a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {
79	use BinaryOpType::*;112	use BinaryOpType::*;
84		(a, Eq, b) => Bool(equals(s, a, b)?),117		(a, Eq, b) => Bool(equals(s, a, b)?),
85		(a, Neq, b) => Bool(!equals(s, a, b)?),118		(a, Neq, b) => Bool(!equals(s, a, b)?),
119
120		(a, Lt, b) => Bool(evaluate_compare_op(s, a, Lt, b)?.is_lt()),
121		(a, Gt, b) => Bool(evaluate_compare_op(s, a, Gt, b)?.is_gt()),
122		(a, Lte, b) => Bool(evaluate_compare_op(s, a, Lte, b)?.is_le()),
123		(a, Gte, b) => Bool(evaluate_compare_op(s, a, Gte, b)?.is_ge()),
86124
87		(Str(a), In, Obj(obj)) => Bool(obj.has_field_ex(a.clone(), true)),125		(Str(a), In, Obj(obj)) => Bool(obj.has_field_ex(a.clone(), true)),
88		(a, Mod, b) => evaluate_mod_op(s, a, b)?,126		(a, Mod, b) => evaluate_mod_op(s, a, b)?,
93		(Bool(a), And, Bool(b)) => Bool(*a && *b),131		(Bool(a), And, Bool(b)) => Bool(*a && *b),
94		(Bool(a), Or, Bool(b)) => Bool(*a || *b),132		(Bool(a), Or, Bool(b)) => Bool(*a || *b),
95
96		// Str X Str
97		(Str(v1), Lt, Str(v2)) => Bool(v1 < v2),
98		(Str(v1), Gt, Str(v2)) => Bool(v1 > v2),
99		(Str(v1), Lte, Str(v2)) => Bool(v1 <= v2),
100		(Str(v1), Gte, Str(v2)) => Bool(v1 >= v2),
101133
102		// Num X Num134		// Num X Num
103		(Num(v1), Mul, Num(v2)) => Val::new_checked_num(v1 * v2)?,135		(Num(v1), Mul, Num(v2)) => Val::new_checked_num(v1 * v2)?,
104		(Num(v1), Div, Num(v2)) => {136		(Num(v1), Div, Num(v2)) => {
105			if *v2 <= f64::EPSILON {137			if *v2 == 0.0 {
106				throw!(DivisionByZero)138				throw!(DivisionByZero)
107			}139			}
108			Val::new_checked_num(v1 / v2)?140			Val::new_checked_num(v1 / v2)?
109		}141		}
110142
111		(Num(v1), Sub, Num(v2)) => Val::new_checked_num(v1 - v2)?,143		(Num(v1), Sub, Num(v2)) => Val::new_checked_num(v1 - v2)?,
112
113		(Num(v1), Lt, Num(v2)) => Bool(v1 < v2),
114		(Num(v1), Gt, Num(v2)) => Bool(v1 > v2),
115		(Num(v1), Lte, Num(v2)) => Bool(v1 <= v2),
116		(Num(v1), Gte, Num(v2)) => Bool(v1 >= v2),
117144
118		(Num(v1), BitAnd, Num(v2)) => Num(((*v1 as i32) & (*v2 as i32)) as f64),145		(Num(v1), BitAnd, Num(v2)) => Num(f64::from((*v1 as i32) & (*v2 as i32))),
119		(Num(v1), BitOr, Num(v2)) => Num(((*v1 as i32) | (*v2 as i32)) as f64),146		(Num(v1), BitOr, Num(v2)) => Num(f64::from((*v1 as i32) | (*v2 as i32))),
120		(Num(v1), BitXor, Num(v2)) => Num(((*v1 as i32) ^ (*v2 as i32)) as f64),147		(Num(v1), BitXor, Num(v2)) => Num(f64::from((*v1 as i32) ^ (*v2 as i32))),
121		(Num(v1), Lhs, Num(v2)) => {148		(Num(v1), Lhs, Num(v2)) => {
122			if *v2 < 0.0 {149			if *v2 < 0.0 {
123				throw!(RuntimeError("shift by negative exponent".into()))150				throw!(RuntimeError("shift by negative exponent".into()))
124			}151			}
125			Num(((*v1 as i32) << (*v2 as i32)) as f64)152			Num(f64::from((*v1 as i32) << (*v2 as i32)))
126		}153		}
127		(Num(v1), Rhs, Num(v2)) => {154		(Num(v1), Rhs, Num(v2)) => {
128			if *v2 < 0.0 {155			if *v2 < 0.0 {
129				throw!(RuntimeError("shift by negative exponent".into()))156				throw!(RuntimeError("shift by negative exponent".into()))
130			}157			}
131			Num(((*v1 as i32) >> (*v2 as i32)) as f64)158			Num(f64::from((*v1 as i32) >> (*v2 as i32)))
132		}159		}
133160
134		_ => throw!(BinaryOperatorDoesNotOperateOnValues(161		_ => throw!(BinaryOperatorDoesNotOperateOnValues(