static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, DWORD flags, dynamic_prop_t **ret) { const BOOL alloc = flags & fdexNameEnsure; dispex_dynamic_data_t *data; dynamic_prop_t *prop; data = get_dynamic_data(This, alloc); if(!data) { if(alloc) return E_OUTOFMEMORY; TRACE("not found %s\n", debugstr_w(name)); return DISP_E_UNKNOWNNAME; } for(prop = data->props; prop < data->props+data->prop_cnt; prop++) { if(flags & fdexNameCaseInsensitive ? !strcmpiW(prop->name, name) : !strcmpW(prop->name, name)) { if(prop->flags & DYNPROP_DELETED) { if(!alloc) return DISP_E_UNKNOWNNAME; prop->flags &= ~DYNPROP_DELETED; } *ret = prop; return S_OK; } } if(!alloc) return DISP_E_UNKNOWNNAME; TRACE("creating dynamic prop %s\n", debugstr_w(name)); if(!data->buf_size) { data->props = heap_alloc(sizeof(dynamic_prop_t)*4); if(!data->props) return E_OUTOFMEMORY; data->buf_size = 4; }else if(data->buf_size == data->prop_cnt) { dynamic_prop_t *new_props; new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1)); if(!new_props) return E_OUTOFMEMORY; data->props = new_props; data->buf_size <<= 1; } prop = data->props + data->prop_cnt; prop->name = heap_strdupW(name); if(!prop->name) return E_OUTOFMEMORY; VariantInit(&prop->var); prop->flags = 0; data->prop_cnt++; *ret = prop; return S_OK; }
static BOOL install_from_registered_dir(void) { char *file_name; HKEY hkey; DWORD res, type, size = MAX_PATH; BOOL ret; /* @@ Wine registry key: HKCU\Software\Wine\MSHTML */ res = RegOpenKeyW(HKEY_CURRENT_USER, mshtml_keyW, &hkey); if(res != ERROR_SUCCESS) return FALSE; file_name = heap_alloc(size+sizeof(GECKO_FILE_NAME)); res = RegGetValueA(hkey, NULL, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)file_name, &size); if(res == ERROR_MORE_DATA) { file_name = heap_realloc(file_name, size+sizeof(GECKO_FILE_NAME)); res = RegGetValueA(hkey, NULL, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)file_name, &size); } RegCloseKey(hkey); if(res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ)) { heap_free(file_name); return FALSE; } strcat(file_name, GECKO_FILE_NAME); TRACE("Trying %s\n", debugstr_a(file_name)); ret = install_from_unix_file(file_name); heap_free(file_name); return ret; }
static enum install_res install_from_registered_dir(void) { char *package_dir; HKEY hkey; DWORD res, type, size = MAX_PATH; enum install_res ret; hkey = open_config_key(); if(!hkey) return INSTALL_NEXT; package_dir = heap_alloc(size); res = RegGetValueA(hkey, NULL, addon->dir_config_key, RRF_RT_ANY, &type, (PBYTE)package_dir, &size); if(res == ERROR_MORE_DATA) { package_dir = heap_realloc(package_dir, size); res = RegGetValueA(hkey, NULL, addon->dir_config_key, RRF_RT_ANY, &type, (PBYTE)package_dir, &size); } RegCloseKey(hkey); if(res == ERROR_FILE_NOT_FOUND) { heap_free(package_dir); return INSTALL_NEXT; } else if(res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ)) { heap_free(package_dir); return INSTALL_FAILED; } TRACE("Trying %s/%s\n", debugstr_a(package_dir), debugstr_a(addon->file_name)); ret = install_from_unix_file(package_dir, "", addon->file_name); heap_free(package_dir); return ret; }
static dispex_data_t *preprocess_dispex_data(DispatchEx *This) { const tid_t *tid = This->data->iface_tids; FUNCDESC *funcdesc; dispex_data_t *data; DWORD size = 16, i; ITypeInfo *ti, *dti; HRESULT hres; TRACE("(%p)\n", This); hres = get_typeinfo(This->data->disp_tid, &dti); if(FAILED(hres)) { ERR("Could not get disp type info: %08x\n", hres); return NULL; } data = heap_alloc(sizeof(dispex_data_t)); data->func_cnt = 0; data->funcs = heap_alloc(size*sizeof(func_info_t)); list_add_tail(&dispex_data_list, &data->entry); while(*tid) { hres = get_typeinfo(*tid, &ti); if(FAILED(hres)) break; i=7; while(1) { hres = ITypeInfo_GetFuncDesc(ti, i++, &funcdesc); if(FAILED(hres)) break; add_func_info(data, &size, *tid, funcdesc->memid, dti); ITypeInfo_ReleaseFuncDesc(ti, funcdesc); } tid++; } if(!data->func_cnt) { heap_free(data->funcs); data->funcs = NULL; }else if(data->func_cnt != size) { data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t)); } qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp); if(data->funcs) { data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*)); for(i=0; i < data->func_cnt; i++) data->name_table[i] = data->funcs+i; qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp); }else { data->name_table = NULL; } return data; }
static enum install_res install_from_registered_dir(void) { char *package_dir; DWORD res, type, size = MAX_PATH; enum install_res ret; package_dir = heap_alloc(size + sizeof(addon->file_name)); res = RegGetValueA(HKEY_CURRENT_USER, mshtml_keyA, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)package_dir, &size); if(res == ERROR_MORE_DATA) { package_dir = heap_realloc(package_dir, size + sizeof(addon->file_name)); res = RegGetValueA(HKEY_CURRENT_USER, mshtml_keyA, "GeckoCabDir", RRF_RT_ANY, &type, (PBYTE)package_dir, &size); } if(res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ)) { heap_free(package_dir); return INSTALL_FAILED; } TRACE("Trying %s/%s\n", debugstr_a(package_dir), debugstr_a(addon->file_name)); ret = install_from_unix_file(package_dir, "", addon->file_name); heap_free(package_dir); return ret; }
/****************************************************************************** * URLMoniker_Construct (local function) *******************************************************************************/ static HRESULT URLMonikerImpl_Construct(URLMonikerImpl* This, LPCOLESTR lpszLeftURLName, LPCOLESTR lpszURLName) { HRESULT hres; DWORD sizeStr = 0; TRACE("(%p,%s,%s)\n",This,debugstr_w(lpszLeftURLName),debugstr_w(lpszURLName)); This->lpvtbl = &VT_URLMonikerImpl; This->ref = 0; This->URLName = heap_alloc(INTERNET_MAX_URL_LENGTH*sizeof(WCHAR)); if(lpszLeftURLName) hres = CoInternetCombineUrl(lpszLeftURLName, lpszURLName, URL_FILE_USE_PATHURL, This->URLName, INTERNET_MAX_URL_LENGTH, &sizeStr, 0); else hres = CoInternetParseUrl(lpszURLName, PARSE_CANONICALIZE, URL_FILE_USE_PATHURL, This->URLName, INTERNET_MAX_URL_LENGTH, &sizeStr, 0); if(FAILED(hres)) { heap_free(This->URLName); return hres; } URLMON_LockModule(); if(sizeStr != INTERNET_MAX_URL_LENGTH) This->URLName = heap_realloc(This->URLName, (sizeStr+1)*sizeof(WCHAR)); TRACE("URLName = %s\n", debugstr_w(This->URLName)); return S_OK; }
static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink, DWORD *pdwCookie) { ConnectionPoint *This = CONPOINT_THIS(iface); IUnknown *sink; DWORD i; HRESULT hres; TRACE("(%p)->(%p %p)\n", This, pUnkSink, pdwCookie); hres = IUnknown_QueryInterface(pUnkSink, This->iid, (void**)&sink); if(FAILED(hres) && !IsEqualGUID(&IID_IPropertyNotifySink, This->iid)) hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink); if(FAILED(hres)) return CONNECT_E_CANNOTCONNECT; if(This->sinks) { for(i=0; i<This->sinks_size; i++) { if(!This->sinks[i].unk) break; } if(i == This->sinks_size) This->sinks = heap_realloc(This->sinks,(++This->sinks_size)*sizeof(*This->sinks)); }else { This->sinks = heap_alloc(sizeof(*This->sinks)); This->sinks_size = 1; i = 0; } This->sinks[i].unk = sink; *pdwCookie = i+1; return S_OK; }
static dispex_data_t *preprocess_dispex_data(DispatchEx *This) { const tid_t *tid; dispex_data_t *data; DWORD size = 16, i; ITypeInfo *dti; HRESULT hres; TRACE("(%p)\n", This); if(This->data->disp_tid) { hres = get_typeinfo(This->data->disp_tid, &dti); if(FAILED(hres)) { ERR("Could not get disp type info: %08x\n", hres); return NULL; } } data = heap_alloc(sizeof(dispex_data_t)); if (!data) { ERR("Out of memory\n"); return NULL; } data->func_cnt = 0; data->func_disp_cnt = 0; data->funcs = heap_alloc_zero(size*sizeof(func_info_t)); if (!data->funcs) { heap_free (data); ERR("Out of memory\n"); return NULL; } list_add_tail(&dispex_data_list, &data->entry); for(tid = This->data->iface_tids; *tid; tid++) { hres = process_interface(data, *tid, dti, &size); if(FAILED(hres)) break; } if(This->data->additional_tid) process_interface(data, This->data->additional_tid, NULL, &size); if(!data->func_cnt) { heap_free(data->funcs); data->name_table = NULL; data->funcs = NULL; return data; } data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t)); qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp); data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*)); for(i=0; i < data->func_cnt; i++) data->name_table[i] = data->funcs+i; qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp); return data; }
void *realloc( void *ptr, size_t new_size) { if(global_heap_ptr) { return heap_realloc(global_heap_ptr, ptr, new_size); } return ::realloc(ptr, new_size); }
static void item_realloc(IndexItem *item, int num_items) { item->nItems = num_items; item->items = heap_realloc(item->items, sizeof(IndexSubItem)*item->nItems); item->items[item->nItems-1].name = NULL; item->items[item->nItems-1].local = NULL; item->itemFlags = 0x00; }
/* escapes special characters like: '<' -> "<" '&' -> "&" '"' -> """ '>' -> ">" */ static WCHAR *get_escaped_string(const WCHAR *str, int *len) { static const WCHAR ltW[] = {'&','l','t',';'}; static const WCHAR ampW[] = {'&','a','m','p',';'}; static const WCHAR quotW[] = {'&','q','u','o','t',';'}; static const WCHAR gtW[] = {'&','g','t',';'}; const int default_alloc = 100; const int grow_thresh = 10; int p = *len, conv_len; WCHAR *ptr, *ret; /* default buffer size to something if length is unknown */ conv_len = *len == -1 ? default_alloc : max(2**len, default_alloc); ptr = ret = heap_alloc(conv_len*sizeof(WCHAR)); while (*str && p) { if (ptr - ret > conv_len - grow_thresh) { int written = ptr - ret; conv_len *= 2; ptr = ret = heap_realloc(ret, conv_len*sizeof(WCHAR)); ptr += written; } switch (*str) { case '<': memcpy(ptr, ltW, sizeof(ltW)); ptr += sizeof(ltW)/sizeof(WCHAR); break; case '&': memcpy(ptr, ampW, sizeof(ampW)); ptr += sizeof(ampW)/sizeof(WCHAR); break; case '"': memcpy(ptr, quotW, sizeof(quotW)); ptr += sizeof(quotW)/sizeof(WCHAR); break; case '>': memcpy(ptr, gtW, sizeof(gtW)); ptr += sizeof(gtW)/sizeof(WCHAR); break; default: *ptr++ = *str; break; } str++; if (*len != -1) p--; } if (*len != -1) *len = ptr-ret; *++ptr = 0; return ret; }
static HRESULT report_data(BindProtocol *This, DWORD bscf, ULONG progress, ULONG progress_max) { if(!This->protocol_sink) return S_OK; if((This->pi & PI_MIMEVERIFICATION) && !This->reported_mime) { BYTE buf[BUFFER_SIZE]; DWORD read = 0; LPWSTR mime; HRESULT hres; do { read = 0; hres = IInternetProtocol_Read(This->protocol, buf, sizeof(buf)-This->buf_size, &read); if(FAILED(hres) && hres != E_PENDING) return hres; if(!This->buf) { This->buf = heap_alloc(BUFFER_SIZE); if(!This->buf) return E_OUTOFMEMORY; }else if(read + This->buf_size > BUFFER_SIZE) { BYTE *tmp; tmp = heap_realloc(This->buf, read+This->buf_size); if(!tmp) return E_OUTOFMEMORY; This->buf = tmp; } memcpy(This->buf+This->buf_size, buf, read); This->buf_size += read; }while(This->buf_size < MIME_TEST_SIZE && hres == S_OK); if(This->buf_size < MIME_TEST_SIZE && hres != S_FALSE) return S_OK; bscf = BSCF_FIRSTDATANOTIFICATION; if(hres == S_FALSE) bscf |= BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE; if(!This->reported_mime) { hres = FindMimeFromData(NULL, This->url, This->buf, min(This->buf_size, MIME_TEST_SIZE), This->mime, 0, &mime, 0); if(FAILED(hres)) return hres; mime_available(This, mime, TRUE); CoTaskMemFree(mime); } } if(!This->protocol_sink) return S_OK; return IInternetProtocolSink_ReportData(This->protocol_sink, bscf, progress, progress_max); }
static void elem_vector_add(elem_vector_t *buf, HTMLElement *elem) { if(buf->len == buf->size) { buf->size <<= 1; buf->buf = heap_realloc(buf->buf, buf->size*sizeof(HTMLElement*)); } buf->buf[buf->len++] = elem; }
static void grow_buffer(encoded_buffer *buffer, int length) { /* grow if needed, plus 4 bytes to be sure null terminator will fit in */ if (buffer->allocated < buffer->written + length + 4) { int grown_size = max(2*buffer->allocated, buffer->allocated + length); buffer->data = heap_realloc(buffer->data, grown_size); buffer->allocated = grown_size; } }
static void strbuf_append(strbuf_t *buf, const char *data, int len) { if(buf->len+len > buf->size) { buf->size = buf->len+len; buf->buf = heap_realloc(buf->buf, buf->size); } memcpy(buf->buf+buf->len, data, len); buf->len += len; }
void *vbsheap_alloc(vbsheap_t *heap, size_t size) { struct list *list; void *tmp; size = (size+3)&~3; if(!heap->block_cnt) { if(!heap->blocks) { heap->blocks = heap_alloc(sizeof(void*)); if(!heap->blocks) return NULL; } tmp = heap_alloc(block_size(0)); if(!tmp) return NULL; heap->blocks[0] = tmp; heap->block_cnt = 1; } if(heap->offset + size <= block_size(heap->last_block)) { tmp = ((BYTE*)heap->blocks[heap->last_block])+heap->offset; heap->offset += size; return tmp; } if(size <= block_size(heap->last_block+1)) { if(heap->last_block+1 == heap->block_cnt) { tmp = heap_realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*)); if(!tmp) return NULL; heap->blocks = tmp; heap->blocks[heap->block_cnt] = heap_alloc(block_size(heap->block_cnt)); if(!heap->blocks[heap->block_cnt]) return NULL; heap->block_cnt++; } heap->last_block++; heap->offset = size; return heap->blocks[heap->last_block]; } list = heap_alloc(size + sizeof(struct list)); if(!list) return NULL; list_add_head(&heap->custom_blocks, list); return list+1; }
static void elem_vector_normalize(elem_vector_t *buf) { if(!buf->len) { heap_free(buf->buf); buf->buf = NULL; }else if(buf->size > buf->len) { buf->buf = heap_realloc(buf->buf, buf->len*sizeof(HTMLElement*)); } buf->size = buf->len; }
static HRESULT parse_url( const WCHAR *url, ULONG len, URL_COMPONENTS *uc ) { HRESULT hr = E_OUTOFMEMORY; WCHAR *tmp; DWORD err; memset( uc, 0, sizeof(*uc) ); uc->dwStructSize = sizeof(*uc); uc->dwHostNameLength = 128; uc->lpszHostName = heap_alloc( uc->dwHostNameLength * sizeof(WCHAR) ); uc->dwUrlPathLength = 128; uc->lpszUrlPath = heap_alloc( uc->dwUrlPathLength * sizeof(WCHAR) ); uc->dwExtraInfoLength = 128; uc->lpszExtraInfo = heap_alloc( uc->dwExtraInfoLength * sizeof(WCHAR) ); if (!uc->lpszHostName || !uc->lpszUrlPath || !uc->lpszExtraInfo) goto error; if (!WinHttpCrackUrl( url, len, ICU_DECODE, uc )) { if ((err = GetLastError()) != ERROR_INSUFFICIENT_BUFFER) { hr = HRESULT_FROM_WIN32( err ); goto error; } if (!(tmp = heap_realloc( uc->lpszHostName, uc->dwHostNameLength * sizeof(WCHAR) ))) goto error; uc->lpszHostName = tmp; if (!(tmp = heap_realloc( uc->lpszUrlPath, uc->dwUrlPathLength * sizeof(WCHAR) ))) goto error; uc->lpszUrlPath = tmp; if (!(tmp = heap_realloc( uc->lpszExtraInfo, uc->dwExtraInfoLength * sizeof(WCHAR) ))) goto error; uc->lpszExtraInfo = tmp; WinHttpCrackUrl( url, len, ICU_DECODE, uc ); } return S_OK; error: heap_free( uc->lpszHostName ); heap_free( uc->lpszUrlPath ); heap_free( uc->lpszExtraInfo ); return hr; }
static HRESULT enum_key( HKEY root, const WCHAR *subkey, VARIANT *names, VARIANT *retval ) { HKEY hkey; HRESULT hr = S_OK; WCHAR buf[256]; BSTR *strings, *tmp; DWORD count = 2, len = sizeof(buf)/sizeof(buf[0]); LONG res, i = 0; TRACE("%p, %s\n", root, debugstr_w(subkey)); if (!(strings = heap_alloc( count * sizeof(BSTR) ))) return E_OUTOFMEMORY; if ((res = RegOpenKeyExW( root, subkey, 0, KEY_ENUMERATE_SUB_KEYS, &hkey ))) { set_variant( VT_UI4, res, NULL, retval ); heap_free( strings ); return S_OK; } for (;;) { if (i >= count) { count *= 2; if (!(tmp = heap_realloc( strings, count * sizeof(BSTR) ))) { RegCloseKey( hkey ); return E_OUTOFMEMORY; } strings = tmp; } if ((res = RegEnumKeyW( hkey, i, buf, len )) == ERROR_NO_MORE_ITEMS) { if (i) res = ERROR_SUCCESS; break; } if (res) break; if (!(strings[i] = SysAllocString( buf ))) { for (i--; i >= 0; i--) SysFreeString( strings[i] ); hr = ERROR_OUTOFMEMORY; break; } i++; } if (hr == S_OK && !res) hr = to_bstr_array( strings, i, names ); set_variant( VT_UI4, res, NULL, retval ); RegCloseKey( hkey ); heap_free( strings ); return hr; }
HRESULT get_plugin_dispid(HTMLPluginContainer *plugin_container, WCHAR *name, DISPID *ret) { IDispatch *disp; DISPID id; DWORD i; HRESULT hres; if(!plugin_container->plugin_host) { WARN("no plugin host\n"); return DISP_E_UNKNOWNNAME; } disp = plugin_container->plugin_host->disp; if(!disp) return DISP_E_UNKNOWNNAME; hres = IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, &id); if(FAILED(hres)) { TRACE("no prop %s\n", debugstr_w(name)); return DISP_E_UNKNOWNNAME; } for(i=0; i < plugin_container->props_len; i++) { if(id == plugin_container->props[i]) { *ret = MSHTML_DISPID_CUSTOM_MIN+i; return S_OK; } } if(!plugin_container->props) { plugin_container->props = heap_alloc(8*sizeof(DISPID)); if(!plugin_container->props) return E_OUTOFMEMORY; plugin_container->props_size = 8; }else if(plugin_container->props_len == plugin_container->props_size) { DISPID *new_props; new_props = heap_realloc(plugin_container->props, plugin_container->props_size*2*sizeof(DISPID)); if(!new_props) return E_OUTOFMEMORY; plugin_container->props = new_props; plugin_container->props_size *= 2; } plugin_container->props[plugin_container->props_len] = id; *ret = MSHTML_DISPID_CUSTOM_MIN+plugin_container->props_len; plugin_container->props_len++; return S_OK; }
static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, BOOL alloc, dynamic_prop_t **ret) { dispex_dynamic_data_t *data = This->dynamic_data; if(data) { unsigned i; for(i=0; i < data->prop_cnt; i++) { if(!strcmpW(data->props[i].name, name)) { *ret = data->props+i; return S_OK; } } } if(alloc) { TRACE("creating dynamic prop %s\n", debugstr_w(name)); if(!data) { data = This->dynamic_data = heap_alloc_zero(sizeof(dispex_dynamic_data_t)); if(!data) return E_OUTOFMEMORY; } if(!data->buf_size) { data->props = heap_alloc(sizeof(dynamic_prop_t)*4); if(!data->props) return E_OUTOFMEMORY; data->buf_size = 4; }else if(data->buf_size == data->prop_cnt) { dynamic_prop_t *new_props; new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1)); if(!new_props) return E_OUTOFMEMORY; data->props = new_props; data->buf_size <<= 1; } data->props[data->prop_cnt].name = heap_strdupW(name); VariantInit(&data->props[data->prop_cnt].var); *ret = data->props + data->prop_cnt++; return S_OK; } TRACE("not found %s\n", debugstr_w(name)); return DISP_E_UNKNOWNNAME; }
static HRESULT WINAPI errorrec_AddErrorRecord(IErrorRecords *iface, ERRORINFO *pErrorInfo, DWORD dwLookupID, DISPPARAMS *pdispparams, IUnknown *punkCustomError, DWORD dwDynamicErrorID) { errorrecords *This = impl_from_IErrorRecords(iface); struct ErrorEntry *entry; HRESULT hr; TRACE("(%p)->(%p %d %p %p %d)\n", This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, dwDynamicErrorID); if(!pErrorInfo) return E_INVALIDARG; if (!This->records) { const unsigned int initial_size = 16; if (!(This->records = heap_alloc(initial_size * sizeof(*This->records)))) return E_OUTOFMEMORY; This->allocated = initial_size; } else if (This->count == This->allocated) { struct ErrorEntry *new_ptr; new_ptr = heap_realloc(This->records, 2 * This->allocated * sizeof(*This->records)); if (!new_ptr) return E_OUTOFMEMORY; This->records = new_ptr; This->allocated *= 2; } entry = This->records + This->count; entry->info = *pErrorInfo; if (FAILED(hr = dup_dispparams(pdispparams, &entry->dispparams))) return hr; entry->custom_error = punkCustomError; if (entry->custom_error) IUnknown_AddRef(entry->custom_error); entry->lookupID = dwDynamicErrorID; This->count++; return S_OK; }
static void set_buffer(LPWSTR *buffer, LPCWSTR string) { static const WCHAR empty_string[] = {0}; ULONG len; if (string == NULL) string = empty_string; len = (wcslen(string) + 1)*sizeof(WCHAR); LPWSTR tmp = (LPWSTR) heap_realloc(*buffer, len); if (tmp) *buffer = tmp; else len = wcslen(*buffer) + 1; StringCchCopyW(*buffer, len, string); }
static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, const FUNCDESC *desc, ITypeInfo *dti) { func_info_t *info; HRESULT hres; if(data->func_cnt && data->funcs[data->func_cnt-1].id == desc->memid) { info = data->funcs+data->func_cnt-1; }else { if(data->func_cnt == *size) data->funcs = heap_realloc(data->funcs, (*size <<= 1)*sizeof(func_info_t)); info = data->funcs+data->func_cnt; hres = ITypeInfo_GetDocumentation(dti, desc->memid, &info->name, NULL, NULL, NULL); if(FAILED(hres)) return; data->func_cnt++; info->id = desc->memid; info->tid = tid; info->func_disp_idx = -1; info->prop_vt = VT_EMPTY; info->put_vtbl_off = 0; info->get_vtbl_off = 0; } if(desc->invkind & DISPATCH_METHOD) { info->func_disp_idx = data->func_disp_cnt++; }else if(desc->invkind & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYGET)) { VARTYPE vt = VT_EMPTY; if(desc->invkind & DISPATCH_PROPERTYGET) { vt = desc->elemdescFunc.tdesc.vt; info->get_vtbl_off = desc->oVft/sizeof(void*); } if(desc->invkind & DISPATCH_PROPERTYPUT) { assert(desc->cParams == 1); vt = desc->lprgelemdescParam->tdesc.vt; info->put_vtbl_off = desc->oVft/sizeof(void*); } assert(info->prop_vt == VT_EMPTY || vt == info->prop_vt); info->prop_vt = vt; } }
static HRESULT receive_message( struct channel *channel, ULONG max_len, char **ret, ULONG *ret_len ) { DWORD len, bytes_read, offset = 0, size = INITIAL_READ_BUFFER_SIZE; char *buf; if (!(buf = heap_alloc( size ))) return E_OUTOFMEMORY; *ret_len = 0; for (;;) { if (!WinHttpQueryDataAvailable( channel->http_request, &len )) { heap_free( buf ); return HRESULT_FROM_WIN32( GetLastError() ); } if (!len) break; if (*ret_len + len > max_len) { heap_free( buf ); return WS_E_QUOTA_EXCEEDED; } if (*ret_len + len > size) { char *tmp; DWORD new_size = max( *ret_len + len, size * 2 ); if (!(tmp = heap_realloc( buf, new_size ))) { heap_free( buf ); return E_OUTOFMEMORY; } buf = tmp; size = new_size; } if (!WinHttpReadData( channel->http_request, buf + offset, len, &bytes_read )) { heap_free( buf ); return HRESULT_FROM_WIN32( GetLastError() ); } if (!bytes_read) break; *ret_len += bytes_read; offset += bytes_read; } *ret = buf; return S_OK; }
static unsigned push_instr(compile_ctx_t *ctx, vbsop_t op) { assert(ctx->instr_size && ctx->instr_size >= ctx->instr_cnt); if(ctx->instr_size == ctx->instr_cnt) { instr_t *new_instr; new_instr = heap_realloc(ctx->code->instrs, ctx->instr_size*2*sizeof(instr_t)); if(!new_instr) return -1; ctx->code->instrs = new_instr; ctx->instr_size *= 2; } ctx->code->instrs[ctx->instr_cnt].op = op; return ctx->instr_cnt++; }
static unsigned push_instr(compiler_ctx_t *ctx, jsop_t op) { assert(ctx->code_size >= ctx->code_off); if(ctx->code_size == ctx->code_off) { instr_t *new_instrs; new_instrs = heap_realloc(ctx->code->instrs, ctx->code_size*2*sizeof(instr_t)); if(!new_instrs) return 0; ctx->code->instrs = new_instrs; ctx->code_size *= 2; } ctx->code->instrs[ctx->code_off].op = op; return ctx->code_off++; }
static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, DISPID id, ITypeInfo *dti) { HRESULT hres; if(data->func_cnt && data->funcs[data->func_cnt-1].id == id) return; if(data->func_cnt == *size) data->funcs = heap_realloc(data->funcs, (*size <<= 1)*sizeof(func_info_t)); hres = ITypeInfo_GetDocumentation(dti, id, &data->funcs[data->func_cnt].name, NULL, NULL, NULL); if(FAILED(hres)) return; data->funcs[data->func_cnt].id = id; data->funcs[data->func_cnt].tid = tid; data->func_cnt++; }
static BOOL stringify_push_obj(stringify_ctx_t *ctx, jsdisp_t *obj) { if(!ctx->stack_size) { ctx->stack = heap_alloc(4*sizeof(*ctx->stack)); if(!ctx->stack) return FALSE; ctx->stack_size = 4; }else if(ctx->stack_top == ctx->stack_size) { jsdisp_t **new_stack; new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(*ctx->stack)); if(!new_stack) return FALSE; ctx->stack = new_stack; ctx->stack_size *= 2; } ctx->stack[ctx->stack_top++] = obj; return TRUE; }
static dispex_prop_t *alloc_prop(DispatchEx *This, const WCHAR *name, prop_type_t type, DWORD flags) { dispex_prop_t *ret; if(This->buf_size == This->prop_cnt) { dispex_prop_t *tmp = heap_realloc(This->props, (This->buf_size<<=1)*sizeof(*This->props)); if(!tmp) return NULL; This->props = tmp; } ret = This->props + This->prop_cnt++; ret->type = type; ret->flags = flags; ret->name = heap_strdupW(name); if(!ret->name) return NULL; return ret; }