dll/win32/msxml3/comment.c

   1 /*
   2  *    DOM comment node implementation
   3  *
   4  * Copyright 2006 Huw Davies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_NO_STATUS
  22 #define _INC_WINDOWS
  23
  24 #define COBJMACROS
  25
  26 #include <config.h>
  27
  28 //#include <stdarg.h>
  29 #ifdef HAVE_LIBXML2
  30 # include <libxml/parser.h>
  31 //# include <libxml/xmlerror.h>
  32 #endif
  33
  34 #include <windef.h>
  35 #include <winbase.h>
  36 //#include "winuser.h"
  37 #include <ole2.h>
  38 #include <msxml6.h>
  39
  40 #include "msxml_private.h"
  41
  42 #include <wine/debug.h>
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  45
  46 #ifdef HAVE_LIBXML2
  47
  48 typedef struct _domcomment
  49 {
  50     xmlnode node;
  51     IXMLDOMComment IXMLDOMComment_iface;
  52     LONG ref;
  53 } domcomment;
  54
  55 static const tid_t domcomment_se_tids[] = {
  56     IXMLDOMNode_tid,
  57     IXMLDOMComment_tid,
  58     0
  59 };
  60
  61 static inline domcomment *impl_from_IXMLDOMComment( IXMLDOMComment *iface )
  62 {
  63     return CONTAINING_RECORD(iface, domcomment, IXMLDOMComment_iface);
  64 }
  65
  66 static HRESULT WINAPI domcomment_QueryInterface(
  67     IXMLDOMComment *iface,
  68     REFIID riid,
  69     void** ppvObject )
  70 {
  71     domcomment *This = impl_from_IXMLDOMComment( iface );
  72     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  73
  74     if ( IsEqualGUID( riid, &IID_IXMLDOMComment ) ||
  75          IsEqualGUID( riid, &IID_IXMLDOMCharacterData) ||
  76          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  77          IsEqualGUID( riid, &IID_IDispatch ) ||
  78          IsEqualGUID( riid, &IID_IUnknown ) )
  79     {
  80         *ppvObject = iface;
  81     }
  82     else if(node_query_interface(&This->node, riid, ppvObject))
  83     {
  84         return *ppvObject ? S_OK : E_NOINTERFACE;
  85     }
  86     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
  87     {
  88         return node_create_supporterrorinfo(domcomment_se_tids, ppvObject);
  89     }
  90     else
  91     {
  92         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
  93         *ppvObject = NULL;
  94         return E_NOINTERFACE;
  95     }
  96
  97     IXMLDOMComment_AddRef(iface);
  98     return S_OK;
  99 }
 100
 101 static ULONG WINAPI domcomment_AddRef(
 102     IXMLDOMComment *iface )
 103 {
 104     domcomment *This = impl_from_IXMLDOMComment( iface );
 105     ULONG ref = InterlockedIncrement( &This->ref );
 106     TRACE("(%p)->(%d)\n", This, ref);
 107     return ref;
 108 }
 109
 110 static ULONG WINAPI domcomment_Release(
 111     IXMLDOMComment *iface )
 112 {
 113     domcomment *This = impl_from_IXMLDOMComment( iface );
 114     ULONG ref = InterlockedDecrement( &This->ref );
 115
 116     TRACE("(%p)->(%d)\n", This, ref);
 117     if ( ref == 0 )
 118     {
 119         destroy_xmlnode(&This->node);
 120         heap_free( This );
 121     }
 122
 123     return ref;
 124 }
 125
 126 static HRESULT WINAPI domcomment_GetTypeInfoCount(
 127     IXMLDOMComment *iface,
 128     UINT* pctinfo )
 129 {
 130     domcomment *This = impl_from_IXMLDOMComment( iface );
 131     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 132 }
 133
 134 static HRESULT WINAPI domcomment_GetTypeInfo(
 135     IXMLDOMComment *iface,
 136     UINT iTInfo, LCID lcid,
 137     ITypeInfo** ppTInfo )
 138 {
 139     domcomment *This = impl_from_IXMLDOMComment( iface );
 140     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface,
 141         iTInfo, lcid, ppTInfo);
 142 }
 143
 144 static HRESULT WINAPI domcomment_GetIDsOfNames(
 145     IXMLDOMComment *iface,
 146     REFIID riid, LPOLESTR* rgszNames,
 147     UINT cNames, LCID lcid, DISPID* rgDispId )
 148 {
 149     domcomment *This = impl_from_IXMLDOMComment( iface );
 150     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
 151         riid, rgszNames, cNames, lcid, rgDispId);
 152 }
 153
 154 static HRESULT WINAPI domcomment_Invoke(
 155     IXMLDOMComment *iface,
 156     DISPID dispIdMember, REFIID riid, LCID lcid,
 157     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 158     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 159 {
 160     domcomment *This = impl_from_IXMLDOMComment( iface );
 161     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
 162         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 163 }
 164
 165 static HRESULT WINAPI domcomment_get_nodeName(
 166     IXMLDOMComment *iface,
 167     BSTR* p )
 168 {
 169     domcomment *This = impl_from_IXMLDOMComment( iface );
 170
 171     static const WCHAR commentW[] = {'#','c','o','m','m','e','n','t',0};
 172
 173     TRACE("(%p)->(%p)\n", This, p);
 174
 175     return return_bstr(commentW, p);
 176 }
 177
 178 static HRESULT WINAPI domcomment_get_nodeValue(
 179     IXMLDOMComment *iface,
 180     VARIANT* value)
 181 {
 182     domcomment *This = impl_from_IXMLDOMComment( iface );
 183
 184     TRACE("(%p)->(%p)\n", This, value);
 185
 186     return node_get_content(&This->node, value);
 187 }
 188
 189 static HRESULT WINAPI domcomment_put_nodeValue(
 190     IXMLDOMComment *iface,
 191     VARIANT value)
 192 {
 193     domcomment *This = impl_from_IXMLDOMComment( iface );
 194
 195     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 196
 197     return node_put_value(&This->node, &value);
 198 }
 199
 200 static HRESULT WINAPI domcomment_get_nodeType(
 201     IXMLDOMComment *iface,
 202     DOMNodeType* domNodeType )
 203 {
 204     domcomment *This = impl_from_IXMLDOMComment( iface );
 205
 206     TRACE("(%p)->(%p)\n", This, domNodeType);
 207
 208     *domNodeType = NODE_COMMENT;
 209     return S_OK;
 210 }
 211
 212 static HRESULT WINAPI domcomment_get_parentNode(
 213     IXMLDOMComment *iface,
 214     IXMLDOMNode** parent )
 215 {
 216     domcomment *This = impl_from_IXMLDOMComment( iface );
 217
 218     TRACE("(%p)->(%p)\n", This, parent);
 219
 220     return node_get_parent(&This->node, parent);
 221 }
 222
 223 static HRESULT WINAPI domcomment_get_childNodes(
 224     IXMLDOMComment *iface,
 225     IXMLDOMNodeList** outList)
 226 {
 227     domcomment *This = impl_from_IXMLDOMComment( iface );
 228
 229     TRACE("(%p)->(%p)\n", This, outList);
 230
 231     return node_get_child_nodes(&This->node, outList);
 232 }
 233
 234 static HRESULT WINAPI domcomment_get_firstChild(
 235     IXMLDOMComment *iface,
 236     IXMLDOMNode** domNode)
 237 {
 238     domcomment *This = impl_from_IXMLDOMComment( iface );
 239
 240     TRACE("(%p)->(%p)\n", This, domNode);
 241
 242     return return_null_node(domNode);
 243 }
 244
 245 static HRESULT WINAPI domcomment_get_lastChild(
 246     IXMLDOMComment *iface,
 247     IXMLDOMNode** domNode)
 248 {
 249     domcomment *This = impl_from_IXMLDOMComment( iface );
 250
 251     TRACE("(%p)->(%p)\n", This, domNode);
 252
 253     return return_null_node(domNode);
 254 }
 255
 256 static HRESULT WINAPI domcomment_get_previousSibling(
 257     IXMLDOMComment *iface,
 258     IXMLDOMNode** domNode)
 259 {
 260     domcomment *This = impl_from_IXMLDOMComment( iface );
 261
 262     TRACE("(%p)->(%p)\n", This, domNode);
 263
 264     return node_get_previous_sibling(&This->node, domNode);
 265 }
 266
 267 static HRESULT WINAPI domcomment_get_nextSibling(
 268     IXMLDOMComment *iface,
 269     IXMLDOMNode** domNode)
 270 {
 271     domcomment *This = impl_from_IXMLDOMComment( iface );
 272
 273     TRACE("(%p)->(%p)\n", This, domNode);
 274
 275     return node_get_next_sibling(&This->node, domNode);
 276 }
 277
 278 static HRESULT WINAPI domcomment_get_attributes(
 279     IXMLDOMComment *iface,
 280     IXMLDOMNamedNodeMap** attributeMap)
 281 {
 282     domcomment *This = impl_from_IXMLDOMComment( iface );
 283
 284     TRACE("(%p)->(%p)\n", This, attributeMap);
 285
 286     return return_null_ptr((void**)attributeMap);
 287 }
 288
 289 static HRESULT WINAPI domcomment_insertBefore(
 290     IXMLDOMComment *iface,
 291     IXMLDOMNode* newNode, VARIANT refChild,
 292     IXMLDOMNode** outOldNode)
 293 {
 294     domcomment *This = impl_from_IXMLDOMComment( iface );
 295
 296     FIXME("(%p)->(%p %s %p) needs test\n", This, newNode, debugstr_variant(&refChild), outOldNode);
 297
 298     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
 299 }
 300
 301 static HRESULT WINAPI domcomment_replaceChild(
 302     IXMLDOMComment *iface,
 303     IXMLDOMNode* newNode,
 304     IXMLDOMNode* oldNode,
 305     IXMLDOMNode** outOldNode)
 306 {
 307     domcomment *This = impl_from_IXMLDOMComment( iface );
 308
 309     FIXME("(%p)->(%p %p %p) needs tests\n", This, newNode, oldNode, outOldNode);
 310
 311     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
 312 }
 313
 314 static HRESULT WINAPI domcomment_removeChild(
 315     IXMLDOMComment *iface,
 316     IXMLDOMNode *child, IXMLDOMNode **oldChild)
 317 {
 318     domcomment *This = impl_from_IXMLDOMComment( iface );
 319     TRACE("(%p)->(%p %p)\n", This, child, oldChild);
 320     return node_remove_child(&This->node, child, oldChild);
 321 }
 322
 323 static HRESULT WINAPI domcomment_appendChild(
 324     IXMLDOMComment *iface,
 325     IXMLDOMNode *child, IXMLDOMNode **outChild)
 326 {
 327     domcomment *This = impl_from_IXMLDOMComment( iface );
 328     TRACE("(%p)->(%p %p)\n", This, child, outChild);
 329     return node_append_child(&This->node, child, outChild);
 330 }
 331
 332 static HRESULT WINAPI domcomment_hasChildNodes(
 333     IXMLDOMComment *iface,
 334     VARIANT_BOOL *ret)
 335 {
 336     domcomment *This = impl_from_IXMLDOMComment( iface );
 337     TRACE("(%p)->(%p)\n", This, ret);
 338     return node_has_childnodes(&This->node, ret);
 339 }
 340
 341 static HRESULT WINAPI domcomment_get_ownerDocument(
 342     IXMLDOMComment   *iface,
 343     IXMLDOMDocument **doc)
 344 {
 345     domcomment *This = impl_from_IXMLDOMComment( iface );
 346     TRACE("(%p)->(%p)\n", This, doc);
 347     return node_get_owner_doc(&This->node, doc);
 348 }
 349
 350 static HRESULT WINAPI domcomment_cloneNode(
 351     IXMLDOMComment *iface,
 352     VARIANT_BOOL deep, IXMLDOMNode** outNode)
 353 {
 354     domcomment *This = impl_from_IXMLDOMComment( iface );
 355     TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 356     return node_clone( &This->node, deep, outNode );
 357 }
 358
 359 static HRESULT WINAPI domcomment_get_nodeTypeString(
 360     IXMLDOMComment *iface,
 361     BSTR* p)
 362 {
 363     domcomment *This = impl_from_IXMLDOMComment( iface );
 364     static const WCHAR commentW[] = {'c','o','m','m','e','n','t',0};
 365
 366     TRACE("(%p)->(%p)\n", This, p);
 367
 368     return return_bstr(commentW, p);
 369 }
 370
 371 static HRESULT WINAPI domcomment_get_text(
 372     IXMLDOMComment *iface,
 373     BSTR* p)
 374 {
 375     domcomment *This = impl_from_IXMLDOMComment( iface );
 376     TRACE("(%p)->(%p)\n", This, p);
 377     return node_get_text(&This->node, p);
 378 }
 379
 380 static HRESULT WINAPI domcomment_put_text(
 381     IXMLDOMComment *iface,
 382     BSTR p)
 383 {
 384     domcomment *This = impl_from_IXMLDOMComment( iface );
 385     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 386     return node_put_text( &This->node, p );
 387 }
 388
 389 static HRESULT WINAPI domcomment_get_specified(
 390     IXMLDOMComment *iface,
 391     VARIANT_BOOL* isSpecified)
 392 {
 393     domcomment *This = impl_from_IXMLDOMComment( iface );
 394     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 395     *isSpecified = VARIANT_TRUE;
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI domcomment_get_definition(
 400     IXMLDOMComment *iface,
 401     IXMLDOMNode** definitionNode)
 402 {
 403     domcomment *This = impl_from_IXMLDOMComment( iface );
 404     FIXME("(%p)->(%p)\n", This, definitionNode);
 405     return E_NOTIMPL;
 406 }
 407
 408 static HRESULT WINAPI domcomment_get_nodeTypedValue(
 409     IXMLDOMComment *iface,
 410     VARIANT* v)
 411 {
 412     domcomment *This = impl_from_IXMLDOMComment( iface );
 413     TRACE("(%p)->(%p)\n", This, v);
 414     return node_get_content(&This->node, v);
 415 }
 416
 417 static HRESULT WINAPI domcomment_put_nodeTypedValue(
 418     IXMLDOMComment *iface,
 419     VARIANT typedValue)
 420 {
 421     domcomment *This = impl_from_IXMLDOMComment( iface );
 422     FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
 423     return E_NOTIMPL;
 424 }
 425
 426 static HRESULT WINAPI domcomment_get_dataType(
 427     IXMLDOMComment *iface,
 428     VARIANT* typename)
 429 {
 430     domcomment *This = impl_from_IXMLDOMComment( iface );
 431     TRACE("(%p)->(%p)\n", This, typename);
 432     return return_null_var( typename );
 433 }
 434
 435 static HRESULT WINAPI domcomment_put_dataType(
 436     IXMLDOMComment *iface,
 437     BSTR p)
 438 {
 439     domcomment *This = impl_from_IXMLDOMComment( iface );
 440
 441     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 442
 443     if(!p)
 444         return E_INVALIDARG;
 445
 446     return E_FAIL;
 447 }
 448
 449 static HRESULT WINAPI domcomment_get_xml(
 450     IXMLDOMComment *iface,
 451     BSTR* p)
 452 {
 453     domcomment *This = impl_from_IXMLDOMComment( iface );
 454
 455     TRACE("(%p)->(%p)\n", This, p);
 456
 457     return node_get_xml(&This->node, FALSE, p);
 458 }
 459
 460 static HRESULT WINAPI domcomment_transformNode(
 461     IXMLDOMComment *iface,
 462     IXMLDOMNode *node, BSTR *p)
 463 {
 464     domcomment *This = impl_from_IXMLDOMComment( iface );
 465     TRACE("(%p)->(%p %p)\n", This, node, p);
 466     return node_transform_node(&This->node, node, p);
 467 }
 468
 469 static HRESULT WINAPI domcomment_selectNodes(
 470     IXMLDOMComment *iface,
 471     BSTR p, IXMLDOMNodeList** outList)
 472 {
 473     domcomment *This = impl_from_IXMLDOMComment( iface );
 474     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
 475     return node_select_nodes(&This->node, p, outList);
 476 }
 477
 478 static HRESULT WINAPI domcomment_selectSingleNode(
 479     IXMLDOMComment *iface,
 480     BSTR p, IXMLDOMNode** outNode)
 481 {
 482     domcomment *This = impl_from_IXMLDOMComment( iface );
 483     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
 484     return node_select_singlenode(&This->node, p, outNode);
 485 }
 486
 487 static HRESULT WINAPI domcomment_get_parsed(
 488     IXMLDOMComment *iface,
 489     VARIANT_BOOL* isParsed)
 490 {
 491     domcomment *This = impl_from_IXMLDOMComment( iface );
 492     FIXME("(%p)->(%p) stub!\n", This, isParsed);
 493     *isParsed = VARIANT_TRUE;
 494     return S_OK;
 495 }
 496
 497 static HRESULT WINAPI domcomment_get_namespaceURI(
 498     IXMLDOMComment *iface,
 499     BSTR* p)
 500 {
 501     domcomment *This = impl_from_IXMLDOMComment( iface );
 502     TRACE("(%p)->(%p)\n", This, p);
 503     return node_get_namespaceURI(&This->node, p);
 504 }
 505
 506 static HRESULT WINAPI domcomment_get_prefix(
 507     IXMLDOMComment *iface,
 508     BSTR* prefix)
 509 {
 510     domcomment *This = impl_from_IXMLDOMComment( iface );
 511     TRACE("(%p)->(%p)\n", This, prefix);
 512     return return_null_bstr( prefix );
 513 }
 514
 515 static HRESULT WINAPI domcomment_get_baseName(
 516     IXMLDOMComment *iface,
 517     BSTR* name)
 518 {
 519     domcomment *This = impl_from_IXMLDOMComment( iface );
 520     TRACE("(%p)->(%p)\n", This, name);
 521     return return_null_bstr( name );
 522 }
 523
 524 static HRESULT WINAPI domcomment_transformNodeToObject(
 525     IXMLDOMComment *iface,
 526     IXMLDOMNode* domNode, VARIANT var1)
 527 {
 528     domcomment *This = impl_from_IXMLDOMComment( iface );
 529     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT WINAPI domcomment_get_data(
 534     IXMLDOMComment *iface,
 535     BSTR *p)
 536 {
 537     domcomment *This = impl_from_IXMLDOMComment( iface );
 538     HRESULT hr;
 539     VARIANT vRet;
 540
 541     TRACE("(%p)->(%p)\n", This, p);
 542
 543     if(!p)
 544         return E_INVALIDARG;
 545
 546     hr = IXMLDOMComment_get_nodeValue( iface, &vRet );
 547     if(hr == S_OK)
 548     {
 549         *p = V_BSTR(&vRet);
 550     }
 551
 552     return hr;
 553 }
 554
 555 static HRESULT WINAPI domcomment_put_data(
 556     IXMLDOMComment *iface,
 557     BSTR data)
 558 {
 559     domcomment *This = impl_from_IXMLDOMComment( iface );
 560     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
 561     return node_set_content(&This->node, data);
 562 }
 563
 564 static HRESULT WINAPI domcomment_get_length(
 565     IXMLDOMComment *iface,
 566     LONG *len)
 567 {
 568     domcomment *This = impl_from_IXMLDOMComment( iface );
 569     HRESULT hr;
 570     BSTR data;
 571
 572     TRACE("(%p)->(%p)\n", This, len);
 573
 574     if(!len)
 575         return E_INVALIDARG;
 576
 577     hr = IXMLDOMComment_get_data(iface, &data);
 578     if(hr == S_OK)
 579     {
 580         *len = SysStringLen(data);
 581         SysFreeString(data);
 582     }
 583
 584     return hr;
 585 }
 586
 587 static HRESULT WINAPI domcomment_substringData(
 588     IXMLDOMComment *iface,
 589     LONG offset, LONG count, BSTR *p)
 590 {
 591     domcomment *This = impl_from_IXMLDOMComment( iface );
 592     HRESULT hr;
 593     BSTR data;
 594
 595     TRACE("(%p)->(%d %d %p)\n", This, offset, count, p);
 596
 597     if(!p)
 598         return E_INVALIDARG;
 599
 600     *p = NULL;
 601     if(offset < 0 || count < 0)
 602         return E_INVALIDARG;
 603
 604     if(count == 0)
 605         return S_FALSE;
 606
 607     hr = IXMLDOMComment_get_data(iface, &data);
 608     if(hr == S_OK)
 609     {
 610         LONG len = SysStringLen(data);
 611
 612         if(offset < len)
 613         {
 614             if(offset + count > len)
 615                 *p = SysAllocString(&data[offset]);
 616             else
 617                 *p = SysAllocStringLen(&data[offset], count);
 618         }
 619         else
 620             hr = S_FALSE;
 621
 622         SysFreeString(data);
 623     }
 624
 625     return hr;
 626 }
 627
 628 static HRESULT WINAPI domcomment_appendData(
 629     IXMLDOMComment *iface,
 630     BSTR p)
 631 {
 632     domcomment *This = impl_from_IXMLDOMComment( iface );
 633     HRESULT hr;
 634     BSTR data;
 635     LONG p_len;
 636
 637     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 638
 639     /* Nothing to do if NULL or an Empty string passed in. */
 640     if((p_len = SysStringLen(p)) == 0) return S_OK;
 641
 642     hr = IXMLDOMComment_get_data(iface, &data);
 643     if(hr == S_OK)
 644     {
 645         LONG len = SysStringLen(data);
 646         BSTR str = SysAllocStringLen(NULL, p_len + len);
 647
 648         memcpy(str, data, len*sizeof(WCHAR));
 649         memcpy(&str[len], p, p_len*sizeof(WCHAR));
 650         str[len+p_len] = 0;
 651
 652         hr = IXMLDOMComment_put_data(iface, str);
 653
 654         SysFreeString(str);
 655         SysFreeString(data);
 656     }
 657
 658     return hr;
 659 }
 660
 661 static HRESULT WINAPI domcomment_insertData(
 662     IXMLDOMComment *iface,
 663     LONG offset, BSTR p)
 664 {
 665     domcomment *This = impl_from_IXMLDOMComment( iface );
 666     HRESULT hr;
 667     BSTR data;
 668     LONG p_len;
 669
 670     TRACE("(%p)->(%d %s)\n", This, offset, debugstr_w(p));
 671
 672     /* If have a NULL or empty string, don't do anything. */
 673     if((p_len = SysStringLen(p)) == 0)
 674         return S_OK;
 675
 676     if(offset < 0)
 677     {
 678         return E_INVALIDARG;
 679     }
 680
 681     hr = IXMLDOMComment_get_data(iface, &data);
 682     if(hr == S_OK)
 683     {
 684         LONG len = SysStringLen(data);
 685         BSTR str;
 686
 687         if(len < offset)
 688         {
 689             SysFreeString(data);
 690             return E_INVALIDARG;
 691         }
 692
 693         str = SysAllocStringLen(NULL, len + p_len);
 694         /* start part, supplied string and end part */
 695         memcpy(str, data, offset*sizeof(WCHAR));
 696         memcpy(&str[offset], p, p_len*sizeof(WCHAR));
 697         memcpy(&str[offset+p_len], &data[offset], (len-offset)*sizeof(WCHAR));
 698         str[len+p_len] = 0;
 699
 700         hr = IXMLDOMComment_put_data(iface, str);
 701
 702         SysFreeString(str);
 703         SysFreeString(data);
 704     }
 705
 706     return hr;
 707 }
 708
 709 static HRESULT WINAPI domcomment_deleteData(
 710     IXMLDOMComment *iface,
 711     LONG offset, LONG count)
 712 {
 713     HRESULT hr;
 714     LONG len = -1;
 715     BSTR str;
 716
 717     TRACE("(%p)->(%d %d)\n", iface, offset, count);
 718
 719     hr = IXMLDOMComment_get_length(iface, &len);
 720     if(hr != S_OK) return hr;
 721
 722     if((offset < 0) || (offset > len) || (count < 0))
 723         return E_INVALIDARG;
 724
 725     if(len == 0) return S_OK;
 726
 727     /* cutting start or end */
 728     if((offset == 0) || ((count + offset) >= len))
 729     {
 730         if(offset == 0)
 731             IXMLDOMComment_substringData(iface, count, len - count, &str);
 732         else
 733             IXMLDOMComment_substringData(iface, 0, offset, &str);
 734         hr = IXMLDOMComment_put_data(iface, str);
 735     }
 736     else
 737     /* cutting from the inside */
 738     {
 739         BSTR str_end;
 740
 741         IXMLDOMComment_substringData(iface, 0, offset, &str);
 742         IXMLDOMComment_substringData(iface, offset + count, len - count, &str_end);
 743
 744         hr = IXMLDOMComment_put_data(iface, str);
 745         if(hr == S_OK)
 746             hr = IXMLDOMComment_appendData(iface, str_end);
 747
 748         SysFreeString(str_end);
 749     }
 750
 751     SysFreeString(str);
 752
 753     return hr;
 754 }
 755
 756 static HRESULT WINAPI domcomment_replaceData(
 757     IXMLDOMComment *iface,
 758     LONG offset, LONG count, BSTR p)
 759 {
 760     domcomment *This = impl_from_IXMLDOMComment( iface );
 761     HRESULT hr;
 762
 763     TRACE("(%p)->(%d %d %s)\n", This, offset, count, debugstr_w(p));
 764
 765     hr = IXMLDOMComment_deleteData(iface, offset, count);
 766
 767     if (hr == S_OK)
 768        hr = IXMLDOMComment_insertData(iface, offset, p);
 769
 770     return hr;
 771 }
 772
 773 static const struct IXMLDOMCommentVtbl domcomment_vtbl =
 774 {
 775     domcomment_QueryInterface,
 776     domcomment_AddRef,
 777     domcomment_Release,
 778     domcomment_GetTypeInfoCount,
 779     domcomment_GetTypeInfo,
 780     domcomment_GetIDsOfNames,
 781     domcomment_Invoke,
 782     domcomment_get_nodeName,
 783     domcomment_get_nodeValue,
 784     domcomment_put_nodeValue,
 785     domcomment_get_nodeType,
 786     domcomment_get_parentNode,
 787     domcomment_get_childNodes,
 788     domcomment_get_firstChild,
 789     domcomment_get_lastChild,
 790     domcomment_get_previousSibling,
 791     domcomment_get_nextSibling,
 792     domcomment_get_attributes,
 793     domcomment_insertBefore,
 794     domcomment_replaceChild,
 795     domcomment_removeChild,
 796     domcomment_appendChild,
 797     domcomment_hasChildNodes,
 798     domcomment_get_ownerDocument,
 799     domcomment_cloneNode,
 800     domcomment_get_nodeTypeString,
 801     domcomment_get_text,
 802     domcomment_put_text,
 803     domcomment_get_specified,
 804     domcomment_get_definition,
 805     domcomment_get_nodeTypedValue,
 806     domcomment_put_nodeTypedValue,
 807     domcomment_get_dataType,
 808     domcomment_put_dataType,
 809     domcomment_get_xml,
 810     domcomment_transformNode,
 811     domcomment_selectNodes,
 812     domcomment_selectSingleNode,
 813     domcomment_get_parsed,
 814     domcomment_get_namespaceURI,
 815     domcomment_get_prefix,
 816     domcomment_get_baseName,
 817     domcomment_transformNodeToObject,
 818     domcomment_get_data,
 819     domcomment_put_data,
 820     domcomment_get_length,
 821     domcomment_substringData,
 822     domcomment_appendData,
 823     domcomment_insertData,
 824     domcomment_deleteData,
 825     domcomment_replaceData
 826 };
 827
 828 static const tid_t domcomment_iface_tids[] = {
 829     IXMLDOMComment_tid,
 830     0
 831 };
 832
 833 static dispex_static_data_t domcomment_dispex = {
 834     NULL,
 835     IXMLDOMComment_tid,
 836     NULL,
 837     domcomment_iface_tids
 838 };
 839
 840 IUnknown* create_comment( xmlNodePtr comment )
 841 {
 842     domcomment *This;
 843
 844     This = heap_alloc( sizeof *This );
 845     if ( !This )
 846         return NULL;
 847
 848     This->IXMLDOMComment_iface.lpVtbl = &domcomment_vtbl;
 849     This->ref = 1;
 850
 851     init_xmlnode(&This->node, comment, (IXMLDOMNode*)&This->IXMLDOMComment_iface, &domcomment_dispex);
 852
 853     return (IUnknown*)&This->IXMLDOMComment_iface;
 854 }
 855
 856 #endif