| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_forms.hxx" |
| #include <string.h> |
| #include <sal/types.h> |
| #include <rtl/alloc.h> |
| #include <rtl/ustring.hxx> |
| #include <rtl/string.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/strbuf.hxx> |
| #include <tools/date.hxx> |
| #include <tools/time.hxx> |
| #include <tools/datetime.hxx> |
| |
| #include <com/sun/star/uno/Reference.hxx> |
| #include <com/sun/star/uno/Sequence.hxx> |
| #include <com/sun/star/uno/Any.hxx> |
| #include <com/sun/star/xforms/XModel.hpp> |
| #include <com/sun/star/xml/dom/XNode.hpp> |
| #include <com/sun/star/xml/dom/XDocument.hpp> |
| #include <com/sun/star/lang/XUnoTunnel.hpp> |
| |
| #include "xpathlib.hxx" |
| |
| #include "extension.hxx" |
| |
| // C interface |
| |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::xml::dom; |
| using namespace com::sun::star::xforms; |
| using namespace com::sun::star::lang; |
| |
| xmlXPathFunction xforms_lookupFunc(void *, const xmlChar *xname, const xmlChar *) |
| { |
| |
| const char *name = (char *)xname; |
| if (strcmp("boolean-from-string", name)==0) |
| return xforms_booleanFromStringFunction; |
| else if ((strcmp("if", name))==0) |
| return xforms_ifFunction; |
| else if ((strcmp("avg", name))==0) |
| return xforms_avgFunction; |
| else if ((strcmp("min", name))==0) |
| return xforms_minFunction; |
| else if ((strcmp("max", name))==0) |
| return xforms_maxFunction; |
| else if ((strcmp("count-non-empty", name))==0) |
| return xforms_countNonEmptyFunction; |
| else if ((strcmp("index", name))==0) |
| return xforms_indexFunction; |
| else if ((strcmp("property", name))==0) |
| return xforms_propertyFunction; |
| else if ((strcmp("now", name))==0) |
| return xforms_nowFunction; |
| else if ((strcmp("days-from-date", name))==0) |
| return xforms_daysFromDateFunction; |
| else if ((strcmp("seconds-from-dateTime", name))==0) |
| return xforms_secondsFromDateTimeFunction; |
| else if ((strcmp("seconds", name))==0) |
| return xforms_secondsFuction; |
| else if ((strcmp("months", name))==0) |
| return xforms_monthsFuction; |
| else if ((strcmp("instance", name))==0) |
| return xforms_instanceFuction; |
| else if ((strcmp("current", name))==0) |
| return xforms_currentFunction; |
| else |
| return NULL; |
| } |
| |
| // boolean functions |
| void xforms_booleanFromStringFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar *pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| ::rtl::OUString aString((char*)pString, strlen((char*)pString), RTL_TEXTENCODING_UTF8); |
| if (aString.equalsIgnoreAsciiCaseAscii("true") || aString.equalsIgnoreAsciiCaseAscii("1")) |
| xmlXPathReturnTrue(ctxt); |
| else if (aString.equalsIgnoreAsciiCaseAscii("false") || aString.equalsIgnoreAsciiCaseAscii("0")) |
| xmlXPathReturnFalse(ctxt); |
| else |
| XP_ERROR(XPATH_NUMBER_ERROR); |
| } |
| |
| void xforms_ifFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 3) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar *s2 = xmlXPathPopString(ctxt); |
| |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| xmlChar *s1 = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| bool aBool = xmlXPathPopBoolean(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| |
| if (aBool) |
| xmlXPathReturnString(ctxt, s1); |
| else |
| xmlXPathReturnString(ctxt, s2); |
| |
| } |
| |
| // Number Functions |
| void xforms_avgFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| // use sum(), div() and count() |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| |
| // save nodeset |
| xmlXPathObjectPtr pObject = valuePop(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| //push back a copy |
| valuePush(ctxt, xmlXPathObjectCopy(pObject)); |
| // get the Sum |
| xmlXPathSumFunction(ctxt, 1); |
| double nSum = xmlXPathPopNumber(ctxt); |
| // push a copy once more |
| valuePush(ctxt, xmlXPathObjectCopy(pObject)); |
| xmlXPathCountFunction(ctxt, 1); |
| double nCount = xmlXPathPopNumber(ctxt); |
| // push args for div() |
| xmlXPathReturnNumber(ctxt, nSum); |
| xmlXPathReturnNumber(ctxt, nCount); |
| xmlXPathDivValues(ctxt); |
| // the result is now on the ctxt stack |
| xmlXPathFreeObject(pObject); |
| } |
| |
| void xforms_minFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlNodeSetPtr pNodeSet = xmlXPathPopNodeSet(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| double nMinimum = 0; |
| double nNumber = 0; |
| for (int i = 0; i < xmlXPathNodeSetGetLength(pNodeSet); i++) |
| { |
| nNumber = xmlXPathCastNodeToNumber(xmlXPathNodeSetItem(pNodeSet, i)); |
| if (xmlXPathIsNaN(nNumber)) |
| { |
| xmlXPathReturnNumber(ctxt, xmlXPathNAN); |
| return; |
| } |
| if (i == 0) |
| nMinimum = nNumber; |
| else if (nNumber < nMinimum) |
| nMinimum = nNumber; |
| } |
| xmlXPathReturnNumber(ctxt, nMinimum); |
| } |
| |
| void xforms_maxFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlNodeSetPtr pNodeSet = xmlXPathPopNodeSet(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| double nMaximum = 0; |
| double nNumber = 0; |
| for (int i = 0; i < xmlXPathNodeSetGetLength(pNodeSet); i++) |
| { |
| nNumber = xmlXPathCastNodeToNumber(xmlXPathNodeSetItem(pNodeSet, i)); |
| if (xmlXPathIsNaN(nNumber)) |
| { |
| xmlXPathReturnNumber(ctxt, xmlXPathNAN); |
| return; |
| } |
| if (i == 0) |
| nMaximum = nNumber; |
| else if (nNumber > nMaximum) |
| nMaximum = nNumber; |
| } |
| xmlXPathReturnNumber(ctxt, nMaximum); |
| } |
| void xforms_countNonEmptyFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlNodeSetPtr pNodeSet = xmlXPathPopNodeSet(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| xmlChar *aString; |
| sal_Int32 nNotEmpty = 0; |
| for (int i = 0; i < xmlXPathNodeSetGetLength(pNodeSet); i++) |
| { |
| aString = xmlXPathCastNodeToString(xmlXPathNodeSetItem(pNodeSet, i)); |
| if (strlen((char*)aString) > 0) nNotEmpty++; |
| } |
| xmlXPathReturnNumber(ctxt, nNotEmpty); |
| } |
| void xforms_indexFunction(xmlXPathParserContextPtr /*ctxt*/, int /*nargs*/) |
| { |
| // function index takes a string argument that is the IDREF of a |
| // 'repeat' and returns the current 1-based position of the repeat |
| // index of the identified repeat -- see xforms/9.3.1 |
| |
| // doc.getElementByID |
| // (...) |
| } |
| |
| // String Functions |
| static const char* _version = "1.0"; |
| static const char* _conformance = "conformance"; |
| void xforms_propertyFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar* pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| ::rtl::OUString aString((char*)pString, strlen((char*)pString), RTL_TEXTENCODING_UTF8); |
| if (aString.equalsIgnoreAsciiCaseAscii("version")) |
| xmlXPathReturnString(ctxt, (xmlChar*)_version); |
| else if (aString.equalsIgnoreAsciiCaseAscii("conformance-level")) |
| xmlXPathReturnString(ctxt, (xmlChar*)_conformance); |
| else |
| xmlXPathReturnEmptyString(ctxt); |
| } |
| |
| // Date and Time Functions |
| |
| static ::rtl::OString makeDateTimeString (const DateTime& aDateTime, sal_Bool bUTC = sal_True) |
| { |
| ::rtl::OStringBuffer aDateTimeString; |
| aDateTimeString.append((sal_Int32)aDateTime.GetYear()); |
| aDateTimeString.append("-"); |
| if (aDateTime.GetMonth()<10) aDateTimeString.append("0"); |
| aDateTimeString.append((sal_Int32)aDateTime.GetMonth()); |
| aDateTimeString.append("-"); |
| if (aDateTime.GetDay()<10) aDateTimeString.append("0"); |
| aDateTimeString.append((sal_Int32)aDateTime.GetDay()); |
| aDateTimeString.append("T"); |
| if (aDateTime.GetHour()<10) aDateTimeString.append("0"); |
| aDateTimeString.append((sal_Int32)aDateTime.GetHour()); |
| aDateTimeString.append(":"); |
| if (aDateTime.GetMin()<10) aDateTimeString.append("0"); |
| aDateTimeString.append((sal_Int32)aDateTime.GetMin()); |
| aDateTimeString.append(":"); |
| if (aDateTime.GetSec()<10) aDateTimeString.append("0"); |
| aDateTimeString.append((sal_Int32)aDateTime.GetSec()); |
| if (bUTC) aDateTimeString.append("Z"); |
| |
| return aDateTimeString.makeStringAndClear(); |
| } |
| |
| // returns current system date and time in canonical xsd:dateTime |
| // format |
| void xforms_nowFunction(xmlXPathParserContextPtr ctxt, int /*nargs*/) |
| { |
| /* |
| A single lexical representation, which is a subset of the lexical representations |
| allowed by [ISO 8601], is allowed for dateTime. This lexical representation is the |
| [ISO 8601] extended format CCYY-MM-DDThh:mm:ss where "CC" represents the century, |
| "YY" the year, "MM" the month and "DD" the day, preceded by an optional leading "-" |
| sign to indicate a negative number. If the sign is omitted, "+" is assumed. The letter |
| "T" is the date/time separator and "hh", "mm", "ss" represent hour, minute and second |
| respectively. |
| */ |
| |
| /* |
| 3.2.7.2 Canonical representation |
| The canonical representation for dateTime is defined by prohibiting certain options |
| from the Lexical representation (par.3.2.7.1). Specifically, either the time zone must |
| be omitted or, if present, the time zone must be Coordinated Universal Time (UTC) |
| indicated by a "Z". |
| */ |
| DateTime aDateTime; |
| ::rtl::OString aDateTimeString = makeDateTimeString(aDateTime); |
| xmlChar *pString = static_cast<xmlChar*>(xmlMalloc(aDateTimeString.getLength()+1)); |
| strncpy((char*)pString, (char*)aDateTimeString.getStr(), aDateTimeString.getLength()); |
| pString[aDateTimeString.getLength()] = 0; |
| xmlXPathReturnString(ctxt, pString); |
| } |
| |
| static sal_Bool parseDateTime(const ::rtl::OUString& aString, DateTime& aDateTime) |
| { |
| // take apart a canonical literal xsd:dateTime string |
| //CCYY-MM-DDThh:mm:ss(Z) |
| |
| ::rtl::OUString aDateTimeString = aString.trim(); |
| |
| // check length |
| if (aDateTimeString.getLength() < 19 || aDateTimeString.getLength() > 20) |
| return sal_False; |
| |
| sal_Int32 nDateLength = 10; |
| sal_Int32 nTimeLength = 8; |
| |
| ::rtl::OUString aDateTimeSep = ::rtl::OUString::createFromAscii("T"); |
| ::rtl::OUString aDateSep = ::rtl::OUString::createFromAscii("-"); |
| ::rtl::OUString aTimeSep = ::rtl::OUString::createFromAscii(":"); |
| ::rtl::OUString aUTCString = ::rtl::OUString::createFromAscii("Z"); |
| |
| ::rtl::OUString aDateString = aDateTimeString.copy(0, nDateLength); |
| ::rtl::OUString aTimeString = aDateTimeString.copy(nDateLength+1, nTimeLength); |
| |
| sal_Int32 nIndex = 0; |
| sal_Int32 nYear = aDateString.getToken(0, '-', nIndex).toInt32(); |
| sal_Int32 nMonth = aDateString.getToken(0, '-', nIndex).toInt32(); |
| sal_Int32 nDay = aDateString.getToken(0, '-', nIndex).toInt32(); |
| nIndex = 0; |
| sal_Int32 nHour = aTimeString.getToken(0, ':', nIndex).toInt32(); |
| sal_Int32 nMinute = aTimeString.getToken(0, ':', nIndex).toInt32(); |
| sal_Int32 nSecond = aTimeString.getToken(0, ':', nIndex).toInt32(); |
| |
| Date tmpDate((sal_uInt16)nDay, (sal_uInt16)nMonth, (sal_uInt16)nYear); |
| Time tmpTime(nHour, nMinute, nSecond); |
| DateTime tmpDateTime(tmpDate, tmpTime); |
| if (aString.indexOf(aUTCString) < 0) |
| tmpDateTime.ConvertToUTC(); |
| |
| aDateTime = tmpDateTime; |
| |
| return sal_True; |
| } |
| |
| |
| void xforms_daysFromDateFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| // number of days from 1970-01-01 to supplied xsd:date(Time) |
| |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar* pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| ::rtl::OUString aString((char*)pString, strlen((char*)pString), RTL_TEXTENCODING_UTF8); |
| |
| DateTime aDateTime; |
| if (parseDateTime(aString, aDateTime)) |
| { |
| Date aReferenceDate(1, 1, 1970); |
| sal_Int32 nDays = aDateTime - aReferenceDate; |
| xmlXPathReturnNumber(ctxt, nDays); |
| } |
| else |
| xmlXPathReturnNumber(ctxt, xmlXPathNAN); |
| |
| |
| } |
| |
| |
| void xforms_secondsFromDateTimeFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| // number of seconds from 1970-01-01T00:00:00Z to supplied xsd:date(Time) |
| |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar* pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| ::rtl::OUString aString((char*)pString, strlen((char*)pString), RTL_TEXTENCODING_UTF8); |
| |
| DateTime aDateTime; |
| |
| if (parseDateTime(aString, aDateTime)) |
| { |
| Date aReferenceDate(1, 1, 1970); |
| Time aReferenceTime(0, 0, 0); |
| sal_Int32 nDays = aDateTime - aReferenceDate; |
| sal_Int32 nSeconds = nDays * 24 * 60 * 60; |
| nSeconds += aDateTime.GetHour() * 60 * 60; |
| nSeconds += aDateTime.GetMin() * 60; |
| nSeconds += aDateTime.GetSec(); |
| xmlXPathReturnNumber(ctxt, nSeconds); |
| } |
| else |
| xmlXPathReturnNumber(ctxt, xmlXPathNAN); |
| |
| } |
| |
| static sal_Bool parseDuration(const xmlChar* aString, sal_Bool& bNegative, sal_Int32& nYears, sal_Int32& nMonth, sal_Int32& nDays, |
| sal_Int32& nHours, sal_Int32& nMinutes, sal_Int32& nSeconds) |
| { |
| sal_Bool bTime = sal_False; // in part after T |
| sal_Int32 nLength = strlen((char*)aString)+1; |
| char *pString = (char*)rtl_allocateMemory(nLength); |
| char *pString0 = pString; |
| strncpy(pString, (char*)aString, nLength); |
| |
| if (pString[0] == '-') { |
| bNegative = sal_True; |
| pString++; |
| } |
| |
| if (pString[0] != 'P') |
| return sal_False; |
| pString++; |
| char* pToken = pString; |
| while(pToken[0] != 0) |
| { |
| switch(pToken[0]) { |
| case 'Y': |
| pToken[0] = 0; |
| nYears = atoi(pString); |
| pString = ++pToken; |
| break; |
| case 'M': |
| pToken[0] = 0; |
| if (!bTime) |
| nMonth = atoi(pString); |
| else |
| nMinutes = atoi(pString); |
| pString = ++pToken; |
| break; |
| case 'D': |
| pToken[0] = 0; |
| nDays = atoi(pString); |
| pString = ++pToken; |
| break; |
| case 'H': |
| pToken[0] = 0; |
| nHours = atoi(pString); |
| pString = ++pToken; |
| break; |
| case 'S': |
| pToken[0] = 0; |
| nSeconds = atoi(pString); |
| pString = ++pToken; |
| break; |
| case 'T': |
| bTime = sal_True; |
| pString = ++pToken; |
| break; |
| default: |
| pToken++; |
| } |
| } |
| rtl_freeMemory(pString0); |
| return sal_True; |
| } |
| |
| void xforms_secondsFuction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| // convert a xsd:duration to seconds |
| // (-)PnYnMnDTnHnMnS |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar* pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| |
| sal_Bool bNegative = sal_False; |
| sal_Int32 nYears = 0; |
| sal_Int32 nMonths = 0; |
| sal_Int32 nDays = 0; |
| sal_Int32 nHours = 0; |
| sal_Int32 nMinutes = 0; |
| sal_Int32 nSeconds = 0; |
| |
| if (parseDuration(pString, bNegative, nYears, nMonths, nDays, nHours, nMinutes, nSeconds)) |
| { |
| nSeconds += nMinutes*60; |
| nSeconds += nHours*60*60; |
| nSeconds += nDays*24*60*60; |
| // year and month are ignored according to spec |
| if (bNegative) |
| nSeconds = 0 - nSeconds; |
| xmlXPathReturnNumber(ctxt, nSeconds); |
| } |
| else |
| xmlXPathReturnNumber(ctxt, xmlXPathNAN); |
| } |
| |
| void xforms_monthsFuction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| // convert a xsd:duration to seconds |
| // (-)PnYnMnDTnHnMnS |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar* pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| |
| sal_Bool bNegative = sal_False; |
| sal_Int32 nYears = 0; |
| sal_Int32 nMonths = 0; |
| sal_Int32 nDays = 0; |
| sal_Int32 nHours = 0; |
| sal_Int32 nMinutes = 0; |
| sal_Int32 nSeconds = 0; |
| |
| if (parseDuration(pString, bNegative, nYears, nMonths, nDays, nHours, nMinutes, nSeconds)) |
| { |
| nMonths += nYears*12; |
| // Days, Houres, Minutes and seconds are ignored, see spec |
| if (bNegative) |
| nMonths = 0 - nMonths; |
| xmlXPathReturnNumber(ctxt, nMonths); |
| } |
| else |
| xmlXPathReturnNumber(ctxt, xmlXPathNAN); |
| |
| } |
| |
| // Node-set Functions |
| void xforms_instanceFuction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY); |
| xmlChar *pString = xmlXPathPopString(ctxt); |
| if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE); |
| ::rtl::OUString aString((char*)pString, strlen((char*)pString), RTL_TEXTENCODING_UTF8); |
| |
| Reference< XModel > aModel = ((CLibxml2XFormsExtension*)ctxt->context->funcLookupData)->getModel(); |
| if (aModel.is()) |
| { |
| Reference< XDocument > aInstance = aModel->getInstanceDocument(aString); |
| if (aInstance.is()) |
| { |
| try { |
| // xmlXPathObjectPtr xmlXPathNewNodeSet (xmlNodePtr val); |
| Reference< XUnoTunnel > aTunnel(aInstance, UNO_QUERY_THROW); |
| xmlNodePtr pNode = reinterpret_cast< xmlNodePtr >( aTunnel->getSomething(Sequence< sal_Int8 >()) ); |
| xmlXPathObjectPtr pObject = xmlXPathNewNodeSet(pNode); |
| xmlXPathReturnNodeSet(ctxt, pObject->nodesetval); |
| } catch (RuntimeException&) |
| { |
| xmlXPathReturnEmptyNodeSet(ctxt); |
| } |
| } |
| else |
| xmlXPathReturnEmptyNodeSet(ctxt); |
| } |
| else |
| xmlXPathReturnEmptyNodeSet(ctxt); |
| |
| } |
| |
| // Node-set Functions, XForms 1.1 |
| void xforms_currentFunction(xmlXPathParserContextPtr ctxt, int nargs) |
| { |
| if (nargs != 0) XP_ERROR(XPATH_INVALID_ARITY); |
| |
| Reference< XNode > aNode = ((CLibxml2XFormsExtension*)ctxt->context->funcLookupData)->getContextNode(); |
| |
| if (aNode.is()) |
| { |
| try { |
| Reference< XUnoTunnel > aTunnel(aNode, UNO_QUERY_THROW); |
| xmlNodePtr pNode = reinterpret_cast< xmlNodePtr >( aTunnel->getSomething(Sequence< sal_Int8 >()) ); |
| xmlXPathObjectPtr pObject = xmlXPathNewNodeSet(pNode); |
| xmlXPathReturnNodeSet(ctxt, pObject->nodesetval); |
| } |
| catch (RuntimeException&) |
| { |
| xmlXPathReturnEmptyNodeSet(ctxt); |
| } |
| } |
| else |
| xmlXPathReturnEmptyNodeSet(ctxt); |
| } |
