| /* |
| * Copyright 2008 Jacek Caban for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include "jscript.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(jscript); |
| |
| typedef struct { |
| DispatchEx dispex; |
| |
| WCHAR *str; |
| DWORD length; |
| } StringInstance; |
| |
| static const WCHAR lengthW[] = {'l','e','n','g','t','h',0}; |
| static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0}; |
| static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0}; |
| static const WCHAR anchorW[] = {'a','n','c','h','o','r',0}; |
| static const WCHAR bigW[] = {'b','i','g',0}; |
| static const WCHAR blinkW[] = {'b','l','i','n','k',0}; |
| static const WCHAR boldW[] = {'b','o','l','d',0}; |
| static const WCHAR charAtW[] = {'c','h','a','r','A','t',0}; |
| static const WCHAR charCodeAtW[] = {'c','h','a','r','C','o','d','e','A','t',0}; |
| static const WCHAR concatW[] = {'c','o','n','c','a','t',0}; |
| static const WCHAR fixedW[] = {'f','i','x','e','d',0}; |
| static const WCHAR fontcolorW[] = {'f','o','n','t','c','o','l','o','r',0}; |
| static const WCHAR fontsizeW[] = {'f','o','n','t','s','i','z','e',0}; |
| static const WCHAR indexOfW[] = {'i','n','d','e','x','O','f',0}; |
| static const WCHAR italicsW[] = {'i','t','a','l','i','c','s',0}; |
| static const WCHAR lastIndexOfW[] = {'l','a','s','t','I','n','d','e','x','O','f',0}; |
| static const WCHAR linkW[] = {'l','i','n','k',0}; |
| static const WCHAR matchW[] = {'m','a','t','c','h',0}; |
| static const WCHAR replaceW[] = {'r','e','p','l','a','c','e',0}; |
| static const WCHAR searchW[] = {'s','e','a','r','c','h',0}; |
| static const WCHAR sliceW[] = {'s','l','i','c','e',0}; |
| static const WCHAR smallW[] = {'s','m','a','l','l',0}; |
| static const WCHAR splitW[] = {'s','p','l','i','t',0}; |
| static const WCHAR strikeW[] = {'s','t','r','i','k','e',0}; |
| static const WCHAR subW[] = {'s','u','b',0}; |
| static const WCHAR substringW[] = {'s','u','b','s','t','r','i','n','g',0}; |
| static const WCHAR substrW[] = {'s','u','b','s','t','r',0}; |
| static const WCHAR supW[] = {'s','u','p',0}; |
| static const WCHAR toLowerCaseW[] = {'t','o','L','o','w','e','r','C','a','s','e',0}; |
| static const WCHAR toUpperCaseW[] = {'t','o','U','p','p','e','r','C','a','s','e',0}; |
| static const WCHAR toLocaleLowerCaseW[] = {'t','o','L','o','c','a','l','e','L','o','w','e','r','C','a','s','e',0}; |
| static const WCHAR toLocaleUpperCaseW[] = {'t','o','L','o','c','a','l','e','U','p','p','e','r','C','a','s','e',0}; |
| static const WCHAR localeCompareW[] = {'l','o','c','a','l','e','C','o','m','p','a','r','e',0}; |
| static const WCHAR hasOwnPropertyW[] = {'h','a','s','O','w','n','P','r','o','p','e','r','t','y',0}; |
| static const WCHAR propertyIsEnumerableW[] = |
| {'p','r','o','p','e','r','t','y','I','s','E','n','u','m','e','r','a','b','l','e',0}; |
| static const WCHAR isPrototypeOfW[] = {'i','s','P','r','o','t','o','t','y','p','e','O','f',0}; |
| |
| static HRESULT String_length(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| TRACE("%p\n", dispex); |
| |
| switch(flags) { |
| case DISPATCH_PROPERTYGET: { |
| StringInstance *jsthis = (StringInstance*)dispex; |
| |
| V_VT(retv) = VT_I4; |
| V_I4(retv) = jsthis->length; |
| break; |
| } |
| default: |
| FIXME("unimplemented flags %x\n", flags); |
| return E_NOTIMPL; |
| } |
| |
| return S_OK; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.2 */ |
| static HRESULT String_toString(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| StringInstance *string; |
| |
| TRACE("\n"); |
| |
| if(!is_class(dispex, JSCLASS_STRING)) { |
| WARN("this is not a string object\n"); |
| return E_FAIL; |
| } |
| |
| string = (StringInstance*)dispex; |
| |
| if(retv) { |
| BSTR str = SysAllocString(string->str); |
| if(!str) |
| return E_OUTOFMEMORY; |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = str; |
| } |
| return S_OK; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.2 */ |
| static HRESULT String_valueOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| TRACE("\n"); |
| |
| return String_toString(dispex, lcid, flags, dp, retv, ei, sp); |
| } |
| |
| static HRESULT do_attributeless_tag_format(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp, const WCHAR *tagname) |
| { |
| static const WCHAR tagfmt[] = {'<','%','s','>','%','s','<','/','%','s','>',0}; |
| StringInstance *string; |
| BSTR ret; |
| |
| if(!is_class(dispex, JSCLASS_STRING)) { |
| WARN("this is not a string object\n"); |
| return E_NOTIMPL; |
| } |
| |
| string = (StringInstance*)dispex; |
| |
| if(retv) { |
| ret = SysAllocStringLen(NULL, string->length + 2*strlenW(tagname) + 5); |
| if(!ret) |
| return E_OUTOFMEMORY; |
| |
| sprintfW(ret, tagfmt, tagname, string->str, tagname); |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = ret; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_anchor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_big(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR bigtagW[] = {'B','I','G',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, bigtagW); |
| } |
| |
| static HRESULT String_blink(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR blinktagW[] = {'B','L','I','N','K',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, blinktagW); |
| } |
| |
| static HRESULT String_bold(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR boldtagW[] = {'B',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, boldtagW); |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.5 */ |
| static HRESULT String_charAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| StringInstance *strobj; |
| BSTR str; |
| INT pos = 0; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| if(dispex->builtin_info->class != JSCLASS_STRING) { |
| FIXME("not string this not supported\n"); |
| return E_NOTIMPL; |
| } |
| |
| strobj = (StringInstance*)dispex; |
| |
| if(arg_cnt(dp)) { |
| VARIANT num; |
| |
| hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &num); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(V_VT(&num) == VT_I4) { |
| pos = V_I4(&num); |
| }else { |
| WARN("pos = %lf\n", V_R8(&num)); |
| pos = -1; |
| } |
| } |
| |
| if(!retv) |
| return S_OK; |
| |
| if(0 <= pos && pos < strobj->length) |
| str = SysAllocStringLen(strobj->str+pos, 1); |
| else |
| str = SysAllocStringLen(NULL, 0); |
| if(!str) |
| return E_OUTOFMEMORY; |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = str; |
| return S_OK; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.5 */ |
| static HRESULT String_charCodeAt(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| const WCHAR *str; |
| DWORD length, idx = 0; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| if(dispex->builtin_info->class == JSCLASS_STRING) { |
| StringInstance *string = (StringInstance*)dispex; |
| |
| str = string->str; |
| length = string->length; |
| }else { |
| FIXME("not string this not supported\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(arg_cnt(dp) > 0) { |
| VARIANT v; |
| |
| hres = to_integer(dispex->ctx, get_arg(dp, 0), ei, &v); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(V_VT(&v) != VT_I4 || V_I4(&v) < 0 || V_I4(&v) >= length) { |
| FIXME("NAN\n"); |
| return E_FAIL; |
| } |
| |
| idx = V_I4(&v); |
| } |
| |
| if(retv) { |
| V_VT(retv) = VT_I4; |
| V_I4(retv) = str[idx]; |
| } |
| return S_OK; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.6 */ |
| static HRESULT String_concat(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| BSTR *strs = NULL, ret = NULL; |
| DWORD len = 0, i, l, str_cnt; |
| VARIANT var; |
| WCHAR *ptr; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| str_cnt = arg_cnt(dp)+1; |
| strs = heap_alloc_zero(str_cnt * sizeof(BSTR)); |
| if(!strs) |
| return E_OUTOFMEMORY; |
| |
| V_VT(&var) = VT_DISPATCH; |
| V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex); |
| |
| hres = to_string(dispex->ctx, &var, ei, strs); |
| if(SUCCEEDED(hres)) { |
| for(i=0; i < arg_cnt(dp); i++) { |
| hres = to_string(dispex->ctx, get_arg(dp, i), ei, strs+i+1); |
| if(FAILED(hres)) |
| break; |
| } |
| } |
| |
| if(SUCCEEDED(hres)) { |
| for(i=0; i < str_cnt; i++) |
| len += SysStringLen(strs[i]); |
| |
| ptr = ret = SysAllocStringLen(NULL, len); |
| |
| for(i=0; i < str_cnt; i++) { |
| l = SysStringLen(strs[i]); |
| memcpy(ptr, strs[i], l*sizeof(WCHAR)); |
| ptr += l; |
| } |
| } |
| |
| for(i=0; i < str_cnt; i++) |
| SysFreeString(strs[i]); |
| heap_free(strs); |
| |
| if(FAILED(hres)) |
| return hres; |
| |
| if(retv) { |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = ret; |
| }else { |
| SysFreeString(ret); |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_fixed(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR fixedtagW[] = {'T','T',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, fixedtagW); |
| } |
| |
| static HRESULT String_fontcolor(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_fontsize(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_indexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| DWORD length, pos = 0; |
| const WCHAR *str; |
| BSTR search_str; |
| INT ret = -1; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| if(is_class(dispex, JSCLASS_STRING)) { |
| StringInstance *string = (StringInstance*)dispex; |
| |
| str = string->str; |
| length = string->length; |
| }else { |
| FIXME("not String this\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(!arg_cnt(dp)) { |
| if(retv) { |
| V_VT(retv) = VT_I4; |
| V_I4(retv) = -1; |
| } |
| return S_OK; |
| } |
| |
| hres = to_string(dispex->ctx, get_arg(dp,0), ei, &search_str); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(arg_cnt(dp) >= 2) { |
| VARIANT ival; |
| |
| hres = to_integer(dispex->ctx, get_arg(dp,1), ei, &ival); |
| if(SUCCEEDED(hres)) { |
| if(V_VT(&ival) == VT_I4) |
| pos = V_VT(&ival) > 0 ? V_I4(&ival) : 0; |
| else |
| pos = V_R8(&ival) > 0.0 ? length : 0; |
| if(pos > length) |
| pos = length; |
| } |
| } |
| |
| if(SUCCEEDED(hres)) { |
| const WCHAR *ptr; |
| |
| ptr = strstrW(str+pos, search_str); |
| if(ptr) |
| ret = ptr - str; |
| else |
| ret = -1; |
| } |
| |
| SysFreeString(search_str); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(retv) { |
| V_VT(retv) = VT_I4; |
| V_I4(retv) = ret; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_italics(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR italicstagW[] = {'I',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, italicstagW); |
| } |
| |
| static HRESULT String_lastIndexOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_link(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.10 */ |
| static HRESULT String_match(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| StringInstance *This = (StringInstance*)dispex; |
| match_result_t *match_result; |
| DispatchEx *regexp; |
| DispatchEx *array; |
| VARIANT var, *arg_var; |
| DWORD match_cnt, i; |
| HRESULT hres = S_OK; |
| |
| TRACE("\n"); |
| |
| if(arg_cnt(dp) != 1) { |
| FIXME("unsupported args\n"); |
| return E_NOTIMPL; |
| } |
| |
| arg_var = get_arg(dp, 0); |
| switch(V_VT(arg_var)) { |
| case VT_DISPATCH: |
| regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var)); |
| if(regexp) { |
| if(regexp->builtin_info->class == JSCLASS_REGEXP) |
| break; |
| jsdisp_release(regexp); |
| } |
| default: { |
| BSTR match_str; |
| |
| hres = to_string(dispex->ctx, arg_var, ei, &match_str); |
| if(FAILED(hres)) |
| return hres; |
| |
| hres = create_regexp_str(dispex->ctx, match_str, SysStringLen(match_str), NULL, 0, ®exp); |
| SysFreeString(match_str); |
| if(FAILED(hres)) |
| return hres; |
| } |
| } |
| |
| hres = regexp_match(regexp, This->str, This->length, FALSE, &match_result, &match_cnt); |
| jsdisp_release(regexp); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(!match_cnt) { |
| TRACE("no match\n"); |
| |
| if(retv) |
| V_VT(retv) = VT_NULL; |
| return S_OK; |
| } |
| |
| hres = create_array(dispex->ctx, match_cnt, &array); |
| if(FAILED(hres)) |
| return hres; |
| |
| V_VT(&var) = VT_BSTR; |
| |
| for(i=0; i < match_cnt; i++) { |
| V_BSTR(&var) = SysAllocStringLen(match_result[i].str, match_result[i].len); |
| if(!V_BSTR(&var)) { |
| hres = E_OUTOFMEMORY; |
| break; |
| } |
| |
| hres = jsdisp_propput_idx(array, i, lcid, &var, ei, NULL/*FIXME*/); |
| SysFreeString(V_BSTR(&var)); |
| if(FAILED(hres)) |
| break; |
| } |
| |
| if(SUCCEEDED(hres) && retv) { |
| V_VT(retv) = VT_DISPATCH; |
| V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array); |
| }else { |
| jsdisp_release(array); |
| } |
| return hres; |
| } |
| |
| typedef struct { |
| WCHAR *buf; |
| DWORD size; |
| DWORD len; |
| } strbuf_t; |
| |
| static HRESULT strbuf_append(strbuf_t *buf, const WCHAR *str, DWORD len) |
| { |
| if(!len) |
| return S_OK; |
| |
| if(len + buf->len > buf->size) { |
| WCHAR *new_buf; |
| DWORD new_size; |
| |
| new_size = buf->size ? buf->size<<1 : 16; |
| if(new_size < buf->len+len) |
| new_size = buf->len+len; |
| if(buf->buf) |
| new_buf = heap_realloc(buf->buf, new_size*sizeof(WCHAR)); |
| else |
| new_buf = heap_alloc(new_size*sizeof(WCHAR)); |
| if(!new_buf) |
| return E_OUTOFMEMORY; |
| |
| buf->buf = new_buf; |
| buf->size = new_size; |
| } |
| |
| memcpy(buf->buf+buf->len, str, len*sizeof(WCHAR)); |
| buf->len += len; |
| return S_OK; |
| } |
| |
| static HRESULT rep_call(DispatchEx *func, const WCHAR *str, match_result_t *match, match_result_t *parens, |
| DWORD parens_cnt, LCID lcid, BSTR *ret, jsexcept_t *ei, IServiceProvider *caller) |
| { |
| DISPPARAMS dp = {NULL, NULL, 0, 0}; |
| VARIANTARG *args, *arg; |
| VARIANT var; |
| DWORD i; |
| HRESULT hres = S_OK; |
| |
| dp.cArgs = parens_cnt+3; |
| dp.rgvarg = args = heap_alloc_zero(sizeof(VARIANT)*dp.cArgs); |
| if(!args) |
| return E_OUTOFMEMORY; |
| |
| arg = get_arg(&dp,0); |
| V_VT(arg) = VT_BSTR; |
| V_BSTR(arg) = SysAllocStringLen(match->str, match->len); |
| if(!V_BSTR(arg)) |
| hres = E_OUTOFMEMORY; |
| |
| if(SUCCEEDED(hres)) { |
| for(i=0; i < parens_cnt; i++) { |
| arg = get_arg(&dp,i+1); |
| V_VT(arg) = VT_BSTR; |
| V_BSTR(arg) = SysAllocStringLen(parens[i].str, parens[i].len); |
| if(!V_BSTR(arg)) { |
| hres = E_OUTOFMEMORY; |
| break; |
| } |
| } |
| } |
| |
| if(SUCCEEDED(hres)) { |
| arg = get_arg(&dp,parens_cnt+1); |
| V_VT(arg) = VT_I4; |
| V_I4(arg) = match->str - str; |
| |
| arg = get_arg(&dp,parens_cnt+2); |
| V_VT(arg) = VT_BSTR; |
| V_BSTR(arg) = SysAllocString(str); |
| if(!V_BSTR(arg)) |
| hres = E_OUTOFMEMORY; |
| } |
| |
| if(SUCCEEDED(hres)) |
| hres = jsdisp_call_value(func, lcid, DISPATCH_METHOD, &dp, &var, ei, caller); |
| |
| for(i=0; i < parens_cnt+1; i++) { |
| if(i != parens_cnt+1) |
| SysFreeString(V_BSTR(get_arg(&dp,i))); |
| } |
| heap_free(args); |
| |
| if(FAILED(hres)) |
| return hres; |
| |
| hres = to_string(func->ctx, &var, ei, ret); |
| VariantClear(&var); |
| return hres; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.11 */ |
| static HRESULT String_replace(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller) |
| { |
| DWORD parens_cnt = 0, parens_size=0, rep_len=0, length; |
| BSTR rep_str = NULL, match_str = NULL, ret_str; |
| DispatchEx *rep_func = NULL, *regexp = NULL; |
| match_result_t *parens = NULL, match; |
| const WCHAR *str; |
| strbuf_t ret = {NULL,0,0}; |
| BOOL gcheck = FALSE; |
| VARIANT *arg_var; |
| HRESULT hres = S_OK; |
| |
| TRACE("\n"); |
| |
| if(is_class(dispex, JSCLASS_STRING)) { |
| StringInstance *string = (StringInstance*)dispex; |
| str = string->str; |
| length = string->length; |
| }else { |
| FIXME("not String this\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(!arg_cnt(dp)) { |
| if(retv) { |
| ret_str = SysAllocString(str); |
| if(!ret_str) |
| return E_OUTOFMEMORY; |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = ret_str; |
| } |
| return S_OK; |
| } |
| |
| arg_var = get_arg(dp, 0); |
| switch(V_VT(arg_var)) { |
| case VT_DISPATCH: |
| regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var)); |
| if(regexp) { |
| if(is_class(regexp, JSCLASS_REGEXP)) { |
| break; |
| }else { |
| jsdisp_release(regexp); |
| regexp = NULL; |
| } |
| } |
| |
| default: |
| hres = to_string(dispex->ctx, arg_var, ei, &match_str); |
| if(FAILED(hres)) |
| return hres; |
| } |
| |
| if(arg_cnt(dp) >= 2) { |
| arg_var = get_arg(dp,1); |
| switch(V_VT(arg_var)) { |
| case VT_DISPATCH: |
| rep_func = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg_var)); |
| if(rep_func) { |
| if(is_class(rep_func, JSCLASS_FUNCTION)) { |
| break; |
| }else { |
| jsdisp_release(rep_func); |
| rep_func = NULL; |
| } |
| } |
| |
| default: |
| hres = to_string(dispex->ctx, arg_var, ei, &rep_str); |
| if(FAILED(hres)) |
| break; |
| |
| if(strchrW(rep_str, '$')) { |
| FIXME("unsupported $ in replace string\n"); |
| hres = E_NOTIMPL; |
| } |
| |
| rep_len = SysStringLen(rep_str); |
| } |
| } |
| |
| if(SUCCEEDED(hres)) { |
| const WCHAR *cp, *ecp; |
| |
| cp = ecp = str; |
| |
| while(1) { |
| if(regexp) { |
| hres = regexp_match_next(regexp, gcheck, str, length, &cp, rep_func ? &parens : NULL, |
| &parens_size, &parens_cnt, &match); |
| gcheck = TRUE; |
| |
| if(hres == S_FALSE) { |
| hres = S_OK; |
| break; |
| } |
| if(FAILED(hres)) |
| break; |
| }else { |
| match.str = strstrW(cp, match_str); |
| if(!match.str) |
| break; |
| match.len = SysStringLen(match_str); |
| cp = match.str+match.len; |
| } |
| |
| hres = strbuf_append(&ret, ecp, match.str-ecp); |
| ecp = match.str+match.len; |
| if(FAILED(hres)) |
| break; |
| |
| if(rep_func) { |
| BSTR cstr; |
| |
| hres = rep_call(rep_func, str, &match, parens, parens_cnt, lcid, &cstr, ei, caller); |
| if(FAILED(hres)) |
| break; |
| |
| hres = strbuf_append(&ret, cstr, SysStringLen(cstr)); |
| SysFreeString(cstr); |
| if(FAILED(hres)) |
| break; |
| }else if(rep_str) { |
| hres = strbuf_append(&ret, rep_str, rep_len); |
| if(FAILED(hres)) |
| break; |
| }else { |
| static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d'}; |
| |
| hres = strbuf_append(&ret, undefinedW, sizeof(undefinedW)/sizeof(WCHAR)); |
| if(FAILED(hres)) |
| break; |
| } |
| } |
| |
| if(SUCCEEDED(hres)) |
| hres = strbuf_append(&ret, ecp, (str+length)-ecp); |
| } |
| |
| if(rep_func) |
| jsdisp_release(rep_func); |
| if(regexp) |
| jsdisp_release(regexp); |
| SysFreeString(rep_str); |
| SysFreeString(match_str); |
| heap_free(parens); |
| |
| if(SUCCEEDED(hres) && retv) { |
| ret_str = SysAllocStringLen(ret.buf, ret.len); |
| if(!ret_str) |
| return E_OUTOFMEMORY; |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = ret_str; |
| TRACE("= %s\n", debugstr_w(ret_str)); |
| } |
| |
| heap_free(ret.buf); |
| return hres; |
| } |
| |
| static HRESULT String_search(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.13 */ |
| static HRESULT String_slice(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| const WCHAR *str; |
| DWORD length; |
| INT start=0, end; |
| VARIANT v; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| if(is_class(dispex, JSCLASS_STRING)) { |
| StringInstance *string = (StringInstance*)dispex; |
| |
| str = string->str; |
| length = string->length; |
| }else { |
| FIXME("this is not a string class\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(arg_cnt(dp)) { |
| hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(V_VT(&v) == VT_I4) { |
| start = V_I4(&v); |
| if(start < 0) { |
| start = length + start; |
| if(start < 0) |
| start = 0; |
| }else if(start > length) { |
| start = length; |
| } |
| }else { |
| start = V_R8(&v) < 0.0 ? 0 : length; |
| } |
| }else { |
| start = 0; |
| } |
| |
| if(arg_cnt(dp) >= 2) { |
| hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(V_VT(&v) == VT_I4) { |
| end = V_I4(&v); |
| if(end < 0) { |
| end = length + end; |
| if(end < 0) |
| end = 0; |
| }else if(end > length) { |
| end = length; |
| } |
| }else { |
| end = V_R8(&v) < 0.0 ? 0 : length; |
| } |
| }else { |
| end = length; |
| } |
| |
| if(end < start) |
| end = start; |
| |
| if(retv) { |
| BSTR retstr = SysAllocStringLen(str+start, end-start); |
| if(!str) |
| return E_OUTOFMEMORY; |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = retstr; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_small(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR smalltagW[] = {'S','M','A','L','L',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, smalltagW); |
| } |
| |
| static HRESULT String_split(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| match_result_t *match_result = NULL; |
| DWORD match_cnt, i, match_len = 0; |
| StringInstance *string; |
| const WCHAR *ptr, *ptr2; |
| VARIANT *arg, var; |
| DispatchEx *array; |
| BSTR match_str = NULL; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| if(!is_class(dispex, JSCLASS_STRING)) { |
| FIXME("not String this\n"); |
| return E_NOTIMPL; |
| } |
| |
| string = (StringInstance*)dispex; |
| |
| if(arg_cnt(dp) != 1) { |
| FIXME("unsupported args\n"); |
| return E_NOTIMPL; |
| } |
| |
| arg = get_arg(dp, 0); |
| switch(V_VT(arg)) { |
| case VT_DISPATCH: { |
| DispatchEx *regexp; |
| |
| regexp = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg)); |
| if(regexp) { |
| if(is_class(regexp, JSCLASS_REGEXP)) { |
| hres = regexp_match(regexp, string->str, string->length, TRUE, &match_result, &match_cnt); |
| jsdisp_release(regexp); |
| if(FAILED(hres)) |
| return hres; |
| break; |
| } |
| jsdisp_release(regexp); |
| } |
| } |
| default: |
| hres = to_string(dispex->ctx, arg, ei, &match_str); |
| if(FAILED(hres)) |
| return hres; |
| |
| match_len = SysStringLen(match_str); |
| if(!match_len) { |
| SysFreeString(match_str); |
| match_str = NULL; |
| } |
| } |
| |
| hres = create_array(dispex->ctx, 0, &array); |
| |
| if(SUCCEEDED(hres)) { |
| ptr = string->str; |
| for(i=0;; i++) { |
| if(match_result) { |
| if(i == match_cnt) |
| break; |
| ptr2 = match_result[i].str; |
| }else if(match_str) { |
| ptr2 = strstrW(ptr, match_str); |
| if(!ptr2) |
| break; |
| }else { |
| if(!*ptr) |
| break; |
| ptr2 = ptr+1; |
| } |
| |
| V_VT(&var) = VT_BSTR; |
| V_BSTR(&var) = SysAllocStringLen(ptr, ptr2-ptr); |
| if(!V_BSTR(&var)) { |
| hres = E_OUTOFMEMORY; |
| break; |
| } |
| |
| hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp); |
| SysFreeString(V_BSTR(&var)); |
| if(FAILED(hres)) |
| break; |
| |
| if(match_result) |
| ptr = match_result[i].str + match_result[i].len; |
| else if(match_str) |
| ptr = ptr2 + match_len; |
| else |
| ptr++; |
| } |
| } |
| |
| if(SUCCEEDED(hres) && (match_str || match_result)) { |
| DWORD len = (string->str+string->length) - ptr; |
| |
| if(len || match_str) { |
| V_VT(&var) = VT_BSTR; |
| V_BSTR(&var) = SysAllocStringLen(ptr, len); |
| |
| if(V_BSTR(&var)) { |
| hres = jsdisp_propput_idx(array, i, lcid, &var, ei, sp); |
| SysFreeString(V_BSTR(&var)); |
| }else { |
| hres = E_OUTOFMEMORY; |
| } |
| } |
| } |
| |
| SysFreeString(match_str); |
| heap_free(match_result); |
| |
| if(SUCCEEDED(hres) && retv) { |
| V_VT(retv) = VT_DISPATCH; |
| V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(array); |
| }else { |
| jsdisp_release(array); |
| } |
| |
| return hres; |
| } |
| |
| static HRESULT String_strike(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR striketagW[] = {'S','T','R','I','K','E',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, striketagW); |
| } |
| |
| static HRESULT String_sub(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR subtagW[] = {'S','U','B',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, subtagW); |
| } |
| |
| /* ECMA-262 3rd Edition 15.5.4.15 */ |
| static HRESULT String_substring(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| const WCHAR *str; |
| INT start=0, end; |
| DWORD length; |
| VARIANT v; |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| if(is_class(dispex, JSCLASS_STRING)) { |
| StringInstance *string = (StringInstance*)dispex; |
| |
| length = string->length; |
| str = string->str; |
| }else { |
| FIXME("not string this not supported\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(arg_cnt(dp) >= 1) { |
| hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-1, ei, &v); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(V_VT(&v) == VT_I4) { |
| start = V_I4(&v); |
| if(start < 0) |
| start = 0; |
| else if(start >= length) |
| start = length; |
| }else { |
| start = V_R8(&v) < 0.0 ? 0 : length; |
| } |
| } |
| |
| if(arg_cnt(dp) >= 2) { |
| hres = to_integer(dispex->ctx, dp->rgvarg + dp->cArgs-2, ei, &v); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(V_VT(&v) == VT_I4) { |
| end = V_I4(&v); |
| if(end < 0) |
| end = 0; |
| else if(end > length) |
| end = length; |
| }else { |
| end = V_R8(&v) < 0.0 ? 0 : length; |
| } |
| }else { |
| end = length; |
| } |
| |
| if(start > end) { |
| INT tmp = start; |
| start = end; |
| end = tmp; |
| } |
| |
| if(retv) { |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = SysAllocStringLen(str+start, end-start); |
| if(!V_BSTR(retv)) |
| return E_OUTOFMEMORY; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_substr(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_sup(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| static const WCHAR suptagW[] = {'S','U','P',0}; |
| return do_attributeless_tag_format(dispex, lcid, flags, dp, retv, ei, sp, suptagW); |
| } |
| |
| static HRESULT String_toLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| StringInstance *string; |
| const WCHAR* str; |
| DWORD length; |
| BSTR bstr; |
| |
| TRACE("\n"); |
| |
| if(is_class(dispex, JSCLASS_STRING)) { |
| string = (StringInstance*)dispex; |
| |
| length = string->length; |
| str = string->str; |
| }else { |
| FIXME("not string this not supported\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(retv) { |
| bstr = SysAllocStringLen(str, length); |
| if (!bstr) |
| return E_OUTOFMEMORY; |
| |
| strlwrW(bstr); |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = bstr; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_toUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| StringInstance *string; |
| const WCHAR* str; |
| DWORD length; |
| BSTR bstr; |
| |
| TRACE("\n"); |
| |
| if(is_class(dispex, JSCLASS_STRING)) { |
| string = (StringInstance*)dispex; |
| |
| length = string->length; |
| str = string->str; |
| }else { |
| FIXME("not string this not supported\n"); |
| return E_NOTIMPL; |
| } |
| |
| if(retv) { |
| bstr = SysAllocStringLen(str, length); |
| if (!bstr) |
| return E_OUTOFMEMORY; |
| |
| struprW(bstr); |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = bstr; |
| } |
| return S_OK; |
| } |
| |
| static HRESULT String_toLocaleLowerCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_toLocaleUpperCase(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_localeCompare(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_hasOwnProperty(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_propertyIsEnumerable(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_isPrototypeOf(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| FIXME("\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT String_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| StringInstance *This = (StringInstance*)dispex; |
| |
| TRACE("\n"); |
| |
| switch(flags) { |
| case DISPATCH_PROPERTYGET: { |
| BSTR str = SysAllocString(This->str); |
| if(!str) |
| return E_OUTOFMEMORY; |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = str; |
| break; |
| } |
| default: |
| FIXME("flags %x\n", flags); |
| return E_NOTIMPL; |
| } |
| |
| return S_OK; |
| } |
| |
| static void String_destructor(DispatchEx *dispex) |
| { |
| StringInstance *This = (StringInstance*)dispex; |
| |
| heap_free(This->str); |
| heap_free(This); |
| } |
| |
| static const builtin_prop_t String_props[] = { |
| {anchorW, String_anchor, PROPF_METHOD}, |
| {bigW, String_big, PROPF_METHOD}, |
| {blinkW, String_blink, PROPF_METHOD}, |
| {boldW, String_bold, PROPF_METHOD}, |
| {charAtW, String_charAt, PROPF_METHOD}, |
| {charCodeAtW, String_charCodeAt, PROPF_METHOD}, |
| {concatW, String_concat, PROPF_METHOD}, |
| {fixedW, String_fixed, PROPF_METHOD}, |
| {fontcolorW, String_fontcolor, PROPF_METHOD}, |
| {fontsizeW, String_fontsize, PROPF_METHOD}, |
| {hasOwnPropertyW, String_hasOwnProperty, PROPF_METHOD}, |
| {indexOfW, String_indexOf, PROPF_METHOD}, |
| {isPrototypeOfW, String_isPrototypeOf, PROPF_METHOD}, |
| {italicsW, String_italics, PROPF_METHOD}, |
| {lastIndexOfW, String_lastIndexOf, PROPF_METHOD}, |
| {lengthW, String_length, 0}, |
| {linkW, String_link, PROPF_METHOD}, |
| {localeCompareW, String_localeCompare, PROPF_METHOD}, |
| {matchW, String_match, PROPF_METHOD}, |
| {propertyIsEnumerableW, String_propertyIsEnumerable, PROPF_METHOD}, |
| {replaceW, String_replace, PROPF_METHOD}, |
| {searchW, String_search, PROPF_METHOD}, |
| {sliceW, String_slice, PROPF_METHOD}, |
| {smallW, String_small, PROPF_METHOD}, |
| {splitW, String_split, PROPF_METHOD}, |
| {strikeW, String_strike, PROPF_METHOD}, |
| {subW, String_sub, PROPF_METHOD}, |
| {substrW, String_substr, PROPF_METHOD}, |
| {substringW, String_substring, PROPF_METHOD}, |
| {supW, String_sup, PROPF_METHOD}, |
| {toLocaleLowerCaseW, String_toLocaleLowerCase, PROPF_METHOD}, |
| {toLocaleUpperCaseW, String_toLocaleUpperCase, PROPF_METHOD}, |
| {toLowerCaseW, String_toLowerCase, PROPF_METHOD}, |
| {toStringW, String_toString, PROPF_METHOD}, |
| {toUpperCaseW, String_toUpperCase, PROPF_METHOD}, |
| {valueOfW, String_valueOf, PROPF_METHOD} |
| }; |
| |
| static const builtin_info_t String_info = { |
| JSCLASS_STRING, |
| {NULL, String_value, 0}, |
| sizeof(String_props)/sizeof(*String_props), |
| String_props, |
| String_destructor, |
| NULL |
| }; |
| |
| static HRESULT StringConstr_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, |
| VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp) |
| { |
| HRESULT hres; |
| |
| TRACE("\n"); |
| |
| switch(flags) { |
| case INVOKE_FUNC: { |
| BSTR str; |
| |
| if(arg_cnt(dp)) { |
| hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str); |
| if(FAILED(hres)) |
| return hres; |
| }else { |
| str = SysAllocStringLen(NULL, 0); |
| if(!str) |
| return E_OUTOFMEMORY; |
| } |
| |
| V_VT(retv) = VT_BSTR; |
| V_BSTR(retv) = str; |
| break; |
| } |
| case DISPATCH_CONSTRUCT: { |
| DispatchEx *ret; |
| |
| if(arg_cnt(dp)) { |
| BSTR str; |
| |
| hres = to_string(dispex->ctx, get_arg(dp, 0), ei, &str); |
| if(FAILED(hres)) |
| return hres; |
| |
| hres = create_string(dispex->ctx, str, SysStringLen(str), &ret); |
| SysFreeString(str); |
| }else { |
| hres = create_string(dispex->ctx, NULL, 0, &ret); |
| } |
| |
| if(FAILED(hres)) |
| return hres; |
| |
| V_VT(retv) = VT_DISPATCH; |
| V_DISPATCH(retv) = (IDispatch*)_IDispatchEx_(ret); |
| break; |
| } |
| |
| default: |
| FIXME("unimplemented flags: %x\n", flags); |
| return E_NOTIMPL; |
| } |
| |
| return S_OK; |
| } |
| |
| static HRESULT string_alloc(script_ctx_t *ctx, BOOL use_constr, StringInstance **ret) |
| { |
| StringInstance *string; |
| HRESULT hres; |
| |
| string = heap_alloc_zero(sizeof(StringInstance)); |
| if(!string) |
| return E_OUTOFMEMORY; |
| |
| if(use_constr) |
| hres = init_dispex_from_constr(&string->dispex, ctx, &String_info, ctx->string_constr); |
| else |
| hres = init_dispex(&string->dispex, ctx, &String_info, NULL); |
| if(FAILED(hres)) { |
| heap_free(string); |
| return hres; |
| } |
| |
| *ret = string; |
| return S_OK; |
| } |
| |
| HRESULT create_string_constr(script_ctx_t *ctx, DispatchEx **ret) |
| { |
| StringInstance *string; |
| HRESULT hres; |
| |
| hres = string_alloc(ctx, FALSE, &string); |
| if(FAILED(hres)) |
| return hres; |
| |
| hres = create_builtin_function(ctx, StringConstr_value, PROPF_CONSTR, &string->dispex, ret); |
| |
| jsdisp_release(&string->dispex); |
| return hres; |
| } |
| |
| HRESULT create_string(script_ctx_t *ctx, const WCHAR *str, DWORD len, DispatchEx **ret) |
| { |
| StringInstance *string; |
| HRESULT hres; |
| |
| hres = string_alloc(ctx, TRUE, &string); |
| if(FAILED(hres)) |
| return hres; |
| |
| if(len == -1) |
| len = strlenW(str); |
| |
| string->length = len; |
| string->str = heap_alloc((len+1)*sizeof(WCHAR)); |
| if(!string->str) { |
| jsdisp_release(&string->dispex); |
| return E_OUTOFMEMORY; |
| } |
| |
| memcpy(string->str, str, len*sizeof(WCHAR)); |
| string->str[len] = 0; |
| |
| *ret = &string->dispex; |
| return S_OK; |
| |
| } |
