diff --git a/Src/IronJS.Runtime/DescriptorAttrs.cs b/Src/IronJS.Runtime/DescriptorAttrs.cs new file mode 100644 index 00000000..4a7ef9b4 --- /dev/null +++ b/Src/IronJS.Runtime/DescriptorAttrs.cs @@ -0,0 +1,15 @@ +using System; + +namespace IronJS.Runtime +{ + [Flags] + public enum DescriptorAttrs : ushort + { + None = 0, + ReadOnly = 1, + DontEnum = 2, + DontDelete = 4, + DontEnumOrDelete = DontEnum | DontDelete, + Immutable = ReadOnly | DontEnum | DontDelete, + } +} diff --git a/Src/IronJS.Runtime/IronJS.Runtime.CLR2.csproj b/Src/IronJS.Runtime/IronJS.Runtime.CLR2.csproj index 59fea8da..36cea107 100644 --- a/Src/IronJS.Runtime/IronJS.Runtime.CLR2.csproj +++ b/Src/IronJS.Runtime/IronJS.Runtime.CLR2.csproj @@ -41,6 +41,7 @@ + diff --git a/Src/IronJS.Runtime/IronJS.Runtime.csproj b/Src/IronJS.Runtime/IronJS.Runtime.csproj index cd8642e7..a2cb0fec 100644 --- a/Src/IronJS.Runtime/IronJS.Runtime.csproj +++ b/Src/IronJS.Runtime/IronJS.Runtime.csproj @@ -41,6 +41,7 @@ + diff --git a/Src/IronJS/Compiler.Scope.fs b/Src/IronJS/Compiler.Scope.fs index 61388cfe..d8416825 100644 --- a/Src/IronJS/Compiler.Scope.fs +++ b/Src/IronJS/Compiler.Scope.fs @@ -3,6 +3,7 @@ open System open IronJS +open IronJS.Runtime open IronJS.Support.CustomOperators open IronJS.Support.Aliases open IronJS.Compiler diff --git a/Src/IronJS/Native.Array.fs b/Src/IronJS/Native.Array.fs index 42ea142e..34a05d4f 100644 --- a/Src/IronJS/Native.Array.fs +++ b/Src/IronJS/Native.Array.fs @@ -2,9 +2,9 @@ open System open IronJS +open IronJS.Runtime open IronJS.Support.Aliases open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs /// module internal Array = @@ -41,10 +41,10 @@ module internal Array = let ctor = new Func(constructor') let ctor = ctor $ Utils.createConstructor env (Some 1) - ctor.Put("prototype", env.Prototypes.Array, Immutable) + ctor.Put("prototype", env.Prototypes.Array, DescriptorAttrs.Immutable) ctor.MetaData.Name <- "Array" - env.Globals.Put("Array", ctor, DontEnum) + env.Globals.Put("Array", ctor, DescriptorAttrs.DontEnum) env.Constructors <- {env.Constructors with Array = ctor} /// @@ -476,40 +476,40 @@ module internal Array = /// let setup (env:Env) = let proto = env.Prototypes.Array - proto.Put("constructor", env.Constructors.Array, DontEnum) + proto.Put("constructor", env.Constructors.Array, DescriptorAttrs.DontEnum) let toString = toString $ Utils.createFunc0 env (Some 0) - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) let toLocaleString = toLocaleString $ Utils.createFunc0 env (Some 0) - proto.Put("toLocaleString", toLocaleString, DontEnum) + proto.Put("toLocaleString", toLocaleString, DescriptorAttrs.DontEnum) let concat = concat $ Utils.createFunc1 env (Some 1) - proto.Put("concat", concat, DontEnum) + proto.Put("concat", concat, DescriptorAttrs.DontEnum) let push = push $ Utils.createFunc1 env (Some 1) - proto.Put("push", push, DontEnum) + proto.Put("push", push, DescriptorAttrs.DontEnum) let pop = pop $ Utils.createFunc0 env (Some 0) - proto.Put("pop", pop, DontEnum) + proto.Put("pop", pop, DescriptorAttrs.DontEnum) let shift = shift $ Utils.createFunc0 env (Some 0) - proto.Put("shift", shift, DontEnum) + proto.Put("shift", shift, DescriptorAttrs.DontEnum) let join = join $ Utils.createFunc1 env (Some 1) - proto.Put("join", join, DontEnum) + proto.Put("join", join, DescriptorAttrs.DontEnum) let reverse = reverse $ Utils.createFunc0 env (Some 0) - proto.Put("reverse", reverse, DontEnum) + proto.Put("reverse", reverse, DescriptorAttrs.DontEnum) let sort = sort $ Utils.createFunc1 env (Some 1) - proto.Put("sort", sort, DontEnum) + proto.Put("sort", sort, DescriptorAttrs.DontEnum) let slice = slice $ Utils.createFunc2 env (Some 2) - proto.Put("slice", slice, DontEnum) + proto.Put("slice", slice, DescriptorAttrs.DontEnum) let unshift = unshift $ Utils.createFunc1 env (Some 1) - proto.Put("unshift", unshift, DontEnum) + proto.Put("unshift", unshift, DescriptorAttrs.DontEnum) let splice = splice $ Utils.createFunc1 env (Some 2) - proto.Put("splice", splice, DontEnum) \ No newline at end of file + proto.Put("splice", splice, DescriptorAttrs.DontEnum) \ No newline at end of file diff --git a/Src/IronJS/Native.Boolean.fs b/Src/IronJS/Native.Boolean.fs index 3f267378..8a4ed316 100644 --- a/Src/IronJS/Native.Boolean.fs +++ b/Src/IronJS/Native.Boolean.fs @@ -2,7 +2,7 @@ open System open IronJS -open IronJS.DescriptorAttrs +open IronJS.Runtime open IronJS.Support.CustomOperators module internal Boolean = @@ -21,9 +21,9 @@ module internal Boolean = let ctor = ctor $ Utils.createConstructor env (Some 1) ctor.MetaData.Name <- "Boolean" - ctor.Put("prototype", env.Prototypes.Boolean, Immutable) + ctor.Put("prototype", env.Prototypes.Boolean, DescriptorAttrs.Immutable) - env.Globals.Put("Boolean", ctor, DontEnum) + env.Globals.Put("Boolean", ctor, DescriptorAttrs.DontEnum) env.Constructors <- {env.Constructors with Boolean=ctor} /// @@ -49,10 +49,10 @@ module internal Boolean = let setup (env:Env) = let proto = env.Prototypes.Boolean; - proto.Put("constructor", env.Constructors.Boolean, DontEnum) + proto.Put("constructor", env.Constructors.Boolean, DescriptorAttrs.DontEnum) let valueOf = Function(valueOf) $ Utils.createFunction env (Some 0) - proto.Put("valueOf", valueOf, DontEnum) + proto.Put("valueOf", valueOf, DescriptorAttrs.DontEnum) let toString = FunctionReturn(toString) $ Utils.createFunction env (Some 0) - proto.Put("toString", toString, DontEnum) \ No newline at end of file + proto.Put("toString", toString, DescriptorAttrs.DontEnum) \ No newline at end of file diff --git a/Src/IronJS/Native.Date.fs b/Src/IronJS/Native.Date.fs index 710bb938..44405dff 100644 --- a/Src/IronJS/Native.Date.fs +++ b/Src/IronJS/Native.Date.fs @@ -8,9 +8,9 @@ open System open System.Globalization open IronJS +open IronJS.Runtime open IronJS.Support.Aliases open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs module Date = @@ -129,17 +129,17 @@ module Date = ctor.MetaData.Name <- "Date" let parse = FunctionReturn(parse) $ Utils.createFunction env (Some 1) - ctor.Put("parse", parse, DontEnum) + ctor.Put("parse", parse, DescriptorAttrs.DontEnum) let parseLocal = FunctionReturn(parseLocal) $ Utils.createFunction env (Some 1) - ctor.Put("parseLocal", parseLocal, DontEnum) + ctor.Put("parseLocal", parseLocal, DescriptorAttrs.DontEnum) let utc = VariadicFunction(utc) $ Utils.createFunction env (Some 7) - ctor.Put("UTC", utc, DontEnum) + ctor.Put("UTC", utc, DescriptorAttrs.DontEnum) - ctor.Put("prototype", env.Prototypes.Date, Immutable) + ctor.Put("prototype", env.Prototypes.Date, DescriptorAttrs.Immutable) - env.Globals.Put("Date", ctor, DontEnum) + env.Globals.Put("Date", ctor, DescriptorAttrs.DontEnum) env.Constructors <- {env.Constructors with Date=ctor} module Prototype = @@ -245,127 +245,127 @@ module Date = let setup (env:Env) = let proto = env.Prototypes.Date - proto.Put("constructor", env.Constructors.Date, DontEnum) + proto.Put("constructor", env.Constructors.Date, DescriptorAttrs.DontEnum) let valueOf = Function(valueOf) $ Utils.createFunction env (Some 0) - proto.Put("valueOf", valueOf, DontEnum) + proto.Put("valueOf", valueOf, DescriptorAttrs.DontEnum) let toString = Function(toString) $ Utils.createFunction env (Some 0) - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) let toDateString = Function(toDateString) $ Utils.createFunction env (Some 0) - proto.Put("toDateString", toDateString, DontEnum) + proto.Put("toDateString", toDateString, DescriptorAttrs.DontEnum) let toTimeString = Function(toTimeString) $ Utils.createFunction env (Some 0) - proto.Put("toTimeString", toTimeString, DontEnum) + proto.Put("toTimeString", toTimeString, DescriptorAttrs.DontEnum) let toLocaleString = Function(toLocaleString) $ Utils.createFunction env (Some 0) - proto.Put("toLocaleString", toLocaleString, DontEnum) + proto.Put("toLocaleString", toLocaleString, DescriptorAttrs.DontEnum) let toLocaleDateString = Function(toLocaleDateString) $ Utils.createFunction env (Some 0) - proto.Put("toLocaleDateString", toLocaleDateString, DontEnum) + proto.Put("toLocaleDateString", toLocaleDateString, DescriptorAttrs.DontEnum) let toLocaleTimeString = Function(toLocaleTimeString) $ Utils.createFunction env (Some 0) - proto.Put("toLocaleTimeString", toLocaleTimeString, DontEnum) + proto.Put("toLocaleTimeString", toLocaleTimeString, DescriptorAttrs.DontEnum) let toUTCString = Function(toUTCString) $ Utils.createFunction env (Some 0) - proto.Put("toUTCString", toUTCString, DontEnum) + proto.Put("toUTCString", toUTCString, DescriptorAttrs.DontEnum) let getTime = Function(getTime) $ Utils.createFunction env (Some 0) - proto.Put("getTime", getTime, DontEnum) + proto.Put("getTime", getTime, DescriptorAttrs.DontEnum) let getFullYear = Function(getFullYear) $ Utils.createFunction env (Some 0) - proto.Put("getFullYear", getFullYear, DontEnum) + proto.Put("getFullYear", getFullYear, DescriptorAttrs.DontEnum) let getUTCFullYear = Function(getUTCFullYear) $ Utils.createFunction env (Some 0) - proto.Put("getUTCFullYear", getUTCFullYear, DontEnum) + proto.Put("getUTCFullYear", getUTCFullYear, DescriptorAttrs.DontEnum) let getMonth = Function(getMonth) $ Utils.createFunction env (Some 0) - proto.Put("getMonth", getMonth, DontEnum) + proto.Put("getMonth", getMonth, DescriptorAttrs.DontEnum) let getUTCMonth = Function(getUTCMonth) $ Utils.createFunction env (Some 0) - proto.Put("getUTCMonth", getUTCMonth, DontEnum) + proto.Put("getUTCMonth", getUTCMonth, DescriptorAttrs.DontEnum) let getDate = Function(getDate) $ Utils.createFunction env (Some 0) - proto.Put("getDate", getDate, DontEnum) + proto.Put("getDate", getDate, DescriptorAttrs.DontEnum) let getUTCDate = Function(getUTCDate) $ Utils.createFunction env (Some 0) - proto.Put("getUTCDate", getUTCDate, DontEnum) + proto.Put("getUTCDate", getUTCDate, DescriptorAttrs.DontEnum) let getDay = Function(getDay) $ Utils.createFunction env (Some 0) - proto.Put("getDay", getDay, DontEnum) + proto.Put("getDay", getDay, DescriptorAttrs.DontEnum) let getUTCDay = Function(getUTCDay) $ Utils.createFunction env (Some 0) - proto.Put("getUTCDay", getUTCDay, DontEnum) + proto.Put("getUTCDay", getUTCDay, DescriptorAttrs.DontEnum) let getHours = Function(getHours) $ Utils.createFunction env (Some 0) - proto.Put("getHours", getHours, DontEnum) + proto.Put("getHours", getHours, DescriptorAttrs.DontEnum) let getUTCHours = Function(getUTCHours) $ Utils.createFunction env (Some 0) - proto.Put("getUTCHours", getUTCHours, DontEnum) + proto.Put("getUTCHours", getUTCHours, DescriptorAttrs.DontEnum) let getMinutes = Function(getMinutes) $ Utils.createFunction env (Some 0) - proto.Put("getMinutes", getMinutes, DontEnum) + proto.Put("getMinutes", getMinutes, DescriptorAttrs.DontEnum) let getUTCMinutes = Function(getUTCMinutes) $ Utils.createFunction env (Some 0) - proto.Put("getUTCMinutes", getUTCMinutes, DontEnum) + proto.Put("getUTCMinutes", getUTCMinutes, DescriptorAttrs.DontEnum) let getSeconds = Function(getSeconds) $ Utils.createFunction env (Some 0) - proto.Put("getSeconds", getSeconds, DontEnum) + proto.Put("getSeconds", getSeconds, DescriptorAttrs.DontEnum) let getUTCSeconds = Function(getUTCSeconds) $ Utils.createFunction env (Some 0) - proto.Put("getUTCSeconds", getUTCSeconds, DontEnum) + proto.Put("getUTCSeconds", getUTCSeconds, DescriptorAttrs.DontEnum) let getMilliseconds = Function(getMilliseconds) $ Utils.createFunction env (Some 0) - proto.Put("getMilliseconds", getMilliseconds, DontEnum) + proto.Put("getMilliseconds", getMilliseconds, DescriptorAttrs.DontEnum) let getUTCMilliseconds = Function(getUTCMilliseconds) $ Utils.createFunction env (Some 0) - proto.Put("getUTCMilliseconds", getUTCMilliseconds, DontEnum) + proto.Put("getUTCMilliseconds", getUTCMilliseconds, DescriptorAttrs.DontEnum) let getTimezoneOffset = Function(getTimezoneOffset) $ Utils.createFunction env (Some 0) - proto.Put("getTimezoneOffset", getTimezoneOffset, DontEnum) + proto.Put("getTimezoneOffset", getTimezoneOffset, DescriptorAttrs.DontEnum) let setTime = FunctionReturn(setTime) $ Utils.createFunction env (Some 1) - proto.Put("setTime", setTime, DontEnum) + proto.Put("setTime", setTime, DescriptorAttrs.DontEnum) let setMilliseconds = SetFunc(setMilliseconds) $ Utils.createFunction env (Some 1) - proto.Put("setMilliseconds", setMilliseconds, DontEnum) + proto.Put("setMilliseconds", setMilliseconds, DescriptorAttrs.DontEnum) let setUTCMilliseconds = SetFunc(setUTCMilliseconds) $ Utils.createFunction env (Some 1) - proto.Put("setUTCMilliseconds", setUTCMilliseconds, DontEnum) + proto.Put("setUTCMilliseconds", setUTCMilliseconds, DescriptorAttrs.DontEnum) let setSeconds = SetFunc(setSeconds) $ Utils.createFunction env (Some 2) - proto.Put("setSeconds", setSeconds, DontEnum) + proto.Put("setSeconds", setSeconds, DescriptorAttrs.DontEnum) let setUTCSeconds = SetFunc(setUTCSeconds) $ Utils.createFunction env (Some 2) - proto.Put("setUTCSeconds", setUTCSeconds, DontEnum) + proto.Put("setUTCSeconds", setUTCSeconds, DescriptorAttrs.DontEnum) let setMinutes = SetFunc(setMinutes) $ Utils.createFunction env (Some 3) - proto.Put("setMinutes", setMinutes, DontEnum) + proto.Put("setMinutes", setMinutes, DescriptorAttrs.DontEnum) let setUTCMinutes = SetFunc(setUTCMinutes) $ Utils.createFunction env (Some 3) - proto.Put("setUTCMinutes", setUTCMinutes, DontEnum) + proto.Put("setUTCMinutes", setUTCMinutes, DescriptorAttrs.DontEnum) let setHours = SetFunc(setHours) $ Utils.createFunction env (Some 4) - proto.Put("setHours", setHours, DontEnum) + proto.Put("setHours", setHours, DescriptorAttrs.DontEnum) let setUTCHours = SetFunc(setUTCHours) $ Utils.createFunction env (Some 4) - proto.Put("setUTCHours", setUTCHours, DontEnum) + proto.Put("setUTCHours", setUTCHours, DescriptorAttrs.DontEnum) let setDate = SetFunc(setDate) $ Utils.createFunction env (Some 1) - proto.Put("setDate", setDate, DontEnum) + proto.Put("setDate", setDate, DescriptorAttrs.DontEnum) let setUTCDate = SetFunc(setUTCDate) $ Utils.createFunction env (Some 1) - proto.Put("setUTCDate", setUTCDate, DontEnum) + proto.Put("setUTCDate", setUTCDate, DescriptorAttrs.DontEnum) let setMonth = SetFunc(setMonth) $ Utils.createFunction env (Some 2) - proto.Put("setMonth", setMonth, DontEnum) + proto.Put("setMonth", setMonth, DescriptorAttrs.DontEnum) let setUTCMonth = SetFunc(setUTCMonth) $ Utils.createFunction env (Some 2) - proto.Put("setUTCMonth", setUTCMonth, DontEnum) + proto.Put("setUTCMonth", setUTCMonth, DescriptorAttrs.DontEnum) let setFullYear = SetFunc(setFullYear) $ Utils.createFunction env (Some 3) - proto.Put("setFullYear", setFullYear, DontEnum) + proto.Put("setFullYear", setFullYear, DescriptorAttrs.DontEnum) let setUTCFullYear = SetFunc(setUTCFullYear) $ Utils.createFunction env (Some 3) - proto.Put("setUTCFullYear", setUTCFullYear, DontEnum) + proto.Put("setUTCFullYear", setUTCFullYear, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Native.Error.fs b/Src/IronJS/Native.Error.fs index 01942085..1a12588d 100644 --- a/Src/IronJS/Native.Error.fs +++ b/Src/IronJS/Native.Error.fs @@ -2,7 +2,7 @@ open System open IronJS -open IronJS.DescriptorAttrs +open IronJS.Runtime module Error = @@ -13,7 +13,7 @@ module Error = if message.Tag <> TypeTags.Undefined then let msg = message |> TypeConverter.ToString - error.Put("message", msg, DontEnum) + error.Put("message", msg, DescriptorAttrs.DontEnum) error.Prototype <- proto error :> CO @@ -23,15 +23,15 @@ module Error = let ctor = ctor |> Utils.createConstructor env (Some 1) ctor.Prototype <- env.Prototypes.Function - ctor.Put("prototype", proto, Immutable) + ctor.Put("prototype", proto, DescriptorAttrs.Immutable) - env.Globals.Put(name, ctor, DontEnum) + env.Globals.Put(name, ctor, DescriptorAttrs.DontEnum) env.Constructors <- update env.Constructors ctor let setupPrototype (n:string) (ctor:FO) (proto:CO) = - proto.Put("name", n, DontEnum) - proto.Put("constructor", ctor, DontEnum) - proto.Put("message", "", DontEnum) + proto.Put("name", n, DescriptorAttrs.DontEnum) + proto.Put("constructor", ctor, DescriptorAttrs.DontEnum) + proto.Put("message", "", DescriptorAttrs.DontEnum) let private name = "Error" let private updater (ctors:Constructors) ctor = {ctors with Error=ctor} @@ -56,7 +56,7 @@ module Error = let toString = Function(toString) let toString = Utils.createHostFunction env toString - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) Utils.setupPrototype name ctor proto diff --git a/Src/IronJS/Native.Function.fs b/Src/IronJS/Native.Function.fs index dec6b10c..5fdb7f21 100644 --- a/Src/IronJS/Native.Function.fs +++ b/Src/IronJS/Native.Function.fs @@ -2,7 +2,7 @@ open System open IronJS -open IronJS.DescriptorAttrs +open IronJS.Runtime open IronJS.Support.CustomOperators /// @@ -158,16 +158,16 @@ module internal Function = let setup (env:Env) = // let proto = env.Prototypes.Function - proto.Put("constructor", env.Constructors.Function, DontEnum) + proto.Put("constructor", env.Constructors.Function, DescriptorAttrs.DontEnum) // let call = call $ Utils.createVariadicFunc env (Some 1) - proto.Put("call", call, DontEnum) + proto.Put("call", call, DescriptorAttrs.DontEnum) // let apply = apply $ Utils.createFunc2 env (Some 2) - proto.Put("apply", apply, DontEnum) + proto.Put("apply", apply, DescriptorAttrs.DontEnum) // let toString = toString $ Utils.createFunc0 env (Some 0) - proto.Put("toString", toString, DontEnum) \ No newline at end of file + proto.Put("toString", toString, DescriptorAttrs.DontEnum) \ No newline at end of file diff --git a/Src/IronJS/Native.Global.fs b/Src/IronJS/Native.Global.fs index ddfbb8ff..54f2fab6 100644 --- a/Src/IronJS/Native.Global.fs +++ b/Src/IronJS/Native.Global.fs @@ -3,9 +3,9 @@ open System open IronJS open IronJS.Compiler +open IronJS.Runtime open IronJS.Support.Aliases open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs open System.Text.RegularExpressions /// @@ -344,33 +344,33 @@ module Global = /// let setup (env:Environment) = env.Globals <- env.NewObject() - env.Globals.Put("NaN", NaN, DontEnumOrDelete) //15.1.1.1 - env.Globals.Put("Infinity", PosInf, DontEnumOrDelete) //15.1.1.2 - env.Globals.Put("undefined", Undefined.Instance, DontEnumOrDelete) //15.1.1.3 + env.Globals.Put("NaN", NaN, DescriptorAttrs.DontEnumOrDelete) //15.1.1.1 + env.Globals.Put("Infinity", PosInf, DescriptorAttrs.DontEnumOrDelete) //15.1.1.2 + env.Globals.Put("undefined", Undefined.Instance, DescriptorAttrs.DontEnumOrDelete) //15.1.1.3 let eval = Func(eval) $ Utils.createFunction env (Some 1) - env.Globals.Put("eval", eval, DontEnum) + env.Globals.Put("eval", eval, DescriptorAttrs.DontEnum) let parseFloat = Func(parseFloat) $ Utils.createFunction env (Some 1) - env.Globals.Put("parseFloat", parseFloat, DontEnum) + env.Globals.Put("parseFloat", parseFloat, DescriptorAttrs.DontEnum) let parseInt = Func(parseInt) $ Utils.createFunction env (Some 2) - env.Globals.Put("parseInt", parseInt, DontEnum) + env.Globals.Put("parseInt", parseInt, DescriptorAttrs.DontEnum) let isNaN = Func(isNaN) $ Utils.createFunction env (Some 1) - env.Globals.Put("isNaN", isNaN, DontEnum) + env.Globals.Put("isNaN", isNaN, DescriptorAttrs.DontEnum) let isFinite = Func(isFinite) $ Utils.createFunction env (Some 1) - env.Globals.Put("isFinite", isFinite, DontEnum) + env.Globals.Put("isFinite", isFinite, DescriptorAttrs.DontEnum) let decodeURI = Function(decodeURI) $ Utils.createFunction env (Some 1) - env.Globals.Put("decodeURI", decodeURI, DontEnum) + env.Globals.Put("decodeURI", decodeURI, DescriptorAttrs.DontEnum) let decodeURIComponent = Function(decodeURIComponent) $ Utils.createFunction env (Some 1) - env.Globals.Put("decodeURIComponent", decodeURIComponent, DontEnum) + env.Globals.Put("decodeURIComponent", decodeURIComponent, DescriptorAttrs.DontEnum) let encodeURI = Function(encodeURI) $ Utils.createFunction env (Some 1) - env.Globals.Put("encodeURI", encodeURI, DontEnum) + env.Globals.Put("encodeURI", encodeURI, DescriptorAttrs.DontEnum) let encodeURIComponent = Function(encodeURIComponent) $ Utils.createFunction env (Some 1) - env.Globals.Put("encodeURIComponent", encodeURIComponent, DontEnum) + env.Globals.Put("encodeURIComponent", encodeURIComponent, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Native.Math.fs b/Src/IronJS/Native.Math.fs index bbab259a..0ad3d196 100644 --- a/Src/IronJS/Native.Math.fs +++ b/Src/IronJS/Native.Math.fs @@ -2,9 +2,9 @@ open System open IronJS +open IronJS.Runtime open IronJS.Support.Aliases open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs module internal Math = @@ -53,67 +53,67 @@ module internal Math = let math = env.NewMath() math.Prototype <- env.Prototypes.Object - math.Put("E", Math.E, Immutable) - math.Put("LN10", Math.Log(10.0), Immutable) - math.Put("LN2", Math.Log(2.0), Immutable) - math.Put("LOG2E", 1.0 / Math.Log(2.0), Immutable) - math.Put("LOG10E", Math.Log10(Math.E), Immutable) - math.Put("PI", Math.PI, Immutable) - math.Put("SQRT1_2", Math.Sqrt(0.5), Immutable) - math.Put("SQRT2", Math.Sqrt(2.0), Immutable) + math.Put("E", Math.E, DescriptorAttrs.Immutable) + math.Put("LN10", Math.Log(10.0), DescriptorAttrs.Immutable) + math.Put("LN2", Math.Log(2.0), DescriptorAttrs.Immutable) + math.Put("LOG2E", 1.0 / Math.Log(2.0), DescriptorAttrs.Immutable) + math.Put("LOG10E", Math.Log10(Math.E), DescriptorAttrs.Immutable) + math.Put("PI", Math.PI, DescriptorAttrs.Immutable) + math.Put("SQRT1_2", Math.Sqrt(0.5), DescriptorAttrs.Immutable) + math.Put("SQRT2", Math.Sqrt(2.0), DescriptorAttrs.Immutable) - env.Globals.Put("Math", math, DontEnum) + env.Globals.Put("Math", math, DescriptorAttrs.DontEnum) let abs = Func(Math.Abs) $ Utils.createFunction env (Some 1) - math.Put("abs", abs, DontEnum) + math.Put("abs", abs, DescriptorAttrs.DontEnum) let acos = Func(Math.Acos) $ Utils.createFunction env (Some 1) - math.Put("acos", acos, DontEnum) + math.Put("acos", acos, DescriptorAttrs.DontEnum) let asin = Func(Math.Asin) $ Utils.createFunction env (Some 1) - math.Put("asin", asin, DontEnum) + math.Put("asin", asin, DescriptorAttrs.DontEnum) let atan = Func(Math.Atan) $ Utils.createFunction env (Some 1) - math.Put("atan", atan, DontEnum) + math.Put("atan", atan, DescriptorAttrs.DontEnum) let atan2 = Func(atan2) $ Utils.createFunction env (Some 2) - math.Put("atan2", atan2, DontEnum) + math.Put("atan2", atan2, DescriptorAttrs.DontEnum) let ceil = Func(Math.Ceiling) $ Utils.createFunction env (Some 1) - math.Put("ceil", ceil, DontEnum) + math.Put("ceil", ceil, DescriptorAttrs.DontEnum) let cos = Func(Math.Cos) $ Utils.createFunction env (Some 1) - math.Put("cos", cos, DontEnum) + math.Put("cos", cos, DescriptorAttrs.DontEnum) let exp = Func(Math.Exp) $ Utils.createFunction env (Some 1) - math.Put("exp", exp, DontEnum) + math.Put("exp", exp, DescriptorAttrs.DontEnum) let floor = Func(Math.Floor) $ Utils.createFunction env (Some 1) - math.Put("floor", floor, DontEnum) + math.Put("floor", floor, DescriptorAttrs.DontEnum) let log = Func(Math.Log) $ Utils.createFunction env (Some 1) - math.Put("log", log, DontEnum) + math.Put("log", log, DescriptorAttrs.DontEnum) let max = Func(max) $ Utils.createFunction env (Some 2) - math.Put("max", max, DontEnum) + math.Put("max", max, DescriptorAttrs.DontEnum) let min = Func(min) $ Utils.createFunction env (Some 2) - math.Put("min", min, DontEnum) + math.Put("min", min, DescriptorAttrs.DontEnum) let pow = Func(pow) $ Utils.createFunction env (Some 2) - math.Put("pow", pow, DontEnum) + math.Put("pow", pow, DescriptorAttrs.DontEnum) let random = Func(random) $ Utils.createFunction env (Some 1) - math.Put("random", random, DontEnum) + math.Put("random", random, DescriptorAttrs.DontEnum) let round = Func(round) $ Utils.createFunction env (Some 1) - math.Put("round", round, DontEnum) + math.Put("round", round, DescriptorAttrs.DontEnum) let sin = Func(Math.Sin) $ Utils.createFunction env (Some 1) - math.Put("sin", sin, DontEnum) + math.Put("sin", sin, DescriptorAttrs.DontEnum) let sqrt = Func(Math.Sqrt) $ Utils.createFunction env (Some 1) - math.Put("sqrt", sqrt, DontEnum) + math.Put("sqrt", sqrt, DescriptorAttrs.DontEnum) let tan = Func(Math.Tan) $ Utils.createFunction env (Some 1) - math.Put("tan", tan, DontEnum) + math.Put("tan", tan, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Native.Number.fs b/Src/IronJS/Native.Number.fs index 4a0734c5..03e385c5 100644 --- a/Src/IronJS/Native.Number.fs +++ b/Src/IronJS/Native.Number.fs @@ -2,9 +2,9 @@ open System open IronJS +open IronJS.Runtime open IronJS.Support.Aliases open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs module internal Number = @@ -26,14 +26,14 @@ module internal Number = ctor.MetaData.Name <- "Number" - ctor.Put("prototype", env.Prototypes.Number, Immutable) - ctor.Put("MAX_VALUE", Double.MaxValue, Immutable) - ctor.Put("MIN_VALUE", Double.Epsilon, Immutable) - ctor.Put("NaN", Double.NaN, Immutable) - ctor.Put("NEGATIVE_INFINITY", NegInf, Immutable) - ctor.Put("POSITIVE_INFINITY", PosInf, Immutable) + ctor.Put("prototype", env.Prototypes.Number, DescriptorAttrs.Immutable) + ctor.Put("MAX_VALUE", Double.MaxValue, DescriptorAttrs.Immutable) + ctor.Put("MIN_VALUE", Double.Epsilon, DescriptorAttrs.Immutable) + ctor.Put("NaN", Double.NaN, DescriptorAttrs.Immutable) + ctor.Put("NEGATIVE_INFINITY", NegInf, DescriptorAttrs.Immutable) + ctor.Put("POSITIVE_INFINITY", PosInf, DescriptorAttrs.Immutable) - env.Globals.Put("Number", ctor, DontEnum) + env.Globals.Put("Number", ctor, DescriptorAttrs.DontEnum) env.Constructors <- {env.Constructors with Number=ctor} /// @@ -164,29 +164,29 @@ module internal Number = /// let setup (env:Env) = let proto = env.Prototypes.Number; - proto.Put("constructor", env.Constructors.Number, DontEnum) + proto.Put("constructor", env.Constructors.Number, DescriptorAttrs.DontEnum) let toString = new Func(toString) let toString = toString $ Utils.createFunction env (Some 1) - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) let toLocaleString = new Func(toLocaleString) let toLocaleString = Utils.createHostFunction env toLocaleString - proto.Put("toLocaleString", toLocaleString, DontEnum) + proto.Put("toLocaleString", toLocaleString, DescriptorAttrs.DontEnum) let valueOf = new Func(valueOf) let valueOf = valueOf $ Utils.createFunction env (Some 0) - proto.Put("valueOf", valueOf, DontEnum) + proto.Put("valueOf", valueOf, DescriptorAttrs.DontEnum) let toFixed = new Func(toFixed) let toFixed = toFixed $ Utils.createFunction env (Some 1) - proto.Put("toFixed", toFixed, DontEnum) + proto.Put("toFixed", toFixed, DescriptorAttrs.DontEnum) let toExponential = new Func(toExponential) let toExponential = toExponential $ Utils.createFunction env (Some 1) - proto.Put("toExponential", toExponential, DontEnum) + proto.Put("toExponential", toExponential, DescriptorAttrs.DontEnum) let toPrecision = new Func(toPrecision) let toPrecision = toPrecision $ Utils.createFunction env (Some 1) - proto.Put("toPrecision", toPrecision, DontEnum) + proto.Put("toPrecision", toPrecision, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Native.Object.fs b/Src/IronJS/Native.Object.fs index e040bee8..b6f93d1a 100644 --- a/Src/IronJS/Native.Object.fs +++ b/Src/IronJS/Native.Object.fs @@ -2,8 +2,8 @@ open System open IronJS +open IronJS.Runtime open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs /// module internal Object = @@ -21,9 +21,9 @@ module internal Object = let ctor = ctor $ Utils.createConstructor env (Some 1) ctor.MetaData.Name <- "Object" - ctor.Put("prototype", env.Prototypes.Object, Immutable) + ctor.Put("prototype", env.Prototypes.Object, DescriptorAttrs.Immutable) - env.Globals.Put("Object", ctor, DontEnum) + env.Globals.Put("Object", ctor, DescriptorAttrs.DontEnum) env.Constructors <- {env.Constructors with Object = ctor} /// @@ -85,28 +85,28 @@ module internal Object = let setup (env:Env) = // let proto = env.Prototypes.Object - proto.Put("constructor", env.Constructors.Object, DontEnum) + proto.Put("constructor", env.Constructors.Object, DescriptorAttrs.DontEnum) // let toString = toString $ Utils.createFunc0 env (Some 0) - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) // let toLocaleString = toLocaleString $ Utils.createFunc0 env (Some 0) - proto.Put("toLocaleString", toLocaleString, DontEnum) + proto.Put("toLocaleString", toLocaleString, DescriptorAttrs.DontEnum) // let valueOf = valueOf $ Utils.createFunc0 env (Some 0) - proto.Put("valueOf", valueOf, DontEnum) + proto.Put("valueOf", valueOf, DescriptorAttrs.DontEnum) // let hasOwnProperty = hasOwnProperty $ Utils.createFunc1 env (Some 1) - proto.Put("hasOwnProperty", hasOwnProperty, DontEnum) + proto.Put("hasOwnProperty", hasOwnProperty, DescriptorAttrs.DontEnum) // let isPrototypeOf = isPrototypeOf $ Utils.createFunc1 env (Some 1) - proto.Put("isPrototypeOf", isPrototypeOf, DontEnum) + proto.Put("isPrototypeOf", isPrototypeOf, DescriptorAttrs.DontEnum) // let isNumerable = propertyIsEnumerable $ Utils.createFunc1 env (Some 1) - proto.Put("propertyIsEnumerable", isNumerable, DontEnum) + proto.Put("propertyIsEnumerable", isNumerable, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Native.RegExp.fs b/Src/IronJS/Native.RegExp.fs index de941824..239d1c15 100644 --- a/Src/IronJS/Native.RegExp.fs +++ b/Src/IronJS/Native.RegExp.fs @@ -5,7 +5,7 @@ #nowarn "46" open IronJS -open IronJS.DescriptorAttrs +open IronJS.Runtime open IronJS.Support.CustomOperators module internal RegExp = @@ -29,11 +29,11 @@ module internal RegExp = /// let setup (env:Env) = let ctor = Function(constructor') $ Utils.createConstructor env (Some 2) - ctor.Put("prototype", env.Prototypes.RegExp, Immutable) + ctor.Put("prototype", env.Prototypes.RegExp, DescriptorAttrs.Immutable) ctor.MetaData.Name <- "RegExp" env.Constructors <- {env.Constructors with RegExp=ctor} - env.Globals.Put("RegExp", ctor, DontEnum) + env.Globals.Put("RegExp", ctor, DescriptorAttrs.DontEnum) /// module Prototype = @@ -138,16 +138,16 @@ module internal RegExp = let proto = env.Prototypes.RegExp // - proto.Put("constructor", env.Constructors.RegExp, DontEnum) + proto.Put("constructor", env.Constructors.RegExp, DescriptorAttrs.DontEnum) // let toString = Function(toString) $ Utils.createFunction env (Some 0) - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) // let exec = Function(exec) $ Utils.createFunction env (Some 1) - proto.Put("exec", exec, DontEnum) + proto.Put("exec", exec, DescriptorAttrs.DontEnum) // let test = Function(test) $ Utils.createFunction env (Some 1) - proto.Put("test", test, DontEnum) + proto.Put("test", test, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Native.String.fs b/Src/IronJS/Native.String.fs index 36e51741..15c2c4be 100644 --- a/Src/IronJS/Native.String.fs +++ b/Src/IronJS/Native.String.fs @@ -4,9 +4,9 @@ open System open System.Text.RegularExpressions open IronJS +open IronJS.Runtime open IronJS.Support.Aliases open IronJS.Support.CustomOperators -open IronJS.DescriptorAttrs /// module internal String = @@ -42,13 +42,13 @@ module internal String = // let fromCharCode = new Func(fromCharCode) $ Utils.createFunction env (Some 1) - ctor.Put("fromCharCode", fromCharCode, DontEnum) + ctor.Put("fromCharCode", fromCharCode, DescriptorAttrs.DontEnum) // - ctor.Put("prototype", env.Prototypes.String, Immutable) + ctor.Put("prototype", env.Prototypes.String, DescriptorAttrs.Immutable) // - env.Globals.Put("String", ctor, DontEnum) + env.Globals.Put("String", ctor, DescriptorAttrs.DontEnum) env.Constructors <- {env.Constructors with String=ctor} /// @@ -377,61 +377,61 @@ module internal String = let setup (env:Env) = let proto = env.Prototypes.String; - proto.Put("constructor", env.Constructors.String, DontEnum) + proto.Put("constructor", env.Constructors.String, DescriptorAttrs.DontEnum) let toString = Function(toString) $ Utils.createFunction env (Some 0) - proto.Put("toString", toString, DontEnum) + proto.Put("toString", toString, DescriptorAttrs.DontEnum) let valueOf = Function(valueOf) $ Utils.createFunction env (Some 0) - proto.Put("valueOf", valueOf, DontEnum) + proto.Put("valueOf", valueOf, DescriptorAttrs.DontEnum) let charAt = FunctionReturn(charAt) $ Utils.createFunction env (Some 1) - proto.Put("charAt", charAt, DontEnum) + proto.Put("charAt", charAt, DescriptorAttrs.DontEnum) let charCodeAt = FunctionReturn(charCodeAt) $ Utils.createFunction env (Some 1) - proto.Put("charCodeAt", charCodeAt, DontEnum) + proto.Put("charCodeAt", charCodeAt, DescriptorAttrs.DontEnum) let concat = FunctionReturn(concat) $ Utils.createFunction env (Some 1) - proto.Put("concat", concat, DontEnum) + proto.Put("concat", concat, DescriptorAttrs.DontEnum) let indexOf = FunctionReturn(indexOf) $ Utils.createFunction env (Some 1) - proto.Put("indexOf", indexOf, DontEnum) + proto.Put("indexOf", indexOf, DescriptorAttrs.DontEnum) let lastIndexOf = FunctionReturn(lastIndexOf) $ Utils.createFunction env (Some 1) - proto.Put("lastIndexOf", lastIndexOf, DontEnum) + proto.Put("lastIndexOf", lastIndexOf, DescriptorAttrs.DontEnum) let localeCompare = FunctionReturn(localeCompare) $ Utils.createFunction env (Some 1) - proto.Put("localeCompare", localeCompare, DontEnum) + proto.Put("localeCompare", localeCompare, DescriptorAttrs.DontEnum) let match' = Function(match') $ Utils.createFunction env (Some 1) - proto.Put("match", match', DontEnum) + proto.Put("match", match', DescriptorAttrs.DontEnum) let replace = FunctionReturn(replace) $ Utils.createFunction env (Some 2) - proto.Put("replace", replace, DontEnum) + proto.Put("replace", replace, DescriptorAttrs.DontEnum) let search = FunctionReturn(search) $ Utils.createFunction env (Some 1) - proto.Put("search", search, DontEnum) + proto.Put("search", search, DescriptorAttrs.DontEnum) let slice = FunctionReturn(slice) $ Utils.createFunction env (Some 2) - proto.Put("slice", slice, DontEnum) + proto.Put("slice", slice, DescriptorAttrs.DontEnum) let split = FunctionReturn(split) $ Utils.createFunction env (Some 2) - proto.Put("split", split, DontEnum) + proto.Put("split", split, DescriptorAttrs.DontEnum) let substring = FunctionReturn(substring) $ Utils.createFunction env (Some 2) - proto.Put("substring", substring, DontEnum) + proto.Put("substring", substring, DescriptorAttrs.DontEnum) let substr = FunctionReturn(substr) $ Utils.createFunction env (Some 2) - proto.Put("substr", substr, DontEnum) + proto.Put("substr", substr, DescriptorAttrs.DontEnum) let toLowerCase = FunctionReturn(toLowerCase) $ Utils.createFunction env (Some 0) - proto.Put("toLowerCase", toLowerCase, DontEnum) + proto.Put("toLowerCase", toLowerCase, DescriptorAttrs.DontEnum) let toLocaleLowerCase = FunctionReturn(toLocaleLowerCase) $ Utils.createFunction env (Some 0) - proto.Put("toLocaleLowerCase", toLocaleLowerCase, DontEnum) + proto.Put("toLocaleLowerCase", toLocaleLowerCase, DescriptorAttrs.DontEnum) let toUpperCase = FunctionReturn(toUpperCase) $ Utils.createFunction env (Some 0) - proto.Put("toUpperCase", toUpperCase, DontEnum) + proto.Put("toUpperCase", toUpperCase, DescriptorAttrs.DontEnum) let toLocaleUpperCase = FunctionReturn(toLocaleUpperCase) $ Utils.createFunction env (Some 0) - proto.Put("toLocaleUpperCase", toLocaleUpperCase, DontEnum) + proto.Put("toLocaleUpperCase", toLocaleUpperCase, DescriptorAttrs.DontEnum) diff --git a/Src/IronJS/Runtime.fs b/Src/IronJS/Runtime.fs index 8044fd37..86402702 100644 --- a/Src/IronJS/Runtime.fs +++ b/Src/IronJS/Runtime.fs @@ -5,9 +5,7 @@ #nowarn "9" open IronJS -#if CLR2 open IronJS.Runtime -#endif open IronJS.Support.Aliases open IronJS.Support.CustomOperators @@ -54,13 +52,6 @@ module BoxFields = let [] Object = "Object" let [] Function = "Func" -module DescriptorAttrs = - let [] ReadOnly = 1us - let [] DontEnum = 2us - let [] DontDelete = 4us - let [] DontEnumOrDelete = 6us - let [] Immutable = 7us - module ParamsModes = let [] NoParams = 0uy let [] ObjectParams = 1uy @@ -263,12 +254,12 @@ and Desc = Descriptor and [] Descriptor = struct val mutable Value : BV - val mutable Attributes : uint16 + val mutable Attributes : DescriptorAttrs val mutable HasValue : bool - member x.IsWritable = (x.Attributes &&& DescriptorAttrs.ReadOnly) = 0us - member x.IsDeletable = (x.Attributes &&& DescriptorAttrs.DontDelete) = 0us - member x.IsEnumerable = (x.Attributes &&& DescriptorAttrs.DontEnum) = 0us + member x.IsWritable = (x.Attributes &&& DescriptorAttrs.ReadOnly) = DescriptorAttrs.None + member x.IsDeletable = (x.Attributes &&& DescriptorAttrs.DontDelete) = DescriptorAttrs.None + member x.IsEnumerable = (x.Attributes &&& DescriptorAttrs.DontEnum) = DescriptorAttrs.None end /// @@ -701,7 +692,7 @@ and [] CommonObject = false // - member x.SetAttrs(name:string, attrs:uint16) = + member x.SetAttrs(name:string, attrs:DescriptorAttrs) = let mutable index = 0 if x.PropertySchema.IndexMap.TryGetValue(name, &index) then @@ -842,35 +833,35 @@ and [] CommonObject = member x.Put(index:uint32, value:CO) : unit = x.Put(index, value, TypeTags.Object) member x.Put(index:uint32, value:FO) : unit = x.Put(index, value, TypeTags.Function) - member x.Put(name:String, value:BV, attrs:uint16) : unit = + member x.Put(name:String, value:BV, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:bool, attrs:uint16) : unit = + member x.Put(name:String, value:bool, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:double, attrs:uint16) : unit = + member x.Put(name:String, value:double, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:obj, attrs:uint16) : unit = + member x.Put(name:String, value:obj, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:String, attrs:uint16) : unit = + member x.Put(name:String, value:String, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:Undefined, attrs:uint16) : unit = + member x.Put(name:String, value:Undefined, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:CO, attrs:uint16) : unit = + member x.Put(name:String, value:CO, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) - member x.Put(name:String, value:FO, attrs:uint16) : unit = + member x.Put(name:String, value:FO, attrs:DescriptorAttrs) : unit = x.Put(name, value) x.SetAttrs(name, attrs) @@ -950,23 +941,23 @@ and [] CommonObject = //---------------------------------------------------------------------------- // Put methods for setting indexes to doubles - member x.Put(index:BV, value:obj, tag:uint32) = + member x.Put(index:BV, value:obj, tag:DescriptorAttrs) = let mutable i = 0u if TC.TryToIndex(index, &i) then x.Put(i, value, tag) else x.Put(TC.ToString(index), value, tag) - member x.Put(index:bool, value:obj, tag:uint32) = + member x.Put(index:bool, value:obj, tag:DescriptorAttrs) = x.Put(TC.ToString(index), value, tag) - member x.Put(index:double, value:obj, tag:uint32) : unit = + member x.Put(index:double, value:obj, tag:DescriptorAttrs) : unit = let mutable parsed = 0u if TC.TryToIndex(index, &parsed) then x.Put(parsed, value, tag) else x.Put(TC.ToString(index), value, tag) - member x.Put(index:obj, value:obj, tag:uint32) : unit = + member x.Put(index:obj, value:obj, tag:DescriptorAttrs) : unit = let index = TC.ToString(index) let mutable parsed = 0u @@ -974,10 +965,10 @@ and [] CommonObject = then x.Put(parsed, value, tag) else x.Put(index, value, tag) - member x.Put(index:Undefined, value:obj, tag:uint32) : unit = + member x.Put(index:Undefined, value:obj, tag:DescriptorAttrs) : unit = x.Put("undefined", value, tag) - member x.Put(index:CO, value:obj, tag:uint32) : unit = + member x.Put(index:CO, value:obj, tag:DescriptorAttrs) : unit = let index = TC.ToString(index) let mutable parsed = 0u diff --git a/Src/Tools/REPL/REPL.fsproj b/Src/Tools/REPL/REPL.fsproj index e9a755bd..c8756752 100644 --- a/Src/Tools/REPL/REPL.fsproj +++ b/Src/Tools/REPL/REPL.fsproj @@ -48,6 +48,11 @@ + + IronJS.Runtime + {f2322575-40e5-4e98-be72-bf4af9c77e77} + True + IronJS {9e257324-94e7-49af-ae83-718288e925d8}