selection.c 21.9 KB
Newer Older
1
/*
2
 *    XPath/XSLPattern query result node list implementation
3 4 5
 *
 * Copyright 2005 Mike McCormack
 * Copyright 2007 Mikolaj Zalewski
6
 * Copyright 2010 Adam Martinson for CodeWeavers
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#define COBJMACROS

#include "config.h"

#include <stdarg.h>
28 29 30 31 32 33 34
#ifdef HAVE_LIBXML2
# include <libxml/parser.h>
# include <libxml/xmlerror.h>
# include <libxml/xpath.h>
# include <libxml/xpathInternals.h>
#endif

35 36 37 38
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
39
#include "msxml6.h"
40
#include "msxml2did.h"
41 42 43 44 45 46 47 48 49 50

#include "msxml_private.h"

#include "wine/debug.h"

/* This file implements the object returned by a XPath query. Note that this is
 * not the IXMLDOMNodeList returned by childNodes - it's implemented in nodelist.c.
 * They are different because the list returned by XPath queries:
 *  - is static - gives the results for the XML tree as it existed during the
 *    execution of the query
51
 *  - supports IXMLDOMSelection
52 53 54 55 56
 *
 */

#ifdef HAVE_LIBXML2

57 58
WINE_DEFAULT_DEBUG_CHANNEL(msxml);

59
int registerNamespaces(xmlXPathContextPtr ctxt);
60
xmlChar* XSLPattern_to_XPath(xmlXPathContextPtr ctxt, xmlChar const* xslpat_str);
61

62
typedef struct
63 64 65 66
{
    IEnumVARIANT IEnumVARIANT_iface;
    LONG ref;

67
    IUnknown *outer;
68
    BOOL own;
69 70

    LONG pos;
71 72

    const struct enumvariant_funcs *funcs;
73 74
} enumvariant;

75
typedef struct
76
{
77
    DispatchEx dispex;
78
    IXMLDOMSelection IXMLDOMSelection_iface;
79 80 81 82
    LONG ref;
    xmlNodePtr node;
    xmlXPathObjectPtr result;
    int resultPos;
83
    IEnumVARIANT *enumvariant;
84
} domselection;
85

86
static HRESULT selection_get_item(IUnknown *iface, LONG index, VARIANT* item)
87
{
88 89
    V_VT(item) = VT_DISPATCH;
    return IXMLDOMSelection_get_item((IXMLDOMSelection*)iface, index, (IXMLDOMNode**)&V_DISPATCH(item));
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
}

static HRESULT selection_next(IUnknown *iface)
{
    IXMLDOMNode *node;
    HRESULT hr = IXMLDOMSelection_nextNode((IXMLDOMSelection*)iface, &node);
    if (hr == S_OK) IXMLDOMNode_Release(node);
    return hr;
}

static const struct enumvariant_funcs selection_enumvariant = {
    selection_get_item,
    selection_next
};

105
static inline domselection *impl_from_IXMLDOMSelection( IXMLDOMSelection *iface )
106
{
107
    return CONTAINING_RECORD(iface, domselection, IXMLDOMSelection_iface);
108 109
}

110 111 112 113 114
static inline enumvariant *impl_from_IEnumVARIANT( IEnumVARIANT *iface )
{
    return CONTAINING_RECORD(iface, enumvariant, IEnumVARIANT_iface);
}

115 116
static HRESULT WINAPI domselection_QueryInterface(
    IXMLDOMSelection *iface,
117 118 119
    REFIID riid,
    void** ppvObject )
{
120
    domselection *This = impl_from_IXMLDOMSelection( iface );
121

122
    TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
123

124 125 126
    if(!ppvObject)
        return E_INVALIDARG;

127
    if ( IsEqualGUID( riid, &IID_IUnknown ) ||
128 129
         IsEqualGUID( riid, &IID_IXMLDOMNodeList ) ||
         IsEqualGUID( riid, &IID_IXMLDOMSelection ))
130
    {
131
        *ppvObject = &This->IXMLDOMSelection_iface;
132
    }
133 134 135 136
    else if (IsEqualGUID( riid, &IID_IEnumVARIANT ))
    {
        if (!This->enumvariant)
        {
137
            HRESULT hr = create_enumvariant((IUnknown*)iface, FALSE, &selection_enumvariant, &This->enumvariant);
138 139 140 141 142 143
            if (FAILED(hr)) return hr;
        }

        return IEnumVARIANT_QueryInterface(This->enumvariant, &IID_IEnumVARIANT, ppvObject);
    }
    else if (dispex_query_interface(&This->dispex, riid, ppvObject))
144 145 146
    {
        return *ppvObject ? S_OK : E_NOINTERFACE;
    }
147 148
    else
    {
149
        TRACE("interface %s not implemented\n", debugstr_guid(riid));
150 151 152 153
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }

154
    IXMLDOMSelection_AddRef( iface );
155 156 157 158

    return S_OK;
}

159 160
static ULONG WINAPI domselection_AddRef(
    IXMLDOMSelection *iface )
161
{
162 163 164 165
    domselection *This = impl_from_IXMLDOMSelection( iface );
    ULONG ref = InterlockedIncrement( &This->ref );
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
166 167
}

168 169
static ULONG WINAPI domselection_Release(
    IXMLDOMSelection *iface )
170
{
171 172
    domselection *This = impl_from_IXMLDOMSelection( iface );
    ULONG ref = InterlockedDecrement(&This->ref);
173

174
    TRACE("(%p)->(%d)\n", This, ref);
175 176 177 178
    if ( ref == 0 )
    {
        xmlXPathFreeObject(This->result);
        xmldoc_release(This->node->doc);
179
        if (This->enumvariant) IEnumVARIANT_Release(This->enumvariant);
180
        heap_free(This);
181 182 183 184 185
    }

    return ref;
}

186 187
static HRESULT WINAPI domselection_GetTypeInfoCount(
    IXMLDOMSelection *iface,
188 189
    UINT* pctinfo )
{
190
    domselection *This = impl_from_IXMLDOMSelection( iface );
191
    return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
192 193
}

194 195
static HRESULT WINAPI domselection_GetTypeInfo(
    IXMLDOMSelection *iface,
196 197 198 199
    UINT iTInfo,
    LCID lcid,
    ITypeInfo** ppTInfo )
{
200
    domselection *This = impl_from_IXMLDOMSelection( iface );
201 202
    return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface,
        iTInfo, lcid, ppTInfo);
203 204
}

205 206
static HRESULT WINAPI domselection_GetIDsOfNames(
    IXMLDOMSelection *iface,
207 208 209 210 211 212
    REFIID riid,
    LPOLESTR* rgszNames,
    UINT cNames,
    LCID lcid,
    DISPID* rgDispId )
{
213
    domselection *This = impl_from_IXMLDOMSelection( iface );
214 215
    return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface,
        riid, rgszNames, cNames, lcid, rgDispId);
216 217
}

218 219
static HRESULT WINAPI domselection_Invoke(
    IXMLDOMSelection *iface,
220 221 222 223 224 225 226 227 228
    DISPID dispIdMember,
    REFIID riid,
    LCID lcid,
    WORD wFlags,
    DISPPARAMS* pDispParams,
    VARIANT* pVarResult,
    EXCEPINFO* pExcepInfo,
    UINT* puArgErr )
{
229
    domselection *This = impl_from_IXMLDOMSelection( iface );
230 231
    return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface,
        dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
232 233
}

234 235
static HRESULT WINAPI domselection_get_item(
        IXMLDOMSelection* iface,
236
        LONG index,
237 238
        IXMLDOMNode** listItem)
{
239
    domselection *This = impl_from_IXMLDOMSelection( iface );
240

241
    TRACE("(%p)->(%d %p)\n", This, index, listItem);
242

243 244 245
    if(!listItem)
        return E_INVALIDARG;

246 247
    *listItem = NULL;

248
    if (index < 0 || index >= xmlXPathNodeSetGetLength(This->result->nodesetval))
249 250
        return S_FALSE;

251
    *listItem = create_node(xmlXPathNodeSetItem(This->result->nodesetval, index));
252
    This->resultPos = index + 1;
253 254 255 256

    return S_OK;
}

257 258
static HRESULT WINAPI domselection_get_length(
        IXMLDOMSelection* iface,
259
        LONG* listLength)
260
{
261
    domselection *This = impl_from_IXMLDOMSelection( iface );
262

263
    TRACE("(%p)->(%p)\n", This, listLength);
264

265 266 267
    if(!listLength)
        return E_INVALIDARG;

268
    *listLength = xmlXPathNodeSetGetLength(This->result->nodesetval);
269 270 271
    return S_OK;
}

272 273
static HRESULT WINAPI domselection_nextNode(
        IXMLDOMSelection* iface,
274 275
        IXMLDOMNode** nextItem)
{
276
    domselection *This = impl_from_IXMLDOMSelection( iface );
277

278
    TRACE("(%p)->(%p)\n", This, nextItem );
279

280 281 282
    if(!nextItem)
        return E_INVALIDARG;

283 284
    *nextItem = NULL;

285
    if (This->resultPos >= xmlXPathNodeSetGetLength(This->result->nodesetval))
286 287
        return S_FALSE;

288
    *nextItem = create_node(xmlXPathNodeSetItem(This->result->nodesetval, This->resultPos));
289 290 291 292
    This->resultPos++;
    return S_OK;
}

293 294
static HRESULT WINAPI domselection_reset(
        IXMLDOMSelection* iface)
295
{
296
    domselection *This = impl_from_IXMLDOMSelection( iface );
297 298 299 300 301 302

    TRACE("%p\n", This);
    This->resultPos = 0;
    return S_OK;
}

303 304
static HRESULT WINAPI domselection_get__newEnum(
        IXMLDOMSelection* iface,
305
        IUnknown** enumv)
306
{
307
    domselection *This = impl_from_IXMLDOMSelection( iface );
308

309
    TRACE("(%p)->(%p)\n", This, enumv);
310

311
    return create_enumvariant((IUnknown*)iface, TRUE, &selection_enumvariant, (IEnumVARIANT**)enumv);
312 313
}

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
static HRESULT WINAPI domselection_get_expr(
        IXMLDOMSelection* iface,
        BSTR *p)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p)\n", This, p);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_put_expr(
        IXMLDOMSelection* iface,
        BSTR p)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%s)\n", This, debugstr_w(p));
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_get_context(
        IXMLDOMSelection* iface,
        IXMLDOMNode **node)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p)\n", This, node);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_putref_context(
        IXMLDOMSelection* iface,
        IXMLDOMNode *node)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p)\n", This, node);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_peekNode(
        IXMLDOMSelection* iface,
        IXMLDOMNode **node)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p)\n", This, node);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_matches(
        IXMLDOMSelection* iface,
        IXMLDOMNode *node,
        IXMLDOMNode **out_node)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p %p)\n", This, node, out_node);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_removeNext(
        IXMLDOMSelection* iface,
        IXMLDOMNode **node)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p)\n", This, node);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_removeAll(
        IXMLDOMSelection* iface)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)\n", This);
    return E_NOTIMPL;
}
385

386 387 388
static HRESULT WINAPI domselection_clone(
        IXMLDOMSelection* iface,
        IXMLDOMSelection **node)
389
{
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%p)\n", This, node);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_getProperty(
        IXMLDOMSelection* iface,
        BSTR p,
        VARIANT *var)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%s %p)\n", This, debugstr_w(p), var);
    return E_NOTIMPL;
}

static HRESULT WINAPI domselection_setProperty(
        IXMLDOMSelection* iface,
        BSTR p,
        VARIANT var)
{
    domselection *This = impl_from_IXMLDOMSelection( iface );
    FIXME("(%p)->(%s %s)\n", This, debugstr_w(p), debugstr_variant(&var));
    return E_NOTIMPL;
}

static const struct IXMLDOMSelectionVtbl domselection_vtbl =
{
    domselection_QueryInterface,
    domselection_AddRef,
    domselection_Release,
    domselection_GetTypeInfoCount,
    domselection_GetTypeInfo,
    domselection_GetIDsOfNames,
    domselection_Invoke,
    domselection_get_item,
    domselection_get_length,
    domselection_nextNode,
    domselection_reset,
    domselection_get__newEnum,
    domselection_get_expr,
    domselection_put_expr,
    domselection_get_context,
    domselection_putref_context,
    domselection_peekNode,
    domselection_matches,
    domselection_removeNext,
    domselection_removeAll,
    domselection_clone,
    domselection_getProperty,
    domselection_setProperty
440 441
};

442 443 444 445 446 447 448 449 450 451 452 453
/* IEnumVARIANT support */
static HRESULT WINAPI enumvariant_QueryInterface(
    IEnumVARIANT *iface,
    REFIID riid,
    void** ppvObject )
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );

    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);

    *ppvObject = NULL;

454 455 456 457 458
    if (IsEqualGUID( riid, &IID_IUnknown ))
    {
        if (This->own)
            *ppvObject = &This->IEnumVARIANT_iface;
        else
459
            return IUnknown_QueryInterface(This->outer, riid, ppvObject);
460 461
    }
    else if (IsEqualGUID( riid, &IID_IEnumVARIANT ))
462 463 464 465
    {
        *ppvObject = &This->IEnumVARIANT_iface;
    }
    else
466
        return IUnknown_QueryInterface(This->outer, riid, ppvObject);
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488

    IEnumVARIANT_AddRef( iface );

    return S_OK;
}

static ULONG WINAPI enumvariant_AddRef(IEnumVARIANT *iface )
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );
    ULONG ref = InterlockedIncrement( &This->ref );
    TRACE("(%p)->(%d)\n", This, ref);
    return ref;
}

static ULONG WINAPI enumvariant_Release(IEnumVARIANT *iface )
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );
    ULONG ref = InterlockedDecrement(&This->ref);

    TRACE("(%p)->(%d)\n", This, ref);
    if ( ref == 0 )
    {
489
        if (This->own) IUnknown_Release(This->outer);
490 491 492 493 494 495 496 497 498
        heap_free(This);
    }

    return ref;
}

static HRESULT WINAPI enumvariant_Next(
    IEnumVARIANT *iface,
    ULONG celt,
499 500
    VARIANT *var,
    ULONG *fetched)
501 502
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );
503 504 505 506 507 508 509 510 511 512
    ULONG ret_count = 0;

    TRACE("(%p)->(%u %p %p)\n", This, celt, var, fetched);

    if (fetched) *fetched = 0;

    if (celt && !var) return E_INVALIDARG;

    for (; celt > 0; celt--, var++, This->pos++)
    {
513 514 515 516 517 518
        HRESULT hr = This->funcs->get_item(This->outer, This->pos, var);
        if (hr != S_OK)
        {
            V_VT(var) = VT_EMPTY;
            break;
        }
519 520 521 522 523 524 525
        ret_count++;
    }

    if (fetched) (*fetched)++;

    /* we need to advance one step more for some reason */
    if (ret_count)
526
    {
527 528
        if (This->funcs->next)
            This->funcs->next(This->outer);
529
    }
530 531

    return celt == 0 ? S_OK : S_FALSE;
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
}

static HRESULT WINAPI enumvariant_Skip(
    IEnumVARIANT *iface,
    ULONG celt)
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );
    FIXME("(%p)->(%u): stub\n", This, celt);
    return E_NOTIMPL;
}

static HRESULT WINAPI enumvariant_Reset(IEnumVARIANT *iface)
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );
    FIXME("(%p): stub\n", This);
    return E_NOTIMPL;
}

static HRESULT WINAPI enumvariant_Clone(
    IEnumVARIANT *iface, IEnumVARIANT **ppenum)
{
    enumvariant *This = impl_from_IEnumVARIANT( iface );
    FIXME("(%p)->(%p): stub\n", This, ppenum);
    return E_NOTIMPL;
}

static const struct IEnumVARIANTVtbl EnumVARIANTVtbl =
{
    enumvariant_QueryInterface,
    enumvariant_AddRef,
    enumvariant_Release,
    enumvariant_Next,
    enumvariant_Skip,
    enumvariant_Reset,
    enumvariant_Clone
};

569
HRESULT create_enumvariant(IUnknown *outer, BOOL own, const struct enumvariant_funcs *funcs, IEnumVARIANT **penum)
570 571 572 573 574 575 576 577
{
    enumvariant *This;

    This = heap_alloc(sizeof(enumvariant));
    if (!This) return E_OUTOFMEMORY;

    This->IEnumVARIANT_iface.lpVtbl = &EnumVARIANTVtbl;
    This->ref = 0;
578
    This->outer = outer;
579
    This->own = own;
580
    This->pos = 0;
581
    This->funcs = funcs;
582 583

    if (This->own)
584
        IUnknown_AddRef(This->outer);
585

586 587
    *penum = &This->IEnumVARIANT_iface;
    IEnumVARIANT_AddRef(*penum);
588
    return S_OK;
589 590
}

591
static HRESULT domselection_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid)
592 593
{
    WCHAR *ptr;
594
    int idx = 0;
595 596 597 598 599 600

    for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
        idx = idx*10 + (*ptr-'0');
    if(*ptr)
        return DISP_E_UNKNOWNNAME;

601
    *dispid = DISPID_DOM_COLLECTION_BASE + idx;
602 603 604 605
    TRACE("ret %x\n", *dispid);
    return S_OK;
}

606
static HRESULT domselection_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
607 608
        VARIANT *res, EXCEPINFO *ei)
{
609
    domselection *This = impl_from_IXMLDOMSelection( (IXMLDOMSelection*)iface );
610

611
    TRACE("(%p)->(%x %x %x %p %p %p)\n", This, id, lcid, flags, params, res, ei);
612 613

    V_VT(res) = VT_DISPATCH;
614 615
    V_DISPATCH(res) = NULL;

616 617 618
    if (id < DISPID_DOM_COLLECTION_BASE || id > DISPID_DOM_COLLECTION_MAX)
        return DISP_E_UNKNOWNNAME;

619 620 621 622 623 624
    switch(flags)
    {
        case INVOKE_PROPERTYGET:
        {
            IXMLDOMNode *disp = NULL;

625
            IXMLDOMSelection_get_item(&This->IXMLDOMSelection_iface, id - DISPID_DOM_COLLECTION_BASE, &disp);
626
            V_DISPATCH(res) = (IDispatch*)disp;
627 628 629 630 631 632 633 634 635
            break;
        }
        default:
        {
            FIXME("unimplemented flags %x\n", flags);
            break;
        }
    }

636 637
    TRACE("ret %p\n", V_DISPATCH(res));

638 639 640
    return S_OK;
}

641 642 643
static const dispex_static_data_vtbl_t domselection_dispex_vtbl = {
    domselection_get_dispid,
    domselection_invoke
644 645
};

646 647
static const tid_t domselection_iface_tids[] = {
    IXMLDOMSelection_tid,
648 649
    0
};
650 651
static dispex_static_data_t domselection_dispex = {
    &domselection_dispex_vtbl,
652
    IXMLDOMSelection_tid,
653
    NULL,
654
    domselection_iface_tids
655 656
};

657 658
#define XSLPATTERN_CHECK_ARGS(n) \
    if (nargs != n) { \
659
        FIXME("XSLPattern syntax error: Expected %i arguments, got %i\n", n, nargs); \
660
        xmlXPathSetArityError(pctx); \
661 662 663 664
        return; \
    }


665
static void XSLPattern_index(xmlXPathParserContextPtr pctx, int nargs)
666 667 668 669
{
    XSLPATTERN_CHECK_ARGS(0);

    xmlXPathPositionFunction(pctx, 0);
670
    xmlXPathReturnNumber(pctx, xmlXPathPopNumber(pctx) - 1.0);
671 672
}

673
static void XSLPattern_end(xmlXPathParserContextPtr pctx, int nargs)
674 675 676 677 678 679 680 681
{
    double pos, last;
    XSLPATTERN_CHECK_ARGS(0);

    xmlXPathPositionFunction(pctx, 0);
    pos = xmlXPathPopNumber(pctx);
    xmlXPathLastFunction(pctx, 0);
    last = xmlXPathPopNumber(pctx);
682
    xmlXPathReturnBoolean(pctx, pos == last);
683 684
}

685
static void XSLPattern_nodeType(xmlXPathParserContextPtr pctx, int nargs)
686 687 688 689 690
{
    XSLPATTERN_CHECK_ARGS(0);
    xmlXPathReturnNumber(pctx, pctx->context->node->type);
}

691
static void XSLPattern_OP_IEq(xmlXPathParserContextPtr pctx, int nargs)
692 693 694 695 696 697
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
698
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) == 0);
699 700 701 702
    xmlFree(arg1);
    xmlFree(arg2);
}

703
static void XSLPattern_OP_INEq(xmlXPathParserContextPtr pctx, int nargs)
704 705 706 707 708 709
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
710
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) != 0);
711 712 713 714
    xmlFree(arg1);
    xmlFree(arg2);
}

715
static void XSLPattern_OP_ILt(xmlXPathParserContextPtr pctx, int nargs)
716 717 718 719 720 721
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
722
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) < 0);
723 724 725 726
    xmlFree(arg1);
    xmlFree(arg2);
}

727
static void XSLPattern_OP_ILEq(xmlXPathParserContextPtr pctx, int nargs)
728 729 730 731 732 733
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
734
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) <= 0);
735 736 737 738
    xmlFree(arg1);
    xmlFree(arg2);
}

739
static void XSLPattern_OP_IGt(xmlXPathParserContextPtr pctx, int nargs)
740 741 742 743 744 745
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
746
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) > 0);
747 748 749 750
    xmlFree(arg1);
    xmlFree(arg2);
}

751
static void XSLPattern_OP_IGEq(xmlXPathParserContextPtr pctx, int nargs)
752 753 754 755 756 757
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
758
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) >= 0);
759 760 761 762
    xmlFree(arg1);
    xmlFree(arg2);
}

763 764
static void query_serror(void* ctx, xmlErrorPtr err)
{
765
    LIBXML2_CALLBACK_SERROR(domselection_create, err);
766 767
}

768
HRESULT create_selection(xmlNodePtr node, xmlChar* query, IXMLDOMNodeList **out)
Piotr Caban's avatar
Piotr Caban committed
769
{
770
    domselection *This = heap_alloc(sizeof(domselection));
Piotr Caban's avatar
Piotr Caban committed
771 772 773
    xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
    HRESULT hr;

774
    TRACE("(%p, %s, %p)\n", node, debugstr_a((char const*)query), out);
Piotr Caban's avatar
Piotr Caban committed
775 776

    *out = NULL;
777
    if (!This || !ctxt || !query)
Piotr Caban's avatar
Piotr Caban committed
778
    {
779 780 781
        xmlXPathFreeContext(ctxt);
        heap_free(This);
        return E_OUTOFMEMORY;
Piotr Caban's avatar
Piotr Caban committed
782 783
    }

784
    This->IXMLDOMSelection_iface.lpVtbl = &domselection_vtbl;
Piotr Caban's avatar
Piotr Caban committed
785 786 787
    This->ref = 1;
    This->resultPos = 0;
    This->node = node;
788
    This->enumvariant = NULL;
789
    init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMSelection_iface, &domselection_dispex);
Piotr Caban's avatar
Piotr Caban committed
790 791
    xmldoc_add_ref(This->node->doc);

792
    ctxt->error = query_serror;
Piotr Caban's avatar
Piotr Caban committed
793
    ctxt->node = node;
794 795
    registerNamespaces(ctxt);

796 797 798
    if (is_xpathmode(This->node->doc))
    {
        xmlXPathRegisterAllFunctions(ctxt);
799
        This->result = xmlXPathEvalExpression(query, ctxt);
800 801 802
    }
    else
    {
803
        xmlChar* pattern_query = XSLPattern_to_XPath(ctxt, query);
804 805 806 807 808 809

        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"not", xmlXPathNotFunction);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"boolean", xmlXPathBooleanFunction);

        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"index", XSLPattern_index);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"end", XSLPattern_end);
810
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"nodeType", XSLPattern_nodeType);
811 812 813 814 815 816 817

        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IEq", XSLPattern_OP_IEq);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_INEq", XSLPattern_OP_INEq);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_ILt", XSLPattern_OP_ILt);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_ILEq", XSLPattern_OP_ILEq);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IGt", XSLPattern_OP_IGt);
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"OP_IGEq", XSLPattern_OP_IGEq);
818

819 820
        This->result = xmlXPathEvalExpression(pattern_query, ctxt);
        xmlFree(pattern_query);
821 822
    }

Piotr Caban's avatar
Piotr Caban committed
823 824 825 826 827 828
    if (!This->result || This->result->type != XPATH_NODESET)
    {
        hr = E_FAIL;
        goto cleanup;
    }

829
    *out = (IXMLDOMNodeList*)&This->IXMLDOMSelection_iface;
Piotr Caban's avatar
Piotr Caban committed
830 831 832 833
    hr = S_OK;
    TRACE("found %d matches\n", xmlXPathNodeSetGetLength(This->result->nodesetval));

cleanup:
834
    if (FAILED(hr))
835
        IXMLDOMSelection_Release( &This->IXMLDOMSelection_iface );
836
    xmlXPathFreeContext(ctxt);
Piotr Caban's avatar
Piotr Caban committed
837 838 839
    return hr;
}

840
#endif