difftreelog
perf faster range
in: master
2 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 == *"sortImpl" || **name == *"range"
)
})
.collect(),
crates/jrsonnet-evaluator/src/evaluate.rsdiffbeforeafterboth1use crate::{2 context_creator, create_error, create_error_result, equals, escape_string_json, future_wrapper,3 lazy_val, manifest_json_ex, parse_args, primitive_equals, push, with_state, Context,4 ContextCreator, Error, FuncDesc, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,5 ValType,6};7use closure::closure;8use jrsonnet_parser::{9 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,10 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,11 Visibility,12};13use std::{cmp::Ordering, collections::HashMap, rc::Rc};1415pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {16 let b = b.clone();17 if let Some(params) = &b.params {18 let params = params.clone();19 (20 b.name.clone(),21 LazyBinding::Bindable(Rc::new(move |this, super_obj| {22 Ok(lazy_val!(23 closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(24 context_creator.0(this.clone(), super_obj.clone())?,25 b.name.clone(),26 params.clone(),27 b.value.clone(),28 )))29 ))30 })),31 )32 } else {33 (34 b.name.clone(),35 LazyBinding::Bindable(Rc::new(move |this, super_obj| {36 Ok(lazy_val!(closure!(clone context_creator, clone b, ||37 evaluate_named(38 context_creator.0(this.clone(), super_obj.clone())?,39 &b.value,40 b.name.clone()41 )42 )))43 })),44 )45 }46}4748pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {49 Val::Func(Rc::new(FuncDesc {50 name,51 ctx,52 params,53 body,54 }))55}5657pub fn evaluate_field_name(58 context: Context,59 field_name: &jrsonnet_parser::FieldName,60) -> Result<Option<Rc<str>>> {61 Ok(match field_name {62 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),63 jrsonnet_parser::FieldName::Dyn(expr) => {64 let lazy = evaluate(context, expr)?;65 let value = lazy.unwrap_if_lazy()?;66 if matches!(value, Val::Null) {67 None68 } else {69 Some(value.try_cast_str("dynamic field name")?)70 }71 }72 })73}7475pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {76 Ok(match (op, b) {77 (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,78 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),79 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),80 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),81 (op, o) => create_error_result(Error::UnaryOperatorDoesNotOperateOnType(82 op,83 o.value_type()?,84 ))?,85 })86}8788pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {89 Ok(match (a, b) {90 (Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),9192 // Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)93 (Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),94 (Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),9596 (Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),97 (o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),9899 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),100 (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),101 (Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,102 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(103 BinaryOpType::Add,104 a.value_type()?,105 b.value_type()?,106 ))?,107 })108}109110pub fn evaluate_binary_op_special(111 context: Context,112 a: &LocExpr,113 op: BinaryOpType,114 b: &LocExpr,115) -> Result<Val> {116 Ok(117 match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {118 (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),119 (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),120 (a, op, eb) => {121 evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?122 }123 },124 )125}126127pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {128 Ok(match (a, op, b) {129 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,130131 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),132133 // Bool X Bool134 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),135 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),136137 // Str X Str138 (Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),139 (Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),140 (Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),141 (Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),142143 // Num X Num144 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,145 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {146 if *v2 <= f64::EPSILON {147 create_error_result(crate::Error::DivisionByZero)?148 }149 Val::new_checked_num(v1 / v2)?150 }151152 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,153154 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),155 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),156 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),157 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),158159 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {160 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)161 }162 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {163 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)164 }165 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {166 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)167 }168 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {169 if *v2 < 0.0 {170 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?171 }172 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)173 }174 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {175 if *v2 < 0.0 {176 create_error_result(Error::RuntimeError("shift by negative exponent".into()))?177 }178 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)179 }180181 _ => create_error_result(Error::BinaryOperatorDoesNotOperateOnValues(182 op,183 a.value_type()?,184 b.value_type()?,185 ))?,186 })187}188189future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);190future_wrapper!(ObjValue, FutureObjValue);191192pub fn evaluate_comp<T>(193 context: Context,194 value: &impl Fn(Context) -> Result<T>,195 specs: &[CompSpec],196) -> Result<Option<Vec<T>>> {197 Ok(match specs.get(0) {198 None => Some(vec![value(context)?]),199 Some(CompSpec::IfSpec(IfSpecData(cond))) => {200 if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {201 evaluate_comp(context, value, &specs[1..])?202 } else {203 None204 }205 }206 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {207 match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {208 Val::Arr(list) => {209 let mut out = Vec::new();210 for item in list.iter() {211 let item = item.unwrap_if_lazy()?;212 out.push(evaluate_comp(213 context.with_var(var.clone(), item.clone())?,214 value,215 &specs[1..],216 )?);217 }218 Some(out.into_iter().flatten().flatten().collect())219 }220 _ => create_error_result(Error::InComprehensionCanOnlyIterateOverArray)?,221 }222 }223 })224}225226pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {227 let new_bindings = FutureNewBindings::new();228 let future_this = FutureObjValue::new();229 let context_creator = context_creator!(230 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {231 Ok(context.extend_unbound(232 new_bindings.clone().unwrap(),233 context.dollar().clone().or_else(||this.clone()),234 Some(this.unwrap()),235 super_obj236 )?)237 })238 );239 {240 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();241 for (n, b) in members242 .iter()243 .filter_map(|m| match m {244 Member::BindStmt(b) => Some(b.clone()),245 _ => None,246 })247 .map(|b| evaluate_binding(&b, context_creator.clone()))248 {249 bindings.insert(n, b);250 }251 new_bindings.fill(bindings);252 }253254 let mut new_members = HashMap::new();255 for member in members.iter() {256 match member {257 Member::Field(FieldMember {258 name,259 plus,260 params: None,261 visibility,262 value,263 }) => {264 let name = evaluate_field_name(context.clone(), &name)?;265 if name.is_none() {266 continue;267 }268 let name = name.unwrap();269 new_members.insert(270 name.clone(),271 ObjMember {272 add: *plus,273 visibility: *visibility,274 invoke: LazyBinding::Bindable(Rc::new(275 closure!(clone name, clone value, clone context_creator, |this, super_obj| {276 Ok(LazyVal::new_resolved(evaluate(277 context_creator.0(this, super_obj)?,278 &value,279 )?))280 }),281 )),282 location: value.1.clone(),283 },284 );285 }286 Member::Field(FieldMember {287 name,288 params: Some(params),289 value,290 ..291 }) => {292 let name = evaluate_field_name(context.clone(), &name)?;293 if name.is_none() {294 continue;295 }296 let name = name.unwrap();297 new_members.insert(298 name.clone(),299 ObjMember {300 add: false,301 visibility: Visibility::Hidden,302 invoke: LazyBinding::Bindable(Rc::new(303 closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {304 // TODO: Assert305 Ok(LazyVal::new_resolved(evaluate_method(306 context_creator.0(this, super_obj)?,307 name.clone(),308 params.clone(),309 value.clone(),310 )))311 }),312 )),313 location: value.1.clone(),314 },315 );316 }317 Member::BindStmt(_) => {}318 Member::AssertStmt(_) => {}319 }320 }321 Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))322}323324pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {325 Ok(match object {326 ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,327 ObjBody::ObjComp(obj) => {328 let future_this = FutureObjValue::new();329 let mut new_members = HashMap::new();330 for (k, v) in evaluate_comp(331 context.clone(),332 &|ctx| {333 let new_bindings = FutureNewBindings::new();334 let context_creator = context_creator!(335 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {336 Ok(context.extend_unbound(337 new_bindings.clone().unwrap(),338 context.dollar().clone().or_else(||this.clone()),339 None,340 super_obj341 )?)342 })343 );344 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();345 for (n, b) in obj346 .pre_locals347 .iter()348 .chain(obj.post_locals.iter())349 .map(|b| evaluate_binding(b, context_creator.clone()))350 {351 bindings.insert(n, b);352 }353 let bindings = new_bindings.fill(bindings);354 let ctx = ctx.extend_unbound(bindings, None, None, None)?;355 let key = evaluate(ctx.clone(), &obj.key)?;356 let value = LazyBinding::Bindable(Rc::new(357 closure!(clone ctx, clone obj.value, |this, _super_obj| {358 Ok(LazyVal::new_resolved(evaluate(ctx.extend(HashMap::new(), None, this, None)?, &value)?))359 }),360 ));361362 Ok((key, value))363 },364 &obj.compspecs,365 )?366 .unwrap()367 {368 match k {369 Val::Null => {}370 Val::Str(n) => {371 new_members.insert(372 n,373 ObjMember {374 add: false,375 visibility: Visibility::Normal,376 invoke: v,377 location: obj.value.1.clone(),378 },379 );380 }381 v => create_error_result(Error::FieldMustBeStringGot(v.value_type()?))?,382 }383 }384385 future_this.fill(ObjValue::new(None, Rc::new(new_members)))386 }387 })388}389390/// Extracts code block and disables inlining for them391/// Fixes WASM to java bytecode compilation failing because of very large method392macro_rules! noinline {393 ($e:expr) => {394 (#[inline(never)]395 move || $e)()396 };397}398399pub fn evaluate_apply(400 context: Context,401 value: &LocExpr,402 args: &ArgsDesc,403 loc: &Option<ExprLocation>,404 tailstrict: bool,405) -> Result<Val> {406 let lazy = evaluate(context.clone(), value)?;407 let value = lazy.unwrap_if_lazy()?;408 Ok(match value {409 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {410 // arr/string/function411 ("std", "length") => noinline!(parse_args!(context, "std.length", args, 1, [412 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];413 ], {414 Ok(match x {415 Val::Str(n) => Val::Num(n.chars().count() as f64),416 Val::Arr(i) => Val::Num(i.len() as f64),417 Val::Obj(o) => Val::Num(418 o.fields_visibility()419 .into_iter()420 .filter(|(_k, v)| *v)421 .count() as f64,422 ),423 _ => unreachable!(),424 })425 }))?,426 // any427 ("std", "type") => parse_args!(context, "std.type", args, 1, [428 0, x, vec![];429 ], {430 Val::Str(x.value_type()?.name().into())431 }),432 // length, idx=>any433 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [434 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];435 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];436 ], {437 if sz < 0.0 {438 create_error_result(crate::error::Error::RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()))?;439 }440 let mut out = Vec::with_capacity(sz as usize);441 for i in 0..sz as usize {442 out.push(func.evaluate_values(443 Context::new(),444 &[Val::Num(i as f64)]445 )?)446 }447 Ok(Val::Arr(Rc::new(out)))448 }))?,449 // string450 ("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [451 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];452 ], {453 assert!(454 str.chars().count() == 1,455 "std.codepoint should receive single char string"456 );457 Val::Num(str.chars().take(1).next().unwrap() as u32 as f64)458 }),459 // object, includeHidden460 ("std", "objectFieldsEx") => {461 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [462 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];463 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];464 ], {465 let mut out = obj.fields_visibility()466 .into_iter()467 .filter(|(_k, v)| *v || inc_hidden)468 .map(|(k, _v)|k)469 .collect::<Vec<_>>();470 out.sort();471 Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))472 }))?473 }474 // object, field, includeHidden475 ("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [476 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];477 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];478 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];479 ], {480 Val::Bool(481 obj.fields_visibility()482 .into_iter()483 .filter(|(_k, v)| *v || inc_hidden)484 .any(|(k, _v)| *k == *f),485 )486 }),487 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [488 0, a, vec![];489 1, b, vec![];490 ], {491 Val::Bool(primitive_equals(&a, &b)?)492 }),493 // faster494 ("std", "equals") => parse_args!(context, "std.equals", args, 2, [495 0, a, vec![];496 1, b, vec![];497 ], {498 Val::Bool(equals(&a, &b)?)499 }),500 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [501 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];502 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];503 ], {504 Val::Num(a % b)505 }),506 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [507 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];508 ], {509 Val::Num(x.floor())510 }),511 ("std", "log") => parse_args!(context, "std.log", args, 2, [512 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];513 ], {514 Val::Num(n.ln())515 }),516 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [517 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];518 1, rest, vec![];519 ], {520 eprint!("TRACE:");521 if let Some(loc) = loc {522 with_state(|s|{523 let locs = s.map_source_locations(&loc.0, &[loc.1]);524 eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);525 });526 }527 eprintln!(" {}", str);528 rest529 }),530 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [531 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];532 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];533 ], {534 Val::Num(x.powf(n))535 }),536 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [537 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];538 ], {539 with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(540 || create_error(crate::Error::UndefinedExternalVariable(x)),541 )?542 }),543 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [544 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];545 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];546 ], {547 Ok(Val::Arr(Rc::new(548 arr.iter()549 .cloned()550 .filter(|e| {551 func552 .evaluate_values(context.clone(), &[e.clone()])553 .unwrap()554 .try_cast_bool("filter predicate")555 .unwrap()556 })557 .collect(),558 )))559 }))?,560 // faster561 ("std", "foldl") => noinline!(parse_args!(context, "std.foldl", args, 3, [562 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];563 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];564 2, init, vec![];565 ], {566 let mut acc = init;567 for i in arr.iter().cloned() {568 acc = func.evaluate_values(context.clone(), &[acc, i])?;569 }570 Ok(acc)571 }))?,572 // faster573 ("std", "foldr") => noinline!(parse_args!(context, "std.foldr", args, 3, [574 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];575 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];576 2, init, vec![];577 ], {578 let mut acc = init;579 for i in arr.iter().rev().cloned() {580 acc = func.evaluate_values(context.clone(), &[acc, i])?;581 }582 Ok(acc)583 }))?,584 // faster585 ("std", "sortImpl") => noinline!(parse_args!(context, "std.sort", args, 2, [586 0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];587 1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];588 ], {589 if arr.len() <= 1 {590 return Ok(Val::Arr(arr))591 }592 let mut new_arr = arr.iter().cloned().collect::<Vec<_>>();593 match keyF.evaluate_values(context.clone(), &[new_arr[0].clone()])? {594 Val::Str(_) => {595 let mut err = None;596 new_arr.sort_by_cached_key(|k| {597 match keyF.evaluate_values(context.clone(), &[k.clone()]) {598 Ok(Val::Str(v)) => v,599 Ok(_) => {600 err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));601 "".into()602 }603 Err(e) => {604 err = Some(e);605 "".into()606 }607 }608 });609 if let Some(e) = err {610 return Err(e);611 }612 },613 Val::Num(_) => {614 let mut err = None;615 new_arr.sort_unstable_by(|a, b| {616 match (keyF.evaluate_values(context.clone(), &[a.clone()]), keyF.evaluate_values(context.clone(), &[b.clone()])) {617 (Ok(Val::Num(a)), Ok(Val::Num(b))) => a.partial_cmp(&b).unwrap(),618 (Ok(_a), Ok(_b)) => {619 err = Some(create_error(crate::error::Error::RuntimeError("types of all array elements should equal".into())));620 Ordering::Equal621 }622 (Err(e), _) | (_, Err(e)) => {623 err = Some(e);624 Ordering::Equal625 }626 }627 });628 if let Some(e) = err {629 return Err(e);630 }631 },632 _ => return Err(create_error(crate::error::Error::RuntimeError("keys should be number or string".into())))633 }634 Ok(Val::Arr(Rc::new(new_arr)))635 }))?,636 ("std", "char") => parse_args!(context, "std.char", args, 1, [637 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];638 ], {639 let mut out = String::new();640 out.push(std::char::from_u32(n as u32).unwrap());641 Val::Str(out.into())642 }),643 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [644 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];645 ], {646 Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect()))647 }),648 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [649 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];650 ], {651 Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))652 }))?,653 // faster654 ("std", "base64") => parse_args!(context, "std.base64", args, 1, [655 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];656 ], {657 Val::Str(match input {658 Val::Str(s) => {659 base64::encode(s.bytes().collect::<Vec<_>>()).into()660 },661 Val::Arr(a) => {662 base64::encode(a.iter().map(|v| {663 Ok(v.clone().try_cast_num("base64 array")? as u8)664 }).collect::<Result<Vec<_>>>()?).into()665 },666 _ => unreachable!()667 })668 }),669 // faster670 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [671 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];672 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];673 ], {674 Ok(match sep {675 Val::Arr(joiner_items) => {676 let mut out = Vec::new();677678 let mut first = true;679 for item in arr.iter().cloned() {680 if let Val::Arr(items) = item.unwrap_if_lazy()? {681 if !first {682 out.reserve(joiner_items.len());683 out.extend(joiner_items.iter().cloned());684 }685 first = false;686 out.reserve(items.len());687 out.extend(items.iter().cloned());688 } else {689 create_error_result(crate::Error::RuntimeError("in std.join all items should be arrays".into()))?;690 }691 }692693 Val::Arr(Rc::new(out))694 },695 Val::Str(sep) => {696 let mut out = String::new();697698 let mut first = true;699 for item in arr.iter().cloned() {700 if let Val::Str(item) = item.unwrap_if_lazy()? {701 if !first {702 out += &sep;703 }704 first = false;705 out += &item;706 } else {707 create_error_result(crate::Error::RuntimeError("in std.join all items should be strings".into()))?;708 }709 }710711 Val::Str(out.into())712 },713 _ => unreachable!()714 })715 }))?,716 // Faster717 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [718 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];719 ], {720 Val::Str(escape_string_json(&str_).into())721 }),722 // Faster723 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [724 0, value, vec![];725 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];726 ], {727 Val::Str(manifest_json_ex(&value, &indent)?.into())728 }),729 (ns, name) => {730 create_error_result(crate::Error::IntristicNotFound(ns.into(), name.into()))?731 }732 },733 Val::Func(f) => {734 let body = || f.evaluate(context, args, tailstrict);735 if tailstrict {736 body()?737 } else {738 push(loc, || format!("function <{}> call", f.name), body)?739 }740 }741 v => create_error_result(crate::Error::OnlyFunctionsCanBeCalledGot(v.value_type()?))?,742 })743}744745pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: Rc<str>) -> Result<Val> {746 use Expr::*;747 let LocExpr(expr, _loc) = lexpr;748 Ok(match &**expr {749 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),750 _ => evaluate(context, lexpr)?,751 })752}753754pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {755 use Expr::*;756 let LocExpr(expr, loc) = expr;757 Ok(match &**expr {758 Literal(LiteralType::This) => Val::Obj(759 context760 .this()761 .clone()762 .ok_or_else(|| create_error(crate::Error::CantUseSelfOutsideOfObject))?,763 ),764 Literal(LiteralType::Dollar) => Val::Obj(765 context766 .dollar()767 .clone()768 .ok_or_else(|| create_error(crate::Error::NoTopLevelObjectFound))?,769 ),770 Literal(LiteralType::True) => Val::Bool(true),771 Literal(LiteralType::False) => Val::Bool(false),772 Literal(LiteralType::Null) => Val::Null,773 Parened(e) => evaluate(context, e)?,774 Str(v) => Val::Str(v.clone()),775 Num(v) => Val::new_checked_num(*v)?,776 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,777 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,778 Var(name) => push(779 loc,780 || format!("variable <{}>", name),781 || Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),782 )?,783 Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {784 let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;785 context786 .super_obj()787 .clone()788 .expect("no super found")789 .get_raw(name, &context.this().clone().expect("no this found"))?790 .expect("value not found")791 }792 Index(value, index) => {793 match (794 evaluate(context.clone(), value)?.unwrap_if_lazy()?,795 evaluate(context, index)?,796 ) {797 (Val::Obj(v), Val::Str(s)) => {798 if let Some(v) = v.get(s.clone())? {799 v.unwrap_if_lazy()?800 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {801 Val::Intristic(n, s)802 } else {803 create_error_result(crate::Error::NoSuchField(s))?804 }805 }806 (Val::Obj(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(807 ValType::Obj,808 ValType::Str,809 n.value_type()?,810 ))?,811812 (Val::Arr(v), Val::Num(n)) => {813 if n.fract() > f64::EPSILON {814 create_error_result(crate::Error::FractionalIndex)?815 }816 v.get(n as usize)817 .ok_or_else(|| {818 create_error(crate::Error::ArrayBoundsError(n as usize, v.len()))819 })?820 .clone()821 .unwrap_if_lazy()?822 }823 (Val::Arr(_), Val::Str(n)) => {824 create_error_result(crate::Error::AttemptedIndexAnArrayWithString(n))?825 }826 (Val::Arr(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(827 ValType::Arr,828 ValType::Num,829 n.value_type()?,830 ))?,831832 (Val::Str(s), Val::Num(n)) => Val::Str(833 s.chars()834 .skip(n as usize)835 .take(1)836 .collect::<String>()837 .into(),838 ),839 (Val::Str(_), n) => create_error_result(crate::Error::ValueIndexMustBeTypeGot(840 ValType::Str,841 ValType::Num,842 n.value_type()?,843 ))?,844845 (v, _) => create_error_result(crate::Error::CantIndexInto(v.value_type()?))?,846 }847 }848 LocalExpr(bindings, returned) => {849 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();850 let future_context = Context::new_future();851852 let context_creator = context_creator!(853 closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))854 );855856 for (k, v) in bindings857 .iter()858 .map(|b| evaluate_binding(b, context_creator.clone()))859 {860 new_bindings.insert(k, v);861 }862863 let context = context864 .extend_unbound(new_bindings, None, None, None)?865 .into_future(future_context);866 evaluate(context, &returned.clone())?867 }868 Arr(items) => {869 let mut out = Vec::with_capacity(items.len());870 for item in items {871 out.push(Val::Lazy(lazy_val!(872 closure!(clone context, clone item, || {873 evaluate(context.clone(), &item)874 })875 )));876 }877 Val::Arr(Rc::new(out))878 }879 ArrComp(expr, compspecs) => Val::Arr(880 // First compspec should be forspec, so no "None" possible here881 Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),882 ),883 Obj(body) => Val::Obj(evaluate_object(context, body)?),884 ObjExtend(s, t) => evaluate_add_op(885 &evaluate(context.clone(), s)?,886 &Val::Obj(evaluate_object(context, t)?),887 )?,888 Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,889 Function(params, body) => {890 evaluate_method(context, "anonymous".into(), params.clone(), body.clone())891 }892 AssertExpr(AssertStmt(value, msg), returned) => {893 let assertion_result = push(894 &value.1,895 || "assertion condition".to_owned(),896 || {897 evaluate(context.clone(), &value)?898 .try_cast_bool("assertion condition should be boolean")899 },900 )?;901 if assertion_result {902 evaluate(context, returned)?903 } else if let Some(msg) = msg {904 create_error_result(crate::Error::AssertionFailed(evaluate(context, msg)?))?905 } else {906 create_error_result(crate::Error::AssertionFailed(Val::Null))?907 }908 }909 Error(e) => push(910 &loc,911 || "error statement".to_owned(),912 || {913 create_error_result(crate::Error::RuntimeError(914 evaluate(context, e)?.try_cast_str("error text should be string")?,915 ))?916 },917 )?,918 IfElse {919 cond,920 cond_then,921 cond_else,922 } => {923 if evaluate(context.clone(), &cond.0)?924 .try_cast_bool("if condition should be boolean")?925 {926 evaluate(context, cond_then)?927 } else {928 match cond_else {929 Some(v) => evaluate(context, v)?,930 None => Val::Null,931 }932 }933 }934 Import(path) => {935 let mut tmp = loc936 .clone()937 .expect("imports can't be used without loc_data")938 .0;939 let import_location = Rc::make_mut(&mut tmp);940 import_location.pop();941 push(942 loc,943 || format!("import {:?}", path),944 || with_state(|s| s.import_file(&import_location, path)),945 )?946 }947 ImportStr(path) => {948 let mut tmp = loc949 .clone()950 .expect("imports can't be used without loc_data")951 .0;952 let import_location = Rc::make_mut(&mut tmp);953 import_location.pop();954 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)955 }956 Literal(LiteralType::Super) => return create_error_result(crate::Error::StandaloneSuper),957 })958}