1use crate::{2 builtin::format::{format_arr, format_obj},3 context_creator, equals,4 error::Error::*,5 escape_string_json, future_wrapper, lazy_val, manifest_json_ex, parse_args, primitive_equals,6 push, throw, with_state, Context, ContextCreator, FuncDesc, LazyBinding, LazyVal, LocError,7 ObjMember, ObjValue, Result, Val, ValType,8};9use closure::closure;10use jrsonnet_parser::{11 ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,12 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,13 Visibility,14};15use std::{cmp::Ordering, collections::HashMap, path::PathBuf, rc::Rc};1617pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {18 let b = b.clone();19 if let Some(params) = &b.params {20 let params = params.clone();21 (22 b.name.clone(),23 LazyBinding::Bindable(Rc::new(move |this, super_obj| {24 Ok(lazy_val!(25 closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(26 context_creator.0(this.clone(), super_obj.clone())?,27 b.name.clone(),28 params.clone(),29 b.value.clone(),30 )))31 ))32 })),33 )34 } else {35 (36 b.name.clone(),37 LazyBinding::Bindable(Rc::new(move |this, super_obj| {38 Ok(lazy_val!(closure!(clone context_creator, clone b, ||39 evaluate_named(40 context_creator.0(this.clone(), super_obj.clone())?,41 &b.value,42 b.name.clone()43 )44 )))45 })),46 )47 }48}4950pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {51 Val::Func(Rc::new(FuncDesc {52 name,53 ctx,54 params,55 body,56 }))57}5859pub fn evaluate_field_name(60 context: Context,61 field_name: &jrsonnet_parser::FieldName,62) -> Result<Option<Rc<str>>> {63 Ok(match field_name {64 jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),65 jrsonnet_parser::FieldName::Dyn(expr) => {66 let lazy = evaluate(context, expr)?;67 let value = lazy.unwrap_if_lazy()?;68 if matches!(value, Val::Null) {69 None70 } else {71 Some(value.try_cast_str("dynamic field name")?)72 }73 }74 })75}7677pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Result<Val> {78 Ok(match (op, b) {79 (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()?)?,80 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),81 (UnaryOpType::Minus, Val::Num(n)) => Val::Num(-*n),82 (UnaryOpType::BitNot, Val::Num(n)) => Val::Num(!(*n as i32) as f64),83 (op, o) => throw!(UnaryOperatorDoesNotOperateOnType(op, o.value_type()?)),84 })85}8687pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {88 Ok(match (a, b) {89 (Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),9091 92 (Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),93 (Val::Str(o), Val::Num(n)) => Val::Str(format!("{}{}", o, n).into()),9495 (Val::Str(s), o) => Val::Str(format!("{}{}", s, o.clone().into_json(0)?).into()),96 (o, Val::Str(s)) => Val::Str(format!("{}{}", o.clone().into_json(0)?, s).into()),9798 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),99 (Val::Arr(a), Val::Arr(b)) => Val::Arr(Rc::new([&a[..], &b[..]].concat())),100 (Val::Num(v1), Val::Num(v2)) => Val::new_checked_num(v1 + v2)?,101 _ => throw!(BinaryOperatorDoesNotOperateOnValues(102 BinaryOpType::Add,103 a.value_type()?,104 b.value_type()?,105 )),106 })107}108109pub fn evaluate_binary_op_special(110 context: Context,111 a: &LocExpr,112 op: BinaryOpType,113 b: &LocExpr,114) -> Result<Val> {115 Ok(116 match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {117 (Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),118 (Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),119 (a, op, eb) => {120 evaluate_binary_op_normal(&a, op, &evaluate(context, eb)?.unwrap_if_lazy()?)?121 }122 },123 )124}125126pub fn evaluate_binary_op_normal(a: &Val, op: BinaryOpType, b: &Val) -> Result<Val> {127 Ok(match (a, op, b) {128 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b)?,129130 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize).into()),131132 133 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),134 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),135136 137 (Val::Str(v1), BinaryOpType::Lt, Val::Str(v2)) => Val::Bool(v1 < v2),138 (Val::Str(v1), BinaryOpType::Gt, Val::Str(v2)) => Val::Bool(v1 > v2),139 (Val::Str(v1), BinaryOpType::Lte, Val::Str(v2)) => Val::Bool(v1 <= v2),140 (Val::Str(v1), BinaryOpType::Gte, Val::Str(v2)) => Val::Bool(v1 >= v2),141142 143 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::new_checked_num(v1 * v2)?,144 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => {145 if *v2 <= f64::EPSILON {146 throw!(DivisionByZero)147 }148 Val::new_checked_num(v1 / v2)?149 }150151 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::new_checked_num(v1 - v2)?,152153 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => Val::Bool(v1 < v2),154 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => Val::Bool(v1 > v2),155 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => Val::Bool(v1 <= v2),156 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => Val::Bool(v1 >= v2),157158 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {159 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)160 }161 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {162 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)163 }164 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {165 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)166 }167 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {168 if *v2 < 0.0 {169 throw!(RuntimeError("shift by negative exponent".into()))170 }171 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)172 }173 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {174 if *v2 < 0.0 {175 throw!(RuntimeError("shift by negative exponent".into()))176 }177 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)178 }179180 _ => throw!(BinaryOperatorDoesNotOperateOnValues(181 op,182 a.value_type()?,183 b.value_type()?,184 )),185 })186}187188future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);189future_wrapper!(ObjValue, FutureObjValue);190191pub fn evaluate_comp<T>(192 context: Context,193 value: &impl Fn(Context) -> Result<T>,194 specs: &[CompSpec],195) -> Result<Option<Vec<T>>> {196 Ok(match specs.get(0) {197 None => Some(vec![value(context)?]),198 Some(CompSpec::IfSpec(IfSpecData(cond))) => {199 if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {200 evaluate_comp(context, value, &specs[1..])?201 } else {202 None203 }204 }205 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {206 match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {207 Val::Arr(list) => {208 let mut out = Vec::new();209 for item in list.iter() {210 let item = item.unwrap_if_lazy()?;211 out.push(evaluate_comp(212 context.clone().with_var(var.clone(), item.clone()),213 value,214 &specs[1..],215 )?);216 }217 Some(out.into_iter().flatten().flatten().collect())218 }219 _ => throw!(InComprehensionCanOnlyIterateOverArray),220 }221 }222 })223}224225pub fn evaluate_member_list_object(context: Context, members: &[Member]) -> Result<ObjValue> {226 let new_bindings = FutureNewBindings::new();227 let future_this = FutureObjValue::new();228 let context_creator = context_creator!(229 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {230 Ok(context.clone().extend_unbound(231 new_bindings.clone().unwrap(),232 context.dollar().clone().or_else(||this.clone()),233 Some(this.unwrap()),234 super_obj235 )?)236 })237 );238 {239 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();240 for (n, b) in members241 .iter()242 .filter_map(|m| match m {243 Member::BindStmt(b) => Some(b.clone()),244 _ => None,245 })246 .map(|b| evaluate_binding(&b, context_creator.clone()))247 {248 bindings.insert(n, b);249 }250 new_bindings.fill(bindings);251 }252253 let mut new_members = HashMap::new();254 for member in members.iter() {255 match member {256 Member::Field(FieldMember {257 name,258 plus,259 params: None,260 visibility,261 value,262 }) => {263 let name = evaluate_field_name(context.clone(), &name)?;264 if name.is_none() {265 continue;266 }267 let name = name.unwrap();268 new_members.insert(269 name.clone(),270 ObjMember {271 add: *plus,272 visibility: *visibility,273 invoke: LazyBinding::Bindable(Rc::new(274 closure!(clone name, clone value, clone context_creator, |this, super_obj| {275 Ok(LazyVal::new_resolved(evaluate(276 context_creator.0(this, super_obj)?,277 &value,278 )?))279 }),280 )),281 location: value.1.clone(),282 },283 );284 }285 Member::Field(FieldMember {286 name,287 params: Some(params),288 value,289 ..290 }) => {291 let name = evaluate_field_name(context.clone(), &name)?;292 if name.is_none() {293 continue;294 }295 let name = name.unwrap();296 new_members.insert(297 name.clone(),298 ObjMember {299 add: false,300 visibility: Visibility::Hidden,301 invoke: LazyBinding::Bindable(Rc::new(302 closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {303 304 Ok(LazyVal::new_resolved(evaluate_method(305 context_creator.0(this, super_obj)?,306 name.clone(),307 params.clone(),308 value.clone(),309 )))310 }),311 )),312 location: value.1.clone(),313 },314 );315 }316 Member::BindStmt(_) => {}317 Member::AssertStmt(_) => {}318 }319 }320 Ok(future_this.fill(ObjValue::new(None, Rc::new(new_members))))321}322323pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {324 Ok(match object {325 ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,326 ObjBody::ObjComp(obj) => {327 let future_this = FutureObjValue::new();328 let mut new_members = HashMap::new();329 for (k, v) in evaluate_comp(330 context.clone(),331 &|ctx| {332 let new_bindings = FutureNewBindings::new();333 let context_creator = context_creator!(334 closure!(clone context, clone new_bindings, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {335 Ok(context.clone().extend_unbound(336 new_bindings.clone().unwrap(),337 context.dollar().clone().or_else(||this.clone()),338 None,339 super_obj340 )?)341 })342 );343 let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();344 for (n, b) in obj345 .pre_locals346 .iter()347 .chain(obj.post_locals.iter())348 .map(|b| evaluate_binding(b, context_creator.clone()))349 {350 bindings.insert(n, b);351 }352 let bindings = new_bindings.fill(bindings);353 let ctx = ctx.extend_unbound(bindings, None, None, None)?;354 let key = evaluate(ctx.clone(), &obj.key)?;355 let value = LazyBinding::Bindable(Rc::new(356 closure!(clone ctx, clone obj.value, |this, _super_obj| {357 Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(HashMap::new(), None, this, None), &value)?))358 }),359 ));360361 Ok((key, value))362 },363 &obj.compspecs,364 )?365 .unwrap()366 {367 match k {368 Val::Null => {}369 Val::Str(n) => {370 new_members.insert(371 n,372 ObjMember {373 add: false,374 visibility: Visibility::Normal,375 invoke: v,376 location: obj.value.1.clone(),377 },378 );379 }380 v => throw!(FieldMustBeStringGot(v.value_type()?)),381 }382 }383384 future_this.fill(ObjValue::new(None, Rc::new(new_members)))385 }386 })387}388389390391macro_rules! noinline {392 ($e:expr) => {393 (#[inline(never)]394 move || $e)()395 };396}397398pub fn evaluate_apply(399 context: Context,400 value: &LocExpr,401 args: &ArgsDesc,402 loc: &Option<ExprLocation>,403 tailstrict: bool,404) -> Result<Val> {405 let lazy = evaluate(context.clone(), value)?;406 let value = lazy.unwrap_if_lazy()?;407 Ok(match value {408 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {409 410 ("std", "length") => parse_args!(context, "std.length", args, 1, [411 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];412 ], {413 Ok(match x {414 Val::Str(n) => Val::Num(n.chars().count() as f64),415 Val::Arr(i) => Val::Num(i.len() as f64),416 Val::Obj(o) => Val::Num(417 o.fields_visibility()418 .into_iter()419 .filter(|(_k, v)| *v)420 .count() as f64,421 ),422 _ => unreachable!(),423 })424 })?,425 426 ("std", "type") => parse_args!(context, "std.type", args, 1, [427 0, x, vec![];428 ], {429 Ok(Val::Str(x.value_type()?.name().into()))430 })?,431 432 ("std", "makeArray") => noinline!(parse_args!(context, "std.makeArray", args, 2, [433 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];434 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];435 ], {436 if sz < 0.0 {437 throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));438 }439 let mut out = Vec::with_capacity(sz as usize);440 for i in 0..sz as usize {441 out.push(func.evaluate_values(442 Context::new(),443 &[Val::Num(i as f64)]444 )?)445 }446 Ok(Val::Arr(Rc::new(out)))447 }))?,448 449 ("std", "codepoint") => parse_args!(context, "std.codepoint", args, 1, [450 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];451 ], {452 assert!(453 str.chars().count() == 1,454 "std.codepoint should receive single char string"455 );456 Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))457 })?,458 459 ("std", "objectFieldsEx") => {460 noinline!(parse_args!(context, "std.objectFieldsEx",args, 2, [461 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];462 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];463 ], {464 let mut out = obj.fields_visibility()465 .into_iter()466 .filter(|(_k, v)| *v || inc_hidden)467 .map(|(k, _v)|k)468 .collect::<Vec<_>>();469 out.sort();470 Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))471 }))?472 }473 474 ("std", "objectHasEx") => parse_args!(context, "std.objectHasEx", args, 3, [475 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];476 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];477 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];478 ], {479 Ok(Val::Bool(480 obj.fields_visibility()481 .into_iter()482 .filter(|(_k, v)| *v || inc_hidden)483 .any(|(k, _v)| *k == *f),484 ))485 })?,486 ("std", "primitiveEquals") => parse_args!(context, "std.primitiveEquals", args, 2, [487 0, a, vec![];488 1, b, vec![];489 ], {490 Ok(Val::Bool(primitive_equals(&a, &b)?))491 })?,492 493 ("std", "equals") => parse_args!(context, "std.equals", args, 2, [494 0, a, vec![];495 1, b, vec![];496 ], {497 Ok(Val::Bool(equals(&a, &b)?))498 })?,499 ("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [500 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];501 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];502 ], {503 Ok(Val::Num(a % b))504 })?,505 ("std", "floor") => parse_args!(context, "std.floor", args, 1, [506 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];507 ], {508 Ok(Val::Num(x.floor()))509 })?,510 ("std", "log") => parse_args!(context, "std.log", args, 2, [511 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];512 ], {513 Ok(Val::Num(n.ln()))514 })?,515 ("std", "trace") => parse_args!(context, "std.trace", args, 2, [516 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];517 1, rest, vec![];518 ], {519 eprint!("TRACE:");520 if let Some(loc) = loc {521 with_state(|s|{522 let locs = s.map_source_locations(&loc.0, &[loc.1]);523 eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);524 });525 }526 eprintln!(" {}", str);527 Ok(rest)528 })?,529 ("std", "pow") => parse_args!(context, "std.modulo", args, 2, [530 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];531 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];532 ], {533 Ok(Val::Num(x.powf(n)))534 })?,535 ("std", "extVar") => parse_args!(context, "std.extVar", args, 2, [536 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];537 ], {538 Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or_else(539 || UndefinedExternalVariable(x),540 )?)541 })?,542 ("std", "filter") => noinline!(parse_args!(context, "std.filter", args, 2, [543 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];544 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];545 ], {546 Ok(Val::Arr(Rc::new(547 arr.iter()548 .cloned()549 .filter(|e| {550 func551 .evaluate_values(context.clone(), &[e.clone()])552 .unwrap()553 .try_cast_bool("filter predicate")554 .unwrap()555 })556 .collect(),557 )))558 }))?,559 560 ("std", "foldl") => noinline!(parse_args!(context, "std.foldl", args, 3, [561 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];562 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];563 2, init, vec![];564 ], {565 let mut acc = init;566 for i in arr.iter().cloned() {567 acc = func.evaluate_values(context.clone(), &[acc, i])?;568 }569 Ok(acc)570 }))?,571 572 ("std", "foldr") => noinline!(parse_args!(context, "std.foldr", args, 3, [573 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];574 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];575 2, init, vec![];576 ], {577 let mut acc = init;578 for i in arr.iter().rev().cloned() {579 acc = func.evaluate_values(context.clone(), &[acc, i])?;580 }581 Ok(acc)582 }))?,583 584 #[allow(non_snake_case)]585 ("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(LocError::new(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(RuntimeError("types of all array elements should equal".into()).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 _ => throw!(RuntimeError("keys should be number or string".into()))633 }634 Ok(Val::Arr(Rc::new(new_arr)))635 }))?,636 637 ("std", "format") => parse_args!(context, "std.format", args, 2, [638 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];639 1, vals, vec![]640 ], {641 push(&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)), ||format!("std.format of {}", str), ||{642 Ok(match vals {643 Val::Arr(vals) => Val::Str(format_arr(&str, &vals)?.into()),644 Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),645 o => Val::Str(format_arr(&str, &[o])?.into()),646 })647 })648 })?,649 650 ("std", "range") => parse_args!(context, "std.range", args, 2, [651 0, from: [Val::Num]!!Val::Num, vec![ValType::Num];652 0, to: [Val::Num]!!Val::Num, vec![ValType::Num];653 ], {654 let mut out = Vec::with_capacity((1+to as usize-from as usize).max(0));655 for i in from as usize..=to as usize {656 out.push(Val::Num(i as f64));657 }658 Ok(Val::Arr(Rc::new(out)))659 })?,660 ("std", "char") => parse_args!(context, "std.char", args, 1, [661 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];662 ], {663 let mut out = String::new();664 out.push(std::char::from_u32(n as u32).ok_or_else(||665 InvalidUnicodeCodepointGot(n as u32)666 )?);667 Ok(Val::Str(out.into()))668 })?,669 ("std", "encodeUTF8") => parse_args!(context, "std.encodeUtf8", args, 1, [670 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];671 ], {672 Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))673 })?,674 ("std", "md5") => noinline!(parse_args!(context, "std.md5", args, 1, [675 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];676 ], {677 Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))678 }))?,679 680 ("std", "base64") => parse_args!(context, "std.base64", args, 1, [681 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];682 ], {683 Ok(Val::Str(match input {684 Val::Str(s) => {685 base64::encode(s.bytes().collect::<Vec<_>>()).into()686 },687 Val::Arr(a) => {688 base64::encode(a.iter().map(|v| {689 Ok(v.clone().try_cast_num("base64 array")? as u8)690 }).collect::<Result<Vec<_>>>()?).into()691 },692 _ => unreachable!()693 }))694 })?,695 696 ("std", "join") => noinline!(parse_args!(context, "std.join", args, 2, [697 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];698 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];699 ], {700 Ok(match sep {701 Val::Arr(joiner_items) => {702 let mut out = Vec::new();703704 let mut first = true;705 for item in arr.iter().cloned() {706 if let Val::Arr(items) = item.unwrap_if_lazy()? {707 if !first {708 out.reserve(joiner_items.len());709 out.extend(joiner_items.iter().cloned());710 }711 first = false;712 out.reserve(items.len());713 out.extend(items.iter().cloned());714 } else {715 throw!(RuntimeError("in std.join all items should be arrays".into()));716 }717 }718719 Val::Arr(Rc::new(out))720 },721 Val::Str(sep) => {722 let mut out = String::new();723724 let mut first = true;725 for item in arr.iter().cloned() {726 if let Val::Str(item) = item.unwrap_if_lazy()? {727 if !first {728 out += &sep;729 }730 first = false;731 out += &item;732 } else {733 throw!(RuntimeError("in std.join all items should be strings".into()));734 }735 }736737 Val::Str(out.into())738 },739 _ => unreachable!()740 })741 }))?,742 743 ("std", "escapeStringJson") => parse_args!(context, "std.escapeStringJson", args, 1, [744 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];745 ], {746 Ok(Val::Str(escape_string_json(&str_).into()))747 })?,748 749 ("std", "manifestJsonEx") => parse_args!(context, "std.manifestJsonEx", args, 2, [750 0, value, vec![];751 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];752 ], {753 Ok(Val::Str(manifest_json_ex(&value, &indent)?.into()))754 })?,755 (ns, name) => throw!(IntristicNotFound(ns.into(), name.into())),756 },757 Val::Func(f) => {758 let body = || f.evaluate(context, args, tailstrict);759 if tailstrict {760 body()?761 } else {762 push(loc, || format!("function <{}> call", f.name), body)?763 }764 }765 v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type()?)),766 })767}768769pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: Rc<str>) -> Result<Val> {770 use Expr::*;771 let LocExpr(expr, _loc) = lexpr;772 Ok(match &**expr {773 Function(params, body) => evaluate_method(context, name, params.clone(), body.clone()),774 _ => evaluate(context, lexpr)?,775 })776}777778pub fn evaluate(context: Context, expr: &LocExpr) -> Result<Val> {779 use Expr::*;780 let LocExpr(expr, loc) = expr;781 Ok(match &**expr {782 Literal(LiteralType::This) => Val::Obj(783 context784 .this()785 .clone()786 .ok_or_else(|| CantUseSelfOutsideOfObject)?,787 ),788 Literal(LiteralType::Dollar) => Val::Obj(789 context790 .dollar()791 .clone()792 .ok_or_else(|| NoTopLevelObjectFound)?,793 ),794 Literal(LiteralType::True) => Val::Bool(true),795 Literal(LiteralType::False) => Val::Bool(false),796 Literal(LiteralType::Null) => Val::Null,797 Parened(e) => evaluate(context, e)?,798 Str(v) => Val::Str(v.clone()),799 Num(v) => Val::new_checked_num(*v)?,800 BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,801 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,802 Var(name) => push(803 loc,804 || format!("variable <{}>", name),805 || Ok(Val::Lazy(context.binding(name.clone())?).unwrap_if_lazy()?),806 )?,807 Index(LocExpr(v, _), index) if matches!(&**v, Expr::Literal(LiteralType::Super)) => {808 let name = evaluate(context.clone(), index)?.try_cast_str("object index")?;809 context810 .super_obj()811 .clone()812 .expect("no super found")813 .get_raw(name, &context.this().clone().expect("no this found"))?814 .expect("value not found")815 }816 Index(value, index) => {817 match (818 evaluate(context.clone(), value)?.unwrap_if_lazy()?,819 evaluate(context, index)?,820 ) {821 (Val::Obj(v), Val::Str(s)) => {822 if let Some(v) = v.get(s.clone())? {823 v.unwrap_if_lazy()?824 } else if let Some(Val::Str(n)) = v.get("__intristic_namespace__".into())? {825 Val::Intristic(n, s)826 } else {827 throw!(NoSuchField(s))828 }829 }830 (Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(831 ValType::Obj,832 ValType::Str,833 n.value_type()?,834 )),835836 (Val::Arr(v), Val::Num(n)) => {837 if n.fract() > f64::EPSILON {838 throw!(FractionalIndex)839 }840 v.get(n as usize)841 .ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?842 .clone()843 .unwrap_if_lazy()?844 }845 (Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),846 (Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(847 ValType::Arr,848 ValType::Num,849 n.value_type()?,850 )),851852 (Val::Str(s), Val::Num(n)) => Val::Str(853 s.chars()854 .skip(n as usize)855 .take(1)856 .collect::<String>()857 .into(),858 ),859 (Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(860 ValType::Str,861 ValType::Num,862 n.value_type()?,863 )),864865 (v, _) => throw!(CantIndexInto(v.value_type()?)),866 }867 }868 LocalExpr(bindings, returned) => {869 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();870 let future_context = Context::new_future();871872 let context_creator = context_creator!(873 closure!(clone future_context, |_, _| Ok(future_context.clone().unwrap()))874 );875876 for (k, v) in bindings877 .iter()878 .map(|b| evaluate_binding(b, context_creator.clone()))879 {880 new_bindings.insert(k, v);881 }882883 let context = context884 .extend_unbound(new_bindings, None, None, None)?885 .into_future(future_context);886 evaluate(context, &returned.clone())?887 }888 Arr(items) => {889 let mut out = Vec::with_capacity(items.len());890 for item in items {891 out.push(Val::Lazy(lazy_val!(892 closure!(clone context, clone item, || {893 evaluate(context.clone(), &item)894 })895 )));896 }897 Val::Arr(Rc::new(out))898 }899 ArrComp(expr, compspecs) => Val::Arr(900 901 Rc::new(evaluate_comp(context, &|ctx| evaluate(ctx, expr), compspecs)?.unwrap()),902 ),903 Obj(body) => Val::Obj(evaluate_object(context, body)?),904 ObjExtend(s, t) => evaluate_add_op(905 &evaluate(context.clone(), s)?,906 &Val::Obj(evaluate_object(context, t)?),907 )?,908 Apply(value, args, tailstrict) => evaluate_apply(context, value, args, loc, *tailstrict)?,909 Function(params, body) => {910 evaluate_method(context, "anonymous".into(), params.clone(), body.clone())911 }912 AssertExpr(AssertStmt(value, msg), returned) => {913 let assertion_result = push(914 &value.1,915 || "assertion condition".to_owned(),916 || {917 evaluate(context.clone(), &value)?918 .try_cast_bool("assertion condition should be boolean")919 },920 )?;921 if assertion_result {922 evaluate(context, returned)?923 } else if let Some(msg) = msg {924 throw!(AssertionFailed(evaluate(context, msg)?));925 } else {926 throw!(AssertionFailed(Val::Null));927 }928 }929 ErrorStmt(e) => push(930 &loc,931 || "error statement".to_owned(),932 || {933 throw!(RuntimeError(934 evaluate(context, e)?.try_cast_str("error text should be string")?,935 ))936 },937 )?,938 IfElse {939 cond,940 cond_then,941 cond_else,942 } => {943 if evaluate(context.clone(), &cond.0)?944 .try_cast_bool("if condition should be boolean")?945 {946 evaluate(context, cond_then)?947 } else {948 match cond_else {949 Some(v) => evaluate(context, v)?,950 None => Val::Null,951 }952 }953 }954 Import(path) => {955 let mut tmp = loc956 .clone()957 .expect("imports can't be used without loc_data")958 .0;959 let import_location = Rc::make_mut(&mut tmp);960 import_location.pop();961 push(962 loc,963 || format!("import {:?}", path),964 || with_state(|s| s.import_file(&import_location, path)),965 )?966 }967 ImportStr(path) => {968 let mut tmp = loc969 .clone()970 .expect("imports can't be used without loc_data")971 .0;972 let import_location = Rc::make_mut(&mut tmp);973 import_location.pop();974 Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)975 }976 Literal(LiteralType::Super) => throw!(StandaloneSuper),977 })978}