if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
domattr *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
TRACE("(%p) ref=%d\n", This, ref);
if(!ref) {
- if(This->binding)
- IBinding_Release(This->binding);
- if(This->memstream)
- IStream_Release(This->memstream);
- HeapFree(GetProcessHeap(), 0, This);
+ if (This->binding) IBinding_Release(This->binding);
+ if (This->memstream) IStream_Release(This->memstream);
+ heap_free(This);
}
return ref;
if(FAILED(hr))
return hr;
- bsc = HeapAlloc(GetProcessHeap(), 0, sizeof(bsc_t));
+ bsc = heap_alloc(sizeof(bsc_t));
bsc->lpVtbl = &bsc_vtbl;
bsc->ref = 1;
if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
}
else
hr = E_FAIL;
- HeapFree(GetProcessHeap(), 0, pContent);
+ heap_free(pContent);
return hr;
}
xmlNodeSetContent(This->node.node, str);
hr = S_OK;
}
- HeapFree(GetProcessHeap(), 0, str);
+ heap_free(str);
SysFreeString(sNewString);
}
IXMLDOMCDATASection *iface,
LONG offset, LONG count)
{
- FIXME("\n");
- return E_NOTIMPL;
+ HRESULT hr;
+ LONG len = -1;
+ BSTR str;
+
+ TRACE("%p %d %d\n", iface, offset, count);
+
+ hr = IXMLDOMCDATASection_get_length(iface, &len);
+ if(hr != S_OK) return hr;
+
+ if((offset < 0) || (offset > len) || (count < 0))
+ return E_INVALIDARG;
+
+ if(len == 0) return S_OK;
+
+ /* cutting start or end */
+ if((offset == 0) || ((count + offset) >= len))
+ {
+ if(offset == 0)
+ IXMLDOMCDATASection_substringData(iface, count, len - count, &str);
+ else
+ IXMLDOMCDATASection_substringData(iface, 0, offset, &str);
+ hr = IXMLDOMCDATASection_put_data(iface, str);
+ }
+ else
+ /* cutting from the inside */
+ {
+ BSTR str_end;
+
+ IXMLDOMCDATASection_substringData(iface, 0, offset, &str);
+ IXMLDOMCDATASection_substringData(iface, offset + count, len - count, &str_end);
+
+ hr = IXMLDOMCDATASection_put_data(iface, str);
+ if(hr == S_OK)
+ hr = IXMLDOMCDATASection_appendData(iface, str_end);
+
+ SysFreeString(str_end);
+ }
+
+ SysFreeString(str);
+
+ return hr;
}
static HRESULT WINAPI domcdata_replaceData(
{
domcdata *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
LONG nLength = 0;
HRESULT hr = S_FALSE;
- TRACE("%p\n", iface);
+ TRACE("%p %d %d %p\n", iface, offset, count, p);
if(!p)
return E_INVALIDARG;
return E_INVALIDARG;
if(count == 0)
- return hr;
+ return S_FALSE;
pContent = xmlNodeGetContent(This->node.node);
if(pContent)
LONG nLength = 0, nLengthP = 0;
xmlChar *str = NULL;
- TRACE("%p\n", This);
+ TRACE("%p %d %p\n", iface, offset, p);
/* If have a NULL or empty string, don't do anything. */
if(SysStringLen(p) == 0)
IXMLDOMComment *iface,
LONG offset, LONG count)
{
- FIXME("\n");
- return E_NOTIMPL;
+ HRESULT hr;
+ LONG len = -1;
+ BSTR str;
+
+ TRACE("%p %d %d\n", iface, offset, count);
+
+ hr = IXMLDOMComment_get_length(iface, &len);
+ if(hr != S_OK) return hr;
+
+ if((offset < 0) || (offset > len) || (count < 0))
+ return E_INVALIDARG;
+
+ if(len == 0) return S_OK;
+
+ /* cutting start or end */
+ if((offset == 0) || ((count + offset) >= len))
+ {
+ if(offset == 0)
+ IXMLDOMComment_substringData(iface, count, len - count, &str);
+ else
+ IXMLDOMComment_substringData(iface, 0, offset, &str);
+ hr = IXMLDOMComment_put_data(iface, str);
+ }
+ else
+ /* cutting from the inside */
+ {
+ BSTR str_end;
+
+ IXMLDOMComment_substringData(iface, 0, offset, &str);
+ IXMLDOMComment_substringData(iface, offset + count, len - count, &str_end);
+
+ hr = IXMLDOMComment_put_data(iface, str);
+ if(hr == S_OK)
+ hr = IXMLDOMComment_appendData(iface, str_end);
+
+ SysFreeString(str_end);
+ }
+
+ SysFreeString(str);
+
+ return hr;
}
static HRESULT WINAPI domcomment_replaceData(
{
domcomment *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
domfrag *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
static xmldoc_priv * create_priv(void)
{
xmldoc_priv *priv;
- priv = HeapAlloc( GetProcessHeap(), 0, sizeof (*priv) );
+ priv = heap_alloc( sizeof (*priv) );
if(priv)
{
LIST_FOR_EACH_ENTRY_SAFE( orphan, orphan2, &priv->orphans, orphan_entry, entry )
{
xmlFreeNode( orphan->node );
- HeapFree( GetProcessHeap(), 0, orphan );
+ heap_free( orphan );
}
- HeapFree(GetProcessHeap(), 0, doc->_private);
+ heap_free(doc->_private);
xmlFreeDoc(doc);
}
xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
orphan_entry *entry;
- entry = HeapAlloc( GetProcessHeap(), 0, sizeof (*entry) );
+ entry = heap_alloc( sizeof (*entry) );
if(!entry)
return E_OUTOFMEMORY;
if( entry->node == node )
{
list_remove( &entry->entry );
- HeapFree( GetProcessHeap(), 0, entry );
+ heap_free( entry );
return S_OK;
}
}
TRACE("created xmlptr %p\n", xmlnode);
elem_unk = create_element(xmlnode);
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
hr = IUnknown_QueryInterface(elem_unk, &IID_IXMLDOMElement, (void **)element);
IUnknown_Release(elem_unk);
xml_content = xmlChar_from_wchar(data);
xmlnode = xmlNewText(xml_content);
- HeapFree(GetProcessHeap(), 0, xml_content);
+ heap_free(xml_content);
if(!xmlnode)
return E_FAIL;
xml_content = xmlChar_from_wchar(data);
xmlnode = xmlNewComment(xml_content);
- HeapFree(GetProcessHeap(), 0, xml_content);
+ heap_free(xml_content);
if(!xmlnode)
return E_FAIL;
xml_content = xmlChar_from_wchar(data);
xmlnode = xmlNewCDataBlock(get_doc( This ), xml_content, strlen( (char*)xml_content) );
- HeapFree(GetProcessHeap(), 0, xml_content);
+ heap_free(xml_content);
if(!xmlnode)
return E_FAIL;
TRACE("created xmlptr %p\n", xmlnode);
*pi = (IXMLDOMProcessingInstruction*)create_pi(xmlnode);
- HeapFree(GetProcessHeap(), 0, xml_content);
- HeapFree(GetProcessHeap(), 0, xml_target);
+ heap_free(xml_content);
+ heap_free(xml_target);
return S_OK;
#else
xml_name = xmlChar_from_wchar(name);
xmlnode = (xmlNode *)xmlNewProp(NULL, xml_name, NULL);
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
if(!xmlnode)
return E_FAIL;
xml_name = xmlChar_from_wchar(name);
xmlnode = xmlNewReference(get_doc( This ), xml_name );
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
if(!xmlnode)
return E_FAIL;
BSTR tagName,
IXMLDOMNodeList** resultList )
{
+ static const WCHAR xpathformat[] =
+ { '/','/','*','[','l','o','c','a','l','-','n','a','m','e','(',')','=','\'','%','s','\'',']',0 };
domdoc *This = impl_from_IXMLDOMDocument2( iface );
LPWSTR szPattern;
HRESULT hr;
TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
- szPattern = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(2+lstrlenW(tagName)+1));
- szPattern[0] = szPattern[1] = '/';
- lstrcpyW(szPattern + 2, tagName);
+ if (tagName[0] == '*' && tagName[1] == 0)
+ {
+ szPattern = heap_alloc(sizeof(WCHAR)*4);
+ szPattern[0] = szPattern[1] = '/';
+ szPattern[2] = '*';
+ szPattern[3] = 0;
+ }
+ else
+ {
+ szPattern = heap_alloc(sizeof(WCHAR)*(20+lstrlenW(tagName)+1));
+ wsprintfW(szPattern, xpathformat, tagName);
+ }
hr = queryresult_create((xmlNodePtr)get_doc(This), szPattern, resultList);
- HeapFree(GetProcessHeap(), 0, szPattern);
+ heap_free(szPattern);
return hr;
}
break;
}
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
if(xmlnode && *node)
{
LPSTR str;
len = WideCharToMultiByte( CP_UTF8, 0, bstr, blen, NULL, 0, NULL, NULL );
- str = HeapAlloc( GetProcessHeap(), 0, len );
+ str = heap_alloc( len );
if ( !str )
return FALSE;
WideCharToMultiByte( CP_UTF8, 0, bstr, blen, str, len, NULL, NULL );
if ( bstrXML && bstr_to_utf8( bstrXML, &str, &len ) )
{
xmldoc = doparse( str, len );
- HeapFree( GetProcessHeap(), 0, str );
+ heap_free( str );
if ( !xmldoc )
This->error = E_FAIL;
else
{
domdoc *doc;
- doc = HeapAlloc( GetProcessHeap(), 0, sizeof (*doc) );
+ doc = heap_alloc( sizeof (*doc) );
if( !doc )
return E_OUTOFMEMORY;
ref = InterlockedDecrement( &This->ref );
if ( ref == 0 )
{
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
domimpl *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->name, -1, NULL, 0 );
if (element->ns)
len += MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->ns->prefix, -1, NULL, 0 );
- str = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
+ str = heap_alloc( len * sizeof (WCHAR) );
if ( !str )
return E_OUTOFMEMORY;
if (element->ns)
}
MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) element->name, -1, str + offset, len - offset );
*p = SysAllocString( str );
- HeapFree( GetProcessHeap(), 0, str );
+ heap_free( str );
return S_OK;
}
else
xml_value = xmlGetNsProp(element, xml_name, NULL);
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
if(xml_value)
{
V_VT(value) = VT_BSTR;
if(!xmlSetNsProp(element, NULL, xml_name, xml_value))
hr = E_FAIL;
- HeapFree(GetProcessHeap(), 0, xml_value);
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_value);
+ heap_free(xml_name);
VariantClear(&var);
return hr;
IXMLDOMElement *iface,
BSTR p)
{
- FIXME("\n");
- return E_NOTIMPL;
+ domelem *This = impl_from_IXMLDOMElement( iface );
+ IXMLDOMNamedNodeMap *attr;
+ HRESULT hr;
+
+ TRACE("(%p)->(%s)", This, debugstr_w(p));
+
+ hr = IXMLDOMElement_get_attributes(iface, &attr);
+ if (hr != S_OK) return hr;
+
+ hr = IXMLDOMNamedNodeMap_removeNamedItem(attr, p, NULL);
+ IXMLDOMNamedNodeMap_Release(attr);
+
+ return hr;
}
static HRESULT WINAPI domelem_getAttributeNode(
if(!xmlValidateNameValue(xml_name))
{
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
return E_FAIL;
}
IUnknown_Release(unk);
}
- HeapFree(GetProcessHeap(), 0, xml_name);
+ heap_free(xml_name);
return hr;
}
IXMLDOMElement *iface,
BSTR bstrName, IXMLDOMNodeList** resultList)
{
+ static const WCHAR xpathformat[] =
+ { '.','/','/','*','[','l','o','c','a','l','-','n','a','m','e','(',')','=','\'','%','s','\'',']',0 };
domelem *This = impl_from_IXMLDOMElement( iface );
LPWSTR szPattern;
xmlNodePtr element;
TRACE("(%p)->(%s,%p)\n", This, debugstr_w(bstrName), resultList);
- szPattern = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(3+lstrlenW(bstrName)+1));
- szPattern[0] = '.';
- szPattern[1] = szPattern[2] = '/';
- lstrcpyW(szPattern+3, bstrName);
+ if (bstrName[0] == '*' && bstrName[1] == 0)
+ {
+ szPattern = heap_alloc(sizeof(WCHAR)*5);
+ szPattern[0] = '.';
+ szPattern[1] = szPattern[2] = '/';
+ szPattern[3] = '*';
+ szPattern[4] = 0;
+ }
+ else
+ {
+ szPattern = heap_alloc(sizeof(WCHAR)*(21+lstrlenW(bstrName)+1));
+ wsprintfW(szPattern, xpathformat, bstrName);
+ }
TRACE("%s\n", debugstr_w(szPattern));
element = get_element(This);
hr = E_FAIL;
else
hr = queryresult_create(element, szPattern, resultList);
- HeapFree(GetProcessHeap(), 0, szPattern);
+ heap_free(szPattern);
return hr;
}
{
domelem *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
entityref *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
if( IsEqualCLSID( rclsid, &CLSID_DOMDocument ) || /* Version indep. v 2.x */
IsEqualCLSID( rclsid, &CLSID_DOMDocument2 ) || /* Version indep. v 3.0 */
- IsEqualCLSID( rclsid, &CLSID_DOMDocument30 ) ) /* Version dep. v 3.0 */
+ IsEqualCLSID( rclsid, &CLSID_DOMDocument30 )|| /* Version dep. v 3.0 */
+ IsEqualCLSID( rclsid, &CLSID_DOMDocument40 )) /* Version dep. v 4.0 */
{
cf = (IClassFactory*) &domdoccf.lpVtbl;
}
ref = InterlockedDecrement( &This->ref );
if ( ref == 0 )
{
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
- req = HeapAlloc( GetProcessHeap(), 0, sizeof (*req) );
+ req = heap_alloc( sizeof (*req) );
if( !req )
return E_OUTOFMEMORY;
extern HRESULT xmldoc_add_orphan( xmlDocPtr doc, xmlNodePtr node );
extern HRESULT xmldoc_remove_orphan( xmlDocPtr doc, xmlNodePtr node );
-extern HRESULT XMLElement_create( IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj );
+extern HRESULT XMLElement_create( IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj, BOOL own );
extern xmlDocPtr parse_xml(char *ptr, int len);
ref = InterlockedDecrement( &This->ref );
if(!ref) {
destroy_xmlnode(This);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
str = xmlChar_from_wchar(V_BSTR(&string_value));
xmlNodeSetContent(This->node, str);
- HeapFree(GetProcessHeap(),0,str);
+ heap_free(str);
hr = S_OK;
break;
}
/* Escape the string. */
str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
- HeapFree(GetProcessHeap(), 0, str);
+ heap_free(str);
xmlNodeSetContent(This->node, str2);
xmlFree(str2);
else
ERR("Failed to Create Namepsace\n");
}
- HeapFree( GetProcessHeap(), 0, str );
+ heap_free( str );
}
return hr;
if ( ref == 0 )
{
xmldoc_release( This->parent->doc );
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
xmlnodelist *nodelist;
- nodelist = HeapAlloc( GetProcessHeap(), 0, sizeof *nodelist );
+ nodelist = heap_alloc( sizeof *nodelist );
if ( !nodelist )
return NULL;
if ( ref == 0 )
{
IXMLDOMNode_Release( This->node );
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
xmlChar *xmlstr;
len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );
- xmlstr = HeapAlloc( GetProcessHeap(), 0, len );
+ xmlstr = heap_alloc( len );
if ( xmlstr )
WideCharToMultiByte( CP_UTF8, 0, str, -1, (LPSTR) xmlstr, len, NULL, NULL );
return xmlstr;
element_name = xmlChar_from_wchar( name );
attr = xmlHasNsProp( node, element_name, NULL );
- HeapFree( GetProcessHeap(), 0, element_name );
+ heap_free( element_name );
if ( !attr )
{
element_name = xmlChar_from_wchar( name );
attr = xmlHasNsProp( node, element_name, NULL );
- HeapFree( GetProcessHeap(), 0, element_name );
+ heap_free( element_name );
if ( !attr )
{
{
xmlnodemap *nodemap;
- nodemap = HeapAlloc( GetProcessHeap(), 0, sizeof *nodemap );
+ nodemap = heap_alloc( sizeof *nodemap );
if ( !nodemap )
return NULL;
SysFreeString(This->url);
SysFreeString(This->reason);
SysFreeString(This->srcText);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
parse_error_t *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
+ This = heap_alloc( sizeof(*This) );
if ( !This )
return NULL;
if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
dom_pi *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
IXMLDOMNodeList_Release( (IXMLDOMNodeList*) &This->lpVtbl );
if (ctxt != NULL)
xmlXPathFreeContext(ctxt);
- HeapFree(GetProcessHeap(), 0, str);
+ heap_free(str);
return hr;
}
#include "wine/debug.h"
#include "wine/unicode.h"
-WINE_DEFAULT_DEBUG_CHANNEL(ole);
+WINE_DEFAULT_DEBUG_CHANNEL(msxml);
/*
* Near the bottom of this file are the exported DllRegisterServer and
};
/***********************************************************************
- * DllRegisterServer (OLEAUT32.@)
+ * DllRegisterServer (MSXML3.@)
*/
HRESULT WINAPI DllRegisterServer(void)
{
}
/***********************************************************************
- * DllUnregisterServer (OLEAUT32.@)
+ * DllUnregisterServer (MSXML3.@)
*/
HRESULT WINAPI DllUnregisterServer(void)
{
return (saxattributes *)((char*)iface - FIELD_OFFSET(saxattributes, lpSAXAttributesVtbl));
}
+static inline BOOL has_content_handler(const saxlocator *locator)
+{
+ return (locator->vbInterface && locator->saxreader->vbcontentHandler) ||
+ (!locator->vbInterface && locator->saxreader->contentHandler);
+}
static HRESULT namespacePush(saxlocator *locator, int ns)
{
dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, NULL, 0);
if(len != -1) dLen++;
- str = HeapAlloc(GetProcessHeap(), 0, dLen * sizeof (WCHAR));
+ str = heap_alloc(dLen * sizeof (WCHAR));
if (!str)
return NULL;
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)buf, len, str, dLen);
if(len != -1) str[dLen-1] = '\0';
bstr = SysAllocString(str);
- HeapFree(GetProcessHeap(), 0, str);
+ heap_free(str);
return bstr;
}
dLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)prefix, -1, NULL, 0)
+ MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, NULL, 0);
- str = HeapAlloc(GetProcessHeap(), 0, dLen * sizeof(WCHAR));
+ str = heap_alloc(dLen * sizeof(WCHAR));
if(!str)
return NULL;
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)name, -1, &str[dLast], dLen-dLast);
bstr = SysAllocString(str);
- HeapFree(GetProcessHeap(), 0, str);
+ heap_free(str);
return bstr;
}
SysFreeString(This->szQName[index]);
}
- HeapFree(GetProcessHeap(), 0, This->szLocalname);
- HeapFree(GetProcessHeap(), 0, This->szURI);
- HeapFree(GetProcessHeap(), 0, This->szValue);
- HeapFree(GetProcessHeap(), 0, This->szQName);
+ heap_free(This->szLocalname);
+ heap_free(This->szURI);
+ heap_free(This->szValue);
+ heap_free(This->szQName);
- HeapFree(GetProcessHeap(), 0, This);
+ heap_free(This);
}
return ref;
int index;
static const xmlChar xmlns[] = "xmlns";
- attributes = HeapAlloc(GetProcessHeap(), 0, sizeof(*attributes));
+ attributes = heap_alloc(sizeof(*attributes));
if(!attributes)
return E_OUTOFMEMORY;
attributes->nb_attributes = nb_namespaces+nb_attributes;
- attributes->szLocalname =
- HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
- attributes->szURI =
- HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
- attributes->szValue =
- HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
- attributes->szQName =
- HeapAlloc(GetProcessHeap(), 0, sizeof(BSTR)*attributes->nb_attributes);
+ attributes->szLocalname = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
+ attributes->szURI = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
+ attributes->szValue = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
+ attributes->szQName = heap_alloc(sizeof(BSTR)*attributes->nb_attributes);
if(!attributes->szLocalname || !attributes->szURI
|| !attributes->szValue || !attributes->szQName)
{
- HeapFree(GetProcessHeap(), 0, attributes->szLocalname);
- HeapFree(GetProcessHeap(), 0, attributes->szURI);
- HeapFree(GetProcessHeap(), 0, attributes->szValue);
- HeapFree(GetProcessHeap(), 0, attributes->szQName);
- HeapFree(GetProcessHeap(), 0, attributes);
+ heap_free(attributes->szLocalname);
+ heap_free(attributes->szURI);
+ heap_free(attributes->szValue);
+ heap_free(attributes->szQName);
+ heap_free(attributes);
return E_FAIL;
}
saxlocator *This = ctx;
HRESULT hr;
- if((This->vbInterface && This->saxreader->vbcontentHandler)
- || (!This->vbInterface && This->saxreader->contentHandler))
+ if(has_content_handler(This))
{
if(This->vbInterface)
hr = IVBSAXContentHandler_startDocument(This->saxreader->vbcontentHandler);
if(This->ret != S_OK) return;
- if((This->vbInterface && This->saxreader->vbcontentHandler)
- || (!This->vbInterface && This->saxreader->contentHandler))
+ if(has_content_handler(This))
{
if(This->vbInterface)
hr = IVBSAXContentHandler_endDocument(This->saxreader->vbcontentHandler);
update_position(This, (xmlChar*)This->pParserCtxt->input->cur+1);
hr = namespacePush(This, nb_namespaces);
- if(hr==S_OK && ((This->vbInterface && This->saxreader->vbcontentHandler)
- || (!This->vbInterface && This->saxreader->contentHandler)))
+ if(hr==S_OK && has_content_handler(This))
{
for(index=0; index<nb_namespaces; index++)
{
nsNr = namespacePop(This);
- if((This->vbInterface && This->saxreader->vbcontentHandler)
- || (!This->vbInterface && This->saxreader->contentHandler))
+ if(has_content_handler(This))
{
NamespaceUri = bstr_from_xmlChar(URI);
LocalName = bstr_from_xmlChar(localname);
xmlChar *end;
BOOL lastEvent = FALSE;
- if((This->vbInterface && !This->saxreader->vbcontentHandler)
- || (!This->vbInterface && !This->saxreader->contentHandler))
- return;
+ if(!(has_content_handler(This))) return;
cur = (xmlChar*)ch;
if(*(ch-1)=='\r') cur--;
va_end(args);
len = MultiByteToWideChar(CP_UNIXCP, 0, message, -1, NULL, 0);
- wszError = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len);
+ wszError = heap_alloc(sizeof(WCHAR)*len);
if(wszError)
MultiByteToWideChar(CP_UNIXCP, 0, message, -1, wszError, len);
ISAXErrorHandler_fatalError(This->saxreader->errorHandler,
(ISAXLocator*)&This->lpSAXLocatorVtbl, wszError, E_FAIL);
- HeapFree(GetProcessHeap(), 0, wszError);
+ heap_free(wszError);
xmlStopParser(This->pParserCtxt);
This->ret = E_FAIL;
if(change) *end = '\n';
- if((This->vbInterface && This->saxreader->vbcontentHandler) ||
- (!This->vbInterface && This->saxreader->contentHandler))
+ if(has_content_handler(This))
{
Chars = bstr_from_xmlCharN(cur, end-cur+1);
if(This->vbInterface)
{
SysFreeString(This->publicId);
SysFreeString(This->systemId);
- HeapFree(GetProcessHeap(), 0, This->nsStack);
+ heap_free(This->nsStack);
ISAXXMLReader_Release((ISAXXMLReader*)&This->saxreader->lpSAXXMLReaderVtbl);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
{
saxlocator *locator;
- locator = HeapAlloc( GetProcessHeap(), 0, sizeof (*locator) );
+ locator = heap_alloc( sizeof (*locator) );
if( !locator )
return E_OUTOFMEMORY;
locator->ret = S_OK;
locator->nsStackSize = 8;
locator->nsStackLast = 0;
- locator->nsStack = HeapAlloc(GetProcessHeap(), 0, locator->nsStackSize);
+ locator->nsStack = heap_alloc(locator->nsStackSize);
if(!locator->nsStack)
{
ISAXXMLReader_Release((ISAXXMLReader*)&reader->lpSAXXMLReaderVtbl);
- HeapFree(GetProcessHeap(), 0, locator);
+ heap_free(locator);
return E_OUTOFMEMORY;
}
return E_FAIL;
}
+ xmlFree(locator->pParserCtxt->sax);
locator->pParserCtxt->sax = &locator->saxreader->sax;
locator->pParserCtxt->userData = locator;
}
This->isParsing = FALSE;
- locator->pParserCtxt->sax = NULL;
xmlFreeParserCtxt(locator->pParserCtxt);
locator->pParserCtxt = NULL;
ISAXLocator_Release((ISAXLocator*)&locator->lpSAXLocatorVtbl);
hr = internal_parseBuffer(This, (const char*)bstrData,
SysStringByteLen(bstrData), vbInterface);
IXMLDOMDocument_Release(xmlDoc);
+ SysFreeString(bstrData);
break;
}
if(IUnknown_QueryInterface(V_UNKNOWN(&varInput),
if(This->vbdeclHandler)
IVBSAXDeclHandler_Release(This->vbdeclHandler);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
- reader = HeapAlloc( GetProcessHeap(), 0, sizeof (*reader) );
+ reader = heap_alloc( sizeof (*reader) );
if( !reader )
return E_OUTOFMEMORY;
if ( ref == 0 )
{
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
HRESULT SchemaCache_create(IUnknown *pUnkOuter, LPVOID *ppObj)
{
- schema_t *schema = HeapAlloc( GetProcessHeap(), 0, sizeof (*schema) );
+ schema_t *schema = heap_alloc( sizeof (*schema) );
if( !schema )
return E_OUTOFMEMORY;
if ( ref == 0 )
{
destroy_xmlnode(&This->node);
- HeapFree( GetProcessHeap(), 0, This );
+ heap_free( This );
}
return ref;
hr = S_OK;
else
hr = E_FAIL;
- HeapFree( GetProcessHeap(), 0, pContent );
+ heap_free( pContent );
}
else
hr = E_FAIL;
xmlNodeSetContent(This->node.node, str);
hr = S_OK;
}
- HeapFree(GetProcessHeap(), 0, str);
+ heap_free(str);
SysFreeString(sNewString);
}
IXMLDOMText *iface,
LONG offset, LONG count)
{
- FIXME("\n");
- return E_NOTIMPL;
+ HRESULT hr;
+ LONG len = -1;
+ BSTR str;
+
+ TRACE("%p %d %d\n", iface, offset, count);
+
+ hr = IXMLDOMText_get_length(iface, &len);
+ if(hr != S_OK) return hr;
+
+ if((offset < 0) || (offset > len) || (count < 0))
+ return E_INVALIDARG;
+
+ if(len == 0) return S_OK;
+
+ /* cutting start or end */
+ if((offset == 0) || ((count + offset) >= len))
+ {
+ if(offset == 0)
+ IXMLDOMText_substringData(iface, count, len - count, &str);
+ else
+ IXMLDOMText_substringData(iface, 0, offset, &str);
+ hr = IXMLDOMText_put_data(iface, str);
+ }
+ else
+ /* cutting from the inside */
+ {
+ BSTR str_end;
+
+ IXMLDOMText_substringData(iface, 0, offset, &str);
+ IXMLDOMText_substringData(iface, offset + count, len - count, &str_end);
+
+ hr = IXMLDOMText_put_data(iface, str);
+ if(hr == S_OK)
+ hr = IXMLDOMText_appendData(iface, str_end);
+
+ SysFreeString(str_end);
+ }
+
+ SysFreeString(str);
+
+ return hr;
}
static HRESULT WINAPI domtext_replaceData(
{
domtext *This;
- This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
+ This = heap_alloc( sizeof *This );
if ( !This )
return NULL;
HRESULT error;
/* IXMLDocument */
- IXMLElement *root;
xmlDocPtr xmldoc;
/* IPersistStream */
{
xmlFreeDoc(This->xmldoc);
if (This->stream) IStream_Release(This->stream);
- HeapFree(GetProcessHeap(), 0, This);
+ heap_free(This);
}
return ref;
static HRESULT WINAPI xmldoc_get_root(IXMLDocument *iface, IXMLElement **p)
{
xmldoc *This = impl_from_IXMLDocument(iface);
+ xmlNodePtr root;
TRACE("(%p, %p)\n", iface, p);
if (!p)
return E_INVALIDARG;
- *p = This->root;
- if (!*p)
+ *p = NULL;
+
+ if (!(root = xmlDocGetRootElement(This->xmldoc)))
return E_FAIL;
- return S_OK;
+ return XMLElement_create((IUnknown *)This, root, (LPVOID *)p, FALSE);
}
static HRESULT WINAPI xmldoc_get_fileSize(IXMLDocument *iface, BSTR *p)
static HRESULT WINAPI xmldoc_get_version(IXMLDocument *iface, BSTR *p)
{
- FIXME("(%p, %p): stub\n", iface, p);
- return E_NOTIMPL;
+ xmldoc *This = impl_from_IXMLDocument(iface);
+
+ TRACE("(%p, %p)\n", This, p);
+
+ if (!p) return E_INVALIDARG;
+ *p = bstr_from_xmlChar(This->xmldoc->version);
+
+ return S_OK;
}
static HRESULT WINAPI xmldoc_get_doctype(IXMLDocument *iface, BSTR *p)
{
- FIXME("(%p, %p): stub\n", iface, p);
- return E_NOTIMPL;
+ xmldoc *This = impl_from_IXMLDocument(iface);
+ xmlDtd *dtd;
+
+ TRACE("(%p, %p)\n", This, p);
+
+ if (!p) return E_INVALIDARG;
+
+ dtd = xmlGetIntSubset(This->xmldoc);
+ if (!dtd) return S_FALSE;
+
+ *p = bstr_from_xmlChar(dtd->name);
+ CharUpperBuffW(*p, SysStringLen(*p));
+
+ return S_OK;
}
static HRESULT WINAPI xmldoc_get_dtdURl(IXMLDocument *iface, BSTR *p)
node->type = type_msxml_to_libxml(V_I4(&vType));
/* FIXME: create xmlNodePtr based on vType and var1 */
- return XMLElement_create((IUnknown *)iface, node, (LPVOID *)ppElem);
+ return XMLElement_create((IUnknown *)iface, node, (LPVOID *)ppElem, TRUE);
}
static const struct IXMLDocumentVtbl xmldoc_vtbl =
static HRESULT WINAPI xmldoc_IPersistStreamInit_GetClassID(
IPersistStreamInit *iface, CLSID *classid)
{
- FIXME("(%p,%p): stub!\n", iface, classid);
- return E_NOTIMPL;
+ xmldoc *this = impl_from_IPersistStreamInit(iface);
+ TRACE("(%p,%p)\n", this, classid);
+
+ if (!classid) return E_POINTER;
+
+ *classid = CLSID_XMLDocument;
+ return S_OK;
}
static HRESULT WINAPI xmldoc_IPersistStreamInit_IsDirty(
IPersistStreamInit *iface, LPSTREAM pStm)
{
xmldoc *This = impl_from_IPersistStreamInit(iface);
- xmlNodePtr xmlnode;
HRESULT hr;
HGLOBAL hglobal;
DWORD read, written, len;
if (!pStm)
return E_INVALIDARG;
+ /* release previously allocated stream */
+ if (This->stream) IStream_Release(This->stream);
hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
if (FAILED(hr))
return hr;
len = GlobalSize(hglobal);
ptr = GlobalLock(hglobal);
if (len != 0)
+ {
+ xmlFreeDoc(This->xmldoc);
This->xmldoc = parse_xml(ptr, len);
+ }
GlobalUnlock(hglobal);
if (!This->xmldoc)
return E_FAIL;
}
- xmlnode = xmlDocGetRootElement(This->xmldoc);
- return XMLElement_create((IUnknown *)This, xmlnode, (LPVOID *)&This->root);
+ return S_OK;
}
static HRESULT WINAPI xmldoc_IPersistStreamInit_Save(
static HRESULT WINAPI xmldoc_IPersistStreamInit_GetSizeMax(
IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
{
- FIXME("(%p, %p): stub!\n", iface, pcbSize);
+ xmldoc *This = impl_from_IPersistStreamInit(iface);
+ TRACE("(%p, %p)\n", This, pcbSize);
return E_NOTIMPL;
}
static HRESULT WINAPI xmldoc_IPersistStreamInit_InitNew(
IPersistStreamInit *iface)
{
- FIXME("(%p): stub!\n", iface);
- return E_NOTIMPL;
+ xmldoc *This = impl_from_IPersistStreamInit(iface);
+ TRACE("(%p)\n", This);
+ return S_OK;
}
static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
- doc = HeapAlloc(GetProcessHeap(), 0, sizeof (*doc));
+ doc = heap_alloc(sizeof (*doc));
if(!doc)
return E_OUTOFMEMORY;
doc->lpvtblIPersistStreamInit = &xmldoc_IPersistStreamInit_VTable;
doc->ref = 1;
doc->error = S_OK;
- doc->root = NULL;
doc->xmldoc = NULL;
doc->stream = NULL;
const IXMLElementVtbl *lpVtbl;
LONG ref;
xmlNodePtr node;
+ BOOL own;
} xmlelem;
static inline xmlelem *impl_from_IXMLElement(IXMLElement *iface)
ref = InterlockedDecrement(&This->ref);
if (ref == 0)
{
- HeapFree(GetProcessHeap(), 0, This);
+ if (This->own) xmlFreeNode(This->node);
+ heap_free(This);
}
return ref;
return hr;
}
-static inline BSTR str_dup_upper(BSTR str)
-{
- INT len = (lstrlenW(str) + 1) * sizeof(WCHAR);
- BSTR p = SysAllocStringLen(NULL, len);
- if (p)
- {
- memcpy(p, str, len);
- CharUpperW(p);
- }
- return p;
-}
-
static HRESULT WINAPI xmlelem_get_tagName(IXMLElement *iface, BSTR *p)
{
xmlelem *This = impl_from_IXMLElement(iface);
- BSTR temp;
TRACE("(%p, %p)\n", iface, p);
if (!p)
return E_INVALIDARG;
- temp = bstr_from_xmlChar(This->node->name);
- *p = str_dup_upper(temp);
- SysFreeString(temp);
+ *p = bstr_from_xmlChar(This->node->name);
+ CharUpperBuffW(*p, SysStringLen(*p));
TRACE("returning %s\n", debugstr_w(*p));
if (!This->node->parent)
return S_FALSE;
- return XMLElement_create((IUnknown *)iface, This->node->parent, (LPVOID *)parent);
+ return XMLElement_create((IUnknown *)iface, This->node->parent, (LPVOID *)parent, FALSE);
}
static HRESULT WINAPI xmlelem_setAttribute(IXMLElement *iface, BSTR strPropertyName,
value = xmlChar_from_wchar(V_BSTR(&PropertyValue));
attr = xmlSetProp(This->node, name, value);
- HeapFree(GetProcessHeap(), 0, name);
- HeapFree(GetProcessHeap(), 0, value);
+ heap_free(name);
+ heap_free(value);
return (attr) ? S_OK : S_FALSE;
}
V_BSTR(PropertyValue) = bstr_from_xmlChar(val);
}
- HeapFree(GetProcessHeap(), 0, name);
+ heap_free(name);
xmlFree(val);
TRACE("returning %s\n", debugstr_w(V_BSTR(PropertyValue)));
return (val) ? S_OK : S_FALSE;
hr = S_OK;
done:
- HeapFree(GetProcessHeap(), 0, name);
+ heap_free(name);
return hr;
}
if (!p)
return E_INVALIDARG;
- return XMLElementCollection_create((IUnknown *)iface, This->node->children, (LPVOID *)p);
+ return XMLElementCollection_create((IUnknown *)iface, This->node, (LPVOID *)p);
}
static LONG type_libxml_to_msxml(xmlElementType type)
content = xmlChar_from_wchar(p);
xmlNodeSetContent(This->node, content);
- HeapFree( GetProcessHeap(), 0, content);
+ heap_free(content);
return S_OK;
}
else
child = xmlAddNextSibling(This->node, childElem->node->last);
+ /* parent is responsible for child data */
+ if (child) childElem->own = FALSE;
+
return (child) ? S_OK : S_FALSE;
}
static HRESULT WINAPI xmlelem_removeChild(IXMLElement *iface, IXMLElement *pChildElem)
{
- FIXME("(%p, %p): stub\n", iface, pChildElem);
- return E_NOTIMPL;
+ xmlelem *This = impl_from_IXMLElement(iface);
+ xmlelem *childElem = impl_from_IXMLElement(pChildElem);
+
+ TRACE("(%p, %p)\n", This, childElem);
+
+ if (!pChildElem)
+ return E_INVALIDARG;
+
+ /* only supported for This is childElem parent case */
+ if (This->node != childElem->node->parent)
+ return E_INVALIDARG;
+
+ xmlUnlinkNode(childElem->node);
+ /* standalone element now */
+ childElem->own = TRUE;
+
+ return S_OK;
}
static const struct IXMLElementVtbl xmlelem_vtbl =
xmlelem_removeChild
};
-HRESULT XMLElement_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
+HRESULT XMLElement_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj, BOOL own)
{
xmlelem *elem;
*ppObj = NULL;
- elem = HeapAlloc(GetProcessHeap(), 0, sizeof (*elem));
+ elem = heap_alloc(sizeof (*elem));
if(!elem)
return E_OUTOFMEMORY;
elem->lpVtbl = &xmlelem_vtbl;
elem->ref = 1;
elem->node = node;
+ elem->own = own;
*ppObj = &elem->lpVtbl;
xmlNodePtr current;
} xmlelem_collection;
+static inline LONG xmlelem_collection_updatelength(xmlelem_collection *collection)
+{
+ xmlNodePtr ptr = collection->node->children;
+
+ collection->length = 0;
+ while (ptr)
+ {
+ collection->length++;
+ ptr = ptr->next;
+ }
+ return collection->length;
+}
+
static inline xmlelem_collection *impl_from_IXMLElementCollection(IXMLElementCollection *iface)
{
return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpVtbl));
ref = InterlockedDecrement(&This->ref);
if (ref == 0)
{
- HeapFree(GetProcessHeap(), 0, This);
+ heap_free(This);
}
return ref;
if (!p)
return E_INVALIDARG;
- *p = This->length;
+ *p = xmlelem_collection_updatelength(This);
return S_OK;
}
VARIANT var2, IDispatch **ppDisp)
{
xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
- xmlNodePtr ptr = This->node;
+ xmlNodePtr ptr = This->node->children;
int index, i;
TRACE("(%p, %p)\n", iface, ppDisp);
index = V_I4(&var1);
if (index < 0)
return E_INVALIDARG;
+
+ xmlelem_collection_updatelength(This);
if (index >= This->length)
return E_FAIL;
for (i = 0; i < index; i++)
ptr = ptr->next;
- return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)ppDisp);
+ return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)ppDisp, FALSE);
}
static const struct IXMLElementCollectionVtbl xmlelem_collection_vtbl =
This->current = This->current->next;
V_VT(rgVar) = VT_DISPATCH;
- return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)&V_DISPATCH(rgVar));
+ return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)&V_DISPATCH(rgVar), FALSE);
}
static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Skip(
IEnumVARIANT *iface)
{
xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
- This->current = This->node;
+ This->current = This->node->children;
return S_OK;
}
static HRESULT XMLElementCollection_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
{
xmlelem_collection *collection;
- xmlNodePtr ptr;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
*ppObj = NULL;
- if (!node)
+ if (!node->children)
return S_FALSE;
- collection = HeapAlloc(GetProcessHeap(), 0, sizeof (*collection));
+ collection = heap_alloc(sizeof (*collection));
if(!collection)
return E_OUTOFMEMORY;
collection->ref = 1;
collection->length = 0;
collection->node = node;
- collection->current = node;
-
- ptr = node;
- while (ptr)
- {
- collection->length++;
- ptr = ptr->next;
- }
+ collection->current = node->children;
+ xmlelem_collection_updatelength(collection);
*ppObj = &collection->lpVtbl;
[default, source] dispinterface XMLDOMDocumentEvents;
}
+[
+ uuid(88d969c0-f192-11d4-a65f-0040963251e5)
+]
+coclass DOMDocument40
+{
+ [default] interface IXMLDOMDocument2;
+ [default, source] dispinterface XMLDOMDocumentEvents;
+}
[
uuid(F6D90F12-9C73-11D3-B32E-00C04F990BB4)
projects / reactos.git / commitdiff