?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
android: Update app-specific/MIME type icons
[LibreOffice.git] / forms / source / xforms / xpathlib / xpathlib.cxx
blobe2f0a10eba5841411030b6db09495021f4fc34a0
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <string.h>
22
23 #include <comphelper/servicehelper.hxx>
24 #include <o3tl/string_view.hxx>
25 #include <sal/types.h>
26 #include <rtl/ustring.hxx>
27 #include <rtl/string.hxx>
28 #include <rtl/strbuf.hxx>
29 #include <tools/date.hxx>
30 #include <tools/time.hxx>
31 #include <tools/datetime.hxx>
32
33 #include <com/sun/star/uno/Reference.hxx>
34 #include <com/sun/star/uno/Sequence.hxx>
35 #include <com/sun/star/xforms/XModel.hpp>
36 #include <com/sun/star/xml/dom/XNode.hpp>
37 #include <com/sun/star/xml/dom/XDocument.hpp>
38 #include <com/sun/star/lang/XUnoTunnel.hpp>
39
40 #include <boost/lexical_cast.hpp>
41 #include <libxml/xpathInternals.h>
42
43 #include "xpathlib.hxx"
44 #include "extension.hxx"
45
46 // C interface
47
48 using namespace com::sun::star::uno;
49 using namespace com::sun::star::xml::dom;
50 using namespace com::sun::star::xforms;
51 using namespace com::sun::star::lang;
52
53 xmlXPathFunction xforms_lookupFunc(void *, const xmlChar *xname, const xmlChar *)
54 {
55
56 const char *name = reinterpret_cast<char const *>(xname);
57 if (strcmp("boolean-from-string", name)==0)
58 return xforms_booleanFromStringFunction;
59 else if ((strcmp("if", name))==0)
60 return xforms_ifFunction;
61 else if ((strcmp("avg", name))==0)
62 return xforms_avgFunction;
63 else if ((strcmp("min", name))==0)
64 return xforms_minFunction;
65 else if ((strcmp("max", name))==0)
66 return xforms_maxFunction;
67 else if ((strcmp("count-non-empty", name))==0)
68 return xforms_countNonEmptyFunction;
69 else if ((strcmp("index", name))==0)
70 return xforms_indexFunction;
71 else if ((strcmp("property", name))==0)
72 return xforms_propertyFunction;
73 else if ((strcmp("now", name))==0)
74 return xforms_nowFunction;
75 else if ((strcmp("days-from-date", name))==0)
76 return xforms_daysFromDateFunction;
77 else if ((strcmp("seconds-from-dateTime", name))==0)
78 return xforms_secondsFromDateTimeFunction;
79 else if ((strcmp("seconds", name))==0)
80 return xforms_secondsFunction;
81 else if ((strcmp("months", name))==0)
82 return xforms_monthsFunction;
83 else if ((strcmp("instance", name))==0)
84 return xforms_instanceFunction;
85 else if ((strcmp("current", name))==0)
86 return xforms_currentFunction;
87 else
88 return nullptr;
89 }
90
91 // boolean functions
92 void xforms_booleanFromStringFunction(xmlXPathParserContextPtr ctxt, int nargs)
93 {
94 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
95 xmlChar *pString = xmlXPathPopString(ctxt);
96 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
97 OUString aString(reinterpret_cast<char*>(pString), strlen(reinterpret_cast<char*>(pString)), RTL_TEXTENCODING_UTF8);
98 if (aString.equalsIgnoreAsciiCase("true") ||
99 aString.equalsIgnoreAsciiCase("1"))
100 xmlXPathReturnTrue(ctxt);
101 else if (aString.equalsIgnoreAsciiCase("false") ||
102 aString.equalsIgnoreAsciiCase("0"))
103 xmlXPathReturnFalse(ctxt);
104 else
105 XP_ERROR(XPATH_NUMBER_ERROR);
106 }
107
108 void xforms_ifFunction(xmlXPathParserContextPtr ctxt, int nargs)
109 {
110 if (nargs != 3) XP_ERROR(XPATH_INVALID_ARITY);
111 xmlChar *s2 = xmlXPathPopString(ctxt);
112
113 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
114 xmlChar *s1 = xmlXPathPopString(ctxt);
115 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
116 bool aBool = xmlXPathPopBoolean(ctxt);
117 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
118
119 if (aBool)
120 xmlXPathReturnString(ctxt, s1);
121 else
122 xmlXPathReturnString(ctxt, s2);
123
124 }
125
126 // Number Functions
127 void xforms_avgFunction(xmlXPathParserContextPtr ctxt, int nargs)
128 {
129 // use sum(), div() and count()
130 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
131
132 // save nodeset
133 xmlXPathObjectPtr pObject = valuePop(ctxt);
134 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
135 //push back a copy
136 valuePush(ctxt, xmlXPathObjectCopy(pObject));
137 // get the Sum
138 xmlXPathSumFunction(ctxt, 1);
139 double nSum = xmlXPathPopNumber(ctxt);
140 // push a copy once more
141 valuePush(ctxt, xmlXPathObjectCopy(pObject));
142 xmlXPathCountFunction(ctxt, 1);
143 double nCount = xmlXPathPopNumber(ctxt);
144 // push args for div()
145 xmlXPathReturnNumber(ctxt, nSum);
146 xmlXPathReturnNumber(ctxt, nCount);
147 xmlXPathDivValues(ctxt);
148 // the result is now on the ctxt stack
149 xmlXPathFreeObject(pObject);
150 }
151
152 void xforms_minFunction(xmlXPathParserContextPtr ctxt, int nargs)
153 {
154 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
155 xmlNodeSetPtr pNodeSet = xmlXPathPopNodeSet(ctxt);
156 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
157 double nMinimum = 0;
158 for (int i = 0; i < xmlXPathNodeSetGetLength(pNodeSet); i++)
159 {
160 double nNumber = xmlXPathCastNodeToNumber(xmlXPathNodeSetItem(pNodeSet, i));
161 if (xmlXPathIsNaN(nNumber))
162 {
163 xmlXPathReturnNumber(ctxt, xmlXPathNAN);
164 return;
165 }
166 if (i == 0)
167 nMinimum = nNumber;
168 else if (nNumber < nMinimum)
169 nMinimum = nNumber;
170 }
171 xmlXPathReturnNumber(ctxt, nMinimum);
172 }
173
174 void xforms_maxFunction(xmlXPathParserContextPtr ctxt, int nargs)
175 {
176 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
177 xmlNodeSetPtr pNodeSet = xmlXPathPopNodeSet(ctxt);
178 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
179 double nMaximum = 0;
180 for (int i = 0; i < xmlXPathNodeSetGetLength(pNodeSet); i++)
181 {
182 double nNumber = xmlXPathCastNodeToNumber(xmlXPathNodeSetItem(pNodeSet, i));
183 if (xmlXPathIsNaN(nNumber))
184 {
185 xmlXPathReturnNumber(ctxt, xmlXPathNAN);
186 return;
187 }
188 if (i == 0)
189 nMaximum = nNumber;
190 else if (nNumber > nMaximum)
191 nMaximum = nNumber;
192 }
193 xmlXPathReturnNumber(ctxt, nMaximum);
194 }
195 void xforms_countNonEmptyFunction(xmlXPathParserContextPtr ctxt, int nargs)
196 {
197 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
198 xmlNodeSetPtr pNodeSet = xmlXPathPopNodeSet(ctxt);
199 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
200 sal_Int32 nNotEmpty = 0;
201 for (int i = 0; i < xmlXPathNodeSetGetLength(pNodeSet); i++)
202 {
203 const xmlChar *aString = xmlXPathCastNodeToString(xmlXPathNodeSetItem(pNodeSet, i));
204 if (*aString != 0) nNotEmpty++;
205 }
206 xmlXPathReturnNumber(ctxt, nNotEmpty);
207 }
208 void xforms_indexFunction(xmlXPathParserContextPtr /*ctxt*/, int /*nargs*/)
209 {
210 // function index takes a string argument that is the IDREF of a
211 // 'repeat' and returns the current 1-based position of the repeat
212 // index of the identified repeat -- see xforms/9.3.1
213
214 // doc.getElementByID
215 // (...)
216 }
217
218 // String Functions
219 void xforms_propertyFunction(xmlXPathParserContextPtr ctxt, int nargs)
220 {
221 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
222 xmlChar* pString = xmlXPathPopString(ctxt);
223 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
224 OUString aString(reinterpret_cast<char*>(pString), strlen(reinterpret_cast<char*>(pString)), RTL_TEXTENCODING_UTF8);
225 if (aString.equalsIgnoreAsciiCase("version"))
226 xmlXPathReturnString(ctxt, reinterpret_cast<xmlChar *>(const_cast<char *>("1.0")));
227 else if (aString.equalsIgnoreAsciiCase("conformance-level"))
228 xmlXPathReturnString(ctxt, reinterpret_cast<xmlChar *>(const_cast<char *>("conformance")));
229 else
230 xmlXPathReturnEmptyString(ctxt);
231 }
232
233 // Date and Time Functions
234
235 static OString makeDateTimeString (const DateTime& aDateTime)
236 {
237 OStringBuffer aDateTimeString;
238 aDateTimeString.append(static_cast<sal_Int32>(aDateTime.GetYear()));
239 aDateTimeString.append('-');
240 if (aDateTime.GetMonth()<10) aDateTimeString.append('0');
241 aDateTimeString.append(static_cast<sal_Int32>(aDateTime.GetMonth()));
242 aDateTimeString.append('-');
243 if (aDateTime.GetDay()<10) aDateTimeString.append('0');
244 aDateTimeString.append(static_cast<sal_Int32>(aDateTime.GetDay()));
245 aDateTimeString.append('T');
246 if (aDateTime.GetHour()<10) aDateTimeString.append('0');
247 aDateTimeString.append(static_cast<sal_Int32>(aDateTime.GetHour()));
248 aDateTimeString.append(':');
249 if (aDateTime.GetMin()<10) aDateTimeString.append('0');
250 aDateTimeString.append(static_cast<sal_Int32>(aDateTime.GetMin()));
251 aDateTimeString.append(':');
252 if (aDateTime.GetSec()<10) aDateTimeString.append('0');
253 aDateTimeString.append(static_cast<sal_Int32>(aDateTime.GetSec()));
254 aDateTimeString.append('Z');
255
256 return aDateTimeString.makeStringAndClear();
257 }
258
259 // returns current system date and time in canonical xsd:dateTime
260 // format
261 void xforms_nowFunction(xmlXPathParserContextPtr ctxt, int /*nargs*/)
262 {
263 /*
264 A single lexical representation, which is a subset of the lexical representations
265 allowed by [ISO 8601], is allowed for dateTime. This lexical representation is the
266 [ISO 8601] extended format CCYY-MM-DDThh:mm:ss where "CC" represents the century,
267 "YY" the year, "MM" the month and "DD" the day, preceded by an optional leading "-"
268 sign to indicate a negative number. If the sign is omitted, "+" is assumed. The letter
269 "T" is the date/time separator and "hh", "mm", "ss" represent hour, minute and second
270 respectively.
271 */
272
273 /*
274 3.2.7.2 Canonical representation
275 The canonical representation for dateTime is defined by prohibiting certain options
276 from the Lexical representation (par.3.2.7.1). Specifically, either the time zone must
277 be omitted or, if present, the time zone must be Coordinated Universal tools::Time (UTC)
278 indicated by a "Z".
279 */
280 DateTime aDateTime( DateTime::SYSTEM );
281 OString aDateTimeString = makeDateTimeString(aDateTime);
282 xmlChar *pString = static_cast<xmlChar*>(xmlMalloc(aDateTimeString.getLength()+1));
283 strncpy(reinterpret_cast<char*>(pString), aDateTimeString.getStr(), aDateTimeString.getLength());
284 pString[aDateTimeString.getLength()] = 0;
285 xmlXPathReturnString(ctxt, pString);
286 }
287
288 static bool parseDateTime(std::u16string_view aString, DateTime& aDateTime)
289 {
290 // take apart a canonical literal xsd:dateTime string
291 //CCYY-MM-DDThh:mm:ss(Z)
292
293 OUString aDateTimeString( o3tl::trim(aString) );
294
295 // check length
296 if (aDateTimeString.getLength() < 19 || aDateTimeString.getLength() > 20)
297 return false;
298
299 sal_Int32 nIndex = 0;
300 sal_Int32 nYear = o3tl::toInt32(o3tl::getToken(aDateTimeString, 0, '-', nIndex));
301 sal_Int32 nMonth = o3tl::toInt32(o3tl::getToken(aDateTimeString, 0, '-', nIndex));
302 sal_Int32 nDay = o3tl::toInt32(o3tl::getToken(aDateTimeString, 0, 'T', nIndex));
303 sal_Int32 nHour = o3tl::toInt32(o3tl::getToken(aDateTimeString, 0, ':', nIndex));
304 sal_Int32 nMinute = o3tl::toInt32(o3tl::getToken(aDateTimeString, 0, ':', nIndex));
305 sal_Int32 nSecond = o3tl::toInt32(o3tl::getToken(aDateTimeString, 0, 'Z', nIndex));
306
307 Date tmpDate(static_cast<sal_uInt16>(nDay), static_cast<sal_uInt16>(nMonth), static_cast<sal_uInt16>(nYear));
308 tools::Time tmpTime(nHour, nMinute, nSecond);
309 DateTime tmpDateTime(tmpDate, tmpTime);
310 if (aString.rfind('Z') == std::u16string_view::npos)
311 tmpDateTime.ConvertToUTC();
312
313 aDateTime = tmpDateTime;
314
315 return true;
316 }
317
318
319 void xforms_daysFromDateFunction(xmlXPathParserContextPtr ctxt, int nargs)
320 {
321 // number of days from 1970-01-01 to supplied xsd:date(Time)
322
323 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
324 xmlChar* pString = xmlXPathPopString(ctxt);
325 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
326 OUString aString(reinterpret_cast<char*>(pString), strlen(reinterpret_cast<char*>(pString)), RTL_TEXTENCODING_UTF8);
327
328 DateTime aDateTime( DateTime::EMPTY );
329 if (parseDateTime(aString, aDateTime))
330 {
331 Date aReferenceDate(1, 1, 1970);
332 sal_Int32 nDays = aDateTime - aReferenceDate;
333 xmlXPathReturnNumber(ctxt, nDays);
334 }
335 else
336 xmlXPathReturnNumber(ctxt, xmlXPathNAN);
337
338
339 }
340
341
342 void xforms_secondsFromDateTimeFunction(xmlXPathParserContextPtr ctxt, int nargs)
343 {
344 // number of seconds from 1970-01-01T00:00:00Z to supplied xsd:date(Time)
345
346 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
347 xmlChar* pString = xmlXPathPopString(ctxt);
348 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
349 OUString aString(reinterpret_cast<char*>(pString), strlen(reinterpret_cast<char*>(pString)), RTL_TEXTENCODING_UTF8);
350
351 DateTime aDateTime( DateTime::EMPTY );
352
353 if (parseDateTime(aString, aDateTime))
354 {
355 Date aReferenceDate(1, 1, 1970);
356 sal_Int32 nDays = aDateTime - aReferenceDate;
357 sal_Int32 nSeconds = nDays * 24 * 60 * 60;
358 nSeconds += aDateTime.GetHour() * 60 * 60;
359 nSeconds += aDateTime.GetMin() * 60;
360 nSeconds += aDateTime.GetSec();
361 xmlXPathReturnNumber(ctxt, nSeconds);
362 }
363 else
364 xmlXPathReturnNumber(ctxt, xmlXPathNAN);
365
366 }
367
368 static bool parseDuration(const xmlChar* aString, bool& bNegative, sal_Int32& nYears, sal_Int32& nMonth, sal_Int32& nDays,
369 sal_Int32& nHours, sal_Int32& nMinutes, sal_Int32& nSeconds)
370 {
371 bool bTime = false; // in part after T
372 const xmlChar *pString = aString;
373
374 if (pString[0] == '-') {
375 bNegative = true;
376 pString++;
377 }
378
379 if (pString[0] != 'P')
380 {
381 return false;
382 }
383
384 pString++;
385 const xmlChar* pToken = pString;
386 while(pToken[0] != 0)
387 {
388 switch(pToken[0]) {
389 case 'Y':
390 nYears = boost::lexical_cast<sal_Int32>(pString, pString-pToken);
391 pString = ++pToken;
392 break;
393 case 'M':
394 if (!bTime)
395 nMonth = boost::lexical_cast<sal_Int32>(pString, pString-pToken);
396 else
397 nMinutes = boost::lexical_cast<sal_Int32>(pString, pString-pToken);
398 pString = ++pToken;
399 break;
400 case 'D':
401 nDays = boost::lexical_cast<sal_Int32>(pString, pString-pToken);
402 pString = ++pToken;
403 break;
404 case 'H':
405 nHours = boost::lexical_cast<sal_Int32>(pString, pString-pToken);
406 pString = ++pToken;
407 break;
408 case 'S':
409 nSeconds = boost::lexical_cast<sal_Int32>(pString, pString-pToken);
410 pString = ++pToken;
411 break;
412 case 'T':
413 bTime = true;
414 pString = ++pToken;
415 break;
416 default:
417 pToken++;
418 }
419 }
420 return true;
421 }
422
423 void xforms_secondsFunction(xmlXPathParserContextPtr ctxt, int nargs)
424 {
425 // convert a xsd:duration to seconds
426 // (-)PnYnMnDTnHnMnS
427 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
428 xmlChar* pString = xmlXPathPopString(ctxt);
429 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
430
431 bool bNegative = false;
432 sal_Int32 nYears = 0;
433 sal_Int32 nMonths = 0;
434 sal_Int32 nDays = 0;
435 sal_Int32 nHours = 0;
436 sal_Int32 nMinutes = 0;
437 sal_Int32 nSeconds = 0;
438
439 if (parseDuration(pString, bNegative, nYears, nMonths, nDays, nHours, nMinutes, nSeconds))
440 {
441 nSeconds += nMinutes*60;
442 nSeconds += nHours*60*60;
443 nSeconds += nDays*24*60*60;
444 // year and month are ignored according to spec
445 if (bNegative)
446 nSeconds = 0 - nSeconds;
447 xmlXPathReturnNumber(ctxt, nSeconds);
448 }
449 else
450 xmlXPathReturnNumber(ctxt, xmlXPathNAN);
451 }
452
453 void xforms_monthsFunction(xmlXPathParserContextPtr ctxt, int nargs)
454 {
455 // convert a xsd:duration to seconds
456 // (-)PnYnMnDTnHnMnS
457 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
458 xmlChar* pString = xmlXPathPopString(ctxt);
459 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
460
461 bool bNegative = false;
462 sal_Int32 nYears = 0;
463 sal_Int32 nMonths = 0;
464 sal_Int32 nDays = 0;
465 sal_Int32 nHours = 0;
466 sal_Int32 nMinutes = 0;
467 sal_Int32 nSeconds = 0;
468
469 if (parseDuration(pString, bNegative, nYears, nMonths, nDays, nHours, nMinutes, nSeconds))
470 {
471 nMonths += nYears*12;
472 // Days, Hours, Minutes and seconds are ignored, see spec
473 if (bNegative)
474 nMonths = 0 - nMonths;
475 xmlXPathReturnNumber(ctxt, nMonths);
476 }
477 else
478 xmlXPathReturnNumber(ctxt, xmlXPathNAN);
479
480 }
481
482 // Node-set Functions
483 void xforms_instanceFunction(xmlXPathParserContextPtr ctxt, int nargs)
484 {
485 if (nargs != 1) XP_ERROR(XPATH_INVALID_ARITY);
486 xmlChar *pString = xmlXPathPopString(ctxt);
487 if (xmlXPathCheckError(ctxt)) XP_ERROR(XPATH_INVALID_TYPE);
488 OUString aString(reinterpret_cast<char*>(pString), strlen(reinterpret_cast<char*>(pString)), RTL_TEXTENCODING_UTF8);
489
490 Reference< XModel > aModel = static_cast<CLibxml2XFormsExtension*>(ctxt->context->funcLookupData)->getModel();
491 if (aModel.is())
492 {
493 Reference< XDocument > aInstance = aModel->getInstanceDocument(aString);
494 if (aInstance.is())
495 {
496 try {
497 // xmlXPathObjectPtr xmlXPathNewNodeSet (xmlNodePtr val);
498 Reference< XUnoTunnel > aTunnel(aInstance, UNO_QUERY_THROW);
499 xmlNodePtr pNode = comphelper::getSomething_cast<xmlNode>(aTunnel->getSomething(Sequence<sal_Int8>()));
500 xmlXPathObjectPtr pObject = xmlXPathNewNodeSet(pNode);
501 xmlXPathReturnNodeSet(ctxt, pObject->nodesetval);
502 } catch (const RuntimeException&)
503 {
504 xmlXPathReturnEmptyNodeSet(ctxt);
505 }
506 }
507 else
508 xmlXPathReturnEmptyNodeSet(ctxt);
509 }
510 else
511 xmlXPathReturnEmptyNodeSet(ctxt);
512
513 }
514
515 // Node-set Functions, XForms 1.1
516 void xforms_currentFunction(xmlXPathParserContextPtr ctxt, int nargs)
517 {
518 if (nargs != 0) XP_ERROR(XPATH_INVALID_ARITY);
519
520 Reference< XNode > aNode = static_cast<CLibxml2XFormsExtension*>(ctxt->context->funcLookupData)->getContextNode();
521
522 if (aNode.is())
523 {
524 try {
525 Reference< XUnoTunnel > aTunnel(aNode, UNO_QUERY_THROW);
526 xmlNodePtr pNode = comphelper::getSomething_cast<xmlNode>(aTunnel->getSomething(Sequence<sal_Int8>()));
527 xmlXPathObjectPtr pObject = xmlXPathNewNodeSet(pNode);
528 xmlXPathReturnNodeSet(ctxt, pObject->nodesetval);
529 }
530 catch (const RuntimeException&)
531 {
532 xmlXPathReturnEmptyNodeSet(ctxt);
533 }
534 }
535 else
536 xmlXPathReturnEmptyNodeSet(ctxt);
537 }
538
539 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE