1use crate::{2 binding, bool_val, context_creator, function_default, function_rhs, future_wrapper,3 lazy_binding, lazy_val, Context, ContextCreator, EvaluationState, FuncDesc, LazyBinding,4 ObjMember, ObjValue, Val,5};6use closure::closure;7use jsonnet_parser::{8 el, Arg, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember,9 ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,10 Visibility,11};12use std::{13 collections::{BTreeMap, HashMap},14 rc::Rc,15};1617pub fn evaluate_binding(18 eval_state: EvaluationState,19 b: &BindSpec,20 context_creator: ContextCreator,21) -> (String, LazyBinding) {22 let b = b.clone();23 if let Some(args) = &b.params {24 let args = args.clone();25 (26 b.name.clone(),27 lazy_binding!(move |this, super_obj| lazy_val!(28 closure!(clone b, clone args, clone context_creator, clone eval_state, || evaluate_method(29 context_creator.0(this.clone(), super_obj.clone()),30 eval_state.clone(),31 &b.value,32 args.clone()33 ))34 )),35 )36 } else {37 (38 b.name.clone(),39 lazy_binding!(move |this, super_obj| {40 lazy_val!(41 closure!(clone context_creator, clone b, clone eval_state, || evaluate(42 context_creator.0(this.clone(), super_obj.clone()),43 eval_state.clone(),44 &b.value45 ))46 )47 }),48 )49 }50}5152pub fn evaluate_method(53 ctx: Context,54 eval_state: EvaluationState,55 expr: &LocExpr,56 arg_spec: ParamsDesc,57) -> Val {58 Val::Func(FuncDesc {59 ctx,60 params: arg_spec,61 eval_rhs: function_rhs!(62 closure!(clone expr, clone eval_state, |ctx| evaluate(ctx, eval_state.clone(), &expr))63 ),64 eval_default: function_default!(65 closure!(clone eval_state, |ctx, default| evaluate(ctx, eval_state.clone(), &default))66 ),67 })68}6970pub fn evaluate_field_name(71 context: Context,72 eval_state: EvaluationState,73 field_name: &jsonnet_parser::FieldName,74) -> String {75 match field_name {76 jsonnet_parser::FieldName::Fixed(n) => n.clone(),77 jsonnet_parser::FieldName::Dyn(expr) => {78 let name = evaluate(context, eval_state, expr).unwrap_if_lazy();79 match name {80 Val::Str(n) => n,81 _ => panic!(82 "dynamic field name can be only evaluated to 'string', got: {:?}",83 name84 ),85 }86 }87 }88}8990pub fn evaluate_unary_op(op: UnaryOpType, b: &Val) -> Val {91 match (op, b) {92 (o, Val::Lazy(l)) => evaluate_unary_op(o, &l.evaluate()),93 (UnaryOpType::Not, Val::Bool(v)) => Val::Bool(!v),94 (op, o) => panic!("unary op not implemented: {:?} {:?}", op, o),95 }96}9798pub fn evaluate_add_op(a: &Val, b: &Val) -> Val {99 match (a, b) {100 (Val::Str(v1), Val::Str(v2)) => Val::Str(v1.to_owned() + &v2),101 (Val::Str(v1), Val::Num(v2)) => Val::Str(format!("{}{}", v1, v2)),102 (Val::Num(v1), Val::Str(v2)) => Val::Str(format!("{}{}", v1, v2)),103 (Val::Obj(v1), Val::Obj(v2)) => Val::Obj(v2.with_super(v1.clone())),104 (Val::Arr(a), Val::Arr(b)) => Val::Arr([&a[..], &b[..]].concat()),105 (Val::Num(v1), Val::Num(v2)) => Val::Num(v1 + v2),106 _ => panic!("can't add: {:?} and {:?}", a, b),107 }108}109110pub fn evaluate_binary_op(111 context: Context,112 eval_state: EvaluationState,113 a: &Val,114 op: BinaryOpType,115 b: &Val,116) -> Val {117 match (a, op, b) {118 (Val::Lazy(a), o, b) => evaluate_binary_op(context, eval_state, &a.evaluate(), o, b),119 (a, o, Val::Lazy(b)) => evaluate_binary_op(context, eval_state, a, o, &b.evaluate()),120121 (a, BinaryOpType::Add, b) => evaluate_add_op(a, b),122123 (Val::Str(v1), BinaryOpType::Ne, Val::Str(v2)) => bool_val(v1 != v2),124125 (Val::Str(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Str(v1.repeat(*v2 as usize)),126 (Val::Str(format), BinaryOpType::Mod, args) => evaluate(127 context128 .with_var("__tmp__format__".to_owned(), Val::Str(format.to_owned()))129 .with_var(130 "__tmp__args__".to_owned(),131 match args {132 Val::Arr(v) => Val::Arr(v.clone()),133 v => Val::Arr(vec![v.clone()]),134 },135 ),136 eval_state,137 &el!(Expr::Apply(138 el!(Expr::Index(139 el!(Expr::Var("std".to_owned())),140 el!(Expr::Str("format".to_owned()))141 )),142 ArgsDesc(vec![143 Arg(None, el!(Expr::Var("__tmp__format__".to_owned()))),144 Arg(None, el!(Expr::Var("__tmp__args__".to_owned())))145 ])146 )),147 ),148149 (Val::Bool(a), BinaryOpType::And, Val::Bool(b)) => Val::Bool(*a && *b),150 (Val::Bool(a), BinaryOpType::Or, Val::Bool(b)) => Val::Bool(*a || *b),151152 (Val::Num(v1), BinaryOpType::Mul, Val::Num(v2)) => Val::Num(v1 * v2),153 (Val::Num(v1), BinaryOpType::Div, Val::Num(v2)) => Val::Num(v1 / v2),154 (Val::Num(v1), BinaryOpType::Mod, Val::Num(v2)) => Val::Num(v1 % v2),155156 (Val::Num(v1), BinaryOpType::Sub, Val::Num(v2)) => Val::Num(v1 - v2),157158 (Val::Num(v1), BinaryOpType::Lhs, Val::Num(v2)) => {159 Val::Num(((*v1 as i32) << (*v2 as i32)) as f64)160 }161 (Val::Num(v1), BinaryOpType::Rhs, Val::Num(v2)) => {162 Val::Num(((*v1 as i32) >> (*v2 as i32)) as f64)163 }164165 (Val::Num(v1), BinaryOpType::Lt, Val::Num(v2)) => bool_val(v1 < v2),166 (Val::Num(v1), BinaryOpType::Gt, Val::Num(v2)) => bool_val(v1 > v2),167 (Val::Num(v1), BinaryOpType::Lte, Val::Num(v2)) => bool_val(v1 <= v2),168 (Val::Num(v1), BinaryOpType::Gte, Val::Num(v2)) => bool_val(v1 >= v2),169170 (Val::Num(v1), BinaryOpType::Eq, Val::Num(v2)) => bool_val((v1 - v2).abs() < f64::EPSILON),171 (Val::Num(v1), BinaryOpType::Ne, Val::Num(v2)) => bool_val((v1 - v2).abs() > f64::EPSILON),172173 (Val::Num(v1), BinaryOpType::BitAnd, Val::Num(v2)) => {174 Val::Num(((*v1 as i32) & (*v2 as i32)) as f64)175 }176 (Val::Num(v1), BinaryOpType::BitOr, Val::Num(v2)) => {177 Val::Num(((*v1 as i32) | (*v2 as i32)) as f64)178 }179 (Val::Num(v1), BinaryOpType::BitXor, Val::Num(v2)) => {180 Val::Num(((*v1 as i32) ^ (*v2 as i32)) as f64)181 }182 (a, BinaryOpType::Eq, b) => bool_val(a == b),183 (a, BinaryOpType::Ne, b) => bool_val(a != b),184 _ => panic!("no rules for binary operation: {:?} {:?} {:?}", a, op, b),185 }186}187188future_wrapper!(HashMap<String, LazyBinding>, FutureNewBindings);189future_wrapper!(ObjValue, FutureObjValue);190191pub fn evaluate_comp(192 context: Context,193 eval_state: EvaluationState,194 value: &LocExpr,195 specs: &[CompSpec],196) -> Option<Vec<Val>> {197 match specs.get(0) {198 None => Some(vec![evaluate(context, eval_state, &value)]),199 Some(CompSpec::IfSpec(IfSpecData(cond))) => {200 match evaluate(context.clone(), eval_state.clone(), &cond).unwrap_if_lazy() {201 Val::Bool(false) => None,202 Val::Bool(true) => evaluate_comp(context, eval_state, value, &specs[1..]),203 _ => panic!("if expression evaluated to non-boolean value"),204 }205 }206 Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {207 match evaluate(context.clone(), eval_state.clone(), &expr).unwrap_if_lazy() {208 Val::Arr(list) => {209 let mut out = Vec::new();210 for item in list {211 let item = item.clone();212 out.push(evaluate_comp(213 context.with_var(var.clone(), item),214 eval_state.clone(),215 value,216 &specs[1..],217 ));218 }219 Some(out.iter().flatten().flatten().cloned().collect())220 }221 _ => panic!("for expression evaluated to non-iterable value"),222 }223 }224 }225}226227228pub fn evaluate_object(context: Context, eval_state: EvaluationState, object: ObjBody) -> ObjValue {229 match object {230 ObjBody::MemberList(members) => {231 let new_bindings = FutureNewBindings::new();232 let future_this = FutureObjValue::new();233 let context_creator = context_creator!(234 closure!(clone context, clone new_bindings, clone future_this, |this: Option<ObjValue>, super_obj: Option<ObjValue>| {235 context.clone().extend(236 new_bindings.clone().unwrap(),237 context.clone().dollar().clone().or_else(||this.clone()),238 Some(this.unwrap()),239 super_obj240 )241 })242 );243 {244 let mut bindings: HashMap<String, LazyBinding> = HashMap::new();245 for (n, b) in members246 .iter()247 .filter_map(|m| match m {248 Member::BindStmt(b) => Some(b.clone()),249 _ => None,250 })251 .map(|b| evaluate_binding(eval_state.clone(), &b, context_creator.clone()))252 {253 bindings.insert(n, b);254 }255 new_bindings.fill(bindings);256 }257258 let mut new_members = BTreeMap::new();259 for member in members.into_iter() {260 match member {261 Member::Field(FieldMember {262 name,263 plus,264 params: None,265 visibility,266 value,267 }) => {268 let name = evaluate_field_name(context.clone(), eval_state.clone(), &name);269 new_members.insert(270 name,271 ObjMember {272 add: plus,273 visibility: visibility.clone(),274 invoke: binding!(275 closure!(clone value, clone context_creator, clone eval_state, |this, super_obj| {276 let context = context_creator.0(this, super_obj);277 278 evaluate(279 context,280 eval_state.clone(),281 &value,282 ).unwrap_if_lazy()283 })284 ),285 },286 );287 }288 Member::Field(FieldMember {289 name,290 params: Some(params),291 value,292 ..293 }) => {294 let name = evaluate_field_name(context.clone(), eval_state.clone(), &name);295 new_members.insert(296 name,297 ObjMember {298 add: false,299 visibility: Visibility::Hidden,300 invoke: binding!(301 closure!(clone value, clone context_creator, clone eval_state, |this, super_obj| {302 303 evaluate_method(304 context_creator.0(this, super_obj),305 eval_state.clone(),306 &value.clone(),307 params.clone(),308 )309 })310 ),311 },312 );313 }314 Member::BindStmt(_) => {}315 Member::AssertStmt(_) => {}316 }317 }318 future_this.fill(ObjValue::new(None, Rc::new(new_members)))319 }320 _ => todo!(),321 }322}323324pub fn evaluate(context: Context, eval_state: EvaluationState, expr: &LocExpr) -> Val {325 use Expr::*;326 eval_state.clone().push(expr.clone(), "expr".to_owned(), || {327 let LocExpr(expr, loc) = expr;328 match &**expr {329 Literal(LiteralType::This) => Val::Obj(330 context331 .this()332 .clone()333 .unwrap_or_else(|| panic!("this not found")),334 ),335 Literal(LiteralType::Super) => Val::Obj(336 context337 .super_obj()338 .clone()339 .unwrap_or_else(|| panic!("super not found")),340 ),341 Literal(LiteralType::True) => Val::Bool(true),342 Literal(LiteralType::False) => Val::Bool(false),343 Literal(LiteralType::Null) => Val::Null,344 Parened(e) => evaluate(context, eval_state.clone(), e),345 Str(v) => Val::Str(v.clone()),346 Num(v) => Val::Num(*v),347 BinaryOp(v1, o, v2) => {348 let a = evaluate(context.clone(), eval_state.clone(), v1).unwrap_if_lazy();349 let op = *o;350 let b = evaluate(context.clone(), eval_state.clone(), v2).unwrap_if_lazy();351 evaluate_binary_op(352 context,353 eval_state,354 &a,355 op,356 &b,357 )358 },359 UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, eval_state, v)),360 Var(name) => Val::Lazy(context.binding(&name)).unwrap_if_lazy(),361 Index(value, index) => {362 match (363 evaluate(context.clone(), eval_state.clone(), value).unwrap_if_lazy(),364 evaluate(context.clone(), eval_state.clone(), index),365 ) {366 (Val::Obj(v), Val::Str(s)) => v367 .get(&s)368 .unwrap_or_else(closure!(clone context, clone eval_state, || {369 if let Some(n) = v.get("__intristic_namespace__") {370 if let Val::Str(n) = n.unwrap_if_lazy() {371 Val::Intristic(n, s)372 } else {373 panic!("__intristic_namespace__ should be string");374 }375 } else {376 panic!("{} not found in {:?}", s, v)377 }378 }))379 .unwrap_if_lazy(),380 (Val::Arr(v), Val::Num(n)) => v381 .get(n as usize)382 .unwrap_or_else(|| panic!("out of bounds"))383 .clone(),384 (Val::Str(s), Val::Num(n)) => {385 Val::Str(s.chars().skip(n as usize).take(1).collect())386 }387 (v, i) => todo!("not implemented: {:?}[{:?}]", v, i.unwrap_if_lazy()),388 }389 }390 LocalExpr(bindings, returned) => {391 let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();392 let future_context = Context::new_future();393394 let context_creator = context_creator!(395 closure!(clone future_context, |_, _| future_context.clone().unwrap())396 );397398 for (k, v) in bindings399 .iter()400 .map(|b| evaluate_binding(eval_state.clone(), b, context_creator.clone()))401 {402 new_bindings.insert(k, v);403 }404405 let context = context406 .extend(new_bindings, None, None, None)407 .into_future(future_context);408 evaluate(context, eval_state.clone(), &returned.clone())409 }410 Arr(items) => {411 let mut out = Vec::with_capacity(items.len());412 for item in items {413 out.push(evaluate(context.clone(), eval_state.clone(), item));414 }415 Val::Arr(out)416 }417 ArrComp(expr, compspecs) => {418 Val::Arr(evaluate_comp(context, eval_state, expr, compspecs).unwrap())419 }420 Obj(body) => Val::Obj(evaluate_object(context, eval_state, body.clone())),421 Apply(value, ArgsDesc(args)) => {422 let value = evaluate(context.clone(), eval_state.clone(), value).unwrap_if_lazy();423 match value {424 425 Val::Intristic(ns, name) => match (&ns as &str, &name as &str) {426 427 ("std", "length") => {428 assert_eq!(args.len(), 1);429 let expr = &args.get(0).unwrap().1;430 match evaluate(context, eval_state.clone(), expr) {431 Val::Str(n) => Val::Num(n.chars().count() as f64),432 Val::Arr(i) => Val::Num(i.len() as f64),433 v => panic!("can't get length of {:?}", v),434 }435 }436 437 ("std", "type") => {438 assert_eq!(args.len(), 1);439 let expr = &args.get(0).unwrap().1;440 Val::Str(evaluate(context, eval_state, expr).type_of().to_owned())441 }442 443 ("std", "makeArray") => {444 assert_eq!(args.len(), 2);445 if let (Val::Num(v), Val::Func(d)) = (446 evaluate(context.clone(), eval_state.clone(), &args[0].1),447 evaluate(context, eval_state, &args[1].1),448 ) {449 assert!(v > 0.0);450 let mut out = Vec::with_capacity(v as usize);451 for i in 0..v as usize {452 out.push(d.evaluate(vec![(None, Val::Num(i as f64))]))453 }454 Val::Arr(out)455 } else {456 panic!("bad makeArray call");457 }458 }459 460 ("std", "codepoint") => {461 assert_eq!(args.len(), 1);462 if let Val::Str(s) = evaluate(context, eval_state, &args[0].1) {463 assert!(464 s.chars().count() == 1,465 "std.codepoint should receive single char string"466 );467 Val::Num(s.chars().take(1).next().unwrap() as u32 as f64)468 } else {469 panic!("bad codepoint call");470 }471 }472 473 ("std", "objectFieldsEx") => {474 assert_eq!(args.len(), 2);475 if let (Val::Obj(body), Val::Bool(_include_hidden)) = (476 evaluate(context.clone(), eval_state.clone(), &args[0].1),477 evaluate(context, eval_state, &args[1].1),478 ) {479 480 Val::Arr(body.fields().into_iter().map(Val::Str).collect())481 } else {482 panic!("bad objectFieldsEx call");483 }484 }485 (ns, name) => panic!("Intristic not found: {}.{}", ns, name),486 },487 Val::Func(f) => f.evaluate(488 args.clone()489 .into_iter()490 .map(move |a| {491 (492 a.clone().0,493 Val::Lazy(lazy_val!(494 closure!(clone context, clone a, clone eval_state, || evaluate(context.clone(), eval_state.clone(), &a.clone().1))495 )),496 )497 })498 .collect(),499 ),500 _ => panic!("{:?} is not a function", value),501 }502 }503 Function(params, body) => evaluate_method(context, eval_state, body, params.clone()),504 AssertExpr(AssertStmt(value, msg), returned) => {505 if evaluate(context.clone(), eval_state.clone(), &value).try_cast_bool() {506 evaluate(context, eval_state, returned)507 }else {508 if let Some(msg) = msg {509 panic!("assertion failed ({:?}): {}", value, evaluate(context, eval_state, msg).try_cast_str());510 } else {511 panic!("assertion failed ({:?}): no message", value);512 }513 }514 },515 Error(e) => panic!("error: {}", evaluate(context, eval_state, e)),516 IfElse {517 cond,518 cond_then,519 cond_else,520 } => match evaluate(context.clone(), eval_state.clone(), &cond.0).unwrap_if_lazy() {521 Val::Bool(true) => evaluate(context, eval_state.clone(), cond_then),522 Val::Bool(false) => match cond_else {523 Some(v) => evaluate(context, eval_state, v),524 None => Val::Bool(false),525 },526 v => panic!("if condition evaluated to {:?} (boolean needed instead)", v),527 },528 _ => panic!(529 "evaluation not implemented: {:?}",530 LocExpr(expr.clone(), loc.clone())531 ),532 }533 })534}