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

   1 /*
   2  * Copyright 2009 Piotr Caban
   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 #include "config.h"
  19 #include "wine/port.h"
  20
  21 #include <math.h>
  22
  23 #include "jscript.h"
  24
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  28
  29 typedef struct {
  30     DispatchEx dispex;
  31 } ErrorInstance;
  32
  33 static const WCHAR descriptionW[] = {'d','e','s','c','r','i','p','t','i','o','n',0};
  34 static const WCHAR messageW[] = {'m','e','s','s','a','g','e',0};
  35 static const WCHAR nameW[] = {'n','a','m','e',0};
  36 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
  37 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
  38
  39 static inline ErrorInstance *error_from_vdisp(vdisp_t *vdisp)
  40 {
  41     return (ErrorInstance*)vdisp->u.jsdisp;
  42 }
  43
  44 static inline ErrorInstance *error_this(vdisp_t *jsthis)
  45 {
  46     return is_vclass(jsthis, JSCLASS_ERROR) ? error_from_vdisp(jsthis) : NULL;
  47 }
  48
  49 /* ECMA-262 3rd Edition    15.11.4.4 */
  50 static HRESULT Error_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
  51         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
  52 {
  53     ErrorInstance *error;
  54     BSTR name, msg = NULL, ret = NULL;
  55     VARIANT v;
  56     HRESULT hres;
  57
  58     static const WCHAR str[] = {'[','o','b','j','e','c','t',' ','E','r','r','o','r',']',0};
  59
  60     TRACE("\n");
  61
  62     error = error_this(jsthis);
  63     if(ctx->version < 2 || !error) {
  64         if(retv) {
  65             V_VT(retv) = VT_BSTR;
  66             V_BSTR(retv) = SysAllocString(str);
  67             if(!V_BSTR(retv))
  68                 return E_OUTOFMEMORY;
  69         }
  70         return S_OK;
  71     }
  72
  73     hres = jsdisp_propget_name(&error->dispex, nameW, &v, ei, caller);
  74     if(FAILED(hres))
  75         return hres;
  76
  77     hres = to_string(ctx, &v, ei, &name);
  78     VariantClear(&v);
  79     if(FAILED(hres))
  80         return hres;
  81
  82     hres = jsdisp_propget_name(&error->dispex, messageW, &v, ei, caller);
  83     if(SUCCEEDED(hres)) {
  84         if(V_VT(&v) != VT_EMPTY) {
  85             hres = to_string(ctx, &v, ei, &msg);
  86             VariantClear(&v);
  87             if(SUCCEEDED(hres) && !*msg) {
  88                 SysFreeString(msg);
  89                 msg = NULL;
  90             }
  91         }
  92     }
  93
  94     if(SUCCEEDED(hres)) {
  95         if(msg) {
  96             DWORD name_len, msg_len;
  97
  98             name_len = SysStringLen(name);
  99             msg_len = SysStringLen(msg);
 100
 101             ret = SysAllocStringLen(NULL, name_len + msg_len + 2);
 102             if(ret) {
 103                 memcpy(ret, name, name_len*sizeof(WCHAR));
 104                 ret[name_len] = ':';
 105                 ret[name_len+1] = ' ';
 106                 memcpy(ret+name_len+2, msg, msg_len*sizeof(WCHAR));
 107             }
 108         }else {
 109             ret = name;
 110             name = NULL;
 111         }
 112     }
 113
 114     SysFreeString(msg);
 115     SysFreeString(name);
 116     if(FAILED(hres))
 117         return hres;
 118     if(!ret)
 119         return E_OUTOFMEMORY;
 120
 121     if(retv) {
 122         V_VT(retv) = VT_BSTR;
 123         V_BSTR(retv) = ret;
 124     }else {
 125         SysFreeString(ret);
 126     }
 127
 128     return S_OK;
 129 }
 130
 131 static HRESULT Error_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 132         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 133 {
 134     TRACE("\n");
 135
 136     switch(flags) {
 137     case INVOKE_FUNC:
 138         return throw_type_error(ctx, ei, IDS_NOT_FUNC, NULL);
 139     default:
 140         FIXME("unimplemented flags %x\n", flags);
 141         return E_NOTIMPL;
 142     }
 143
 144     return S_OK;
 145 }
 146
 147 static void Error_destructor(DispatchEx *dispex)
 148 {
 149     ErrorInstance *This = (ErrorInstance*)dispex;
 150
 151     heap_free(This);
 152 }
 153
 154 static const builtin_prop_t Error_props[] = {
 155     {toStringW,                 Error_toString,                     PROPF_METHOD}
 156 };
 157
 158 static const builtin_info_t Error_info = {
 159     JSCLASS_ERROR,
 160     {NULL, Error_value, 0},
 161     sizeof(Error_props)/sizeof(*Error_props),
 162     Error_props,
 163     Error_destructor,
 164     NULL
 165 };
 166
 167 static const builtin_info_t ErrorInst_info = {
 168     JSCLASS_ERROR,
 169     {NULL, Error_value, 0},
 170     0,
 171     NULL,
 172     Error_destructor,
 173     NULL
 174 };
 175
 176 static HRESULT alloc_error(script_ctx_t *ctx, DispatchEx *prototype,
 177         DispatchEx *constr, ErrorInstance **ret)
 178 {
 179     ErrorInstance *err;
 180     HRESULT hres;
 181
 182     err = heap_alloc_zero(sizeof(ErrorInstance));
 183     if(!err)
 184         return E_OUTOFMEMORY;
 185
 186     if(prototype)
 187         hres = init_dispex(&err->dispex, ctx, &Error_info, prototype);
 188     else
 189         hres = init_dispex_from_constr(&err->dispex, ctx, &ErrorInst_info,
 190             constr ? constr : ctx->error_constr);
 191     if(FAILED(hres)) {
 192         heap_free(err);
 193         return hres;
 194     }
 195
 196     *ret = err;
 197     return S_OK;
 198 }
 199
 200 static HRESULT create_error(script_ctx_t *ctx, DispatchEx *constr,
 201         UINT number, const WCHAR *msg, DispatchEx **ret)
 202 {
 203     ErrorInstance *err;
 204     VARIANT v;
 205     HRESULT hres;
 206
 207     hres = alloc_error(ctx, NULL, constr, &err);
 208     if(FAILED(hres))
 209         return hres;
 210
 211     V_VT(&v) = VT_I4;
 212     V_I4(&v) = number;
 213     hres = jsdisp_propput_name(&err->dispex, numberW, &v, NULL/*FIXME*/, NULL/*FIXME*/);
 214     if(FAILED(hres)) {
 215         jsdisp_release(&err->dispex);
 216         return hres;
 217     }
 218
 219     V_VT(&v) = VT_BSTR;
 220     if(msg) V_BSTR(&v) = SysAllocString(msg);
 221     else V_BSTR(&v) = SysAllocStringLen(NULL, 0);
 222     if(V_BSTR(&v)) {
 223         hres = jsdisp_propput_name(&err->dispex, messageW, &v, NULL/*FIXME*/, NULL/*FIXME*/);
 224         if(SUCCEEDED(hres))
 225             hres = jsdisp_propput_name(&err->dispex, descriptionW, &v, NULL/*FIXME*/, NULL/*FIXME*/);
 226         SysFreeString(V_BSTR(&v));
 227     }else {
 228         hres = E_OUTOFMEMORY;
 229     }
 230     if(FAILED(hres)) {
 231         jsdisp_release(&err->dispex);
 232         return hres;
 233     }
 234
 235     *ret = &err->dispex;
 236     return S_OK;
 237 }
 238
 239 static HRESULT error_constr(script_ctx_t *ctx, WORD flags, DISPPARAMS *dp,
 240         VARIANT *retv, jsexcept_t *ei, DispatchEx *constr) {
 241     DispatchEx *err;
 242     UINT num = 0;
 243     BSTR msg = NULL;
 244     HRESULT hres;
 245
 246     if(arg_cnt(dp)) {
 247         VARIANT numv;
 248
 249         hres = to_number(ctx, get_arg(dp, 0), ei, &numv);
 250         if(FAILED(hres) || (V_VT(&numv)==VT_R8 && isnan(V_R8(&numv))))
 251             hres = to_string(ctx, get_arg(dp, 0), ei, &msg);
 252         else if(V_VT(&numv) == VT_I4)
 253             num = V_I4(&numv);
 254         else
 255             num = V_R8(&numv);
 256
 257         if(FAILED(hres))
 258             return hres;
 259     }
 260
 261     if(arg_cnt(dp)>1 && !msg) {
 262         hres = to_string(ctx, get_arg(dp, 1), ei, &msg);
 263         if(FAILED(hres))
 264             return hres;
 265     }
 266
 267     switch(flags) {
 268     case INVOKE_FUNC:
 269     case DISPATCH_CONSTRUCT:
 270         hres = create_error(ctx, constr, num, msg, &err);
 271         SysFreeString(msg);
 272
 273         if(FAILED(hres))
 274             return hres;
 275
 276         if(retv) {
 277             V_VT(retv) = VT_DISPATCH;
 278             V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(err);
 279         }
 280         else
 281             jsdisp_release(err);
 282
 283         return S_OK;
 284
 285     default:
 286         FIXME("unimplemented flags %x\n", flags);
 287         return E_NOTIMPL;
 288     }
 289 }
 290
 291 static HRESULT ErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 292         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 293 {
 294     TRACE("\n");
 295     return error_constr(ctx, flags, dp, retv, ei, ctx->error_constr);
 296 }
 297
 298 static HRESULT EvalErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 299         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 300 {
 301     TRACE("\n");
 302     return error_constr(ctx, flags, dp, retv, ei, ctx->eval_error_constr);
 303 }
 304
 305 static HRESULT RangeErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 306         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 307 {
 308     TRACE("\n");
 309     return error_constr(ctx, flags, dp, retv, ei, ctx->range_error_constr);
 310 }
 311
 312 static HRESULT ReferenceErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 313         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 314 {
 315     TRACE("\n");
 316     return error_constr(ctx, flags, dp, retv, ei, ctx->reference_error_constr);
 317 }
 318
 319 static HRESULT RegExpErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 320         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 321 {
 322     TRACE("\n");
 323     return error_constr(ctx, flags, dp, retv, ei, ctx->regexp_error_constr);
 324 }
 325
 326 static HRESULT SyntaxErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 327         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 328 {
 329     TRACE("\n");
 330     return error_constr(ctx, flags, dp, retv, ei, ctx->syntax_error_constr);
 331 }
 332
 333 static HRESULT TypeErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 334         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 335 {
 336     TRACE("\n");
 337     return error_constr(ctx, flags, dp, retv, ei, ctx->type_error_constr);
 338 }
 339
 340 static HRESULT URIErrorConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags,
 341         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 342 {
 343     TRACE("\n");
 344     return error_constr(ctx, flags, dp, retv, ei, ctx->uri_error_constr);
 345 }
 346
 347 HRESULT init_error_constr(script_ctx_t *ctx, DispatchEx *object_prototype)
 348 {
 349     static const WCHAR ErrorW[] = {'E','r','r','o','r',0};
 350     static const WCHAR EvalErrorW[] = {'E','v','a','l','E','r','r','o','r',0};
 351     static const WCHAR RangeErrorW[] = {'R','a','n','g','e','E','r','r','o','r',0};
 352     static const WCHAR ReferenceErrorW[] = {'R','e','f','e','r','e','n','c','e','E','r','r','o','r',0};
 353     static const WCHAR RegExpErrorW[] = {'R','e','g','E','x','p','E','r','r','o','r',0};
 354     static const WCHAR SyntaxErrorW[] = {'S','y','n','t','a','x','E','r','r','o','r',0};
 355     static const WCHAR TypeErrorW[] = {'T','y','p','e','E','r','r','o','r',0};
 356     static const WCHAR URIErrorW[] = {'U','R','I','E','r','r','o','r',0};
 357     static const WCHAR *names[] = {ErrorW, EvalErrorW, RangeErrorW,
 358         ReferenceErrorW, RegExpErrorW, SyntaxErrorW, TypeErrorW, URIErrorW};
 359     DispatchEx **constr_addr[] = {&ctx->error_constr, &ctx->eval_error_constr,
 360         &ctx->range_error_constr, &ctx->reference_error_constr, &ctx->regexp_error_constr,
 361         &ctx->syntax_error_constr, &ctx->type_error_constr,
 362         &ctx->uri_error_constr};
 363     static builtin_invoke_t constr_val[] = {ErrorConstr_value, EvalErrorConstr_value,
 364         RangeErrorConstr_value, ReferenceErrorConstr_value, RegExpErrorConstr_value,
 365         SyntaxErrorConstr_value, TypeErrorConstr_value, URIErrorConstr_value};
 366
 367     ErrorInstance *err;
 368     INT i;
 369     VARIANT v;
 370     HRESULT hres;
 371
 372     for(i=0; i < sizeof(names)/sizeof(names[0]); i++) {
 373         hres = alloc_error(ctx, i==0 ? object_prototype : NULL, NULL, &err);
 374         if(FAILED(hres))
 375             return hres;
 376
 377         V_VT(&v) = VT_BSTR;
 378         V_BSTR(&v) = SysAllocString(names[i]);
 379         if(!V_BSTR(&v)) {
 380             jsdisp_release(&err->dispex);
 381             return E_OUTOFMEMORY;
 382         }
 383
 384         hres = jsdisp_propput_name(&err->dispex, nameW, &v, NULL/*FIXME*/, NULL/*FIXME*/);
 385
 386         if(SUCCEEDED(hres))
 387             hres = create_builtin_function(ctx, constr_val[i], names[i], NULL,
 388                     PROPF_CONSTR|1, &err->dispex, constr_addr[i]);
 389
 390         jsdisp_release(&err->dispex);
 391         VariantClear(&v);
 392         if(FAILED(hres))
 393             return hres;
 394     }
 395
 396     return S_OK;
 397 }
 398
 399 static HRESULT throw_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str, DispatchEx *constr)
 400 {
 401     WCHAR buf[1024], *pos = NULL;
 402     DispatchEx *err;
 403     HRESULT hres;
 404
 405     buf[0] = '\0';
 406     LoadStringW(jscript_hinstance, id&0xFFFF,  buf, sizeof(buf)/sizeof(WCHAR));
 407
 408     if(str) pos = strchrW(buf, '|');
 409     if(pos) {
 410         int len = strlenW(str);
 411         memmove(pos+len, pos+1, (strlenW(pos+1)+1)*sizeof(WCHAR));
 412         memcpy(pos, str, len*sizeof(WCHAR));
 413     }
 414
 415     WARN("%s\n", debugstr_w(buf));
 416
 417     id |= JSCRIPT_ERROR;
 418     hres = create_error(ctx, constr, id, buf, &err);
 419     if(FAILED(hres))
 420         return hres;
 421
 422     if(!ei)
 423         return id;
 424
 425     V_VT(&ei->var) = VT_DISPATCH;
 426     V_DISPATCH(&ei->var) = (IDispatch*)_IDispatchEx_(err);
 427
 428     return id;
 429 }
 430
 431 HRESULT throw_generic_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 432 {
 433     return throw_error(ctx, ei, id, str, ctx->error_constr);
 434 }
 435
 436 HRESULT throw_range_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 437 {
 438     return throw_error(ctx, ei, id, str, ctx->range_error_constr);
 439 }
 440
 441 HRESULT throw_reference_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 442 {
 443     return throw_error(ctx, ei, id, str, ctx->reference_error_constr);
 444 }
 445
 446 HRESULT throw_regexp_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 447 {
 448     return throw_error(ctx, ei, id, str, ctx->regexp_error_constr);
 449 }
 450
 451 HRESULT throw_syntax_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 452 {
 453     return throw_error(ctx, ei, id, str, ctx->syntax_error_constr);
 454 }
 455
 456 HRESULT throw_type_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 457 {
 458     return throw_error(ctx, ei, id, str, ctx->type_error_constr);
 459 }
 460
 461 HRESULT throw_uri_error(script_ctx_t *ctx, jsexcept_t *ei, UINT id, const WCHAR *str)
 462 {
 463     return throw_error(ctx, ei, id, str, ctx->uri_error_constr);
 464 }