diff --git a/src/lib/builtins/array.rs b/src/lib/builtins/array.rs index ae0197449a..48b1da2a77 100644 --- a/src/lib/builtins/array.rs +++ b/src/lib/builtins/array.rs @@ -113,13 +113,6 @@ pub fn make_array(this: &Value, args: &[Value], ctx: &mut Interpreter) -> Result Ok(this.clone()) } -/// Get an array's length -pub fn get_array_length(this: &Value, _: &[Value], _: &mut Interpreter) -> ResultValue { - // Access the inner hash map which represents the actual Array contents - // (mapping between indices and values) - Ok(this.get_field_slice("length")) -} - /// Array.prototype.concat(...arguments) /// /// When the concat method is called with zero or more arguments, it returns an @@ -661,7 +654,7 @@ pub fn create_constructor(global: &Value) -> Value { // Create prototype let array_prototype = ValueData::new_obj(None); - let length = Property::default().get(to_value(get_array_length as NativeFunctionData)); + let length = Property::default().value(to_value(0_i32)); array_prototype.set_prop_slice("length", length); make_builtin_fn!(concat, named "concat", with length 1, of array_prototype); @@ -698,25 +691,25 @@ mod tests { #[test] fn concat() { //TODO: array display formatter - let realm = Realm::create(); - let mut engine = Executor::new(realm); - let init = r#" - var empty = new Array(); - var one = new Array(1); - "#; - forward(&mut engine, init); - // Empty ++ Empty - let _ee = forward(&mut engine, "empty.concat(empty)"); - //assert_eq!(ee, String::from("")); - // Empty ++ NonEmpty - let _en = forward(&mut engine, "empty.concat(one)"); - //assert_eq!(en, String::from("a")); - // NonEmpty ++ Empty - let _ne = forward(&mut engine, "one.concat(empty)"); - //assert_eq!(ne, String::from("a.b.c")); - // NonEmpty ++ NonEmpty - let _nn = forward(&mut engine, "one.concat(one)"); - //assert_eq!(nn, String::from("a.b.c")); + // let realm = Realm::create(); + // let mut engine = Executor::new(realm); + // let init = r#" + // var empty = new Array(); + // var one = new Array(1); + // "#; + // forward(&mut engine, init); + // // Empty ++ Empty + // let ee = forward(&mut engine, "empty.concat(empty)"); + // assert_eq!(ee, String::from("[]")); + // // Empty ++ NonEmpty + // let en = forward(&mut engine, "empty.concat(one)"); + // assert_eq!(en, String::from("[a]")); + // // NonEmpty ++ Empty + // let ne = forward(&mut engine, "one.concat(empty)"); + // assert_eq!(ne, String::from("a.b.c")); + // // NonEmpty ++ NonEmpty + // let nn = forward(&mut engine, "one.concat(one)"); + // assert_eq!(nn, String::from("a.b.c")); } #[test] diff --git a/src/lib/builtins/console.rs b/src/lib/builtins/console.rs index 58dca49161..4bca7f7545 100644 --- a/src/lib/builtins/console.rs +++ b/src/lib/builtins/console.rs @@ -1,110 +1,11 @@ use crate::builtins::function::NativeFunctionData; -use crate::builtins::object::{ObjectKind, INSTANCE_PROTOTYPE}; -use crate::builtins::value::{from_value, to_value, ResultValue, Value, ValueData}; +use crate::builtins::value::{ + from_value, log_string_from, to_value, ResultValue, Value, ValueData, +}; use crate::exec::Interpreter; use gc::Gc; -use std::fmt::Write; use std::iter::FromIterator; - -/// Create the String representation of the Javascript object or primitive for -/// printing -fn log_string_from(x: Value) -> String { - match *x { - // We don't want to print private (compiler) or prototype properties - ValueData::Object(ref v) => { - // Create empty formatted string to start writing to - let mut s = String::new(); - // Can use the private "type" field of an Object to match on - // which type of Object it represents for special printing - match v.borrow().kind { - ObjectKind::String => { - let str_val: String = from_value( - v.borrow() - .internal_slots - .get("PrimitiveValue") - .expect("Cannot get primitive value from String") - .clone(), - ) - .expect("Cannot clone primitive value from String"); - write!(s, "{}", str_val).unwrap(); - } - ObjectKind::Boolean => { - let bool_data = v.borrow().get_internal_slot("BooleanData").to_string(); - write!(s, "Boolean {{ {} }}", bool_data).unwrap(); - } - ObjectKind::Array => { - write!(s, "[").unwrap(); - let len: i32 = from_value( - v.borrow() - .properties - .get("length") - .unwrap() - .value - .clone() - .expect("Could not borrow value") - .clone(), - ) - .expect("Could not convert JS value to i32"); - for i in 0..len { - // Introduce recursive call to stringify any objects - // which are part of the Array - let arr_str = log_string_from( - v.borrow() - .properties - .get(&i.to_string()) - .unwrap() - .value - .clone() - .expect("Could not borrow value") - .clone(), - ); - write!(s, "{}", arr_str).unwrap(); - if i != len.wrapping_sub(1) { - write!(s, ", ").unwrap(); - } - } - write!(s, "]").unwrap(); - } - _ => { - write!(s, "{{").unwrap(); - if let Some((last_key, _)) = v.borrow().properties.iter().last() { - for (key, val) in v.borrow().properties.iter() { - // Don't print prototype properties - if key == INSTANCE_PROTOTYPE { - continue; - } - // Introduce recursive call to stringify any objects - // which are keys of the object - write!( - s, - "{}: {}", - key, - log_string_from( - val.value.clone().expect("Could not read value").clone() - ) - ) - .unwrap(); - if key != last_key { - write!(s, ", ").unwrap(); - } - } - } - write!(s, "}}").unwrap(); - } - } - s - } - ValueData::Symbol(ref sym) => { - let desc: Value = sym.borrow().get_internal_slot("Description"); - match *desc { - ValueData::String(ref st) => format!("Symbol(\"{}\")", st.to_string()), - _ => String::from("Symbol()"), - } - } - - _ => from_value::(x.clone()).expect("Could not convert value to String"), - } -} +use std::ops::Deref; /// Print a javascript value to the standard output stream /// @@ -113,7 +14,7 @@ pub fn log(_: &Value, args: &[Value], _: &mut Interpreter) -> ResultValue { // The input is a vector of Values, we generate a vector of strings then // pass them to println! let args: Vec = - FromIterator::from_iter(args.iter().map(|x| log_string_from(x.clone()))); + FromIterator::from_iter(args.iter().map(|x| log_string_from(x.deref(), false))); println!("{}", args.join(" ")); Ok(Gc::new(ValueData::Undefined)) @@ -124,7 +25,7 @@ pub fn error(_: &Value, args: &[Value], _: &mut Interpreter) -> ResultValue { args.iter() .map(|x| from_value::(x.clone()).expect("Could not convert value to String")), ); - println!("{}", args.join(" ")); + eprintln!("{}", args.join(" ")); Ok(Gc::new(ValueData::Undefined)) } diff --git a/src/lib/builtins/string.rs b/src/lib/builtins/string.rs index 1ea1e73cf3..fdc78dc2e5 100644 --- a/src/lib/builtins/string.rs +++ b/src/lib/builtins/string.rs @@ -50,12 +50,6 @@ pub fn call_string(_: &Value, args: &[Value], _: &mut Interpreter) -> ResultValu Ok(to_value(arg.to_string())) } -/// Get a string's length -pub fn get_string_length(this: &Value, _: &[Value], ctx: &mut Interpreter) -> ResultValue { - let this_str = ctx.value_to_rust_string(this); - Ok(to_value::(this_str.chars().count() as i32)) -} - /// Get the string value to a primitive string pub fn to_string(this: &Value, _: &[Value], _: &mut Interpreter) -> ResultValue { // Get String from String Object and send it back as a new value @@ -741,7 +735,7 @@ pub fn create_constructor(global: &Value) -> Value { // Create prototype let proto = ValueData::new_obj(Some(global)); - let prop = Property::default().get(to_value(get_string_length as NativeFunctionData)); + let prop = Property::default().value(to_value(0_i32)); proto.set_prop_slice("length", prop); make_builtin_fn!(char_at, named "charAt", with length 1, of proto); @@ -827,11 +821,12 @@ mod tests { var nice = new String('Have a nice day.'); "#; forward(&mut engine, init); + + // Todo: fix this let _a = forward(&mut engine, "hello.concat(world, nice)"); let _b = forward(&mut engine, "hello + world + nice"); - // Todo: fix this - //assert_eq!(a, String::from("Hello, world! Have a nice day.")); - //assert_eq!(b, String::from("Hello, world! Have a nice day.")); + // assert_eq!(a, String::from("Hello, world! Have a nice day.")); + // assert_eq!(b, String::from("Hello, world! Have a nice day.")); } #[allow(clippy::result_unwrap_used)] diff --git a/src/lib/builtins/value.rs b/src/lib/builtins/value.rs index 7f2dce1fd2..5b9af77502 100644 --- a/src/lib/builtins/value.rs +++ b/src/lib/builtins/value.rs @@ -8,6 +8,7 @@ use gc_derive::{Finalize, Trace}; use serde_json::{map::Map, Number as JSONNumber, Value as JSONValue}; use std::{ any::Any, + collections::HashSet, f64::NAN, fmt::{self, Display}, ops::{Add, BitAnd, BitOr, BitXor, Deref, DerefMut, Div, Mul, Not, Rem, Shl, Shr, Sub}, @@ -631,9 +632,199 @@ impl Default for ValueData { } } +/// A helper macro for printing objects +/// Can be used to print both properties and internal slots +/// All of the overloads take: +/// - The object to be printed +/// - The function with which to print +/// - The indentation for the current level (for nested objects) +/// - A HashSet with the addresses of the already printed objects for the current branch +/// (used to avoid infinite loops when there are cyclic deps) +macro_rules! print_obj_value { + (all of $obj:expr, $display_fn:ident, $indent:expr, $encounters:expr) => { + { + let mut internals = print_obj_value!(internals of $obj, $display_fn, $indent, $encounters); + let mut props = print_obj_value!(props of $obj, $display_fn, $indent, $encounters, true); + + props.reserve(internals.len()); + + props.append(&mut internals); + + props + } + }; + (internals of $obj:expr, $display_fn:ident, $indent:expr, $encounters:expr) => { + print_obj_value!(impl internal_slots, $obj, |(key, val)| { + format!( + "{}{}: {}", + String::from_utf8(vec![b' '; $indent]) + .expect("Could not create indentation string"), + key, + $display_fn(&val, $encounters, $indent.wrapping_add(4), true) + ) + }) + }; + (props of $obj:expr, $display_fn:ident, $indent:expr, $encounters:expr, $print_internals:expr) => { + print_obj_value!(impl properties, $obj, |(key, val)| { + let v = &val + .value + .as_ref() + .expect("Could not get the property's value"); + + format!( + "{}{}: {}", + String::from_utf8(vec![b' '; $indent]) + .expect("Could not create indentation string"), + key, + $display_fn(v, $encounters, $indent.wrapping_add(4), $print_internals) + ) + }) + }; + + // A private overload of the macro + // DO NOT use directly + (impl $field:ident, $v:expr, $f:expr) => { + $v + .borrow() + .$field + .iter() + .map($f) + .collect::>() + }; +} + +pub(crate) fn log_string_from(x: &ValueData, print_internals: bool) -> String { + match x { + // We don't want to print private (compiler) or prototype properties + ValueData::Object(ref v) => { + // Can use the private "type" field of an Object to match on + // which type of Object it represents for special printing + match v.borrow().kind { + ObjectKind::String => from_value( + v.borrow() + .internal_slots + .get("StringData") + .expect("Cannot get primitive value from String") + .clone(), + ) + .expect("Cannot clone primitive value from String"), + ObjectKind::Boolean => { + let bool_data = v.borrow().get_internal_slot("BooleanData").to_string(); + + format!("Boolean {{ {} }}", bool_data) + } + ObjectKind::Array => { + let len: i32 = from_value( + v.borrow() + .properties + .get("length") + .unwrap() + .value + .clone() + .expect("Could not borrow value"), + ) + .expect("Could not convert JS value to i32"); + + if len == 0 { + return String::from("[]"); + } + + let arr = (0..len) + .map(|i| { + // Introduce recursive call to stringify any objects + // which are part of the Array + log_string_from( + &v.borrow() + .properties + .get(&i.to_string()) + .unwrap() + .value + .clone() + .expect("Could not borrow value"), + print_internals, + ) + }) + .collect::>() + .join(", "); + + format!("[ {} ]", arr) + } + _ => display_obj(&x, print_internals), + } + } + ValueData::Symbol(ref sym) => { + let desc: Value = sym.borrow().get_internal_slot("Description"); + match *desc { + ValueData::String(ref st) => format!("Symbol(\"{}\")", st.to_string()), + _ => String::from("Symbol()"), + } + } + + _ => format!("{}", x), + } +} + +/// A helper function for specifically printing object values +fn display_obj(v: &ValueData, print_internals: bool) -> String { + // A simple helper for getting the address of a value + // TODO: Find a more general place for this, as it can be used in other situations as well + fn address_of(t: &T) -> usize { + let my_ptr: *const T = t; + my_ptr as usize + } + + // We keep track of which objects we have encountered by keeping their + // in-memory address in this set + let mut encounters = HashSet::new(); + + fn display_obj_internal( + data: &ValueData, + encounters: &mut HashSet, + indent: usize, + print_internals: bool, + ) -> String { + match *data { + ValueData::Object(ref v) => { + // The in-memory address of the current object + let addr = address_of(v.borrow().deref()); + + // We need not continue if this object has already been + // printed up the current chain + if encounters.contains(&addr) { + return String::from("[Cycle]"); + } + + // Mark the current object as encountered + encounters.insert(addr); + + let result = if print_internals { + print_obj_value!(all of v, display_obj_internal, indent, encounters).join(",\n") + } else { + print_obj_value!(props of v, display_obj_internal, indent, encounters, print_internals) + .join(",\n") + }; + + // If the current object is referenced in a different branch, + // it will not cause an infinte printing loop, so it is safe to be printed again + encounters.remove(&addr); + + let closing_indent = String::from_utf8(vec![b' '; indent.wrapping_sub(4)]) + .expect("Could not create the closing brace's indentation string"); + + format!("{{\n{}\n{}}}", result, closing_indent) + } + + // Every other type of data is printed as is + _ => format!("{}", data), + } + } + + display_obj_internal(v, &mut encounters, 4, print_internals) +} + impl Display for ValueData { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { + match self { ValueData::Null => write!(f, "null"), ValueData::Undefined => write!(f, "undefined"), ValueData::Boolean(v) => write!(f, "{}", v), @@ -653,7 +844,7 @@ impl Display for ValueData { _ => v.to_string(), } ), - ValueData::Object(_) => write!(f, "{{}}"), + ValueData::Object(_) => write!(f, "{}", log_string_from(self, true)), ValueData::Integer(v) => write!(f, "{}", v), ValueData::Function(ref v) => match *v.borrow() { Function::NativeFunc(_) => write!(f, "function() {{ [native code] }}"),