queryresult.c 14.6 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 28 29 30 31
 *
 * 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>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
32
#include "msxml6.h"
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#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
 *  - supports IXMLDOMSelection (TODO)
 *
 */

WINE_DEFAULT_DEBUG_CHANNEL(msxml);

#ifdef HAVE_LIBXML2

#include <libxml/xpath.h>
52
#include <libxml/xpathInternals.h>
53

54
int registerNamespaces(xmlXPathContextPtr ctxt);
55
BOOL is_xpathmode(const xmlDocPtr doc);
56
xmlChar* XSLPattern_to_XPath(xmlXPathContextPtr ctxt, xmlChar const* xslpat_str);
57

58 59
typedef struct _queryresult
{
60
    DispatchEx dispex;
61 62 63 64 65 66 67 68 69 70 71 72
    const struct IXMLDOMNodeListVtbl *lpVtbl;
    LONG ref;
    xmlNodePtr node;
    xmlXPathObjectPtr result;
    int resultPos;
} queryresult;

static inline queryresult *impl_from_IXMLDOMNodeList( IXMLDOMNodeList *iface )
{
    return (queryresult *)((char*)iface - FIELD_OFFSET(queryresult, lpVtbl));
}

73 74
#define XMLQUERYRES(x)  ((IXMLDOMNodeList*)&(x)->lpVtbl)

75 76 77 78 79
static HRESULT WINAPI queryresult_QueryInterface(
    IXMLDOMNodeList *iface,
    REFIID riid,
    void** ppvObject )
{
80 81
    queryresult *This = impl_from_IXMLDOMNodeList( iface );

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

84 85 86
    if(!ppvObject)
        return E_INVALIDARG;

87 88 89 90 91
    if ( IsEqualGUID( riid, &IID_IUnknown ) ||
         IsEqualGUID( riid, &IID_IXMLDOMNodeList ) )
    {
        *ppvObject = iface;
    }
92 93 94 95
    else if(dispex_query_interface(&This->dispex, riid, ppvObject))
    {
        return *ppvObject ? S_OK : E_NOINTERFACE;
    }
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
    else
    {
        FIXME("interface %s not implemented\n", debugstr_guid(riid));
        *ppvObject = NULL;
        return E_NOINTERFACE;
    }

    IXMLDOMNodeList_AddRef( iface );

    return S_OK;
}

static ULONG WINAPI queryresult_AddRef(
    IXMLDOMNodeList *iface )
{
    queryresult *This = impl_from_IXMLDOMNodeList( iface );
    return InterlockedIncrement( &This->ref );
}

static ULONG WINAPI queryresult_Release(
    IXMLDOMNodeList *iface )
{
    queryresult *This = impl_from_IXMLDOMNodeList( iface );
    ULONG ref;

    ref = InterlockedDecrement(&This->ref);
    if ( ref == 0 )
    {
        xmlXPathFreeObject(This->result);
        xmldoc_release(This->node->doc);
126
        heap_free(This);
127 128 129 130 131 132 133 134 135
    }

    return ref;
}

static HRESULT WINAPI queryresult_GetTypeInfoCount(
    IXMLDOMNodeList *iface,
    UINT* pctinfo )
{
136 137 138 139 140 141 142
    queryresult *This = impl_from_IXMLDOMNodeList( iface );

    TRACE("(%p)->(%p)\n", This, pctinfo);

    *pctinfo = 1;

    return S_OK;
143 144 145 146 147 148 149 150
}

static HRESULT WINAPI queryresult_GetTypeInfo(
    IXMLDOMNodeList *iface,
    UINT iTInfo,
    LCID lcid,
    ITypeInfo** ppTInfo )
{
151 152 153 154 155 156 157 158
    queryresult *This = impl_from_IXMLDOMNodeList( iface );
    HRESULT hr;

    TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);

    hr = get_typeinfo(IXMLDOMNodeList_tid, ppTInfo);

    return hr;
159 160 161 162 163 164 165 166 167 168
}

static HRESULT WINAPI queryresult_GetIDsOfNames(
    IXMLDOMNodeList *iface,
    REFIID riid,
    LPOLESTR* rgszNames,
    UINT cNames,
    LCID lcid,
    DISPID* rgDispId )
{
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
    queryresult *This = impl_from_IXMLDOMNodeList( iface );
    ITypeInfo *typeinfo;
    HRESULT hr;

    TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
          lcid, rgDispId);

    if(!rgszNames || cNames == 0 || !rgDispId)
        return E_INVALIDARG;

    hr = get_typeinfo(IXMLDOMNodeList_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
        ITypeInfo_Release(typeinfo);
    }

    return hr;
187 188 189 190 191 192 193 194 195 196 197 198 199
}

static HRESULT WINAPI queryresult_Invoke(
    IXMLDOMNodeList *iface,
    DISPID dispIdMember,
    REFIID riid,
    LCID lcid,
    WORD wFlags,
    DISPPARAMS* pDispParams,
    VARIANT* pVarResult,
    EXCEPINFO* pExcepInfo,
    UINT* puArgErr )
{
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
    queryresult *This = impl_from_IXMLDOMNodeList( iface );
    ITypeInfo *typeinfo;
    HRESULT hr;

    TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
          lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);

    hr = get_typeinfo(IXMLDOMNodeList_tid, &typeinfo);
    if(SUCCEEDED(hr))
    {
        hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
                pVarResult, pExcepInfo, puArgErr);
        ITypeInfo_Release(typeinfo);
    }

    return hr;
216 217 218 219
}

static HRESULT WINAPI queryresult_get_item(
        IXMLDOMNodeList* iface,
220
        LONG index,
221 222 223 224
        IXMLDOMNode** listItem)
{
    queryresult *This = impl_from_IXMLDOMNodeList( iface );

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

227 228 229
    if(!listItem)
        return E_INVALIDARG;

230 231
    *listItem = NULL;

232
    if (index < 0 || index >= xmlXPathNodeSetGetLength(This->result->nodesetval))
233 234
        return S_FALSE;

235
    *listItem = create_node(xmlXPathNodeSetItem(This->result->nodesetval, index));
236
    This->resultPos = index + 1;
237 238 239 240 241 242

    return S_OK;
}

static HRESULT WINAPI queryresult_get_length(
        IXMLDOMNodeList* iface,
243
        LONG* listLength)
244 245 246
{
    queryresult *This = impl_from_IXMLDOMNodeList( iface );

247
    TRACE("(%p)->(%p)\n", This, listLength);
248

249 250 251
    if(!listLength)
        return E_INVALIDARG;

252
    *listLength = xmlXPathNodeSetGetLength(This->result->nodesetval);
253 254 255 256 257 258 259 260 261
    return S_OK;
}

static HRESULT WINAPI queryresult_nextNode(
        IXMLDOMNodeList* iface,
        IXMLDOMNode** nextItem)
{
    queryresult *This = impl_from_IXMLDOMNodeList( iface );

262
    TRACE("(%p)->(%p)\n", This, nextItem );
263

264 265 266
    if(!nextItem)
        return E_INVALIDARG;

267 268
    *nextItem = NULL;

269
    if (This->resultPos >= xmlXPathNodeSetGetLength(This->result->nodesetval))
270 271
        return S_FALSE;

272
    *nextItem = create_node(xmlXPathNodeSetItem(This->result->nodesetval, This->resultPos));
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
    This->resultPos++;
    return S_OK;
}

static HRESULT WINAPI queryresult_reset(
        IXMLDOMNodeList* iface)
{
    queryresult *This = impl_from_IXMLDOMNodeList( iface );

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

static HRESULT WINAPI queryresult__newEnum(
        IXMLDOMNodeList* iface,
        IUnknown** ppUnk)
{
291 292
    queryresult *This = impl_from_IXMLDOMNodeList( iface );
    FIXME("(%p)->(%p)\n", This, ppUnk);
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
    return E_NOTIMPL;
}


static const struct IXMLDOMNodeListVtbl queryresult_vtbl =
{
    queryresult_QueryInterface,
    queryresult_AddRef,
    queryresult_Release,
    queryresult_GetTypeInfoCount,
    queryresult_GetTypeInfo,
    queryresult_GetIDsOfNames,
    queryresult_Invoke,
    queryresult_get_item,
    queryresult_get_length,
    queryresult_nextNode,
    queryresult_reset,
    queryresult__newEnum,
};

313 314 315 316
static HRESULT queryresult_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid)
{
    queryresult *This = impl_from_IXMLDOMNodeList( (IXMLDOMNodeList*)iface );
    WCHAR *ptr;
317
    int idx = 0;
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336

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

    if(idx >= xmlXPathNodeSetGetLength(This->result->nodesetval))
        return DISP_E_UNKNOWNNAME;

    *dispid = MSXML_DISPID_CUSTOM_MIN + idx;
    TRACE("ret %x\n", *dispid);
    return S_OK;
}

static HRESULT queryresult_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
        VARIANT *res, EXCEPINFO *ei)
{
    queryresult *This = impl_from_IXMLDOMNodeList( (IXMLDOMNodeList*)iface );

337
    TRACE("(%p)->(%x %x %x %p %p %p)\n", This, id, lcid, flags, params, res, ei);
338 339

    V_VT(res) = VT_DISPATCH;
340 341 342 343 344 345 346 347 348
    V_DISPATCH(res) = NULL;

    switch(flags)
    {
        case INVOKE_PROPERTYGET:
        {
            IXMLDOMNode *disp = NULL;

            queryresult_get_item(XMLQUERYRES(This), id - MSXML_DISPID_CUSTOM_MIN, &disp);
349
            V_DISPATCH(res) = (IDispatch*)disp;
350 351 352 353 354 355 356 357 358
            break;
        }
        default:
        {
            FIXME("unimplemented flags %x\n", flags);
            break;
        }
    }

359 360
    TRACE("ret %p\n", V_DISPATCH(res));

361 362 363 364 365 366 367 368
    return S_OK;
}

static const dispex_static_data_vtbl_t queryresult_dispex_vtbl = {
    queryresult_get_dispid,
    queryresult_invoke
};

369 370 371 372 373
static const tid_t queryresult_iface_tids[] = {
    IXMLDOMNodeList_tid,
    0
};
static dispex_static_data_t queryresult_dispex = {
374
    &queryresult_dispex_vtbl,
375
    IXMLDOMSelection_tid,
376 377 378 379
    NULL,
    queryresult_iface_tids
};

380 381
#define XSLPATTERN_CHECK_ARGS(n) \
    if (nargs != n) { \
382
        FIXME("XSLPattern syntax error: Expected %i arguments, got %i\n", n, nargs); \
383
        xmlXPathSetArityError(pctx); \
384 385 386 387 388 389 390 391 392
        return; \
    }


void XSLPattern_index(xmlXPathParserContextPtr pctx, int nargs)
{
    XSLPATTERN_CHECK_ARGS(0);

    xmlXPathPositionFunction(pctx, 0);
393
    xmlXPathReturnNumber(pctx, xmlXPathPopNumber(pctx) - 1.0);
394 395 396 397 398 399 400 401 402 403 404
}

void XSLPattern_end(xmlXPathParserContextPtr pctx, int nargs)
{
    double pos, last;
    XSLPATTERN_CHECK_ARGS(0);

    xmlXPathPositionFunction(pctx, 0);
    pos = xmlXPathPopNumber(pctx);
    xmlXPathLastFunction(pctx, 0);
    last = xmlXPathPopNumber(pctx);
405
    xmlXPathReturnBoolean(pctx, pos == last);
406 407
}

408 409 410 411 412 413
void XSLPattern_nodeType(xmlXPathParserContextPtr pctx, int nargs)
{
    XSLPATTERN_CHECK_ARGS(0);
    xmlXPathReturnNumber(pctx, pctx->context->node->type);
}

414 415 416 417 418 419 420
void XSLPattern_OP_IEq(xmlXPathParserContextPtr pctx, int nargs)
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
421
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) == 0);
422 423 424 425 426 427 428 429 430 431 432
    xmlFree(arg1);
    xmlFree(arg2);
}

void XSLPattern_OP_INEq(xmlXPathParserContextPtr pctx, int nargs)
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
433
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) != 0);
434 435 436 437 438 439 440 441 442 443 444
    xmlFree(arg1);
    xmlFree(arg2);
}

void XSLPattern_OP_ILt(xmlXPathParserContextPtr pctx, int nargs)
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
445
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) < 0);
446 447 448 449 450 451 452 453 454 455 456
    xmlFree(arg1);
    xmlFree(arg2);
}

void XSLPattern_OP_ILEq(xmlXPathParserContextPtr pctx, int nargs)
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
457
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) <= 0);
458 459 460 461 462 463 464 465 466 467 468
    xmlFree(arg1);
    xmlFree(arg2);
}

void XSLPattern_OP_IGt(xmlXPathParserContextPtr pctx, int nargs)
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
469
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) > 0);
470 471 472 473 474 475 476 477 478 479 480
    xmlFree(arg1);
    xmlFree(arg2);
}

void XSLPattern_OP_IGEq(xmlXPathParserContextPtr pctx, int nargs)
{
    xmlChar *arg1, *arg2;
    XSLPATTERN_CHECK_ARGS(2);

    arg2 = xmlXPathPopString(pctx);
    arg1 = xmlXPathPopString(pctx);
481
    xmlXPathReturnBoolean(pctx, xmlStrcasecmp(arg1, arg2) >= 0);
482 483 484 485
    xmlFree(arg1);
    xmlFree(arg2);
}

486 487 488 489 490
static void query_serror(void* ctx, xmlErrorPtr err)
{
    LIBXML2_CALLBACK_SERROR(queryresult_create, err);
}

491
HRESULT queryresult_create(xmlNodePtr node, LPCWSTR szQuery, IXMLDOMNodeList **out)
Piotr Caban's avatar
Piotr Caban committed
492
{
493
    queryresult *This = heap_alloc_zero(sizeof(queryresult));
Piotr Caban's avatar
Piotr Caban committed
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
    xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
    xmlChar *str = xmlChar_from_wchar(szQuery);
    HRESULT hr;

    TRACE("(%p, %s, %p)\n", node, wine_dbgstr_w(szQuery), out);

    *out = NULL;
    if (This == NULL || ctxt == NULL || str == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto cleanup;
    }

    This->lpVtbl = &queryresult_vtbl;
    This->ref = 1;
    This->resultPos = 0;
    This->node = node;
    xmldoc_add_ref(This->node->doc);

513
    ctxt->error = query_serror;
Piotr Caban's avatar
Piotr Caban committed
514
    ctxt->node = node;
515 516
    registerNamespaces(ctxt);

517 518 519 520 521 522 523 524
    if (is_xpathmode(This->node->doc))
    {
        xmlXPathRegisterAllFunctions(ctxt);
    }
    else
    {
        xmlChar* tmp;
        int len;
525
        tmp = XSLPattern_to_XPath(ctxt, str);
526 527 528 529 530 531 532 533 534 535
        len = (xmlStrlen(tmp)+1)*sizeof(xmlChar);
        str = heap_realloc(str, len);
        memcpy(str, tmp, len);
        xmlFree(tmp);

        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);
536
        xmlXPathRegisterFunc(ctxt, (xmlChar const*)"nodeType", XSLPattern_nodeType);
537 538 539 540 541 542 543 544 545

        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);
    }

546
    This->result = xmlXPathEvalExpression(str, ctxt);
Piotr Caban's avatar
Piotr Caban committed
547 548 549 550 551 552
    if (!This->result || This->result->type != XPATH_NODESET)
    {
        hr = E_FAIL;
        goto cleanup;
    }

553 554 555
    init_dispex(&This->dispex, (IUnknown*)&This->lpVtbl, &queryresult_dispex);

    *out = (IXMLDOMNodeList *) &This->lpVtbl;
Piotr Caban's avatar
Piotr Caban committed
556 557 558 559 560 561
    hr = S_OK;
    TRACE("found %d matches\n", xmlXPathNodeSetGetLength(This->result->nodesetval));

cleanup:
    if (This != NULL && FAILED(hr))
        IXMLDOMNodeList_Release( (IXMLDOMNodeList*) &This->lpVtbl );
562
    xmlXPathFreeContext(ctxt);
563
    heap_free(str);
Piotr Caban's avatar
Piotr Caban committed
564 565 566
    return hr;
}

567
#endif