Coverage Report

Created: 2023-03-26 10:05

/src/libxslt/libexslt/sets.c
Line
Count
Source (jump to first uncovered line)
1
#define IN_LIBEXSLT
2
#include "libexslt/libexslt.h"
3
4
#include <libxml/tree.h>
5
#include <libxml/xpath.h>
6
#include <libxml/xpathInternals.h>
7
8
#include <libxslt/xsltutils.h>
9
#include <libxslt/xsltInternals.h>
10
#include <libxslt/extensions.h>
11
12
#include "exslt.h"
13
14
/**
15
 * exsltSetsDifferenceFunction:
16
 * @ctxt:  an XPath parser context
17
 * @nargs:  the number of arguments
18
 *
19
 * Wraps #xmlXPathDifference for use by the XPath processor
20
 */
21
static void
22
247
exsltSetsDifferenceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
23
247
    xmlNodeSetPtr arg1, arg2, ret;
24
25
247
    if (nargs != 2) {
26
25
  xmlXPathSetArityError(ctxt);
27
25
  return;
28
25
    }
29
30
222
    arg2 = xmlXPathPopNodeSet(ctxt);
31
222
    if (xmlXPathCheckError(ctxt))
32
15
  return;
33
34
207
    arg1 = xmlXPathPopNodeSet(ctxt);
35
207
    if (xmlXPathCheckError(ctxt)) {
36
18
        xmlXPathFreeNodeSet(arg2);
37
18
  return;
38
18
    }
39
40
189
    ret = xmlXPathDifference(arg1, arg2);
41
42
189
    if (ret != arg1)
43
150
  xmlXPathFreeNodeSet(arg1);
44
189
    xmlXPathFreeNodeSet(arg2);
45
46
189
    xmlXPathReturnNodeSet(ctxt, ret);
47
189
}
48
49
/**
50
 * exsltSetsIntersectionFunction:
51
 * @ctxt:  an XPath parser context
52
 * @nargs:  the number of arguments
53
 *
54
 * Wraps #xmlXPathIntersection for use by the XPath processor
55
 */
56
static void
57
255
exsltSetsIntersectionFunction (xmlXPathParserContextPtr ctxt, int nargs) {
58
255
    xmlNodeSetPtr arg1, arg2, ret;
59
60
255
    if (nargs != 2) {
61
27
  xmlXPathSetArityError(ctxt);
62
27
  return;
63
27
    }
64
65
228
    arg2 = xmlXPathPopNodeSet(ctxt);
66
228
    if (xmlXPathCheckError(ctxt))
67
21
  return;
68
69
207
    arg1 = xmlXPathPopNodeSet(ctxt);
70
207
    if (xmlXPathCheckError(ctxt)) {
71
15
        xmlXPathFreeNodeSet(arg2);
72
15
  return;
73
15
    }
74
75
192
    ret = xmlXPathIntersection(arg1, arg2);
76
77
192
    xmlXPathFreeNodeSet(arg1);
78
192
    xmlXPathFreeNodeSet(arg2);
79
80
192
    xmlXPathReturnNodeSet(ctxt, ret);
81
192
}
82
83
/**
84
 * exsltSetsDistinctFunction:
85
 * @ctxt:  an XPath parser context
86
 * @nargs:  the number of arguments
87
 *
88
 * Wraps #xmlXPathDistinct for use by the XPath processor
89
 */
90
static void
91
682
exsltSetsDistinctFunction (xmlXPathParserContextPtr ctxt, int nargs) {
92
682
    xmlXPathObjectPtr obj;
93
682
    xmlNodeSetPtr ns, ret;
94
682
    int boolval = 0;
95
682
    void *user = NULL;
96
97
682
    if (nargs != 1) {
98
18
  xmlXPathSetArityError(ctxt);
99
18
  return;
100
18
    }
101
102
664
    if (ctxt->value != NULL) {
103
664
        boolval = ctxt->value->boolval;
104
664
  user = ctxt->value->user;
105
664
  ctxt->value->boolval = 0;
106
664
  ctxt->value->user = NULL;
107
664
    }
108
664
    ns = xmlXPathPopNodeSet(ctxt);
109
664
    if (xmlXPathCheckError(ctxt))
110
20
  return;
111
112
    /* !!! must be sorted !!! */
113
644
    ret = xmlXPathDistinctSorted(ns);
114
115
644
  if (ret != ns)
116
604
    xmlXPathFreeNodeSet(ns);
117
118
644
    obj = xmlXPathWrapNodeSet(ret);
119
644
    obj->user = user;
120
644
    obj->boolval = boolval;
121
644
    valuePush((ctxt), obj);
122
644
}
123
124
/**
125
 * exsltSetsHasSameNodesFunction:
126
 * @ctxt:  an XPath parser context
127
 * @nargs:  the number of arguments
128
 *
129
 * Wraps #xmlXPathHasSameNodes for use by the XPath processor
130
 */
131
static void
132
exsltSetsHasSameNodesFunction (xmlXPathParserContextPtr ctxt,
133
218
            int nargs) {
134
218
    xmlNodeSetPtr arg1, arg2;
135
218
    int ret;
136
137
218
    if (nargs != 2) {
138
21
  xmlXPathSetArityError(ctxt);
139
21
  return;
140
21
    }
141
142
197
    arg2 = xmlXPathPopNodeSet(ctxt);
143
197
    if (xmlXPathCheckError(ctxt))
144
21
  return;
145
146
176
    arg1 = xmlXPathPopNodeSet(ctxt);
147
176
    if (xmlXPathCheckError(ctxt)) {
148
14
        xmlXPathFreeNodeSet(arg2);
149
14
  return;
150
14
    }
151
152
162
    ret = xmlXPathHasSameNodes(arg1, arg2);
153
154
162
    xmlXPathFreeNodeSet(arg1);
155
162
    xmlXPathFreeNodeSet(arg2);
156
157
162
    xmlXPathReturnBoolean(ctxt, ret);
158
162
}
159
160
/**
161
 * exsltSetsLeadingFunction:
162
 * @ctxt:  an XPath parser context
163
 * @nargs:  the number of arguments
164
 *
165
 * Wraps #xmlXPathLeading for use by the XPath processor
166
 */
167
static void
168
377
exsltSetsLeadingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
169
377
    xmlNodeSetPtr arg1, arg2, ret;
170
171
377
    if (nargs != 2) {
172
37
  xmlXPathSetArityError(ctxt);
173
37
  return;
174
37
    }
175
176
340
    arg2 = xmlXPathPopNodeSet(ctxt);
177
340
    if (xmlXPathCheckError(ctxt))
178
19
  return;
179
180
321
    arg1 = xmlXPathPopNodeSet(ctxt);
181
321
    if (xmlXPathCheckError(ctxt)) {
182
18
  xmlXPathFreeNodeSet(arg2);
183
18
  return;
184
18
    }
185
186
    /*  If the second node set is empty, then the first node set is
187
     * returned.
188
     */
189
303
    if (xmlXPathNodeSetIsEmpty(arg2)) {
190
124
  xmlXPathReturnNodeSet(ctxt, arg1);
191
192
124
  xmlXPathFreeNodeSet(arg2);
193
194
124
  return;
195
124
    }
196
    /* !!! must be sorted */
197
179
    ret = xmlXPathNodeLeadingSorted(arg1, xmlXPathNodeSetItem(arg2, 0));
198
199
179
    xmlXPathFreeNodeSet(arg1);
200
179
    xmlXPathFreeNodeSet(arg2);
201
202
179
    xmlXPathReturnNodeSet(ctxt, ret);
203
179
}
204
205
/**
206
 * exsltSetsTrailingFunction:
207
 * @ctxt:  an XPath parser context
208
 * @nargs:  the number of arguments
209
 *
210
 * Wraps #xmlXPathTrailing for use by the XPath processor
211
 */
212
static void
213
324
exsltSetsTrailingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
214
324
    xmlNodeSetPtr arg1, arg2, ret;
215
216
324
    if (nargs != 2) {
217
56
  xmlXPathSetArityError(ctxt);
218
56
  return;
219
56
    }
220
221
268
    arg2 = xmlXPathPopNodeSet(ctxt);
222
268
    if (xmlXPathCheckError(ctxt))
223
20
  return;
224
225
248
    arg1 = xmlXPathPopNodeSet(ctxt);
226
248
    if (xmlXPathCheckError(ctxt)) {
227
38
  xmlXPathFreeNodeSet(arg2);
228
38
  return;
229
38
    }
230
231
    /*  If the second node set is empty, then the first node set is
232
     * returned.
233
     */
234
210
    if (xmlXPathNodeSetIsEmpty(arg2)) {
235
46
  xmlXPathReturnNodeSet(ctxt, arg1);
236
237
46
  xmlXPathFreeNodeSet(arg2);
238
239
46
  return;
240
46
    }
241
    /* !!! mist be sorted */
242
164
    ret = xmlXPathNodeTrailingSorted(arg1, xmlXPathNodeSetItem(arg2, 0));
243
244
164
    xmlXPathFreeNodeSet(arg1);
245
164
    xmlXPathFreeNodeSet(arg2);
246
247
164
    xmlXPathReturnNodeSet(ctxt, ret);
248
164
}
249
250
/**
251
 * exsltSetsRegister:
252
 *
253
 * Registers the EXSLT - Sets module
254
 */
255
256
void
257
3.75k
exsltSetsRegister (void) {
258
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "difference",
259
3.75k
           EXSLT_SETS_NAMESPACE,
260
3.75k
           exsltSetsDifferenceFunction);
261
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "intersection",
262
3.75k
           EXSLT_SETS_NAMESPACE,
263
3.75k
           exsltSetsIntersectionFunction);
264
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "distinct",
265
3.75k
           EXSLT_SETS_NAMESPACE,
266
3.75k
           exsltSetsDistinctFunction);
267
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "has-same-node",
268
3.75k
           EXSLT_SETS_NAMESPACE,
269
3.75k
           exsltSetsHasSameNodesFunction);
270
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "leading",
271
3.75k
           EXSLT_SETS_NAMESPACE,
272
3.75k
           exsltSetsLeadingFunction);
273
3.75k
    xsltRegisterExtModuleFunction ((const xmlChar *) "trailing",
274
3.75k
           EXSLT_SETS_NAMESPACE,
275
3.75k
           exsltSetsTrailingFunction);
276
3.75k
}
277
278
/**
279
 * exsltSetsXpathCtxtRegister:
280
 *
281
 * Registers the EXSLT - Sets module for use outside XSLT
282
 */
283
int
284
exsltSetsXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix)
285
0
{
286
0
    if (ctxt
287
0
        && prefix
288
0
        && !xmlXPathRegisterNs(ctxt,
289
0
                               prefix,
290
0
                               (const xmlChar *) EXSLT_SETS_NAMESPACE)
291
0
        && !xmlXPathRegisterFuncNS(ctxt,
292
0
                                   (const xmlChar *) "difference",
293
0
                                   (const xmlChar *) EXSLT_SETS_NAMESPACE,
294
0
                                   exsltSetsDifferenceFunction)
295
0
        && !xmlXPathRegisterFuncNS(ctxt,
296
0
                                   (const xmlChar *) "intersection",
297
0
                                   (const xmlChar *) EXSLT_SETS_NAMESPACE,
298
0
                                   exsltSetsIntersectionFunction)
299
0
        && !xmlXPathRegisterFuncNS(ctxt,
300
0
                                   (const xmlChar *) "distinct",
301
0
                                   (const xmlChar *) EXSLT_SETS_NAMESPACE,
302
0
                                   exsltSetsDistinctFunction)
303
0
        && !xmlXPathRegisterFuncNS(ctxt,
304
0
                                   (const xmlChar *) "has-same-node",
305
0
                                   (const xmlChar *) EXSLT_SETS_NAMESPACE,
306
0
                                   exsltSetsHasSameNodesFunction)
307
0
        && !xmlXPathRegisterFuncNS(ctxt,
308
0
                                   (const xmlChar *) "leading",
309
0
                                   (const xmlChar *) EXSLT_SETS_NAMESPACE,
310
0
                                   exsltSetsLeadingFunction)
311
0
        && !xmlXPathRegisterFuncNS(ctxt,
312
0
                                   (const xmlChar *) "trailing",
313
0
                                   (const xmlChar *) EXSLT_SETS_NAMESPACE,
314
0
                                   exsltSetsTrailingFunction)) {
315
0
        return 0;
316
0
    }
317
0
    return -1;
318
0
}