dlls/msxml3/element.c

   1 /*
   2  *    DOM Document implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   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 "config.h"
  24
  25 #include <stdarg.h>
  26 #ifdef HAVE_LIBXML2
  27 # include <libxml/parser.h>
  28 # include <libxml/xmlerror.h>
  29 #endif
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winuser.h"
  34 #include "winnls.h"
  35 #include "ole2.h"
  36 #include "msxml6.h"
  37
  38 #include "msxml_private.h"
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 static const xmlChar DT_prefix[] = "dt";
  47 static const xmlChar DT_nsURI[] = "urn:schemas-microsoft-com:datatypes";
  48
  49 typedef struct _domelem
  50 {
  51     xmlnode node;
  52     IXMLDOMElement IXMLDOMElement_iface;
  53     LONG ref;
  54 } domelem;
  55
  56 static inline domelem *impl_from_IXMLDOMElement( IXMLDOMElement *iface )
  57 {
  58     return CONTAINING_RECORD(iface, domelem, IXMLDOMElement_iface);
  59 }
  60
  61 static inline xmlNodePtr get_element( const domelem *This )
  62 {
  63     return This->node.node;
  64 }
  65
  66 static HRESULT WINAPI domelem_QueryInterface(
  67     IXMLDOMElement *iface,
  68     REFIID riid,
  69     void** ppvObject )
  70 {
  71     domelem *This = impl_from_IXMLDOMElement( iface );
  72
  73     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  74
  75     if ( IsEqualGUID( riid, &IID_IXMLDOMElement ) ||
  76          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  77          IsEqualGUID( riid, &IID_IDispatch ) ||
  78          IsEqualGUID( riid, &IID_IUnknown ) )
  79     {
  80         *ppvObject = &This->IXMLDOMElement_iface;
  81     }
  82     else if(node_query_interface(&This->node, riid, ppvObject))
  83     {
  84         return *ppvObject ? S_OK : E_NOINTERFACE;
  85     }
  86     else
  87     {
  88         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  89         *ppvObject = NULL;
  90         return E_NOINTERFACE;
  91     }
  92
  93     IUnknown_AddRef( (IUnknown*)*ppvObject );
  94     return S_OK;
  95 }
  96
  97 static ULONG WINAPI domelem_AddRef(
  98     IXMLDOMElement *iface )
  99 {
 100     domelem *This = impl_from_IXMLDOMElement( iface );
 101     LONG ref = InterlockedIncrement(&This->ref);
 102
 103     TRACE("(%p)->(%d)\n", This, ref);
 104
 105     return ref;
 106 }
 107
 108 static ULONG WINAPI domelem_Release(
 109     IXMLDOMElement *iface )
 110 {
 111     domelem *This = impl_from_IXMLDOMElement( iface );
 112     ULONG ref = InterlockedDecrement(&This->ref);
 113
 114     TRACE("(%p)->(%d)\n", This, ref);
 115
 116     if(!ref) {
 117         destroy_xmlnode(&This->node);
 118         heap_free(This);
 119     }
 120
 121     return ref;
 122 }
 123
 124 static HRESULT WINAPI domelem_GetTypeInfoCount(
 125     IXMLDOMElement *iface,
 126     UINT* pctinfo )
 127 {
 128     domelem *This = impl_from_IXMLDOMElement( iface );
 129
 130     TRACE("(%p)->(%p)\n", This, pctinfo);
 131
 132     *pctinfo = 1;
 133
 134     return S_OK;
 135 }
 136
 137 static HRESULT WINAPI domelem_GetTypeInfo(
 138     IXMLDOMElement *iface,
 139     UINT iTInfo, LCID lcid,
 140     ITypeInfo** ppTInfo )
 141 {
 142     domelem *This = impl_from_IXMLDOMElement( iface );
 143     HRESULT hr;
 144
 145     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 146
 147     hr = get_typeinfo(IXMLDOMElement_tid, ppTInfo);
 148
 149     return hr;
 150 }
 151
 152 static HRESULT WINAPI domelem_GetIDsOfNames(
 153     IXMLDOMElement *iface,
 154     REFIID riid, LPOLESTR* rgszNames,
 155     UINT cNames, LCID lcid, DISPID* rgDispId )
 156 {
 157     domelem *This = impl_from_IXMLDOMElement( iface );
 158     ITypeInfo *typeinfo;
 159     HRESULT hr;
 160
 161     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 162           lcid, rgDispId);
 163
 164     if(!rgszNames || cNames == 0 || !rgDispId)
 165         return E_INVALIDARG;
 166
 167     hr = get_typeinfo(IXMLDOMElement_tid, &typeinfo);
 168     if(SUCCEEDED(hr))
 169     {
 170         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 171         ITypeInfo_Release(typeinfo);
 172     }
 173
 174     return hr;
 175 }
 176
 177 static HRESULT WINAPI domelem_Invoke(
 178     IXMLDOMElement *iface,
 179     DISPID dispIdMember, REFIID riid, LCID lcid,
 180     WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
 181     EXCEPINFO* pExcepInfo, UINT* puArgErr )
 182 {
 183     domelem *This = impl_from_IXMLDOMElement( iface );
 184     ITypeInfo *typeinfo;
 185     HRESULT hr;
 186
 187     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 188           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 189
 190     hr = get_typeinfo(IXMLDOMElement_tid, &typeinfo);
 191     if(SUCCEEDED(hr))
 192     {
 193         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLDOMElement_iface, dispIdMember, wFlags,
 194                 pDispParams, pVarResult, pExcepInfo, puArgErr);
 195         ITypeInfo_Release(typeinfo);
 196     }
 197
 198     return hr;
 199 }
 200
 201 static HRESULT WINAPI domelem_get_nodeName(
 202     IXMLDOMElement *iface,
 203     BSTR* p )
 204 {
 205     domelem *This = impl_from_IXMLDOMElement( iface );
 206
 207     TRACE("(%p)->(%p)\n", This, p);
 208
 209     return node_get_nodeName(&This->node, p);
 210 }
 211
 212 static HRESULT WINAPI domelem_get_nodeValue(
 213     IXMLDOMElement *iface,
 214     VARIANT* value)
 215 {
 216     domelem *This = impl_from_IXMLDOMElement( iface );
 217
 218     TRACE("(%p)->(%p)\n", This, value);
 219
 220     if(!value)
 221         return E_INVALIDARG;
 222
 223     V_VT(value) = VT_NULL;
 224     V_BSTR(value) = NULL; /* tests show that we should do this */
 225     return S_FALSE;
 226 }
 227
 228 static HRESULT WINAPI domelem_put_nodeValue(
 229     IXMLDOMElement *iface,
 230     VARIANT value)
 231 {
 232     domelem *This = impl_from_IXMLDOMElement( iface );
 233     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 234     return E_FAIL;
 235 }
 236
 237 static HRESULT WINAPI domelem_get_nodeType(
 238     IXMLDOMElement *iface,
 239     DOMNodeType* domNodeType )
 240 {
 241     domelem *This = impl_from_IXMLDOMElement( iface );
 242
 243     TRACE("(%p)->(%p)\n", This, domNodeType);
 244
 245     *domNodeType = NODE_ELEMENT;
 246     return S_OK;
 247 }
 248
 249 static HRESULT WINAPI domelem_get_parentNode(
 250     IXMLDOMElement *iface,
 251     IXMLDOMNode** parent )
 252 {
 253     domelem *This = impl_from_IXMLDOMElement( iface );
 254
 255     TRACE("(%p)->(%p)\n", This, parent);
 256
 257     return node_get_parent(&This->node, parent);
 258 }
 259
 260 static HRESULT WINAPI domelem_get_childNodes(
 261     IXMLDOMElement *iface,
 262     IXMLDOMNodeList** outList)
 263 {
 264     domelem *This = impl_from_IXMLDOMElement( iface );
 265
 266     TRACE("(%p)->(%p)\n", This, outList);
 267
 268     return node_get_child_nodes(&This->node, outList);
 269 }
 270
 271 static HRESULT WINAPI domelem_get_firstChild(
 272     IXMLDOMElement *iface,
 273     IXMLDOMNode** domNode)
 274 {
 275     domelem *This = impl_from_IXMLDOMElement( iface );
 276
 277     TRACE("(%p)->(%p)\n", This, domNode);
 278
 279     return node_get_first_child(&This->node, domNode);
 280 }
 281
 282 static HRESULT WINAPI domelem_get_lastChild(
 283     IXMLDOMElement *iface,
 284     IXMLDOMNode** domNode)
 285 {
 286     domelem *This = impl_from_IXMLDOMElement( iface );
 287
 288     TRACE("(%p)->(%p)\n", This, domNode);
 289
 290     return node_get_last_child(&This->node, domNode);
 291 }
 292
 293 static HRESULT WINAPI domelem_get_previousSibling(
 294     IXMLDOMElement *iface,
 295     IXMLDOMNode** domNode)
 296 {
 297     domelem *This = impl_from_IXMLDOMElement( iface );
 298
 299     TRACE("(%p)->(%p)\n", This, domNode);
 300
 301     return node_get_previous_sibling(&This->node, domNode);
 302 }
 303
 304 static HRESULT WINAPI domelem_get_nextSibling(
 305     IXMLDOMElement *iface,
 306     IXMLDOMNode** domNode)
 307 {
 308     domelem *This = impl_from_IXMLDOMElement( iface );
 309
 310     TRACE("(%p)->(%p)\n", This, domNode);
 311
 312     return node_get_next_sibling(&This->node, domNode);
 313 }
 314
 315 static HRESULT WINAPI domelem_get_attributes(
 316     IXMLDOMElement *iface,
 317     IXMLDOMNamedNodeMap** map)
 318 {
 319     domelem *This = impl_from_IXMLDOMElement( iface );
 320
 321     TRACE("(%p)->(%p)\n", This, map);
 322
 323     *map = create_nodemap(This->node.node);
 324     return S_OK;
 325 }
 326
 327 static HRESULT WINAPI domelem_insertBefore(
 328     IXMLDOMElement *iface,
 329     IXMLDOMNode* newNode, VARIANT refChild,
 330     IXMLDOMNode** outOldNode)
 331 {
 332     domelem *This = impl_from_IXMLDOMElement( iface );
 333
 334     TRACE("(%p)->(%p %s %p)\n", This, newNode, debugstr_variant(&refChild), outOldNode);
 335
 336     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
 337 }
 338
 339 static HRESULT WINAPI domelem_replaceChild(
 340     IXMLDOMElement *iface,
 341     IXMLDOMNode* newNode,
 342     IXMLDOMNode* oldNode,
 343     IXMLDOMNode** outOldNode)
 344 {
 345     domelem *This = impl_from_IXMLDOMElement( iface );
 346
 347     TRACE("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
 348
 349     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
 350 }
 351
 352 static HRESULT WINAPI domelem_removeChild(
 353     IXMLDOMElement *iface,
 354     IXMLDOMNode *child, IXMLDOMNode **oldChild)
 355 {
 356     domelem *This = impl_from_IXMLDOMElement( iface );
 357     TRACE("(%p)->(%p %p)\n", This, child, oldChild);
 358     return node_remove_child(&This->node, child, oldChild);
 359 }
 360
 361 static HRESULT WINAPI domelem_appendChild(
 362     IXMLDOMElement *iface,
 363     IXMLDOMNode *child, IXMLDOMNode **outChild)
 364 {
 365     domelem *This = impl_from_IXMLDOMElement( iface );
 366     TRACE("(%p)->(%p %p)\n", This, child, outChild);
 367     return node_append_child(&This->node, child, outChild);
 368 }
 369
 370 static HRESULT WINAPI domelem_hasChildNodes(
 371     IXMLDOMElement *iface,
 372     VARIANT_BOOL *ret)
 373 {
 374     domelem *This = impl_from_IXMLDOMElement( iface );
 375     TRACE("(%p)->(%p)\n", This, ret);
 376     return node_has_childnodes(&This->node, ret);
 377 }
 378
 379 static HRESULT WINAPI domelem_get_ownerDocument(
 380     IXMLDOMElement   *iface,
 381     IXMLDOMDocument **doc)
 382 {
 383     domelem *This = impl_from_IXMLDOMElement( iface );
 384     TRACE("(%p)->(%p)\n", This, doc);
 385     return node_get_owner_doc(&This->node, doc);
 386 }
 387
 388 static HRESULT WINAPI domelem_cloneNode(
 389     IXMLDOMElement *iface,
 390     VARIANT_BOOL deep, IXMLDOMNode** outNode)
 391 {
 392     domelem *This = impl_from_IXMLDOMElement( iface );
 393     TRACE("(%p)->(%d %p)\n", This, deep, outNode);
 394     return node_clone( &This->node, deep, outNode );
 395 }
 396
 397 static HRESULT WINAPI domelem_get_nodeTypeString(
 398     IXMLDOMElement *iface,
 399     BSTR* p)
 400 {
 401     domelem *This = impl_from_IXMLDOMElement( iface );
 402     static const WCHAR elementW[] = {'e','l','e','m','e','n','t',0};
 403
 404     TRACE("(%p)->(%p)\n", This, p);
 405
 406     return return_bstr(elementW, p);
 407 }
 408
 409 static HRESULT WINAPI domelem_get_text(
 410     IXMLDOMElement *iface,
 411     BSTR* p)
 412 {
 413     domelem *This = impl_from_IXMLDOMElement( iface );
 414     TRACE("(%p)->(%p)\n", This, p);
 415     return node_get_text(&This->node, p);
 416 }
 417
 418 static HRESULT WINAPI domelem_put_text(
 419     IXMLDOMElement *iface,
 420     BSTR p)
 421 {
 422     domelem *This = impl_from_IXMLDOMElement( iface );
 423     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
 424     return node_put_text( &This->node, p );
 425 }
 426
 427 static HRESULT WINAPI domelem_get_specified(
 428     IXMLDOMElement *iface,
 429     VARIANT_BOOL* isSpecified)
 430 {
 431     domelem *This = impl_from_IXMLDOMElement( iface );
 432     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 433     *isSpecified = VARIANT_TRUE;
 434     return S_OK;
 435 }
 436
 437 static HRESULT WINAPI domelem_get_definition(
 438     IXMLDOMElement *iface,
 439     IXMLDOMNode** definitionNode)
 440 {
 441     domelem *This = impl_from_IXMLDOMElement( iface );
 442     FIXME("(%p)->(%p)\n", This, definitionNode);
 443     return E_NOTIMPL;
 444 }
 445
 446 static inline BYTE hex_to_byte(xmlChar c)
 447 {
 448     if(c <= '9') return c-'0';
 449     if(c <= 'F') return c-'A'+10;
 450     return c-'a'+10;
 451 }
 452
 453 static inline BYTE base64_to_byte(xmlChar c)
 454 {
 455     if(c == '+') return 62;
 456     if(c == '/') return 63;
 457     if(c <= '9') return c-'0'+52;
 458     if(c <= 'Z') return c-'A';
 459     return c-'a'+26;
 460 }
 461
 462 static inline HRESULT VARIANT_from_DT(XDR_DT dt, xmlChar* str, VARIANT* v)
 463 {
 464     VARIANT src;
 465     HRESULT hr = S_OK;
 466     BOOL handled = FALSE;
 467
 468     VariantInit(&src);
 469
 470     switch (dt)
 471     {
 472     case DT_INVALID:
 473     case DT_STRING:
 474     case DT_NMTOKEN:
 475     case DT_NMTOKENS:
 476     case DT_NUMBER:
 477     case DT_URI:
 478     case DT_UUID:
 479         {
 480             V_VT(v) = VT_BSTR;
 481             V_BSTR(v) = bstr_from_xmlChar(str);
 482
 483             if(!V_BSTR(v))
 484                 return E_OUTOFMEMORY;
 485             handled = TRUE;
 486         }
 487         break;
 488     case DT_DATE:
 489     case DT_DATE_TZ:
 490     case DT_DATETIME:
 491     case DT_DATETIME_TZ:
 492     case DT_TIME:
 493     case DT_TIME_TZ:
 494         {
 495             WCHAR *p, *e;
 496             SYSTEMTIME st;
 497             DOUBLE date = 0.0;
 498
 499             st.wYear = 1899;
 500             st.wMonth = 12;
 501             st.wDay = 30;
 502             st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 503
 504             V_VT(&src) = VT_BSTR;
 505             V_BSTR(&src) = bstr_from_xmlChar(str);
 506
 507             if(!V_BSTR(&src))
 508                 return E_OUTOFMEMORY;
 509
 510             p = V_BSTR(&src);
 511             e = p + SysStringLen(V_BSTR(&src));
 512
 513             if(p+4<e && *(p+4)=='-') /* parse date (yyyy-mm-dd) */
 514             {
 515                 st.wYear = atoiW(p);
 516                 st.wMonth = atoiW(p+5);
 517                 st.wDay = atoiW(p+8);
 518                 p += 10;
 519
 520                 if(*p == 'T') p++;
 521             }
 522
 523             if(p+2<e && *(p+2)==':') /* parse time (hh:mm:ss.?) */
 524             {
 525                 st.wHour = atoiW(p);
 526                 st.wMinute = atoiW(p+3);
 527                 st.wSecond = atoiW(p+6);
 528                 p += 8;
 529
 530                 if(*p == '.')
 531                 {
 532                     p++;
 533                     while(isdigitW(*p)) p++;
 534                 }
 535             }
 536
 537             SystemTimeToVariantTime(&st, &date);
 538             V_VT(v) = VT_DATE;
 539             V_DATE(v) = date;
 540
 541             if(*p == '+') /* parse timezone offset (+hh:mm) */
 542                 V_DATE(v) += (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 543             else if(*p == '-') /* parse timezone offset (-hh:mm) */
 544                 V_DATE(v) -= (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 545
 546             VariantClear(&src);
 547             handled = TRUE;
 548         }
 549         break;
 550     case DT_BIN_HEX:
 551         {
 552             SAFEARRAYBOUND sab;
 553             int i, len;
 554
 555             len = xmlStrlen(str)/2;
 556             sab.lLbound = 0;
 557             sab.cElements = len;
 558
 559             V_VT(v) = (VT_ARRAY|VT_UI1);
 560             V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 561
 562             if(!V_ARRAY(v))
 563                 return E_OUTOFMEMORY;
 564
 565             for(i=0; i<len; i++)
 566                 ((BYTE*)V_ARRAY(v)->pvData)[i] = (hex_to_byte(str[2*i])<<4)
 567                     + hex_to_byte(str[2*i+1]);
 568             handled = TRUE;
 569         }
 570         break;
 571     case DT_BIN_BASE64:
 572         {
 573             SAFEARRAYBOUND sab;
 574             int i, len;
 575
 576             len  = xmlStrlen(str);
 577             if(str[len-2] == '=') i = 2;
 578             else if(str[len-1] == '=') i = 1;
 579             else i = 0;
 580
 581             sab.lLbound = 0;
 582             sab.cElements = len/4*3-i;
 583
 584             V_VT(v) = (VT_ARRAY|VT_UI1);
 585             V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 586
 587             if(!V_ARRAY(v))
 588                 return E_OUTOFMEMORY;
 589
 590             for(i=0; i<len/4; i++)
 591             {
 592                 ((BYTE*)V_ARRAY(v)->pvData)[3*i] = (base64_to_byte(str[4*i])<<2)
 593                     + (base64_to_byte(str[4*i+1])>>4);
 594                 if(3*i+1 < sab.cElements)
 595                     ((BYTE*)V_ARRAY(v)->pvData)[3*i+1] = (base64_to_byte(str[4*i+1])<<4)
 596                         + (base64_to_byte(str[4*i+2])>>2);
 597                 if(3*i+2 < sab.cElements)
 598                     ((BYTE*)V_ARRAY(v)->pvData)[3*i+2] = (base64_to_byte(str[4*i+2])<<6)
 599                         + base64_to_byte(str[4*i+3]);
 600             }
 601             handled = TRUE;
 602         }
 603         break;
 604     case DT_BOOLEAN:
 605         V_VT(v) = VT_BOOL;
 606         break;
 607     case DT_FIXED_14_4:
 608         V_VT(v) = VT_CY;
 609         break;
 610     case DT_I1:
 611         V_VT(v) = VT_I1;
 612         break;
 613     case DT_I2:
 614         V_VT(v) = VT_I2;
 615         break;
 616     case DT_I4:
 617     case DT_INT:
 618         V_VT(v) = VT_I4;
 619         break;
 620     case DT_I8:
 621         V_VT(v) = VT_I8;
 622         break;
 623     case DT_R4:
 624         V_VT(v) = VT_R4;
 625         break;
 626     case DT_FLOAT:
 627     case DT_R8:
 628         V_VT(v) = VT_R8;
 629         break;
 630     case DT_UI1:
 631         V_VT(v) = VT_UI1;
 632         break;
 633     case DT_UI2:
 634         V_VT(v) = VT_UI2;
 635         break;
 636     case DT_UI4:
 637         V_VT(v) = VT_UI4;
 638         break;
 639     case DT_UI8:
 640         V_VT(v) = VT_UI8;
 641         break;
 642     case DT_CHAR:
 643     case DT_ENTITY:
 644     case DT_ENTITIES:
 645     case DT_ENUMERATION:
 646     case DT_ID:
 647     case DT_IDREF:
 648     case DT_IDREFS:
 649     case DT_NOTATION:
 650         FIXME("need to handle dt:%s\n", dt_to_str(dt));
 651         V_VT(v) = VT_BSTR;
 652         V_BSTR(v) = bstr_from_xmlChar(str);
 653         if (!V_BSTR(v))
 654             return E_OUTOFMEMORY;
 655         handled = TRUE;
 656         break;
 657     }
 658
 659     if (!handled)
 660     {
 661         V_VT(&src) = VT_BSTR;
 662         V_BSTR(&src) = bstr_from_xmlChar(str);
 663
 664         if(!V_BSTR(&src))
 665             return E_OUTOFMEMORY;
 666
 667         hr = VariantChangeTypeEx(v, &src,
 668                 MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),0, V_VT(v));
 669         VariantClear(&src);
 670     }
 671     return hr;
 672 }
 673
 674 static HRESULT WINAPI domelem_get_nodeTypedValue(
 675     IXMLDOMElement *iface,
 676     VARIANT* var1)
 677 {
 678     domelem *This = impl_from_IXMLDOMElement( iface );
 679     XDR_DT dt;
 680     xmlChar* content;
 681     HRESULT hr;
 682
 683     TRACE("(%p)->(%p)\n", This, var1);
 684
 685     if(!var1)
 686         return E_INVALIDARG;
 687
 688     V_VT(var1) = VT_NULL;
 689
 690     dt = element_get_dt(get_element(This));
 691     content = xmlNodeGetContent(get_element(This));
 692     hr = VARIANT_from_DT(dt, content, var1);
 693     xmlFree(content);
 694
 695     return hr;
 696 }
 697
 698 static HRESULT WINAPI domelem_put_nodeTypedValue(
 699     IXMLDOMElement *iface,
 700     VARIANT value)
 701 {
 702     domelem *This = impl_from_IXMLDOMElement( iface );
 703     VARIANT type;
 704     HRESULT hr;
 705
 706     TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
 707
 708     /* for untyped node coerce to BSTR and set */
 709     if (IXMLDOMElement_get_dataType(iface, &type) == S_FALSE)
 710     {
 711         if (V_VT(&value) != VT_BSTR)
 712         {
 713             hr = VariantChangeType(&value, &value, 0, VT_BSTR);
 714             if (hr == S_OK)
 715             {
 716                 hr = node_set_content(&This->node, V_BSTR(&value));
 717                 VariantClear(&value);
 718             }
 719         }
 720         else
 721             hr = node_set_content(&This->node, V_BSTR(&value));
 722     }
 723     else
 724     {
 725         FIXME("not implemented for typed nodes. type %s\n", debugstr_w(V_BSTR(&value)));
 726         VariantClear(&type);
 727         return E_NOTIMPL;
 728     }
 729
 730     return hr;
 731 }
 732
 733 XDR_DT element_get_dt(xmlNodePtr node)
 734 {
 735     XDR_DT dt = DT_INVALID;
 736
 737     TRACE("(%p)\n", node);
 738     if(node->type != XML_ELEMENT_NODE)
 739     {
 740         FIXME("invalid element node\n");
 741         return dt;
 742     }
 743
 744     if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI))
 745     {
 746         dt = str_to_dt(node->name, -1);
 747     }
 748     else
 749     {
 750         xmlChar* pVal = xmlGetNsProp(node, BAD_CAST "dt", DT_nsURI);
 751         if (pVal)
 752         {
 753             dt = str_to_dt(pVal, -1);
 754             xmlFree(pVal);
 755         }
 756         else if (node->doc)
 757         {
 758             IXMLDOMDocument3* doc = (IXMLDOMDocument3*)create_domdoc((xmlNodePtr)node->doc);
 759             if (doc)
 760             {
 761                 VARIANT v;
 762                 VariantInit(&v);
 763
 764                 if (IXMLDOMDocument3_get_schemas(doc, &v) == S_OK &&
 765                     V_VT(&v) == VT_DISPATCH)
 766                 {
 767                     dt = SchemaCache_get_node_dt((IXMLDOMSchemaCollection2*)V_DISPATCH(&v), node);
 768                 }
 769                 VariantClear(&v);
 770                 IXMLDOMDocument3_Release(doc);
 771             }
 772         }
 773     }
 774
 775     TRACE("=> dt:%s\n", dt_to_str(dt));
 776     return dt;
 777 }
 778
 779 static HRESULT WINAPI domelem_get_dataType(
 780     IXMLDOMElement *iface,
 781     VARIANT* typename)
 782 {
 783     domelem *This = impl_from_IXMLDOMElement( iface );
 784     XDR_DT dt;
 785
 786     TRACE("(%p)->(%p)\n", This, typename);
 787
 788     if (!typename)
 789         return E_INVALIDARG;
 790
 791     dt = element_get_dt(get_element(This));
 792     switch (dt)
 793     {
 794         case DT_BIN_BASE64:
 795         case DT_BIN_HEX:
 796         case DT_BOOLEAN:
 797         case DT_CHAR:
 798         case DT_DATE:
 799         case DT_DATE_TZ:
 800         case DT_DATETIME:
 801         case DT_DATETIME_TZ:
 802         case DT_FIXED_14_4:
 803         case DT_FLOAT:
 804         case DT_I1:
 805         case DT_I2:
 806         case DT_I4:
 807         case DT_I8:
 808         case DT_INT:
 809         case DT_NUMBER:
 810         case DT_R4:
 811         case DT_R8:
 812         case DT_TIME:
 813         case DT_TIME_TZ:
 814         case DT_UI1:
 815         case DT_UI2:
 816         case DT_UI4:
 817         case DT_UI8:
 818         case DT_URI:
 819         case DT_UUID:
 820             V_VT(typename) = VT_BSTR;
 821             V_BSTR(typename) = SysAllocString(dt_to_bstr(dt));
 822
 823             if (!V_BSTR(typename))
 824                 return E_OUTOFMEMORY;
 825             break;
 826         default:
 827             /* Other types (DTD equivalents) do not return anything here,
 828              * but the pointer part of the VARIANT is set to NULL */
 829             V_VT(typename) = VT_NULL;
 830             V_BSTR(typename) = NULL;
 831             break;
 832     }
 833     return (V_VT(typename) != VT_NULL) ? S_OK : S_FALSE;
 834 }
 835
 836 static HRESULT WINAPI domelem_put_dataType(
 837     IXMLDOMElement *iface,
 838     BSTR dtName)
 839 {
 840     domelem *This = impl_from_IXMLDOMElement( iface );
 841     HRESULT hr = E_FAIL;
 842     xmlChar *str;
 843     XDR_DT dt;
 844
 845     TRACE("(%p)->(%s)\n", This, debugstr_w(dtName));
 846
 847     if(dtName == NULL)
 848         return E_INVALIDARG;
 849
 850     dt = bstr_to_dt(dtName, -1);
 851
 852     /* An example of this is. The Text in the node needs to be a 0 or 1 for a boolean type.
 853        This applies to changing types (string->bool) or setting a new one
 854      */
 855     str = xmlNodeGetContent(get_element(This));
 856     hr = dt_validate(dt, str);
 857     xmlFree(str);
 858
 859     /* Check all supported types. */
 860     if (hr == S_OK)
 861     {
 862         switch (dt)
 863         {
 864         case DT_BIN_BASE64:
 865         case DT_BIN_HEX:
 866         case DT_BOOLEAN:
 867         case DT_CHAR:
 868         case DT_DATE:
 869         case DT_DATE_TZ:
 870         case DT_DATETIME:
 871         case DT_DATETIME_TZ:
 872         case DT_FIXED_14_4:
 873         case DT_FLOAT:
 874         case DT_I1:
 875         case DT_I2:
 876         case DT_I4:
 877         case DT_I8:
 878         case DT_INT:
 879         case DT_NMTOKEN:
 880         case DT_NMTOKENS:
 881         case DT_NUMBER:
 882         case DT_R4:
 883         case DT_R8:
 884         case DT_STRING:
 885         case DT_TIME:
 886         case DT_TIME_TZ:
 887         case DT_UI1:
 888         case DT_UI2:
 889         case DT_UI4:
 890         case DT_UI8:
 891         case DT_URI:
 892         case DT_UUID:
 893             {
 894                 xmlAttrPtr attr = xmlHasNsProp(get_element(This), DT_prefix, DT_nsURI);
 895                 if (attr)
 896                 {
 897                     attr = xmlSetNsProp(get_element(This), attr->ns, DT_prefix, dt_to_str(dt));
 898                     hr = S_OK;
 899                 }
 900                 else
 901                 {
 902                     xmlNsPtr ns = xmlNewNs(get_element(This), DT_nsURI, DT_prefix);
 903                     if (ns)
 904                     {
 905                         attr = xmlNewNsProp(get_element(This), ns, DT_prefix, dt_to_str(dt));
 906                         if (attr)
 907                         {
 908                             xmlAddChild(get_element(This), (xmlNodePtr)attr);
 909                             hr = S_OK;
 910                         }
 911                         else
 912                             ERR("Failed to create Attribute\n");
 913                     }
 914                     else
 915                         ERR("Failed to create Namespace\n");
 916                 }
 917             }
 918             break;
 919         default:
 920             FIXME("need to handle dt:%s\n", dt_to_str(dt));
 921             break;
 922         }
 923     }
 924
 925     return hr;
 926 }
 927
 928 static HRESULT WINAPI domelem_get_xml(
 929     IXMLDOMElement *iface,
 930     BSTR* p)
 931 {
 932     domelem *This = impl_from_IXMLDOMElement( iface );
 933
 934     TRACE("(%p)->(%p)\n", This, p);
 935
 936     return node_get_xml(&This->node, TRUE, FALSE, p);
 937 }
 938
 939 static HRESULT WINAPI domelem_transformNode(
 940     IXMLDOMElement *iface,
 941     IXMLDOMNode *node, BSTR *p)
 942 {
 943     domelem *This = impl_from_IXMLDOMElement( iface );
 944     TRACE("(%p)->(%p %p)\n", This, node, p);
 945     return node_transform_node(&This->node, node, p);
 946 }
 947
 948 static HRESULT WINAPI domelem_selectNodes(
 949     IXMLDOMElement *iface,
 950     BSTR p, IXMLDOMNodeList** outList)
 951 {
 952     domelem *This = impl_from_IXMLDOMElement( iface );
 953     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
 954     return node_select_nodes(&This->node, p, outList);
 955 }
 956
 957 static HRESULT WINAPI domelem_selectSingleNode(
 958     IXMLDOMElement *iface,
 959     BSTR p, IXMLDOMNode** outNode)
 960 {
 961     domelem *This = impl_from_IXMLDOMElement( iface );
 962     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
 963     return node_select_singlenode(&This->node, p, outNode);
 964 }
 965
 966 static HRESULT WINAPI domelem_get_parsed(
 967     IXMLDOMElement *iface,
 968     VARIANT_BOOL* isParsed)
 969 {
 970     domelem *This = impl_from_IXMLDOMElement( iface );
 971     FIXME("(%p)->(%p) stub!\n", This, isParsed);
 972     *isParsed = VARIANT_TRUE;
 973     return S_OK;
 974 }
 975
 976 static HRESULT WINAPI domelem_get_namespaceURI(
 977     IXMLDOMElement *iface,
 978     BSTR* p)
 979 {
 980     domelem *This = impl_from_IXMLDOMElement( iface );
 981     TRACE("(%p)->(%p)\n", This, p);
 982     return node_get_namespaceURI(&This->node, p);
 983 }
 984
 985 static HRESULT WINAPI domelem_get_prefix(
 986     IXMLDOMElement *iface,
 987     BSTR* prefix)
 988 {
 989     domelem *This = impl_from_IXMLDOMElement( iface );
 990     TRACE("(%p)->(%p)\n", This, prefix);
 991     return node_get_prefix( &This->node, prefix );
 992 }
 993
 994 static HRESULT WINAPI domelem_get_baseName(
 995     IXMLDOMElement *iface,
 996     BSTR* name)
 997 {
 998     domelem *This = impl_from_IXMLDOMElement( iface );
 999     TRACE("(%p)->(%p)\n", This, name);
1000     return node_get_base_name( &This->node, name );
1001 }
1002
1003 static HRESULT WINAPI domelem_transformNodeToObject(
1004     IXMLDOMElement *iface,
1005     IXMLDOMNode* domNode, VARIANT var1)
1006 {
1007     domelem *This = impl_from_IXMLDOMElement( iface );
1008     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI domelem_get_tagName(
1013     IXMLDOMElement *iface,
1014     BSTR* p)
1015 {
1016     domelem *This = impl_from_IXMLDOMElement( iface );
1017     xmlNodePtr element;
1018     const xmlChar *prefix;
1019     xmlChar *qname;
1020
1021     TRACE("(%p)->(%p)\n", This, p );
1022
1023     if (!p) return E_INVALIDARG;
1024
1025     element = get_element( This );
1026     if ( !element )
1027         return E_FAIL;
1028
1029     prefix = element->ns ? element->ns->prefix : NULL;
1030     qname = xmlBuildQName(element->name, prefix, NULL, 0);
1031
1032     *p = bstr_from_xmlChar(qname);
1033     if (qname != element->name) xmlFree(qname);
1034
1035     return *p ? S_OK : E_OUTOFMEMORY;
1036 }
1037
1038 static HRESULT WINAPI domelem_getAttribute(
1039     IXMLDOMElement *iface,
1040     BSTR name, VARIANT* value)
1041 {
1042     domelem *This = impl_from_IXMLDOMElement( iface );
1043     xmlNodePtr element;
1044     xmlChar *xml_name, *xml_value = NULL;
1045     HRESULT hr = S_FALSE;
1046
1047     TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), value);
1048
1049     if(!value || !name)
1050         return E_INVALIDARG;
1051
1052     element = get_element( This );
1053     if ( !element )
1054         return E_FAIL;
1055
1056     V_BSTR(value) = NULL;
1057     V_VT(value) = VT_NULL;
1058
1059     xml_name = xmlchar_from_wchar( name );
1060
1061     if(!xmlValidateNameValue(xml_name))
1062         hr = E_FAIL;
1063     else
1064         xml_value = xmlGetNsProp(element, xml_name, NULL);
1065
1066     heap_free(xml_name);
1067     if(xml_value)
1068     {
1069         V_VT(value) = VT_BSTR;
1070         V_BSTR(value) = bstr_from_xmlChar( xml_value );
1071         xmlFree(xml_value);
1072         hr = S_OK;
1073     }
1074
1075     return hr;
1076 }
1077
1078 static HRESULT WINAPI domelem_setAttribute(
1079     IXMLDOMElement *iface,
1080     BSTR name, VARIANT value)
1081 {
1082     domelem *This = impl_from_IXMLDOMElement( iface );
1083     xmlNodePtr element;
1084     xmlChar *xml_name, *xml_value;
1085     HRESULT hr;
1086     VARIANT var;
1087
1088     TRACE("(%p)->(%s %s)\n", This, debugstr_w(name), debugstr_variant(&value));
1089
1090     element = get_element( This );
1091     if ( !element )
1092         return E_FAIL;
1093
1094     VariantInit(&var);
1095     hr = VariantChangeType(&var, &value, 0, VT_BSTR);
1096     if(hr != S_OK)
1097     {
1098         FIXME("VariantChangeType failed\n");
1099         return hr;
1100     }
1101
1102     xml_name = xmlchar_from_wchar( name );
1103     xml_value = xmlchar_from_wchar( V_BSTR(&var) );
1104
1105     if(!xmlSetNsProp(element, NULL,  xml_name, xml_value))
1106         hr = E_FAIL;
1107
1108     heap_free(xml_value);
1109     heap_free(xml_name);
1110     VariantClear(&var);
1111
1112     return hr;
1113 }
1114
1115 static HRESULT WINAPI domelem_removeAttribute(
1116     IXMLDOMElement *iface,
1117     BSTR p)
1118 {
1119     domelem *This = impl_from_IXMLDOMElement( iface );
1120     IXMLDOMNamedNodeMap *attr;
1121     HRESULT hr;
1122
1123     TRACE("(%p)->(%s)\n", This, debugstr_w(p));
1124
1125     hr = IXMLDOMElement_get_attributes(iface, &attr);
1126     if (hr != S_OK) return hr;
1127
1128     hr = IXMLDOMNamedNodeMap_removeNamedItem(attr, p, NULL);
1129     IXMLDOMNamedNodeMap_Release(attr);
1130
1131     return hr;
1132 }
1133
1134 static HRESULT WINAPI domelem_getAttributeNode(
1135     IXMLDOMElement *iface,
1136     BSTR p, IXMLDOMAttribute** attributeNode )
1137 {
1138     domelem *This = impl_from_IXMLDOMElement( iface );
1139     xmlChar *xml_name;
1140     xmlNodePtr element;
1141     xmlAttrPtr attr;
1142     IUnknown *unk;
1143     HRESULT hr = S_FALSE;
1144
1145     TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), attributeNode);
1146
1147     if(!attributeNode)
1148         return E_FAIL;
1149
1150     *attributeNode = NULL;
1151
1152     element = get_element( This );
1153     if ( !element )
1154         return E_FAIL;
1155
1156     xml_name = xmlchar_from_wchar(p);
1157
1158     if(!xmlValidateNameValue(xml_name))
1159     {
1160         heap_free(xml_name);
1161         return E_FAIL;
1162     }
1163
1164     attr = xmlHasProp(element, xml_name);
1165     if(attr) {
1166         unk = create_attribute((xmlNodePtr)attr);
1167         hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMAttribute, (void**)attributeNode);
1168         IUnknown_Release(unk);
1169     }
1170
1171     heap_free(xml_name);
1172
1173     return hr;
1174 }
1175
1176 static HRESULT WINAPI domelem_setAttributeNode(
1177     IXMLDOMElement *iface,
1178     IXMLDOMAttribute* attribute,
1179     IXMLDOMAttribute** old)
1180 {
1181     domelem *This = impl_from_IXMLDOMElement( iface );
1182     static const WCHAR xmlnsW[] = {'x','m','l','n','s',0};
1183     xmlChar *name, *value;
1184     BSTR nameW, prefix;
1185     xmlnode *attr_node;
1186     xmlAttrPtr attr;
1187     VARIANT valueW;
1188     HRESULT hr;
1189
1190     FIXME("(%p)->(%p %p): semi-stub\n", This, attribute, old);
1191
1192     if (!attribute) return E_INVALIDARG;
1193
1194     attr_node = get_node_obj((IXMLDOMNode*)attribute);
1195     if (!attr_node) return E_FAIL;
1196
1197     if (attr_node->parent)
1198     {
1199         WARN("attempt to add already used attribute\n");
1200         return E_FAIL;
1201     }
1202
1203     hr = IXMLDOMAttribute_get_nodeName(attribute, &nameW);
1204     if (hr != S_OK) return hr;
1205
1206     /* adding xmlns attribute doesn't change a tree or existing namespace definition */
1207     if (!strcmpW(nameW, xmlnsW))
1208     {
1209         SysFreeString(nameW);
1210         return DISP_E_UNKNOWNNAME;
1211     }
1212
1213     hr = IXMLDOMAttribute_get_nodeValue(attribute, &valueW);
1214     if (hr != S_OK)
1215     {
1216         SysFreeString(nameW);
1217         return hr;
1218     }
1219
1220     if (old) *old = NULL;
1221
1222     TRACE("attribute: %s=%s\n", debugstr_w(nameW), debugstr_w(V_BSTR(&valueW)));
1223
1224     hr = IXMLDOMAttribute_get_prefix(attribute, &prefix);
1225     if (hr == S_OK)
1226     {
1227         FIXME("namespaces not supported: %s\n", debugstr_w(prefix));
1228         SysFreeString(prefix);
1229     }
1230
1231     name = xmlchar_from_wchar(nameW);
1232     value = xmlchar_from_wchar(V_BSTR(&valueW));
1233
1234     if (!name || !value)
1235     {
1236         SysFreeString(nameW);
1237         VariantClear(&valueW);
1238         heap_free(name);
1239         heap_free(value);
1240         return E_OUTOFMEMORY;
1241     }
1242
1243     attr = xmlSetNsProp(get_element(This), NULL, name, value);
1244     if (attr)
1245         attr_node->parent = (IXMLDOMNode*)iface;
1246
1247     SysFreeString(nameW);
1248     VariantClear(&valueW);
1249     heap_free(name);
1250     heap_free(value);
1251
1252     return attr ? S_OK : E_FAIL;
1253 }
1254
1255 static HRESULT WINAPI domelem_removeAttributeNode(
1256     IXMLDOMElement *iface,
1257     IXMLDOMAttribute* domAttribute,
1258     IXMLDOMAttribute** attributeNode)
1259 {
1260     domelem *This = impl_from_IXMLDOMElement( iface );
1261     FIXME("(%p)->(%p %p)\n", This, domAttribute, attributeNode);
1262     return E_NOTIMPL;
1263 }
1264
1265 static HRESULT WINAPI domelem_getElementsByTagName(
1266     IXMLDOMElement *iface,
1267     BSTR tagName, IXMLDOMNodeList** resultList)
1268 {
1269     domelem *This = impl_from_IXMLDOMElement( iface );
1270     xmlChar *query;
1271     HRESULT hr;
1272     BOOL XPath;
1273
1274     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
1275
1276     if (!tagName || !resultList) return E_INVALIDARG;
1277
1278     XPath = is_xpathmode(get_element(This)->doc);
1279     set_xpathmode(get_element(This)->doc, TRUE);
1280     query = tagName_to_XPath(tagName);
1281     hr = queryresult_create(get_element(This), query, resultList);
1282     xmlFree(query);
1283     set_xpathmode(get_element(This)->doc, XPath);
1284
1285     return hr;
1286 }
1287
1288 static HRESULT WINAPI domelem_normalize(
1289     IXMLDOMElement *iface )
1290 {
1291     domelem *This = impl_from_IXMLDOMElement( iface );
1292     FIXME("%p\n", This);
1293     return E_NOTIMPL;
1294 }
1295
1296 static const struct IXMLDOMElementVtbl domelem_vtbl =
1297 {
1298     domelem_QueryInterface,
1299     domelem_AddRef,
1300     domelem_Release,
1301     domelem_GetTypeInfoCount,
1302     domelem_GetTypeInfo,
1303     domelem_GetIDsOfNames,
1304     domelem_Invoke,
1305     domelem_get_nodeName,
1306     domelem_get_nodeValue,
1307     domelem_put_nodeValue,
1308     domelem_get_nodeType,
1309     domelem_get_parentNode,
1310     domelem_get_childNodes,
1311     domelem_get_firstChild,
1312     domelem_get_lastChild,
1313     domelem_get_previousSibling,
1314     domelem_get_nextSibling,
1315     domelem_get_attributes,
1316     domelem_insertBefore,
1317     domelem_replaceChild,
1318     domelem_removeChild,
1319     domelem_appendChild,
1320     domelem_hasChildNodes,
1321     domelem_get_ownerDocument,
1322     domelem_cloneNode,
1323     domelem_get_nodeTypeString,
1324     domelem_get_text,
1325     domelem_put_text,
1326     domelem_get_specified,
1327     domelem_get_definition,
1328     domelem_get_nodeTypedValue,
1329     domelem_put_nodeTypedValue,
1330     domelem_get_dataType,
1331     domelem_put_dataType,
1332     domelem_get_xml,
1333     domelem_transformNode,
1334     domelem_selectNodes,
1335     domelem_selectSingleNode,
1336     domelem_get_parsed,
1337     domelem_get_namespaceURI,
1338     domelem_get_prefix,
1339     domelem_get_baseName,
1340     domelem_transformNodeToObject,
1341     domelem_get_tagName,
1342     domelem_getAttribute,
1343     domelem_setAttribute,
1344     domelem_removeAttribute,
1345     domelem_getAttributeNode,
1346     domelem_setAttributeNode,
1347     domelem_removeAttributeNode,
1348     domelem_getElementsByTagName,
1349     domelem_normalize,
1350 };
1351
1352 static const tid_t domelem_iface_tids[] = {
1353     IXMLDOMElement_tid,
1354     0
1355 };
1356
1357 static dispex_static_data_t domelem_dispex = {
1358     NULL,
1359     IXMLDOMElement_tid,
1360     NULL,
1361     domelem_iface_tids
1362 };
1363
1364 IUnknown* create_element( xmlNodePtr element )
1365 {
1366     domelem *This;
1367
1368     This = heap_alloc( sizeof *This );
1369     if ( !This )
1370         return NULL;
1371
1372     This->IXMLDOMElement_iface.lpVtbl = &domelem_vtbl;
1373     This->ref = 1;
1374
1375     init_xmlnode(&This->node, element, (IXMLDOMNode*)&This->IXMLDOMElement_iface, &domelem_dispex);
1376
1377     return (IUnknown*)&This->IXMLDOMElement_iface;
1378 }
1379
1380 #endif