dlls/msxml3/pi.c

   1 /*
   2  *    DOM processing instruction 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 COBJMACROS
  22
  23 #include <stdarg.h>
  24 #include <libxml/parser.h>
  25 #include <libxml/xmlerror.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "msxml6.h"
  32
  33 #include "xmlparser.h"
  34 #include "msxml_private.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  39
  40 typedef struct _dom_pi
  41 {
  42     xmlnode node;
  43     IXMLDOMProcessingInstruction IXMLDOMProcessingInstruction_iface;
  44     LONG ref;
  45 } dom_pi;
  46
  47 static const struct nodemap_funcs dom_pi_attr_map;
  48
  49 static const tid_t dompi_se_tids[] = {
  50     IXMLDOMNode_tid,
  51     IXMLDOMProcessingInstruction_tid,
  52     NULL_tid
  53 };
  54
  55 static inline dom_pi *impl_from_IXMLDOMProcessingInstruction( IXMLDOMProcessingInstruction *iface )
  56 {
  57     return CONTAINING_RECORD(iface, dom_pi, IXMLDOMProcessingInstruction_iface);
  58 }
  59
  60 static HRESULT WINAPI dom_pi_QueryInterface(
  61     IXMLDOMProcessingInstruction *iface,
  62     REFIID riid,
  63     void** ppvObject )
  64 {
  65     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
  66     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  67
  68     if ( IsEqualGUID( riid, &IID_IXMLDOMProcessingInstruction ) ||
  69          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  70          IsEqualGUID( riid, &IID_IDispatch ) ||
  71          IsEqualGUID( riid, &IID_IUnknown ) )
  72     {
  73         *ppvObject = iface;
  74     }
  75     else if(node_query_interface(&This->node, riid, ppvObject))
  76     {
  77         return *ppvObject ? S_OK : E_NOINTERFACE;
  78     }
  79     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
  80     {
  81         return node_create_supporterrorinfo(dompi_se_tids, ppvObject);
  82     }
  83     else
  84     {
  85         TRACE("Unsupported interface %s\n", debugstr_guid(riid));
  86         *ppvObject = NULL;
  87         return E_NOINTERFACE;
  88     }
  89
  90     IUnknown_AddRef((IUnknown*)*ppvObject);
  91     return S_OK;
  92 }
  93
  94 static ULONG WINAPI dom_pi_AddRef(
  95     IXMLDOMProcessingInstruction *iface )
  96 {
  97     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
  98     ULONG ref = InterlockedIncrement( &This->ref );
  99     TRACE("%p, refcount %lu.\n", iface, ref);
 100     return ref;
 101 }
 102
 103 static ULONG WINAPI dom_pi_Release(
 104     IXMLDOMProcessingInstruction *iface )
 105 {
 106     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 107     ULONG ref = InterlockedDecrement( &This->ref );
 108
 109     TRACE("%p, refcount %lu.\n", iface, ref);
 110     if ( ref == 0 )
 111     {
 112         destroy_xmlnode(&This->node);
 113         heap_free( This );
 114     }
 115
 116     return ref;
 117 }
 118
 119 static HRESULT WINAPI dom_pi_GetTypeInfoCount(
 120     IXMLDOMProcessingInstruction *iface,
 121     UINT* pctinfo )
 122 {
 123     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 124     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 125 }
 126
 127 static HRESULT WINAPI dom_pi_GetTypeInfo(
 128     IXMLDOMProcessingInstruction *iface,
 129     UINT iTInfo, LCID lcid,
 130     ITypeInfo** ppTInfo )
 131 {
 132     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 133     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface,
 134         iTInfo, lcid, ppTInfo);
 135 }
 136
 137 static HRESULT WINAPI dom_pi_GetIDsOfNames(
 138     IXMLDOMProcessingInstruction *iface,
 139     REFIID riid, LPOLESTR* rgszNames,
 140     UINT cNames, LCID lcid, DISPID* rgDispId )
 141 {
 142     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 143     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
 144         riid, rgszNames, cNames, lcid, rgDispId);
 145 }
 146
 147 static HRESULT WINAPI dom_pi_Invoke(
 148     IXMLDOMProcessingInstruction *iface,
 149     DISPID dispIdMember, REFIID riid, LCID lcid,
 150     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 151     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 152 {
 153     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 154     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
 155         dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 156 }
 157
 158 static HRESULT WINAPI dom_pi_get_nodeName(
 159     IXMLDOMProcessingInstruction *iface,
 160     BSTR* p )
 161 {
 162     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 163
 164     TRACE("(%p)->(%p)\n", This, p);
 165
 166     return node_get_nodeName(&This->node, p);
 167 }
 168
 169 static HRESULT WINAPI dom_pi_get_nodeValue(
 170     IXMLDOMProcessingInstruction *iface,
 171     VARIANT* value)
 172 {
 173     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 174
 175     TRACE("(%p)->(%p)\n", This, value);
 176
 177     return node_get_content(&This->node, value);
 178 }
 179
 180 static HRESULT WINAPI dom_pi_put_nodeValue(
 181     IXMLDOMProcessingInstruction *iface,
 182     VARIANT value)
 183 {
 184     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 185     BSTR target;
 186     HRESULT hr;
 187
 188     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 189
 190     /* Cannot set data to a PI node whose target is 'xml' */
 191     hr = IXMLDOMProcessingInstruction_get_nodeName(iface, &target);
 192     if(hr == S_OK)
 193     {
 194         static const WCHAR xmlW[] = {'x','m','l',0};
 195         if(!wcscmp(target, xmlW))
 196         {
 197             SysFreeString(target);
 198             return E_FAIL;
 199         }
 200
 201         SysFreeString(target);
 202     }
 203
 204     return node_put_value(&This->node, &value);
 205 }
 206
 207 static HRESULT WINAPI dom_pi_get_nodeType(
 208     IXMLDOMProcessingInstruction *iface,
 209     DOMNodeType* domNodeType )
 210 {
 211     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 212
 213     TRACE("(%p)->(%p)\n", This, domNodeType);
 214
 215     *domNodeType = NODE_PROCESSING_INSTRUCTION;
 216     return S_OK;
 217 }
 218
 219 static HRESULT WINAPI dom_pi_get_parentNode(
 220     IXMLDOMProcessingInstruction *iface,
 221     IXMLDOMNode** parent )
 222 {
 223     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 224
 225     TRACE("(%p)->(%p)\n", This, parent);
 226
 227     return node_get_parent(&This->node, parent);
 228 }
 229
 230 static HRESULT WINAPI dom_pi_get_childNodes(
 231     IXMLDOMProcessingInstruction *iface,
 232     IXMLDOMNodeList** outList)
 233 {
 234     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 235
 236     TRACE("(%p)->(%p)\n", This, outList);
 237
 238     return node_get_child_nodes(&This->node, outList);
 239 }
 240
 241 static HRESULT WINAPI dom_pi_get_firstChild(
 242     IXMLDOMProcessingInstruction *iface,
 243     IXMLDOMNode** domNode)
 244 {
 245     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 246
 247     TRACE("(%p)->(%p)\n", This, domNode);
 248
 249     return return_null_node(domNode);
 250 }
 251
 252 static HRESULT WINAPI dom_pi_get_lastChild(
 253     IXMLDOMProcessingInstruction *iface,
 254     IXMLDOMNode** domNode)
 255 {
 256     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 257
 258     TRACE("(%p)->(%p)\n", This, domNode);
 259
 260     return return_null_node(domNode);
 261 }
 262
 263 static HRESULT WINAPI dom_pi_get_previousSibling(
 264     IXMLDOMProcessingInstruction *iface,
 265     IXMLDOMNode** domNode)
 266 {
 267     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 268
 269     TRACE("(%p)->(%p)\n", This, domNode);
 270
 271     return node_get_previous_sibling(&This->node, domNode);
 272 }
 273
 274 static HRESULT WINAPI dom_pi_get_nextSibling(
 275     IXMLDOMProcessingInstruction *iface,
 276     IXMLDOMNode** domNode)
 277 {
 278     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 279
 280     TRACE("(%p)->(%p)\n", This, domNode);
 281
 282     return node_get_next_sibling(&This->node, domNode);
 283 }
 284
 285 static HRESULT xml_get_value(xmlChar **p, xmlChar **value)
 286 {
 287     xmlChar *v, q;
 288     int len;
 289
 290     while (isspace(**p)) *p += 1;
 291     if (**p != '=') return XML_E_MISSINGEQUALS;
 292     *p += 1;
 293
 294     while (isspace(**p)) *p += 1;
 295     if (**p != '"' && **p != '\'') return XML_E_MISSINGQUOTE;
 296     q = **p;
 297     *p += 1;
 298
 299     v = *p;
 300     while (**p && **p != q) *p += 1;
 301     if (!**p) return XML_E_BADCHARINSTRING;
 302     len = *p - v;
 303     if (!len) return XML_E_MISSINGNAME;
 304     *p += 1;
 305
 306     *value = heap_alloc(len + 1);
 307     if (!*value) return E_OUTOFMEMORY;
 308     memcpy(*value, v, len);
 309     *(*value + len) = 0;
 310
 311     return S_OK;
 312 }
 313
 314 static void set_prop(xmlNodePtr node, xmlAttrPtr attr)
 315 {
 316     xmlAttrPtr prop;
 317
 318     if (!node->properties)
 319     {
 320         node->properties = attr;
 321         return;
 322     }
 323
 324     prop = node->properties;
 325     while (prop->next) prop = prop->next;
 326
 327     prop->next = attr;
 328 }
 329
 330 static HRESULT parse_xml_decl(xmlNodePtr node)
 331 {
 332     xmlChar *version, *encoding, *standalone, *p;
 333     xmlAttrPtr attr;
 334     HRESULT hr = S_OK;
 335
 336     if (!node->content) return S_OK;
 337
 338     version = encoding = standalone = NULL;
 339
 340     p = node->content;
 341
 342     while (*p)
 343     {
 344         while (isspace(*p)) p++;
 345         if (!*p) break;
 346
 347         if (!strncmp((const char *)p, "version", 7))
 348         {
 349             p += 7;
 350             if ((hr = xml_get_value(&p, &version)) != S_OK) goto fail;
 351         }
 352         else if (!strncmp((const char *)p, "encoding", 8))
 353         {
 354             p += 8;
 355             if ((hr = xml_get_value(&p, &encoding)) != S_OK) goto fail;
 356         }
 357         else if (!strncmp((const char *)p, "standalone", 10))
 358         {
 359             p += 10;
 360             if ((hr = xml_get_value(&p, &standalone)) != S_OK) goto fail;
 361         }
 362         else
 363         {
 364             FIXME("unexpected XML attribute %s\n", debugstr_a((const char *)p));
 365             hr = XML_E_UNEXPECTED_ATTRIBUTE;
 366             goto fail;
 367         }
 368     }
 369
 370     /* xmlSetProp/xmlSetNsProp accept only nodes of type XML_ELEMENT_NODE,
 371      * so we have to create and assign attributes to a node by hand.
 372      */
 373
 374     if (version)
 375     {
 376         attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"version", version);
 377         if (attr)
 378         {
 379             attr->doc = node->doc;
 380             set_prop(node, attr);
 381         }
 382         else hr = E_OUTOFMEMORY;
 383     }
 384     if (encoding)
 385     {
 386         attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"encoding", encoding);
 387         if (attr)
 388         {
 389             attr->doc = node->doc;
 390             set_prop(node, attr);
 391         }
 392         else hr = E_OUTOFMEMORY;
 393     }
 394     if (standalone)
 395     {
 396         attr = xmlSetNsProp(NULL, NULL, (const xmlChar *)"standalone", standalone);
 397         if (attr)
 398         {
 399             attr->doc = node->doc;
 400             set_prop(node, attr);
 401         }
 402         else hr = E_OUTOFMEMORY;
 403     }
 404
 405 fail:
 406     if (hr != S_OK)
 407     {
 408         xmlFreePropList(node->properties);
 409         node->properties = NULL;
 410     }
 411
 412     heap_free(version);
 413     heap_free(encoding);
 414     heap_free(standalone);
 415     return hr;
 416 }
 417
 418 static HRESULT WINAPI dom_pi_get_attributes(
 419     IXMLDOMProcessingInstruction *iface,
 420     IXMLDOMNamedNodeMap** map)
 421 {
 422     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 423     static const WCHAR xmlW[] = {'x','m','l',0};
 424     HRESULT hr;
 425     BSTR name;
 426
 427     TRACE("(%p)->(%p)\n", This, map);
 428
 429     if (!map) return E_INVALIDARG;
 430
 431     *map = NULL;
 432
 433     hr = node_get_nodeName(&This->node, &name);
 434     if (hr != S_OK) return hr;
 435
 436     if (!wcscmp(name, xmlW))
 437         *map = create_nodemap(This->node.node, &dom_pi_attr_map);
 438
 439     SysFreeString(name);
 440
 441     return *map ? S_OK : S_FALSE;
 442 }
 443
 444 static HRESULT WINAPI dom_pi_insertBefore(
 445     IXMLDOMProcessingInstruction *iface,
 446     IXMLDOMNode* newNode, VARIANT refChild,
 447     IXMLDOMNode** outOldNode)
 448 {
 449     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 450
 451     FIXME("(%p)->(%p %s %p) needs test\n", This, newNode, debugstr_variant(&refChild), outOldNode);
 452
 453     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
 454 }
 455
 456 static HRESULT WINAPI dom_pi_replaceChild(
 457     IXMLDOMProcessingInstruction *iface,
 458     IXMLDOMNode* newNode,
 459     IXMLDOMNode* oldNode,
 460     IXMLDOMNode** outOldNode)
 461 {
 462     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 463
 464     FIXME("(%p)->(%p %p %p) needs test\n", This, newNode, oldNode, outOldNode);
 465
 466     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
 467 }
 468
 469 static HRESULT WINAPI dom_pi_removeChild(
 470     IXMLDOMProcessingInstruction *iface,
 471     IXMLDOMNode *child, IXMLDOMNode **oldChild)
 472 {
 473     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 474     TRACE("(%p)->(%p %p)\n", This, child, oldChild);
 475     return node_remove_child(&This->node, child, oldChild);
 476 }
 477
 478 static HRESULT WINAPI dom_pi_appendChild(
 479     IXMLDOMProcessingInstruction *iface,
 480     IXMLDOMNode *child, IXMLDOMNode **outChild)
 481 {
 482     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 483     TRACE("(%p)->(%p %p)\n", This, child, outChild);
 484     return node_append_child(&This->node, child, outChild);
 485 }
 486
 487 static HRESULT WINAPI dom_pi_hasChildNodes(
 488     IXMLDOMProcessingInstruction *iface,
 489     VARIANT_BOOL *ret)
 490 {
 491     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 492     TRACE("(%p)->(%p)\n", This, ret);
 493     return node_has_childnodes(&This->node, ret);
 494 }
 495
 496 static HRESULT WINAPI dom_pi_get_ownerDocument(
 497     IXMLDOMProcessingInstruction *iface,
 498     IXMLDOMDocument **doc)
 499 {
 500     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 501     TRACE("(%p)->(%p)\n", This, doc);
 502     return node_get_owner_doc(&This->node, doc);
 503 }
 504
 505 static HRESULT WINAPI dom_pi_cloneNode(
 506     IXMLDOMProcessingInstruction *iface,
 507     VARIANT_BOOL deep, IXMLDOMNode** outNode)
 508 {
 509     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 510     TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 511     return node_clone( &This->node, deep, outNode );
 512 }
 513
 514 static HRESULT WINAPI dom_pi_get_nodeTypeString(
 515     IXMLDOMProcessingInstruction *iface,
 516     BSTR* p)
 517 {
 518     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 519     static const WCHAR processinginstructionW[] =
 520         {'p','r','o','c','e','s','s','i','n','g','i','n','s','t','r','u','c','t','i','o','n',0};
 521
 522     TRACE("(%p)->(%p)\n", This, p);
 523
 524     return return_bstr(processinginstructionW, p);
 525 }
 526
 527 static HRESULT WINAPI dom_pi_get_text(
 528     IXMLDOMProcessingInstruction *iface,
 529     BSTR* p)
 530 {
 531     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 532     TRACE("(%p)->(%p)\n", This, p);
 533     return node_get_text(&This->node, p);
 534 }
 535
 536 static HRESULT WINAPI dom_pi_put_text(
 537     IXMLDOMProcessingInstruction *iface,
 538     BSTR p)
 539 {
 540     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 541     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 542     return node_put_text( &This->node, p );
 543 }
 544
 545 static HRESULT WINAPI dom_pi_get_specified(
 546     IXMLDOMProcessingInstruction *iface,
 547     VARIANT_BOOL* isSpecified)
 548 {
 549     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 550     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 551     *isSpecified = VARIANT_TRUE;
 552     return S_OK;
 553 }
 554
 555 static HRESULT WINAPI dom_pi_get_definition(
 556     IXMLDOMProcessingInstruction *iface,
 557     IXMLDOMNode** definitionNode)
 558 {
 559     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 560     FIXME("(%p)->(%p)\n", This, definitionNode);
 561     return E_NOTIMPL;
 562 }
 563
 564 static HRESULT WINAPI dom_pi_get_nodeTypedValue(
 565     IXMLDOMProcessingInstruction *iface,
 566     VARIANT* v)
 567 {
 568     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 569     TRACE("(%p)->(%p)\n", This, v);
 570     return node_get_content(&This->node, v);
 571 }
 572
 573 static HRESULT WINAPI dom_pi_put_nodeTypedValue(
 574     IXMLDOMProcessingInstruction *iface,
 575     VARIANT typedValue)
 576 {
 577     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 578     FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI dom_pi_get_dataType(
 583     IXMLDOMProcessingInstruction *iface,
 584     VARIANT* typename)
 585 {
 586     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 587     TRACE("(%p)->(%p)\n", This, typename);
 588     return return_null_var( typename );
 589 }
 590
 591 static HRESULT WINAPI dom_pi_put_dataType(
 592     IXMLDOMProcessingInstruction *iface,
 593     BSTR p)
 594 {
 595     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 596
 597     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 598
 599     if(!p)
 600         return E_INVALIDARG;
 601
 602     return E_FAIL;
 603 }
 604
 605 static HRESULT WINAPI dom_pi_get_xml(
 606     IXMLDOMProcessingInstruction *iface,
 607     BSTR* p)
 608 {
 609     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 610
 611     TRACE("(%p)->(%p)\n", This, p);
 612
 613     return node_get_xml(&This->node, FALSE, p);
 614 }
 615
 616 static HRESULT WINAPI dom_pi_transformNode(
 617     IXMLDOMProcessingInstruction *iface,
 618     IXMLDOMNode *node, BSTR *p)
 619 {
 620     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 621     TRACE("(%p)->(%p %p)\n", This, node, p);
 622     return node_transform_node(&This->node, node, p);
 623 }
 624
 625 static HRESULT WINAPI dom_pi_selectNodes(
 626     IXMLDOMProcessingInstruction *iface,
 627     BSTR p, IXMLDOMNodeList** outList)
 628 {
 629     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 630     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
 631     return node_select_nodes(&This->node, p, outList);
 632 }
 633
 634 static HRESULT WINAPI dom_pi_selectSingleNode(
 635     IXMLDOMProcessingInstruction *iface,
 636     BSTR p, IXMLDOMNode** outNode)
 637 {
 638     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 639     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
 640     return node_select_singlenode(&This->node, p, outNode);
 641 }
 642
 643 static HRESULT WINAPI dom_pi_get_parsed(
 644     IXMLDOMProcessingInstruction *iface,
 645     VARIANT_BOOL* isParsed)
 646 {
 647     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 648     FIXME("(%p)->(%p) stub!\n", This, isParsed);
 649     *isParsed = VARIANT_TRUE;
 650     return S_OK;
 651 }
 652
 653 static HRESULT WINAPI dom_pi_get_namespaceURI(
 654     IXMLDOMProcessingInstruction *iface,
 655     BSTR* p)
 656 {
 657     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 658     TRACE("(%p)->(%p)\n", This, p);
 659     return node_get_namespaceURI(&This->node, p);
 660 }
 661
 662 static HRESULT WINAPI dom_pi_get_prefix(
 663     IXMLDOMProcessingInstruction *iface,
 664     BSTR* prefix)
 665 {
 666     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 667     TRACE("(%p)->(%p)\n", This, prefix);
 668     return return_null_bstr( prefix );
 669 }
 670
 671 static HRESULT WINAPI dom_pi_get_baseName(
 672     IXMLDOMProcessingInstruction *iface,
 673     BSTR* name)
 674 {
 675     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 676     TRACE("(%p)->(%p)\n", This, name);
 677     return node_get_base_name( &This->node, name );
 678 }
 679
 680 static HRESULT WINAPI dom_pi_transformNodeToObject(
 681     IXMLDOMProcessingInstruction *iface,
 682     IXMLDOMNode* domNode, VARIANT var1)
 683 {
 684     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 685     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI dom_pi_get_target(
 690     IXMLDOMProcessingInstruction *iface,
 691     BSTR *p)
 692 {
 693     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 694
 695     TRACE("(%p)->(%p)\n", This, p);
 696
 697     /* target returns the same value as nodeName property */
 698     return node_get_nodeName(&This->node, p);
 699 }
 700
 701 static HRESULT WINAPI dom_pi_get_data(
 702     IXMLDOMProcessingInstruction *iface,
 703     BSTR *p)
 704 {
 705     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 706     HRESULT hr;
 707     VARIANT ret;
 708
 709     TRACE("(%p)->(%p)\n", This, p);
 710
 711     if(!p)
 712         return E_INVALIDARG;
 713
 714     hr = IXMLDOMProcessingInstruction_get_nodeValue( iface, &ret );
 715     if(hr == S_OK)
 716     {
 717         *p = V_BSTR(&ret);
 718     }
 719
 720     return hr;
 721 }
 722
 723 static HRESULT WINAPI dom_pi_put_data(
 724     IXMLDOMProcessingInstruction *iface,
 725     BSTR data)
 726 {
 727     dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
 728     BSTR target;
 729     HRESULT hr;
 730
 731     TRACE("(%p)->(%s)\n", This, debugstr_w(data) );
 732
 733     /* cannot set data to a PI node whose target is 'xml' */
 734     hr = IXMLDOMProcessingInstruction_get_nodeName(iface, &target);
 735     if(hr == S_OK)
 736     {
 737         static const WCHAR xmlW[] = {'x','m','l',0};
 738         if(!wcscmp(target, xmlW))
 739         {
 740             SysFreeString(target);
 741             return E_FAIL;
 742         }
 743
 744         SysFreeString(target);
 745     }
 746
 747     return node_set_content(&This->node, data);
 748 }
 749
 750 HRESULT dom_pi_put_xml_decl(IXMLDOMNode *node, BSTR data)
 751 {
 752     static const WCHAR xmlW[] = {'x','m','l',0};
 753     xmlnode *node_obj;
 754     HRESULT hr;
 755     BSTR name;
 756
 757     if (!data)
 758         return XML_E_XMLDECLSYNTAX;
 759
 760     node_obj = get_node_obj(node);
 761     hr = node_set_content(node_obj, data);
 762     if (FAILED(hr))
 763         return hr;
 764
 765     hr = node_get_nodeName(node_obj, &name);
 766     if (FAILED(hr))
 767         return hr;
 768
 769     if (!lstrcmpW(name, xmlW) && !node_obj->node->properties)
 770         hr = parse_xml_decl(node_obj->node);
 771     else
 772         hr = S_OK;
 773
 774     SysFreeString(name);
 775     return hr;
 776 }
 777
 778 static const struct IXMLDOMProcessingInstructionVtbl dom_pi_vtbl =
 779 {
 780     dom_pi_QueryInterface,
 781     dom_pi_AddRef,
 782     dom_pi_Release,
 783     dom_pi_GetTypeInfoCount,
 784     dom_pi_GetTypeInfo,
 785     dom_pi_GetIDsOfNames,
 786     dom_pi_Invoke,
 787     dom_pi_get_nodeName,
 788     dom_pi_get_nodeValue,
 789     dom_pi_put_nodeValue,
 790     dom_pi_get_nodeType,
 791     dom_pi_get_parentNode,
 792     dom_pi_get_childNodes,
 793     dom_pi_get_firstChild,
 794     dom_pi_get_lastChild,
 795     dom_pi_get_previousSibling,
 796     dom_pi_get_nextSibling,
 797     dom_pi_get_attributes,
 798     dom_pi_insertBefore,
 799     dom_pi_replaceChild,
 800     dom_pi_removeChild,
 801     dom_pi_appendChild,
 802     dom_pi_hasChildNodes,
 803     dom_pi_get_ownerDocument,
 804     dom_pi_cloneNode,
 805     dom_pi_get_nodeTypeString,
 806     dom_pi_get_text,
 807     dom_pi_put_text,
 808     dom_pi_get_specified,
 809     dom_pi_get_definition,
 810     dom_pi_get_nodeTypedValue,
 811     dom_pi_put_nodeTypedValue,
 812     dom_pi_get_dataType,
 813     dom_pi_put_dataType,
 814     dom_pi_get_xml,
 815     dom_pi_transformNode,
 816     dom_pi_selectNodes,
 817     dom_pi_selectSingleNode,
 818     dom_pi_get_parsed,
 819     dom_pi_get_namespaceURI,
 820     dom_pi_get_prefix,
 821     dom_pi_get_baseName,
 822     dom_pi_transformNodeToObject,
 823
 824     dom_pi_get_target,
 825     dom_pi_get_data,
 826     dom_pi_put_data
 827 };
 828
 829 static xmlAttrPtr node_has_prop(const xmlNode *node, const xmlChar *name)
 830 {
 831     xmlAttrPtr prop;
 832
 833     /* xmlHasNsProp accepts only nodes of type XML_ELEMENT_NODE,
 834      * so we have to look for an attribute in the node by hand.
 835      */
 836
 837     prop = node->properties;
 838
 839     while (prop)
 840     {
 841         if (xmlStrEqual(prop->name, name))
 842             return prop;
 843
 844         prop = prop->next;
 845     }
 846
 847     return NULL;
 848 }
 849
 850 static HRESULT dom_pi_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR uri,
 851     IXMLDOMNode **item)
 852 {
 853     FIXME("(%p)->(%s %s %p): stub\n", node, debugstr_w(name), debugstr_w(uri), item);
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT dom_pi_get_named_item(const xmlNodePtr node, BSTR name, IXMLDOMNode **item)
 858 {
 859     xmlChar *nameA;
 860     xmlAttrPtr attr;
 861
 862     TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item);
 863
 864     if (!item) return E_POINTER;
 865
 866     nameA = xmlchar_from_wchar(name);
 867     if (!nameA) return E_OUTOFMEMORY;
 868
 869     attr = node_has_prop(node, nameA);
 870     heap_free(nameA);
 871
 872     if (!attr)
 873     {
 874         *item = NULL;
 875         return S_FALSE;
 876     }
 877
 878     *item = create_node((xmlNodePtr)attr);
 879
 880     return S_OK;
 881 }
 882
 883 static HRESULT dom_pi_set_named_item(xmlNodePtr node, IXMLDOMNode *newItem, IXMLDOMNode **namedItem)
 884 {
 885     FIXME("(%p)->(%p %p): stub\n", node, newItem, namedItem );
 886     return E_NOTIMPL;
 887 }
 888
 889 static HRESULT dom_pi_remove_qualified_item(xmlNodePtr node, BSTR name, BSTR uri, IXMLDOMNode **item)
 890 {
 891     FIXME("(%p)->(%s %s %p): stub\n", node, debugstr_w(name), debugstr_w(uri), item);
 892     return E_NOTIMPL;
 893 }
 894
 895 static HRESULT dom_pi_remove_named_item(xmlNodePtr node, BSTR name, IXMLDOMNode **item)
 896 {
 897     FIXME("(%p)->(%s %p): stub\n", node, debugstr_w(name), item);
 898     return E_NOTIMPL;
 899 }
 900
 901 static HRESULT dom_pi_get_item(const xmlNodePtr node, LONG index, IXMLDOMNode **item)
 902 {
 903     FIXME("%p, %ld, %p: stub\n", node, index, item);
 904     return E_NOTIMPL;
 905 }
 906
 907 static HRESULT dom_pi_get_length(const xmlNodePtr node, LONG *length)
 908 {
 909     FIXME("(%p)->(%p): stub\n", node, length);
 910
 911     *length = 0;
 912     return S_OK;
 913 }
 914
 915 static HRESULT dom_pi_next_node(const xmlNodePtr node, LONG *iter, IXMLDOMNode **nextNode)
 916 {
 917     FIXME("%p, %ld, %p: stub\n", node, *iter, nextNode);
 918     return E_NOTIMPL;
 919 }
 920
 921 static const struct nodemap_funcs dom_pi_attr_map = {
 922     dom_pi_get_named_item,
 923     dom_pi_set_named_item,
 924     dom_pi_remove_named_item,
 925     dom_pi_get_item,
 926     dom_pi_get_length,
 927     dom_pi_get_qualified_item,
 928     dom_pi_remove_qualified_item,
 929     dom_pi_next_node
 930 };
 931
 932 static const tid_t dompi_iface_tids[] = {
 933     IXMLDOMProcessingInstruction_tid,
 934     0
 935 };
 936
 937 static dispex_static_data_t dompi_dispex = {
 938     NULL,
 939     IXMLDOMProcessingInstruction_tid,
 940     NULL,
 941     dompi_iface_tids
 942 };
 943
 944 IUnknown* create_pi( xmlNodePtr pi )
 945 {
 946     dom_pi *This;
 947
 948     This = heap_alloc( sizeof *This );
 949     if ( !This )
 950         return NULL;
 951
 952     This->IXMLDOMProcessingInstruction_iface.lpVtbl = &dom_pi_vtbl;
 953     This->ref = 1;
 954
 955     init_xmlnode(&This->node, pi, (IXMLDOMNode*)&This->IXMLDOMProcessingInstruction_iface, &dompi_dispex);
 956
 957     return (IUnknown*)&This->IXMLDOMProcessingInstruction_iface;
 958 }