git.oblomov.eu Git - wine/blob - dlls/jscript/function.c

   1 /*
   2  * Copyright 2008 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "jscript.h"
  20 #include "engine.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  25
  26 typedef struct {
  27     DispatchEx dispex;
  28     builtin_invoke_t value_proc;
  29     DWORD flags;
  30     source_elements_t *source;
  31     parameter_t *parameters;
  32     scope_chain_t *scope_chain;
  33     parser_ctx_t *parser;
  34     const WCHAR *src_str;
  35     DWORD src_len;
  36     DWORD length;
  37 } FunctionInstance;
  38
  39 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
  40
  41 static const WCHAR lengthW[] = {'l','e','n','g','t','h',0};
  42 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
  43 static const WCHAR applyW[] = {'a','p','p','l','y',0};
  44 static const WCHAR callW[] = {'c','a','l','l',0};
  45
  46 static IDispatch *get_this(DISPPARAMS *dp)
  47 {
  48     DWORD i;
  49
  50     for(i=0; i < dp->cNamedArgs; i++) {
  51         if(dp->rgdispidNamedArgs[i] == DISPID_THIS) {
  52             if(V_VT(dp->rgvarg+i) == VT_DISPATCH)
  53                 return V_DISPATCH(dp->rgvarg+i);
  54
  55             WARN("This is not VT_DISPATCH\n");
  56             return NULL;
  57         }
  58     }
  59
  60     TRACE("no this passed\n");
  61     return NULL;
  62 }
  63
  64 static HRESULT init_parameters(DispatchEx *var_disp, FunctionInstance *function, LCID lcid, DISPPARAMS *dp,
  65         jsexcept_t *ei, IServiceProvider *caller)
  66 {
  67     parameter_t *param;
  68     VARIANT var_empty;
  69     DWORD cargs, i=0;
  70     HRESULT hres;
  71
  72     V_VT(&var_empty) = VT_EMPTY;
  73     cargs = dp->cArgs - dp->cNamedArgs;
  74
  75     for(param = function->parameters; param; param = param->next) {
  76         hres = jsdisp_propput_name(var_disp, param->identifier, lcid,
  77                 i < cargs ? dp->rgvarg + dp->cArgs-1 - i : &var_empty,
  78                 ei, caller);
  79         if(FAILED(hres))
  80             return hres;
  81
  82         i++;
  83     }
  84
  85     return S_OK;
  86 }
  87
  88 static HRESULT init_arguments(DispatchEx *arg_disp, FunctionInstance *function, LCID lcid, DISPPARAMS *dp,
  89         jsexcept_t *ei, IServiceProvider *caller)
  90 {
  91     VARIANT var;
  92     DWORD i;
  93     HRESULT hres;
  94
  95     for(i=0; i < dp->cArgs-dp->cNamedArgs; i++) {
  96         hres = jsdisp_propput_idx(arg_disp, i, lcid, dp->rgvarg+dp->cArgs-1-i, ei, caller);
  97         if(FAILED(hres))
  98             return hres;
  99     }
 100
 101     V_VT(&var) = VT_I4;
 102     V_I4(&var) = dp->cArgs - dp->cNamedArgs;
 103     return jsdisp_propput_name(arg_disp, lengthW, lcid, &var, ei, caller);
 104 }
 105
 106 static HRESULT create_var_disp(FunctionInstance *function, LCID lcid, DISPPARAMS *dp, jsexcept_t *ei,
 107                                IServiceProvider *caller, DispatchEx **ret)
 108 {
 109     DispatchEx *var_disp, *arg_disp;
 110     HRESULT hres;
 111
 112     static const WCHAR argumentsW[] = {'a','r','g','u','m','e','n','t','s',0};
 113
 114     hres = create_dispex(function->dispex.ctx, NULL, NULL, &var_disp);
 115     if(FAILED(hres))
 116         return hres;
 117
 118     hres = create_dispex(function->dispex.ctx, NULL, NULL, &arg_disp);
 119     if(SUCCEEDED(hres)) {
 120         hres = init_arguments(arg_disp, function, lcid, dp, ei, caller);
 121         if(SUCCEEDED(hres)) {
 122             VARIANT var;
 123
 124             V_VT(&var) = VT_DISPATCH;
 125             V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(arg_disp);
 126             hres = jsdisp_propput_name(var_disp, argumentsW, lcid, &var, ei, caller);
 127         }
 128
 129         jsdisp_release(arg_disp);
 130     }
 131
 132     if(SUCCEEDED(hres))
 133         hres = init_parameters(var_disp, function, lcid, dp, ei, caller);
 134     if(FAILED(hres)) {
 135         jsdisp_release(var_disp);
 136         return hres;
 137     }
 138
 139     *ret = var_disp;
 140     return S_OK;
 141 }
 142
 143 static HRESULT invoke_source(FunctionInstance *function, IDispatch *this_obj, LCID lcid, DISPPARAMS *dp,
 144         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 145 {
 146     DispatchEx *var_disp;
 147     exec_ctx_t *exec_ctx;
 148     scope_chain_t *scope;
 149     HRESULT hres;
 150
 151     if(!function->source) {
 152         FIXME("no source\n");
 153         return E_FAIL;
 154     }
 155
 156     hres = create_var_disp(function, lcid, dp, ei, caller, &var_disp);
 157     if(FAILED(hres))
 158         return hres;
 159
 160     hres = scope_push(function->scope_chain, var_disp, &scope);
 161     if(SUCCEEDED(hres)) {
 162         hres = create_exec_ctx(this_obj, var_disp, scope, &exec_ctx);
 163         scope_release(scope);
 164     }
 165     if(FAILED(hres))
 166         return hres;
 167
 168     hres = exec_source(exec_ctx, function->parser, function->source, ei, retv);
 169     exec_release(exec_ctx);
 170
 171     return hres;
 172 }
 173
 174 static HRESULT invoke_function(FunctionInstance *function, LCID lcid, DISPPARAMS *dp,
 175         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 176 {
 177     IDispatch *this_obj;
 178
 179     if(!(this_obj = get_this(dp)))
 180         this_obj = (IDispatch*)_IDispatchEx_(function->dispex.ctx->script_disp);
 181
 182     return invoke_source(function, this_obj, lcid, dp, retv, ei, caller);
 183 }
 184
 185 static HRESULT invoke_constructor(FunctionInstance *function, LCID lcid, DISPPARAMS *dp,
 186         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 187 {
 188     DispatchEx *this_obj;
 189     HRESULT hres;
 190
 191     hres = create_object(function->dispex.ctx, &function->dispex, &this_obj);
 192     if(FAILED(hres))
 193         return hres;
 194
 195     hres = invoke_source(function, (IDispatch*)_IDispatchEx_(this_obj), lcid, dp, retv, ei, caller);
 196     if(FAILED(hres)) {
 197         jsdisp_release(this_obj);
 198         return hres;
 199     }
 200
 201     V_VT(retv) = VT_DISPATCH;
 202     V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(this_obj);
 203     return S_OK;
 204 }
 205
 206 static HRESULT invoke_value_proc(FunctionInstance *function, LCID lcid, WORD flags, DISPPARAMS *dp,
 207         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 208 {
 209     DispatchEx *this_obj = NULL;
 210     IDispatch *this_disp;
 211     HRESULT hres;
 212
 213     this_disp = get_this(dp);
 214     if(this_disp)
 215         this_obj = iface_to_jsdisp((IUnknown*)this_disp);
 216
 217     hres = function->value_proc(this_obj ? this_obj : function->dispex.ctx->script_disp, lcid,
 218                                 flags, dp, retv, ei, caller);
 219
 220     if(this_obj)
 221         jsdisp_release(this_obj);
 222     return hres;
 223 }
 224
 225 static HRESULT function_to_string(FunctionInstance *function, BSTR *ret)
 226 {
 227     BSTR str;
 228
 229     if(function->value_proc) {
 230         FIXME("Builtin functions not implemented\n");
 231         return E_NOTIMPL;
 232     }
 233
 234     str = SysAllocStringLen(function->src_str, function->src_len);
 235     if(!str)
 236         return E_OUTOFMEMORY;
 237
 238     *ret = str;
 239     return S_OK;
 240 }
 241
 242 static HRESULT Function_length(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 243         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 244 {
 245     FunctionInstance *This = (FunctionInstance*)dispex;
 246
 247     TRACE("%p %d\n", This, This->length);
 248
 249     switch(flags) {
 250     case DISPATCH_PROPERTYGET:
 251         V_VT(retv) = VT_I4;
 252         V_I4(retv) = This->length;
 253         break;
 254     default:
 255         FIXME("unimplemented flags %x\n", flags);
 256         return E_NOTIMPL;
 257     }
 258
 259     return S_OK;
 260 }
 261
 262 static HRESULT Function_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 263         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 264 {
 265     FunctionInstance *function;
 266     BSTR str;
 267     HRESULT hres;
 268
 269     TRACE("\n");
 270
 271     if(!is_class(dispex, JSCLASS_FUNCTION))
 272         return throw_type_error(dispex->ctx, ei, IDS_NOT_FUNC, NULL);
 273
 274     function = (FunctionInstance*)dispex;
 275
 276     hres = function_to_string(function, &str);
 277     if(FAILED(hres))
 278         return hres;
 279
 280     if(retv) {
 281         V_VT(retv) = VT_BSTR;
 282         V_BSTR(retv) = str;
 283     }else {
 284         SysFreeString(str);
 285     }
 286     return S_OK;
 287 }
 288
 289 static HRESULT Function_apply(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 290         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 291 {
 292     FIXME("\n");
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT Function_call(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 297         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 298 {
 299     FIXME("\n");
 300     return E_NOTIMPL;
 301 }
 302
 303 HRESULT Function_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 304         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
 305 {
 306     FunctionInstance *function;
 307
 308     TRACE("\n");
 309
 310     if(dispex->builtin_info->class != JSCLASS_FUNCTION) {
 311         ERR("dispex is not a function\n");
 312         return E_FAIL;
 313     }
 314
 315     function = (FunctionInstance*)dispex;
 316
 317     switch(flags) {
 318     case DISPATCH_METHOD:
 319         if(function->value_proc)
 320             return invoke_value_proc(function, lcid, flags, dp, retv, ei, caller);
 321
 322         return invoke_function(function, lcid, dp, retv, ei, caller);
 323
 324     case DISPATCH_PROPERTYGET: {
 325         HRESULT hres;
 326         BSTR str;
 327
 328         hres = function_to_string(function, &str);
 329         if(FAILED(hres))
 330             return hres;
 331
 332         V_VT(retv) = VT_BSTR;
 333         V_BSTR(retv) = str;
 334         break;
 335     }
 336
 337     case DISPATCH_CONSTRUCT:
 338         if(function->value_proc)
 339             return invoke_value_proc(function, lcid, flags, dp, retv, ei, caller);
 340
 341         return invoke_constructor(function, lcid, dp, retv, ei, caller);
 342
 343     default:
 344         FIXME("not implemented flags %x\n", flags);
 345         return E_NOTIMPL;
 346     }
 347
 348     return S_OK;
 349 }
 350
 351 static void Function_destructor(DispatchEx *dispex)
 352 {
 353     FunctionInstance *This = (FunctionInstance*)dispex;
 354
 355     if(This->parser)
 356         parser_release(This->parser);
 357     if(This->scope_chain)
 358         scope_release(This->scope_chain);
 359     heap_free(This);
 360 }
 361
 362 static const builtin_prop_t Function_props[] = {
 363     {applyW,                 Function_apply,                 PROPF_METHOD|2},
 364     {callW,                  Function_call,                  PROPF_METHOD|1},
 365     {lengthW,                Function_length,                0},
 366     {toStringW,              Function_toString,              PROPF_METHOD}
 367 };
 368
 369 static const builtin_info_t Function_info = {
 370     JSCLASS_FUNCTION,
 371     {NULL, Function_value, 0},
 372     sizeof(Function_props)/sizeof(*Function_props),
 373     Function_props,
 374     Function_destructor,
 375     NULL
 376 };
 377
 378 static HRESULT FunctionConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 379         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 380 {
 381     FIXME("\n");
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT FunctionProt_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp,
 386         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 387 {
 388     FIXME("\n");
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT create_function(script_ctx_t *ctx, const builtin_info_t *builtin_info, DWORD flags,
 393         BOOL funcprot, DispatchEx *prototype, FunctionInstance **ret)
 394 {
 395     FunctionInstance *function;
 396     HRESULT hres;
 397
 398     function = heap_alloc_zero(sizeof(FunctionInstance));
 399     if(!function)
 400         return E_OUTOFMEMORY;
 401
 402     if(funcprot)
 403         hres = init_dispex(&function->dispex, ctx, &Function_info, prototype);
 404     else if(builtin_info)
 405         hres = init_dispex_from_constr(&function->dispex, ctx, builtin_info, ctx->function_constr);
 406     else
 407         hres = init_dispex_from_constr(&function->dispex, ctx, &Function_info, ctx->function_constr);
 408     if(FAILED(hres))
 409         return hres;
 410
 411     function->flags = flags;
 412     function->length = flags & PROPF_ARGMASK;
 413
 414     *ret = function;
 415     return S_OK;
 416 }
 417
 418 static HRESULT set_prototype(script_ctx_t *ctx, DispatchEx *dispex, DispatchEx *prototype)
 419 {
 420     jsexcept_t jsexcept;
 421     VARIANT var;
 422
 423     V_VT(&var) = VT_DISPATCH;
 424     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(prototype);
 425     memset(&jsexcept, 0, sizeof(jsexcept));
 426
 427     return jsdisp_propput_name(dispex, prototypeW, ctx->lcid, &var, &jsexcept, NULL/*FIXME*/);
 428 }
 429
 430 HRESULT create_builtin_function(script_ctx_t *ctx, builtin_invoke_t value_proc,
 431         const builtin_info_t *builtin_info, DWORD flags, DispatchEx *prototype, DispatchEx **ret)
 432 {
 433     FunctionInstance *function;
 434     HRESULT hres;
 435
 436     hres = create_function(ctx, builtin_info, flags, FALSE, NULL, &function);
 437     if(FAILED(hres))
 438         return hres;
 439
 440     hres = set_prototype(ctx, &function->dispex, prototype);
 441     if(FAILED(hres)) {
 442         jsdisp_release(&function->dispex);
 443         return hres;
 444     }
 445
 446     function->value_proc = value_proc;
 447
 448     *ret = &function->dispex;
 449     return S_OK;
 450 }
 451
 452 HRESULT create_source_function(parser_ctx_t *ctx, parameter_t *parameters, source_elements_t *source,
 453         scope_chain_t *scope_chain, const WCHAR *src_str, DWORD src_len, DispatchEx **ret)
 454 {
 455     FunctionInstance *function;
 456     DispatchEx *prototype;
 457     parameter_t *iter;
 458     DWORD length = 0;
 459     HRESULT hres;
 460
 461     hres = create_object(ctx->script, NULL, &prototype);
 462     if(FAILED(hres))
 463         return hres;
 464
 465     hres = create_function(ctx->script, NULL, PROPF_CONSTR, FALSE, NULL, &function);
 466     if(SUCCEEDED(hres)) {
 467         hres = set_prototype(ctx->script, &function->dispex, prototype);
 468         if(FAILED(hres))
 469             jsdisp_release(&function->dispex);
 470     }
 471     jsdisp_release(prototype);
 472     if(FAILED(hres))
 473         return hres;
 474
 475     function->source = source;
 476     function->parameters = parameters;
 477
 478     if(scope_chain) {
 479         scope_addref(scope_chain);
 480         function->scope_chain = scope_chain;
 481     }
 482
 483     parser_addref(ctx);
 484     function->parser = ctx;
 485
 486     for(iter = parameters; iter; iter = iter->next)
 487         length++;
 488     function->length = length;
 489
 490     function->src_str = src_str;
 491     function->src_len = src_len;
 492
 493     *ret = &function->dispex;
 494     return S_OK;
 495 }
 496
 497 HRESULT init_function_constr(script_ctx_t *ctx, DispatchEx *object_prototype)
 498 {
 499     FunctionInstance *prot, *constr;
 500     HRESULT hres;
 501
 502     hres = create_function(ctx, NULL, PROPF_CONSTR, TRUE, object_prototype, &prot);
 503     if(FAILED(hres))
 504         return hres;
 505
 506     prot->value_proc = FunctionProt_value;
 507
 508     hres = create_function(ctx, NULL, PROPF_CONSTR, TRUE, &prot->dispex, &constr);
 509     if(SUCCEEDED(hres)) {
 510         constr->value_proc = FunctionConstr_value;
 511         hres = set_prototype(ctx, &constr->dispex, &prot->dispex);
 512         if(FAILED(hres))
 513             jsdisp_release(&constr->dispex);
 514     }
 515     jsdisp_release(&prot->dispex);
 516     if(FAILED(hres))
 517         return hres;
 518
 519     ctx->function_constr = &constr->dispex;
 520     return S_OK;
 521 }