github
/
boa
mirror of https://github.com/boa-dev/boa.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

creating String() constructor function

pull/8/head
Jason Williams 6 years ago
parent
3c282d879a
commit
7c2aa5601d
6 changed files with 139 additions and 35 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      src/bin/bin.rs
  2. 17
      src/lib/exec.rs
  3. 2
      src/lib/js/object.rs
  4. 20
      src/lib/js/string.rs
  5. 132
      src/lib/js/value.rs
  6. 2
      tests/js/test.js

1
src/bin/bin.rs
Unescape View File

@ -12,6 +12,7 @@ pub fn main() {
// Setup executor // Setup executor
let expr = Parser::new(tokens).parse_all().unwrap(); let expr = Parser::new(tokens).parse_all().unwrap();
// print!("{:#?}", expr);
let mut engine: Interpreter = Executor::new(); let mut engine: Interpreter = Executor::new();
let result = engine.run(&expr); let result = engine.run(&expr);

17
src/lib/exec.rs
Unescape View File

@ -1,13 +1,13 @@
use gc::{Gc, GcCell};
use crate::js::function::{Function, RegularFunction}; use crate::js::function::{Function, RegularFunction};
use crate::js::object::{INSTANCE_PROTOTYPE, PROTOTYPE}; use crate::js::object::{INSTANCE_PROTOTYPE, PROTOTYPE};
use crate::js::value::{from_value, to_value, ResultValue, Value, ValueData}; use crate::js::value::{from_value, to_value, ResultValue, Value, ValueData};
use crate::js::{array, console, function, json, math, object, string}; use crate::js::{array, console, function, json, math, object, string};
use std::borrow::Borrow;
use std::collections::HashMap;
use crate::syntax::ast::constant::Const; use crate::syntax::ast::constant::Const;
use crate::syntax::ast::expr::{Expr, ExprDef}; use crate::syntax::ast::expr::{Expr, ExprDef};
use crate::syntax::ast::op::{BinOp, BitOp, CompOp, LogOp, NumOp, UnaryOp}; use crate::syntax::ast::op::{BinOp, BitOp, CompOp, LogOp, NumOp, UnaryOp};
use gc::{Gc, GcCell};
use std::borrow::Borrow;
use std::collections::HashMap;
/// A variable scope /// A variable scope
#[derive(Trace, Finalize, Clone, Debug)] #[derive(Trace, Finalize, Clone, Debug)]
pub struct Scope { pub struct Scope {
@ -117,7 +117,7 @@ impl Executor for Interpreter {
let vars = scope.vars.clone(); let vars = scope.vars.clone();
let vars_ptr = vars.borrow(); let vars_ptr = vars.borrow();
match *vars_ptr.clone() { match *vars_ptr.clone() {
ValueData::Object(ref obj) => match obj.borrow().get(name) { ValueData::Object(ref obj, _) => match obj.borrow().get(name) {
Some(v) => { Some(v) => {
val = v.value.clone(); val = v.value.clone();
break; break;
@ -335,14 +335,17 @@ impl Executor for Interpreter {
for arg in args.iter() { for arg in args.iter() {
v_args.push(r#try!(self.run(arg))); v_args.push(r#try!(self.run(arg)));
} }
let this = Gc::new(ValueData::Object(GcCell::new(HashMap::new()))); let this = Gc::new(ValueData::Object(
GcCell::new(HashMap::new()),
GcCell::new(HashMap::new()),
));
// Create a blank object, then set its __proto__ property to the [Constructor].prototype
this.borrow() this.borrow()
.set_field_slice(INSTANCE_PROTOTYPE, func.borrow().get_field_slice(PROTOTYPE)); .set_field_slice(INSTANCE_PROTOTYPE, func.borrow().get_field_slice(PROTOTYPE));
match *func { match *func {
ValueData::Function(ref func) => match func.clone().into_inner() { ValueData::Function(ref func) => match func.clone().into_inner() {
Function::NativeFunc(ref ntv) => { Function::NativeFunc(ref ntv) => {
let func = ntv.data; let func = ntv.data;
println!("{:#?}", this);
func(this, self.run(callee)?, v_args) func(this, self.run(callee)?, v_args)
} }
Function::RegularFunc(ref data) => { Function::RegularFunc(ref data) => {
@ -400,7 +403,7 @@ impl Executor for Interpreter {
let val = r#try!(self.run(val_e)); let val = r#try!(self.run(val_e));
Ok(to_value(match *val { Ok(to_value(match *val {
ValueData::Undefined => "undefined", ValueData::Undefined => "undefined",
ValueData::Null | ValueData::Object(_) => "object", ValueData::Null | ValueData::Object(_, _) => "object",
ValueData::Boolean(_) => "boolean", ValueData::Boolean(_) => "boolean",
ValueData::Number(_) | ValueData::Integer(_) => "number", ValueData::Number(_) | ValueData::Integer(_) => "number",
ValueData::String(_) => "string", ValueData::String(_) => "string",

2
src/lib/js/object.rs
Unescape View File

@ -1,6 +1,6 @@
use gc::Gc;
use crate::js::function::NativeFunctionData; use crate::js::function::NativeFunctionData;
use crate::js::value::{from_value, to_value, FromValue, ResultValue, ToValue, Value, ValueData}; use crate::js::value::{from_value, to_value, FromValue, ResultValue, ToValue, Value, ValueData};
use gc::Gc;
use std::collections::HashMap; use std::collections::HashMap;
pub static PROTOTYPE: &'static str = "prototype"; pub static PROTOTYPE: &'static str = "prototype";
pub static INSTANCE_PROTOTYPE: &'static str = "__proto__"; pub static INSTANCE_PROTOTYPE: &'static str = "__proto__";

20
src/lib/js/string.rs
Unescape View File

@ -1,22 +1,33 @@
use gc::Gc;
use crate::js::function::NativeFunctionData; use crate::js::function::NativeFunctionData;
use crate::js::object::{Property, PROTOTYPE}; use crate::js::object::{Property, PROTOTYPE};
use crate::js::value::{from_value, to_value, ResultValue, Value, ValueData}; use crate::js::value::{from_value, to_value, ResultValue, Value, ValueData};
use gc::Gc;
/// Create new string /// Create new string
/// https://searchfox.org/mozilla-central/source/js/src/vm/StringObject.h#19 /// https://searchfox.org/mozilla-central/source/js/src/vm/StringObject.h#19
// This gets called when a new String() is created, it's called by exec:346
pub fn make_string(this: Value, _: Value, args: Vec<Value>) -> ResultValue { pub fn make_string(this: Value, _: Value, args: Vec<Value>) -> ResultValue {
// If we're constructing a string, we should set the initial length // If we're constructing a string, we should set the initial length
// To do this we need to convert the string back to a Rust String, then get the .len() // To do this we need to convert the string back to a Rust String, then get the .len()
let a: String = from_value(args[0].clone()).unwrap(); // let a: String = from_value(args[0].clone()).unwrap();
this.set_field_slice("length", to_value(a.len() as i32)); // this.set_field_slice("length", to_value(a.len() as i32));
this.set_private_field_slice("PrimitiveValue", args[0].clone());
Ok(this) Ok(this)
} }
/// Get a string's length /// Get a string's length
pub fn get_string_length(this: Value, _: Value, _: Vec<Value>) -> ResultValue { pub fn get_string_length(this: Value, _: Value, _: Vec<Value>) -> ResultValue {
let this_str: String = from_value(this).unwrap(); let this_str: String =
from_value(this.get_private_field(String::from("PrimitiveValue"))).unwrap();
Ok(to_value::<i32>(this_str.len() as i32)) Ok(to_value::<i32>(this_str.len() as i32))
} }
/// Get the string representation of the error
pub fn to_string(_: Value, _: Value, _: Vec<Value>) -> ResultValue {
Ok(to_value(format!("{}", String::from("test")).to_string()))
}
/// Create a new `String` object /// Create a new `String` object
pub fn _create(global: Value) -> Value { pub fn _create(global: Value) -> Value {
let string = to_value(make_string as NativeFunctionData); let string = to_value(make_string as NativeFunctionData);
@ -30,6 +41,7 @@ pub fn _create(global: Value) -> Value {
set: Gc::new(ValueData::Undefined), set: Gc::new(ValueData::Undefined),
}; };
proto.set_prop_slice("length", prop); proto.set_prop_slice("length", prop);
proto.set_field_slice("toString", to_value(to_string as NativeFunctionData));
string.set_field_slice(PROTOTYPE, proto); string.set_field_slice(PROTOTYPE, proto);
string string
} }

132
src/lib/js/value.rs
Unescape View File

@ -1,6 +1,6 @@
use gc::{Gc, GcCell};
use crate::js::function::{Function, NativeFunction, NativeFunctionData}; use crate::js::function::{Function, NativeFunction, NativeFunctionData};
use crate::js::object::{ObjectData, Property, INSTANCE_PROTOTYPE, PROTOTYPE}; use crate::js::object::{ObjectData, Property, INSTANCE_PROTOTYPE, PROTOTYPE};
use gc::{Gc, GcCell};
use serde_json::map::Map; use serde_json::map::Map;
use serde_json::Number as JSONNumber; use serde_json::Number as JSONNumber;
use serde_json::Value as JSONValue; use serde_json::Value as JSONValue;
@ -37,7 +37,8 @@ pub enum ValueData {
Integer(i32), Integer(i32),
/// `Object` - An object, such as `Math`, represented by a binary tree of string keys to Javascript values /// `Object` - An object, such as `Math`, represented by a binary tree of string keys to Javascript values
/// Some Objects will need an internal slot to hold private values, so our second ObjectData is for that /// Some Objects will need an internal slot to hold private values, so our second ObjectData is for that
Object(GcCell<ObjectData>), /// The second object storage is optional for now
Object(GcCell<ObjectData>, GcCell<ObjectData>),
/// `Function` - A runnable block of code, such as `Math.sqrt`, which can take some variables and return a useful value or act upon an object /// `Function` - A runnable block of code, such as `Math.sqrt`, which can take some variables and return a useful value or act upon an object
Function(GcCell<Function>), Function(GcCell<Function>),
} }
@ -46,6 +47,7 @@ impl ValueData {
/// Returns a new empty object /// Returns a new empty object
pub fn new_obj(global: Option<Value>) -> Value { pub fn new_obj(global: Option<Value>) -> Value {
let mut obj: ObjectData = HashMap::new(); let mut obj: ObjectData = HashMap::new();
let mut private_obj: ObjectData = HashMap::new();
if global.is_some() { if global.is_some() {
let obj_proto = global let obj_proto = global
.unwrap() .unwrap()
@ -53,20 +55,27 @@ impl ValueData {
.get_field_slice(PROTOTYPE); .get_field_slice(PROTOTYPE);
obj.insert(INSTANCE_PROTOTYPE.to_string(), Property::new(obj_proto)); obj.insert(INSTANCE_PROTOTYPE.to_string(), Property::new(obj_proto));
} }
Gc::new(ValueData::Object(GcCell::new(obj))) Gc::new(ValueData::Object(
GcCell::new(obj),
GcCell::new(private_obj),
))
} }
/// Similar to `new_obj`, but you can pass a prototype to create from /// Similar to `new_obj`, but you can pass a prototype to create from
pub fn new_obj_from_prototype(proto: Value) -> Value { pub fn new_obj_from_prototype(proto: Value) -> Value {
let mut obj: ObjectData = HashMap::new(); let mut obj: ObjectData = HashMap::new();
let mut private_obj: ObjectData = HashMap::new();
obj.insert(INSTANCE_PROTOTYPE.to_string(), Property::new(proto)); obj.insert(INSTANCE_PROTOTYPE.to_string(), Property::new(proto));
Gc::new(ValueData::Object(GcCell::new(obj))) Gc::new(ValueData::Object(
GcCell::new(obj),
GcCell::new(private_obj),
))
} }
/// Returns true if the value is an object /// Returns true if the value is an object
pub fn is_object(&self) -> bool { pub fn is_object(&self) -> bool {
match *self { match *self {
ValueData::Object(_) => true, ValueData::Object(_, _) => true,
_ => false, _ => false,
} }
} }
@ -115,7 +124,7 @@ impl ValueData {
/// [toBoolean](https://tc39.github.io/ecma262/#sec-toboolean) /// [toBoolean](https://tc39.github.io/ecma262/#sec-toboolean)
pub fn is_true(&self) -> bool { pub fn is_true(&self) -> bool {
match *self { match *self {
ValueData::Object(_) => true, ValueData::Object(_, _) => true,
ValueData::String(ref s) if !s.is_empty() => true, ValueData::String(ref s) if !s.is_empty() => true,
ValueData::Number(n) if n >= 1.0 && n % 1.0 == 0.0 => true, ValueData::Number(n) if n >= 1.0 && n % 1.0 == 0.0 => true,
ValueData::Integer(n) if n > 1 => true, ValueData::Integer(n) if n > 1 => true,
@ -127,7 +136,7 @@ impl ValueData {
/// Converts the value into a 64-bit floating point number /// Converts the value into a 64-bit floating point number
pub fn to_num(&self) -> f64 { pub fn to_num(&self) -> f64 {
match *self { match *self {
ValueData::Object(_) | ValueData::Undefined | ValueData::Function(_) => NAN, ValueData::Object(_, _) | ValueData::Undefined | ValueData::Function(_) => NAN,
ValueData::String(ref str) => match FromStr::from_str(str) { ValueData::String(ref str) => match FromStr::from_str(str) {
Ok(num) => num, Ok(num) => num,
Err(_) => NAN, Err(_) => NAN,
@ -142,7 +151,7 @@ impl ValueData {
/// Converts the value into a 32-bit integer /// Converts the value into a 32-bit integer
pub fn to_int(&self) -> i32 { pub fn to_int(&self) -> i32 {
match *self { match *self {
ValueData::Object(_) ValueData::Object(_, _)
| ValueData::Undefined | ValueData::Undefined
| ValueData::Null | ValueData::Null
| ValueData::Boolean(false) | ValueData::Boolean(false)
@ -164,25 +173,46 @@ impl ValueData {
// This is only for primitive strings, String() objects have their lengths calculated in string.rs // This is only for primitive strings, String() objects have their lengths calculated in string.rs
if self.is_string() && field == "length" { if self.is_string() && field == "length" {
if let ValueData::String(ref s) = *self { if let ValueData::String(ref s) = *self {
return Some(Property::new(to_value(s.len() as i32))) return Some(Property::new(to_value(s.len() as i32)));
} }
} }
let obj: ObjectData = match *self { let obj: ObjectData = match *self {
ValueData::Object(ref obj) => { ValueData::Object(ref obj, _) => {
let hash = obj.clone(); let hash = obj.clone();
hash.into_inner() hash.into_inner()
} }
// Accesing .object on borrow() seems to automatically dereference it, so we don't need the * // Accesing .object on borrow() seems to automatically dereference it, so we don't need the *
ValueData::Function(ref func) => match func.clone().into_inner() { ValueData::Function(ref func) => match func.clone().into_inner() {
Function::NativeFunc(ref func) => func.object.clone(), Function::NativeFunc(ref func) => func.object.clone(),
Function::RegularFunc(ref func) => func.object.clone() Function::RegularFunc(ref func) => func.object.clone(),
},
_ => return None,
};
match obj.get(&field) {
Some(val) => Some(val.clone()),
None => match obj.get(&INSTANCE_PROTOTYPE.to_string()) {
Some(prop) => prop.value.get_prop(field),
None => None,
},
}
}
/// Resolve the property in the object
/// Returns a copy of the Property
pub fn get_private_prop(&self, field: String) -> Option<Property> {
let obj: ObjectData = match *self {
ValueData::Object(_, ref obj) => {
let hash = obj.clone();
hash.into_inner()
} }
_ => return None, _ => return None,
}; };
match obj.get(&field) { match obj.get(&field) {
Some(val) => Some(val.clone()), Some(val) => Some(val.clone()),
None => match obj.get(&PROTOTYPE.to_string()) { None => match obj.get(&INSTANCE_PROTOTYPE.to_string()) {
Some(prop) => prop.value.get_prop(field), Some(prop) => prop.value.get_prop(field),
None => None, None => None,
}, },
@ -190,9 +220,44 @@ impl ValueData {
} }
/// Resolve the property in the object and get its value, or undefined if this is not an object or the field doesn't exist /// Resolve the property in the object and get its value, or undefined if this is not an object or the field doesn't exist
/// get_field recieves a Property from get_prop(). It should then return the [[Get]] result value if that's set, otherwise fall back to [[Value]]
pub fn get_private_field(&self, field: String) -> Value {
match self.get_private_prop(field) {
Some(prop) => prop.value.clone(),
None => Gc::new(ValueData::Undefined),
}
}
/// Resolve the property in the object and get its value, or undefined if this is not an object or the field doesn't exist
/// get_field recieves a Property from get_prop(). It should then return the [[Get]] result value if that's set, otherwise fall back to [[Value]]
pub fn get_field(&self, field: String) -> Value { pub fn get_field(&self, field: String) -> Value {
match self.get_prop(field) { match self.get_prop(field) {
Some(prop) => prop.value.clone(), Some(prop) => {
// If the Property has [[Get]] set to a function, we should run that and return the Value
let prop_getter = match *prop.get {
ValueData::Function(ref v) => match *v.borrow() {
Function::NativeFunc(ref ntv) => {
let func = ntv.data;
Some(
func(
Gc::new(self.clone()),
Gc::new(self.clone()),
vec![Gc::new(self.clone())],
)
.unwrap(),
)
}
_ => None,
},
_ => None,
};
// If the getter is populated, use that. If not use [[Value]] instead
match prop_getter {
Some(val) => val,
None => prop.value.clone(),
}
}
None => Gc::new(ValueData::Undefined), None => Gc::new(ValueData::Undefined),
} }
} }
@ -205,7 +270,7 @@ impl ValueData {
/// Set the field in the value /// Set the field in the value
pub fn set_field(&self, field: String, val: Value) -> Value { pub fn set_field(&self, field: String, val: Value) -> Value {
match *self { match *self {
ValueData::Object(ref obj) => { ValueData::Object(ref obj, _) => {
obj.borrow_mut() obj.borrow_mut()
.insert(field.clone(), Property::new(val.clone())); .insert(field.clone(), Property::new(val.clone()));
} }
@ -229,10 +294,27 @@ impl ValueData {
self.set_field(field.to_string(), val) self.set_field(field.to_string(), val)
} }
/// Set the private field in the value
pub fn set_private_field(&self, field: String, val: Value) -> Value {
match *self {
ValueData::Object(_, ref obj) => {
obj.borrow_mut()
.insert(field.clone(), Property::new(val.clone()));
}
_ => (),
}
val
}
/// Set the private field in the value
pub fn set_private_field_slice<'a>(&self, field: &'a str, val: Value) -> Value {
self.set_private_field(field.to_string(), val)
}
/// Set the property in the value /// Set the property in the value
pub fn set_prop(&self, field: String, prop: Property) -> Property { pub fn set_prop(&self, field: String, prop: Property) -> Property {
match *self { match *self {
ValueData::Object(ref obj) => { ValueData::Object(ref obj, _) => {
obj.borrow_mut().insert(field.clone(), prop.clone()); obj.borrow_mut().insert(field.clone(), prop.clone());
} }
ValueData::Function(ref func) => { ValueData::Function(ref func) => {
@ -261,6 +343,7 @@ impl ValueData {
JSONValue::Bool(v) => ValueData::Boolean(v), JSONValue::Bool(v) => ValueData::Boolean(v),
JSONValue::Array(vs) => { JSONValue::Array(vs) => {
let mut i = 0; let mut i = 0;
let mut private_data: ObjectData = HashMap::new();
let mut data: ObjectData = FromIterator::from_iter(vs.iter().map(|json| { let mut data: ObjectData = FromIterator::from_iter(vs.iter().map(|json| {
i += 1; i += 1;
( (
@ -272,14 +355,15 @@ impl ValueData {
"length".to_string(), "length".to_string(),
Property::new(to_value(vs.len() as i32)), Property::new(to_value(vs.len() as i32)),
); );
ValueData::Object(GcCell::new(data)) ValueData::Object(GcCell::new(data), GcCell::new(private_data))
} }
JSONValue::Object(obj) => { JSONValue::Object(obj) => {
let mut private_data: ObjectData = HashMap::new();
let data: ObjectData = FromIterator::from_iter( let data: ObjectData = FromIterator::from_iter(
obj.iter() obj.iter()
.map(|(key, json)| (key.clone(), Property::new(to_value(json.clone())))), .map(|(key, json)| (key.clone(), Property::new(to_value(json.clone())))),
); );
ValueData::Object(GcCell::new(data)) ValueData::Object(GcCell::new(data), GcCell::new(private_data))
} }
JSONValue::Null => ValueData::Null, JSONValue::Null => ValueData::Null,
} }
@ -289,7 +373,7 @@ impl ValueData {
match *self { match *self {
ValueData::Null | ValueData::Undefined => JSONValue::Null, ValueData::Null | ValueData::Undefined => JSONValue::Null,
ValueData::Boolean(b) => JSONValue::Bool(b), ValueData::Boolean(b) => JSONValue::Bool(b),
ValueData::Object(ref obj) => { ValueData::Object(ref obj, _) => {
let mut nobj = Map::new(); let mut nobj = Map::new();
for (k, v) in obj.borrow().iter() { for (k, v) in obj.borrow().iter() {
if k != INSTANCE_PROTOTYPE { if k != INSTANCE_PROTOTYPE {
@ -335,8 +419,8 @@ impl Display for ValueData {
_ => v.to_string(), _ => v.to_string(),
} }
), ),
ValueData::Object(ref v) => { ValueData::Object(ref v, _) => {
r#try!(write!(f, "{}", "{")); write!(f, "{}", "{")?;
match v.borrow().iter().last() { match v.borrow().iter().last() {
Some((last_key, _)) => { Some((last_key, _)) => {
for (key, val) in v.borrow().iter() { for (key, val) in v.borrow().iter() {
@ -567,14 +651,18 @@ impl<T: FromValue> FromValue for Vec<T> {
impl ToValue for ObjectData { impl ToValue for ObjectData {
fn to_value(&self) -> Value { fn to_value(&self) -> Value {
Gc::new(ValueData::Object(GcCell::new(self.clone()))) let mut private_obj: ObjectData = HashMap::new();
Gc::new(ValueData::Object(
GcCell::new(self.clone()),
GcCell::new(private_obj),
))
} }
} }
impl FromValue for ObjectData { impl FromValue for ObjectData {
fn from_value(v: Value) -> Result<ObjectData, &'static str> { fn from_value(v: Value) -> Result<ObjectData, &'static str> {
match *v { match *v {
ValueData::Object(ref obj) => Ok(obj.clone().into_inner()), ValueData::Object(ref obj, _) => Ok(obj.clone().into_inner()),
ValueData::Function(ref func) => Ok(match *func.borrow().deref() { ValueData::Function(ref func) => Ok(match *func.borrow().deref() {
Function::NativeFunc(ref data) => data.object.clone(), Function::NativeFunc(ref data) => data.object.clone(),
Function::RegularFunc(ref data) => data.object.clone(), Function::RegularFunc(ref data) => data.object.clone(),

2
tests/js/test.js
Unescape View File

@ -1,2 +1,2 @@
var a = new String("test"); var a = new String("test");
a; a.length;
Write Preview
Loading…
Cancel
Save