IE8 Beta1 is now available here.

It has remarkable script improvements in JScript performance. It also features handy JScript Debugger for developers.

I will soon be writing more about JScript Debugger - what went into designing this debugger the way it is, features etc. So stay tuned.

Mean while you can read up on what are few improvements related to performance.

Lets say out function foo takes parameter a, b and c and just alerts the values one by one.

function foo(a, b, c)

{

    alert("a = " + a);

    alert("b = " + b);

    alert("c = " + c);

}

Now as earlier we need to use dispParams to pass the parameters. But the trickier part here is the order in which the parameters need to be passed. You need to pass in parameters in exactly opposite order as expected. That is the array of parameter arguments should be in order c, b, a.

So we define one VARIANTARG here as :

// Parameters in exactly opposite order.

VARIANTARG param[3];

param[0].vt = VT_INT;

param[0].intVal = 10; // c

param[1].vt = VT_INT;

param[1].intVal = 20; // b

param[2].vt = VT_INT;

param[2].intVal = 30; // a

Then intialise it in dispParams as

DISPPARAMS dispParams = {

      param, // paramters

      NULL, // Named Parameters = JScript doesn't understand this

      3, // no. of parameters

      0 }; // no. of named parameters

That’s it. Calling Invoke now would call the function with parameters

m_disp->Invoke(

      DISPID_VALUE,

      IID_NULL,

      LOCALE_USER_DEFAULT,

      DISPATCH_METHOD,

      &dispParams,

      NULL,

      NULL,

      NULL);

Sample.zip

Lets implement an adder that takes one integer as parameter and return the result as paramter + 1.

function adder(a)

{

    alert("a = " + a);

    return a + 1;

}

We have already seen how to pass a parameter using dispParams to JScript Function. Now we just need to define result variant to store the result and then invoke the Invoke on the dispatch.

VARIANT result;

Call to the invoke

m_disp->Invoke(

      DISPID_VALUE,

      IID_NULL,

      LOCALE_USER_DEFAULT,

      DISPATCH_METHOD,

      &dispParams,

      &result,

      NULL,

      NULL);

Attached code contains the complete adder code.

Adder.zip

function alerter(b)

{

    alert("b = " + b);

}

Now to call this function we need to use other parameters of Invoke method of IDispatch which we had initialised to default.

DISPPARARMS dispParams that we intialised earlier with default value needs attention here. It takes the variant arguments, and named arguments. JScript does not support named arguments. So we can only use variant arg parameter.

So we define one VARIANTARG with interger value here.

VARIANTARG param;

param.vt = VT_INT;

param.intVal = 10;

And then intialise it in dispParams as

DISPPARAMS dispParams = {

&param, // paramters

      NULL, // Named Parameters = JScript doesn't understand this

      1, // no. of parameters

      0 }; // no. of named parameters

That’s it. Calling Invoke now would call the alerter.

m_disp->Invoke(

      DISPID_VALUE,

      IID_NULL,

      LOCALE_USER_DEFAULT,

      DISPATCH_METHOD,

      &dispParams,

      NULL,

      NULL,

      NULL);

Next post we will see how to use return value.

Alerter.zip

To make COM and JScript interoperable and allow COM component to call JScript function we need to pass JScript function to the COM component so that COM component receives it as IDispatch. Later to invoke this function, Invoke method on this IDispatch can be used.

How? Here is step by step explanation

Callback function:

function scriptCallBack()

{

    alert("In script callback");

}

Sending callback function to ActiveXObject:

x.SetCallBack(scriptCallBack);

COM function in class Test that implements SetCallBack:

STDMETHODIMP CTest::SetCallBack(IDispatch* disp)

{

      m_disp = disp;

      m_disp->AddRef();

      return S_OK;

}

COM function that calls CallBack:

STDMETHODIMP CTest::SomeFuncThatCallsCallBack(void)

{

      // Do Something

      // Call the callback

      if(m_disp)

      {

            DISPPARAMS dispParams = { NULL, NULL, 0, 0 };

            m_disp->Invoke(

                  DISPID_VALUE,

                  IID_NULL,

                  LOCALE_USER_DEFAULT,

                  DISPATCH_METHOD,

                  &dispParams,

                  NULL,

                  NULL,

                  NULL);

      }

      return S_OK;

}

Now this works perfectly fine, To test it I write the JScript code:

x.SomeFuncThatCallsCallBack();

Attached is the sample code

Sample.zip

To be able to invoke functions on the instantiated COM function through JScript, we need to add the method to the ITest interface which is derived from IDispatch.

Lets start with a example of a COM function Func1 which takes 2 parameters and returns the product of two numbers.

First step is to add the method for ITest interface:

I added this through ATL wizard, its much simpler that way. Note that return value is indicated as retval.

[id(1), helpstring("method Func1")] HRESULT Func1([in] FLOAT a, [in] FLOAT b, [out,retval] FLOAT* result);

Implementing this function on Test class:

STDMETHODIMP CTest::Func1(FLOAT a, FLOAT b, FLOAT* result)

{

      *result = a * b;

      return S_OK;

}

To call this method from JScript now we just need to pass in the parameters and store the result the way we normally do in JScript.

var result = x.Func1(10, 20);

What if you wants the function that returns array. It becomes really tricky but here is how one can achieve it.

To start with we need to add a method to ITest that would have retVal of VARIANT*

[id(2), helpstring("method Func2")] HRESULT Func2([out,retval] VARIANT* arrayVal);

After this here is how we implement the SafeArray in the func2.

Creation of the array:

SAFEARRAY * psa;

SAFEARRAYBOUND rgsabound[1];

rgsabound[0].lLbound = 0;

rgsabound[0].cElements = 5;

psa = SafeArrayCreate(VT_VARIANT, 1, rgsabound);

Populating data within this array:

VARIANT  HUGEP *pInteger;

SafeArrayAccessData(psa, (void HUGEP**)&pInteger);

for (int i = 0; i < psa->rgsabound->cElements; i++)

{

      pInteger[i].intVal = i;

      pInteger[i].vt = VT_INT;

}

SafeArrayUnaccessData(psa);

Now note that JScript can return or receive arrays of VARIANTs only. That was the reason the the method defined is with returnVal type of VARIANT.

VARIANT var;

var.vt = VT_ARRAY | VT_VARIANT;

var.parray = psa;

*arrayVal = var;

Now story does not end here. It is  even more trickier to use this array in Jscript. The variable needs to be converted to VB array first and then we need to use toArray method on this to actually get JScript Array. Here is how:

var array1 = x.Func2();

var array2 = new VBArray(array1);

var actualArray = array2.toArray(); 

For more information on VARIANTs you can check out this MSDN link:

https://msdn2.microsoft.com/en-us/library/ms221627.aspx

There is also a nice post on MSDN for JScript Types and COM types at:

https://blogs.msdn.com/ericlippert/archive/2004/07/14/183241.aspx

Sample.zip

Instantiating a COM class.

COM class should implement IDispatch and be registered with ProgID, so that JScript can invoke it using ActiveXObject semantics.

I used ATL library to create a ATL project called Sample and then added the Test which implements IDispatch and has progID = “Sample.Test”

Register this class using command

regsvr32 <path>Sample.dll

Now this class can be instantiated in JScript using:

var x = new ActiveXObject(“Sample.Test”);

Methods of Class Test can be invoked now using variable x.

I will talk about different mechanisms for passing parameters to and fro in next Posts.

Attached Zip contains the sample code.

Sample.zip

So the final setup looks like this:

Unregister RET csm.dll using regsvr32 /u <path for RET csm.dll>

Register CHK csm.dll using regsvr32 <path for CHK csm.dll>

CHK VS has venus project in which you can set bp in script etc. Pressing F5 invokes IE and breaks at previosly set BP. (You will need to check off option from Tools -> Internet Options -> Advanced -> Disable Script Debugging to enable script debugging)

In RET VS you need to attach to IE and CHK VS.

And you are ready to debug script debugging. Happy Debugging!!