jurassic Wiki Rss Feed

Updated Wiki: Home

paulbartrum — Tue, 30 Apr 2013 00:09:40 GMT

What is Jurassic?

Jurassic is an implementation of the ECMAScript language and runtime. It aims to provide the best performing and most standards-compliant implementation of JavaScript for .NET. Jurassic is not intended for end-users; instead it is intended to be integrated into .NET programs. If you are the author of a .NET program, you can use Jurassic to compile and execute JavaScript code.

Features

Supports all ECMAScript 3 and ECMAScript 5 functionality, including ES5 strict mode
Well tested - passes over five thousand unit tests (with over thirty thousand asserts)
Simple yet powerful API
Compiles JavaScript into .NET bytecode (CIL); not an interpreter
Deployed as a single .NET assembly (no native code)
Basic support for integrated debugging within Visual Studio
Uses light-weight code generation, so generated code is fully garbage collected
Tested on .NET 3.5, .NET 4 and Silverlight

Try it Now

You can enter javascript commands into the console below (requires silverlight).

You need to install Microsoft Silverlight to view this content. Get Silverlight!

Example: 5+5
Example: Math.sin(3)
Example: for(var i=0;i<8;i++)console.log(i&2?new Array((i&1)+1).join(' ')+'\\':new Array(2-(i&1)).join(' ')+'/')

Acknowledgements

Thanks to JetBrains for providing a free license for dotTrace Performance 4.0!

Updated Wiki: Home

paulbartrum — Tue, 30 Apr 2013 00:09:03 GMT

What is Jurassic?

Features

Supports all ECMAScript 3 and ECMAScript 5 functionality, including ES5 strict mode
Well tested - passes over five thousand unit tests (with over thirty thousand asserts)
Simple yet powerful API
Compiles JavaScript into .NET bytecode (CIL); not an interpreter
Deployed as a single .NET assembly (no native code)
Basic support for integrated debugging within Visual Studio
Uses light-weight code generation, so generated code is fully garbage collected
Tested on .NET 3.5, .NET 4 and Silverlight

Try it Now

You can enter javascript commands into the console below (requires silverlight).

You need to install Microsoft Silverlight to view this content. Get Silverlight!

Example: 5+5
Example: Math.sin(3)
Example: for(var i=0;i<8;i++)console.log(i&2?new Array((i&1)+1).join(' ')+'\\':new Array(2-(i&1)).join(' ')+'/')

Acknowledgements

Thanks to JetBrains for providing a free license for dotTrace Performance 4.0!

New Comment on "Benchmarks"

paulbartrum — Thu, 04 Apr 2013 10:24:08 GMT

Numbers are milliseconds, and lower is better.

New Comment on "Benchmarks"

stonstad — Wed, 03 Apr 2013 16:57:21 GMT

What unit are these numbers in? Is lower better or higher??

New Comment on "Debugging"

paulbartrum — Sun, 02 Sep 2012 23:42:03 GMT

Global variables are not locals, so I don't think you can call DeclareLocal on them :-) To get the value of a global variable, call scope.GetValue("name of global") (where "scope" is the second parameter of the generated method).

New Comment on "Debugging"

XIU — Fri, 31 Aug 2012 15:31:09 GMT

One extra comment, the locals will only work for variables that are inside a function, so I debug it like this: function test() { debugger;// var x; // Shows is locals window } test(); Looks like global variables don't call the the DeclareLocal method on ILGenerator

New Comment on "Debugging"

XIU — Fri, 31 Aug 2012 12:40:45 GMT

I've got the locals window working: in MethodGenerator.cs: - optimizationInfo.DebugDocument = reflectionEmitInfo.ModuleBuilder.DefineDocument(this.Source.Path, COMHelpers.LanguageType, COMHelpers.LanguageVendor, COMHelpers.DocumentType); - methodBuilder.DefineParameter(1, System.Reflection.ParameterAttributes.None, "scriptEngine"); - methodBuilder.DefineParameter(2, System.Reflection.ParameterAttributes.None, "scope"); - methodBuilder.DefineParameter(3, System.Reflection.ParameterAttributes.None, "thisValue"); - generator.MarkSequencePoint(optimizationInfo.DebugDocument, new SourceCodeSpan(1, 1, 1, 1)); + optimizationInfo.DebugDocument = reflectionEmitInfo.ModuleBuilder.DefineDocument(this.Source.Path, Guid.Empty, Guid.Empty, Guid.Empty);//, COMHelpers.LanguageType, COMHelpers.LanguageVendor, COMHelpers.DocumentType); + //methodBuilder.DefineParameter(1, System.Reflection.ParameterAttributes.None, "scriptEngine"); + //methodBuilder.DefineParameter(2, System.Reflection.ParameterAttributes.None, "scope"); + //methodBuilder.DefineParameter(3, System.Reflection.ParameterAttributes.None, "thisValue"); + //generator.MarkSequencePoint(optimizationInfo.DebugDocument, new SourceCodeSpan(1, 1, 1, 1)); in ReflactionEmitILGenerator.cs: - return new ReflectionEmitILLocalVariable(this.generator.DeclareLocal(type), name); + var declareLocal = this.generator.DeclareLocal(type); + if (name != null && name != "returnValue") + declareLocal.SetLocalSymInfo(name); + return new ReflectionEmitILLocalVariable(declareLocal, name); in OptimizationInfo.cs: return this.MethodOptimizationHints.HasArguments == false && this.MethodOptimizationHints.HasEval == false && this.MethodOptimizationHints.HasNestedFunction == false && - this.EvalResult == null; + this.EvalResult == null && + this.DebugDocument == null;

Updated Wiki: Exposing a .NET class to JavaScript

paulbartrum — Sat, 07 Apr 2012 07:02:36 GMT

Exposing a .NET class to JavaScript

Building a property bag class

To start with, let's create a class that contains a couple of properties.

using Jurassic;
using Jurassic.Library;

public class AppInfo : ObjectInstance
{
    public AppInfo(ScriptEngine engine)
        : base(engine)
    {
        // Read-write property (name).
        this["name"] = "Test Application";

        // Read-only property (version).
        this.DefineProperty("version", new PropertyDescriptor(5, PropertyAttributes.Sealed), true);
    }
}

In this example there are a few things to note:

Classes that are exposed to JavaScript are required to inherit from Jurassic.Library.ObjectInstance.
Passing a ScriptEngine to the base class constructor means that the object will have no prototype. Therefore the usual functions (hasOwnProperty, toString) will not be available.
The class indexer can be used to create read-write properties.
DefineProperty can be used to create read-only properties.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("appInfo", new AppInfo(engine));
Console.WriteLine(engine.Evaluate<string>("appInfo.name + ' ' + appInfo.version"));

This will output "Test Application 5" to the console.

Building a class with static functions

The next step up is to create a class with static functions, similar to how the built-in Math object works. For example, say you want to create a new Math2 object with a log10 function:

using Jurassic;
using Jurassic.Library;

public class Math2 : ObjectInstance
{
    public Math2(ScriptEngine engine)
        : base(engine)
    {
        this.PopulateFunctions();
    }

    [JSFunction(Name = "log10")]
    public static double Log10(double num)
    {
        return Math.Log10(num);
    }
}

Note the following:

PopulateFunctions searches the class for JSFunction attributes and creates a function for each one it finds.
The JSFunction attributes allows the JavaScript function name to be different from the .NET method name.
The parameter types and the return type must be on the list of supported types.
Please note: This feature requires the latest build from source control and is not yet in the official Downloads Decorating a property with the JSProperty attribute allows properties to be exposed to script as accessors. You can therefore code properties, complete with backers, in CLR, or make read-only properties in CLR code.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("math2", new Math2(engine));
Console.WriteLine(engine.Evaluate<double>("math2.log10(1000)"));

This will output "3" to the console.

Building an instance class

Objects that can be instantiated, like the built-in Number, String, Array and RegExp objects, require two .NET classes, one for the constructor and one for the instance. For example, let's make a JavaScript object that works similar to the .NET Random class (with a seed, since JavaScript doesn't support this):

using Jurassic;
using Jurassic.Library;

public class RandomConstructor : ClrFunction
{
    public RandomConstructor(ScriptEngine engine)
        : base(engine.Function.InstancePrototype, "Random", new RandomInstance(engine.Object.InstancePrototype))
    {
    }

    [JSConstructorFunction]
    public RandomInstance Construct(int seed)
    {
        return new RandomInstance(this.InstancePrototype, seed);
    }
}

public class RandomInstance : ObjectInstance
{
    private Random random;

    public RandomInstance(ObjectInstance prototype)
        : base(prototype)
    {
        this.PopulateFunctions();
        this.random = new Random(0);
    }

    public RandomInstance(ObjectInstance prototype, int seed)
        : base(prototype)
    {
        this.random = new Random(seed);
    }

    [JSFunction(Name = "nextDouble")]
    public double NextDouble()
    {
        return this.random.NextDouble();
    }
}

Note the following:

You need two classes - one is the constructor (i.e. the function object that you call new on) and one is for the instance object.
The ClrFunction base class requires three parameters: the prototype for the function object, the name of the function and the prototype for any instances created using the function.
The JSConstructorFunction attribute marks the method that is called when the new operator is used. You can also use JSCallFunction to mark the method that is called when the function is called directly.
The RandomInstance class has two constructors - one is used to initialize the prototype, one is used to initialize all other instances. PopulateFunctions should only be called from the prototype object.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("Random", new RandomConstructor(engine));
Console.WriteLine(engine.Evaluate<double>("var rand = new Random(1000); rand.nextDouble()"));

This will output "0.151557459100875" to the console (since we are using a seed, the first call to nextDouble() will be the same every time).

This example is much more involved, but it supports all of the advanced JavaScript concepts:

rand supports the built-in Object functions (hasOwnProperty, toString, etc).
rand utilizes prototypical inheritance. In this case you have the following prototype chain: random instance (with no properties) -> random prototype (with nextDouble defined) -> object prototype -> null.

Next tutorial: Loading a script from a custom source

Updated Wiki: Exposing a .NET class to JavaScript

paulbartrum — Sat, 07 Apr 2012 07:00:32 GMT

Exposing a .NET class to JavaScript

Building a property bag class

To start with, let's create a class that contains a couple of properties.

using Jurassic;
using Jurassic.Library;

public class AppInfo : ObjectInstance
{
    public AppInfo(ScriptEngine engine)
        : base(engine)
    {
        // Read-write property (name).
        this["name"] = "Test Application";

        // Read-only property (version).
        this.DefineProperty("version", new PropertyDescriptor(5, PropertyAttributes.Sealed), true);
    }
}

In this example there are a few things to note:

Classes that are exposed to JavaScript are required to inherit from Jurassic.Library.ObjectInstance.
Passing a ScriptEngine to the base class constructor means that the object will have no prototype. Therefore the usual functions (hasOwnProperty, toString) will not be available.
The class indexer can be used to create read-write properties.
DefineProperty can be used to create read-only properties.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("appInfo", new AppInfo(engine));
Console.WriteLine(engine.Evaluate<string>("appInfo.name + ' ' + appInfo.version"));

This will output "Test Application 5" to the console.

Building a class with static functions

The next step up is to create a class with static functions, similar to how the built-in Math object works. For example, say you want to create a new Math2 object with a log10 function:

using Jurassic;
using Jurassic.Library;

public class Math2 : ObjectInstance
{
    public Math2(ScriptEngine engine)
        : base(engine)
    {
        this.PopulateFunctions();
    }

    [JSFunction(Name = "log10")]
    public static double Log10(double num)
    {
        return Math.Log10(num);
    }
}

Note the following:

PopulateFunctions searches the class for JSFunction attributes and creates a function for each one it finds.
The JSFunction attributes allows the JavaScript function name to be different from the .NET method name.
The parameter types and the return type must be on the list of supported types.
Please note: This feature requires the latest build from source control and is not yet in the official Downloads Decorating a property with the JSProperty attribute allows properties to be exposed to script as accessors. You can therefore code properties, complete with backers, in CLR, or make read-only properties in CLR code.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("math2", new Math2(engine));
Console.WriteLine(engine.Evaluate<double>("math2.log10(1000)"));

This will output "3" to the console.

Building an instance class

using Jurassic;
using Jurassic.Library;

public class RandomConstructor : ClrFunction
{
    public RandomConstructor(ScriptEngine engine)
        : base(engine.Function.InstancePrototype, "Random", new RandomInstance(engine.Object.InstancePrototype))
    {
    }

    [JSConstructorFunction]
    public RandomInstance Construct(int seed)
    {
        return new RandomInstance(this.InstancePrototype, seed);
    }
}

public class RandomInstance : ObjectInstance
{
    private Random random;

    public RandomInstance(ObjectInstance prototype)
        : base(prototype)
    {
        this.PopulateFunctions();
        this.random = new Random(0);
    }

    public RandomInstance(ObjectInstance prototype, int seed)
        : base(prototype)
    {
        this.random = new Random(seed);
    }

    [JSFunction(Name = "nextDouble")]
    public double NextDouble()
    {
        return this.random.NextDouble();
    }
}

Note the following:

You need two classes - one is the constructor (i.e. the function object that you call new on) and one is for the instance object.
The ClrFunction base class requires three parameters: the prototype for the function object, the name of the function and the prototype for any instances created using the function.
The JSConstructorFunction attribute marks the method that is called when the new operator is used. You can also use JSCallFunction to mark the method that is called when the function is called directly.
The RandomInstance class has two constructors - one is used to initialize the prototype, one is used to initialize all other instances. PopulateFunctions should only be called from the prototype object.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("Random", new RandomConstructor(engine));
Console.WriteLine(engine.Evaluate<double>("var rand = new Random(1000); rand.nextDouble()"));

This will output "0.151557459100875" to the console (since we are using a seed, it will be the same every time).

This example is much more involved, but it supports all of the advanced JavaScript concepts:

rand supports the built-in Object functions (hasOwnProperty, toString, etc).
rand utilizes prototypical inheritance. In this case you have the following prototype chain: random instance (with no properties) -> random prototype (with nextDouble defined) -> object prototype -> null.

Next tutorial: Loading a script from a custom source

Updated Wiki: Exposing a .NET class to JavaScript

paulbartrum — Sat, 07 Apr 2012 07:00:05 GMT

Exposing a .NET class to JavaScript

Building a property bag class

To start with, let's create a class that contains a couple of properties.

using Jurassic;
using Jurassic.Library;

public class AppInfo : ObjectInstance
{
    public AppInfo(ScriptEngine engine)
        : base(engine)
    {
        // Read-write property (name).
        this["name"] = "Test Application";

        // Read-only property (version).
        this.DefineProperty("version", new PropertyDescriptor(5, PropertyAttributes.Sealed), true);
    }
}

In this example there are a few things to note:

Classes that are exposed to JavaScript are required to inherit from Jurassic.Library.ObjectInstance.
Passing a ScriptEngine to the base class constructor means that the object will have no prototype. Therefore the usual functions (hasOwnProperty, toString) will not be available.
The class indexer can be used to create read-write properties.
DefineProperty can be used to create read-only properties.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("appInfo", new AppInfo(engine));
Console.WriteLine(engine.Evaluate<string>("appInfo.name + " " + appInfo.version"));

This will output "Test Application 5" to the console.

Building a class with static functions

The next step up is to create a class with static functions, similar to how the built-in Math object works. For example, say you want to create a new Math2 object with a log10 function:

using Jurassic;
using Jurassic.Library;

public class Math2 : ObjectInstance
{
    public Math2(ScriptEngine engine)
        : base(engine)
    {
        this.PopulateFunctions();
    }

    [JSFunction(Name = "log10")]
    public static double Log10(double num)
    {
        return Math.Log10(num);
    }
}

Note the following:

PopulateFunctions searches the class for JSFunction attributes and creates a function for each one it finds.
The JSFunction attributes allows the JavaScript function name to be different from the .NET method name.
The parameter types and the return type must be on the list of supported types.
Please note: This feature requires the latest build from source control and is not yet in the official Downloads Decorating a property with the JSProperty attribute allows properties to be exposed to script as accessors. You can therefore code properties, complete with backers, in CLR, or make read-only properties in CLR code.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("math2", new Math2(engine));
Console.WriteLine(engine.Evaluate<double>("math2.log10(1000)"));

This will output "3" to the console.

Building an instance class

using Jurassic;
using Jurassic.Library;

public class RandomConstructor : ClrFunction
{
    public RandomConstructor(ScriptEngine engine)
        : base(engine.Function.InstancePrototype, "Random", new RandomInstance(engine.Object.InstancePrototype))
    {
    }

    [JSConstructorFunction]
    public RandomInstance Construct(int seed)
    {
        return new RandomInstance(this.InstancePrototype, seed);
    }
}

public class RandomInstance : ObjectInstance
{
    private Random random;

    public RandomInstance(ObjectInstance prototype)
        : base(prototype)
    {
        this.PopulateFunctions();
        this.random = new Random(0);
    }

    public RandomInstance(ObjectInstance prototype, int seed)
        : base(prototype)
    {
        this.random = new Random(seed);
    }

    [JSFunction(Name = "nextDouble")]
    public double NextDouble()
    {
        return this.random.NextDouble();
    }
}

Note the following:

You need two classes - one is the constructor (i.e. the function object that you call new on) and one is for the instance object.
The ClrFunction base class requires three parameters: the prototype for the function object, the name of the function and the prototype for any instances created using the function.
The JSConstructorFunction attribute marks the method that is called when the new operator is used. You can also use JSCallFunction to mark the method that is called when the function is called directly.
The RandomInstance class has two constructors - one is used to initialize the prototype, one is used to initialize all other instances. PopulateFunctions should only be called from the prototype object.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("Random", new RandomConstructor(engine));
Console.WriteLine(engine.Evaluate<double>("var rand = new Random(1000); rand.nextDouble()"));

rand supports the built-in Object functions (hasOwnProperty, toString, etc).
rand utilizes prototypical inheritance. In this case you have the following prototype chain: random instance (with no properties) -> random prototype (with nextDouble defined) -> object prototype -> null.

Next tutorial: Loading a script from a custom source

Updated Wiki: Exposing a .NET class to JavaScript

paulbartrum — Sat, 07 Apr 2012 06:57:44 GMT

Exposing a .NET class to JavaScript

Building a property bag class

To start with, let's create a class that contains a couple of properties.

using Jurassic;
using Jurassic.Library;

public class AppInfo : ObjectInstance
{
    public AppInfo(ScriptEngine engine)
        : base(engine)
    {
        this["name"] = "Test Application";
        this["version"] = 5;
    }
}

In this example there are a few things to note:

Classes that are exposed to JavaScript are required to inherit from Jurassic.Library.ObjectInstance.
Passing a ScriptEngine to the base class constructor means that the object will have no prototype. Therefore the usual functions (hasOwnProperty, toString) will not be available.
DefineProperty is used to create read-only properties. SetPropertyValue is simpler, but only creates read-write properties.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("appInfo", new AppInfo(engine));
Console.WriteLine(engine.Evaluate<string>("appInfo.name + " " + appInfo.version"));

This will output "Test Application 5" to the console.

Building a class with static functions

The next step up is to create a class with static functions, similar to how the built-in Math object works. For example, say you want to create a new Math2 object with a log10 function:

using Jurassic;
using Jurassic.Library;

public class Math2 : ObjectInstance
{
    public Math2(ScriptEngine engine)
        : base(engine)
    {
        this.PopulateFunctions();
    }

    [JSFunction(Name = "log10")]
    public static double Log10(double num)
    {
        return Math.Log10(num);
    }
}

Note the following:

PopulateFunctions searches the class for JSFunction attributes and creates a function for each one it finds.
The JSFunction attributes allows the JavaScript function name to be different from the .NET method name.
The parameter types and the return type must be on the list of supported types.
Please note: This feature requires the latest build from source control and is not yet in the official Downloads Decorating a property with the JSProperty attribute allows properties to be exposed to script as accessors. You can therefore code properties, complete with backers, in CLR, or make read-only properties in CLR code.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("math2", new Math2(engine));
Console.WriteLine(engine.Evaluate<double>("math2.log10(1000)"));

This will output "3" to the console.

Building an instance class

using Jurassic;
using Jurassic.Library;

public class RandomConstructor : ClrFunction
{
    public RandomConstructor(ScriptEngine engine)
        : base(engine.Function.InstancePrototype, "Random", new RandomInstance(engine.Object.InstancePrototype))
    {
    }

    [JSConstructorFunction]
    public RandomInstance Construct(int seed)
    {
        return new RandomInstance(this.InstancePrototype, seed);
    }
}

public class RandomInstance : ObjectInstance
{
    private Random random;

    public RandomInstance(ObjectInstance prototype)
        : base(prototype)
    {
        this.PopulateFunctions();
        this.random = new Random(0);
    }

    public RandomInstance(ObjectInstance prototype, int seed)
        : base(prototype)
    {
        this.random = new Random(seed);
    }

    [JSFunction(Name = "nextDouble")]
    public double NextDouble()
    {
        return this.random.NextDouble();
    }
}

Note the following:

You need two classes - one is the constructor (i.e. the function object that you call new on) and one is for the instance object.
The ClrFunction base class requires three parameters: the prototype for the function object, the name of the function and the prototype for any instances created using the function.
The JSConstructorFunction attribute marks the method that is called when the new operator is used. You can also use JSCallFunction to mark the method that is called when the function is called directly.
The RandomInstance class has two constructors - one is used to initialize the prototype, one is used to initialize all other instances. PopulateFunctions should only be called from the prototype object.

Here's an example of how to create and use the new class:

var engine = new Jurassic.ScriptEngine();
engine.SetGlobalValue("Random", new RandomConstructor(engine));
Console.WriteLine(engine.Evaluate<double>("var rand = new Random(1000); rand.nextDouble()"));

rand supports the built-in Object functions (hasOwnProperty, toString, etc).
rand utilizes prototypical inheritance. In this case you have the following prototype chain: random instance (with no properties) -> random prototype (with nextDouble defined) -> object prototype -> null.

Next tutorial: Loading a script from a custom source

New Comment on "Future plans"

cmcbf — Mon, 06 Feb 2012 00:21:21 GMT

1) An debug api to step into, step out (execute line by line), get source line, inspect variable, run, stop. This allow an aplication to emulate an debugger (see remobjects.com, they already do that in their javascript engine) 2) Ability to generate an DLL file from js, to posterior use with Engine (like Engine.ExecutePrecompiledJavascriptDll ("mydll.dll"); that skip parse, and compile and optimization stages and executes directly, speeding execution; 3) Make ToJSDate public 4) Implement SetTimeOut, SetInterval and WebWorker 5) Implement XMLHttpRequest object 6) Integrate DynamicObjectWraper directly inside of Objectinstance (Only when Jurassic nevermore support Net 3.5) 7) Implement Typed Array, and Binary types, like Int64 - http://www.khronos.org/registry/typedarray/specs/latest/ this will permit usage of Jurassic with WEBGL, 3d graphic aplications and the usage of Jurassic with databases that have biginteger fields. 8) An visual Studio debug PlugIn May be http://msdn.microsoft.com/en-us/library/bb161694(v=vs.80).aspx help to implement this.

New Comment on "Future plans"

cmcbf — Mon, 06 Feb 2012 00:19:18 GMT

1) An debug api to step into, step out (execute line by line), get source line, inspect variable, run, stop. This allow an aplication to emulate an debugger (see remobjects.com, they already do that in their javascript engine) 2) Ability to generate an DLL file from js, to posterior use with Engine (like Engine.ExecutePrecompiledJavascriptDll ("mydll.dll"); that skip parse, and compile and optimization stages and executes directly, speeding execution; 3) Make ToJSDate public 4) Implement SetTimeOut, SetInterval and WebWorker 5) Implement XMLHttpRequest object 6) an option to ScriptEngine to register Global Object as window by default Like engine.TreatGlobalObjectAsWindow = true; 7) Integrate DynamicObjectWraper directly inside of Objectinstance (Only when Jurassic nevermore support Net 3.5) 8) Implement Typed Array, and Binary types, like Int64 - http://www.khronos.org/registry/typedarray/specs/latest/ this will permit usage of Jurassic with WEBGL, 3d graphic aplications and the usage of Jurassic with databases that have biginteger fields. 9) An visual Studio debug PlugIn May be http://msdn.microsoft.com/en-us/library/bb161694(v=vs.80).aspx help to implement this.

New Comment on "Debugging"

cmcbf — Fri, 03 Feb 2012 14:31:50 GMT

@paulbartrum -: hummmm. To hard to implement. The MSDN documentation is very extense and dificult to understand....

New Comment on "Debugging"

cmcbf — Fri, 03 Feb 2012 14:30:54 GMT

@pau -: hummmm. To hard to implement. The MSDN documentation is very extense and dificult to understand.... Thanks paul.

New Comment on "Future plans"

cmcbf — Fri, 03 Feb 2012 13:26:35 GMT

1) An debug api to step into, step out (execute line by line), get source line, inspect variable, run, stop. This allow an aplication to emulate an debugger (see remobjects.com, they already do that in their javascript engine) 2) Ability to generate an DLL file from js, to posterior use with Engine (like Engine.ExecutePrecompiledJavascriptDll ("mydll.dll"); and speed execution; 3) Make ToJSDate public 4) Implement SetTimeOut, SetInterval and WebWorker 5) Implement XMLHttpRequest object 6) an option to ScriptEngine to register Global Object as window by default Like engine.TreatGlobalObjectAsWindow = true; 7) Integrate DynamicObjectWraper directly inside of Objectinstance (Only when Jurassic nevermore support Net 3.5) 8) Implement Typed Array, and Binary types, like Int64 this will permit usage of Jurassic with WEBGL, 3d graphic aplications and the usage of Jurassic with databases that have biginteger fields. 9) An visual Studio debug PlugIn May be http://msdn.microsoft.com/en-us/library/bb161694(v=vs.80).aspx help to implement this.

New Comment on "Future plans"

cmcbf — Fri, 03 Feb 2012 13:25:37 GMT

some ideas: 1) An debug api to step into, step out (execute line by line), get source line, inspect variable, run, stop. This allow an aplication to emulate an debugger (see remobjects.com, they already do that in their javascript engine) 2) Ability to generate an DLL file from js, to posterior use with Engine (like Engine.ExecutePrecompiledJavascriptDll ("mydll.dll"); and speed execution; 4) Make ToJSDate public 5) Implement SetTimeOut, SetInterval and WebWorker 6) Implement XMLHttpRequest object 7) an option to ScriptEngine to register Global Object as window by default Like engine.TreatGlobalObjectAsWindow = true; 7) Integrate DynamicObjectWraper directly inside of Objectinstance (Only when Jurassic nevermore support Net 3.5) 8) Implement Typed Array, and Binary types, like Int64 this will permit usage of Jurassic with WEBGL, 3d graphic aplications and the usage of Jurassic with databases that have biginteger fields. 9) An visual Studio debug PlugIn May be http://msdn.microsoft.com/en-us/library/bb161694(v=vs.80).aspx help to implement this.

New Comment on "Debugging"

paulbartrum — Thu, 02 Feb 2012 22:51:33 GMT

@cmcbf - if only it was that easy! To make this work, you actually have to write an expression evaluator, which is documented here: http://msdn.microsoft.com/en-us/library/bb161694.aspx

New Comment on "Debugging"

cmcbf — Thu, 02 Feb 2012 15:04:13 GMT

May be this article help to add visual debug support I think IL generation needs to add these atributes described in article. See http://msdn.microsoft.com/en-us/magazine/cc163974.aspx Also I modified FirebugConsole to suport output to Visual Studio Debug Console, see http://jurassic.codeplex.com/discussions/289027

New Comment on "Debugging"

cmcbf — Thu, 02 Feb 2012 15:01:09 GMT

http://msdn.microsoft.com/en-us/magazine/cc163974.aspx

jurassic Wiki Rss Feed

Updated Wiki: Home

What is Jurassic?

Features

See Also

Try it Now

Acknowledgements

Updated Wiki: Home

What is Jurassic?

Features

See Also

Try it Now

Acknowledgements

New Comment on "Benchmarks"

New Comment on "Benchmarks"

New Comment on "Debugging"

New Comment on "Debugging"

New Comment on "Debugging"

Updated Wiki: Exposing a .NET class to JavaScript

Exposing a .NET class to JavaScript

Building a property bag class

Building a class with static functions

Building an instance class

Updated Wiki: Exposing a .NET class to JavaScript

Exposing a .NET class to JavaScript

Building a property bag class

Building a class with static functions

Building an instance class

Updated Wiki: Exposing a .NET class to JavaScript

Exposing a .NET class to JavaScript

Building a property bag class

Building a class with static functions

Building an instance class

Updated Wiki: Exposing a .NET class to JavaScript

Exposing a .NET class to JavaScript

Building a property bag class

Building a class with static functions

Building an instance class

New Comment on "Future plans"

New Comment on "Future plans"

New Comment on "Debugging"

New Comment on "Debugging"

New Comment on "Future plans"

New Comment on "Future plans"

New Comment on "Debugging"

New Comment on "Debugging"

New Comment on "Debugging"