fasthtmlparser-pure 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- fasthtmlparser_pure/__init__.py +41 -0
- fasthtmlparser_pure/_api.py +636 -0
- fasthtmlparser_pure/_api.pyi +342 -0
- fasthtmlparser_pure/_attrs.py +270 -0
- fasthtmlparser_pure/_chars.py +124 -0
- fasthtmlparser_pure/_css.py +861 -0
- fasthtmlparser_pure/_decode.py +144 -0
- fasthtmlparser_pure/_links.py +483 -0
- fasthtmlparser_pure/_parser.py +866 -0
- fasthtmlparser_pure/_query.py +128 -0
- fasthtmlparser_pure/_tables.py +2494 -0
- fasthtmlparser_pure/_text.py +257 -0
- fasthtmlparser_pure/_xpath.py +1594 -0
- fasthtmlparser_pure/py.typed +0 -0
- fasthtmlparser_pure-0.1.0.dist-info/METADATA +166 -0
- fasthtmlparser_pure-0.1.0.dist-info/RECORD +19 -0
- fasthtmlparser_pure-0.1.0.dist-info/WHEEL +5 -0
- fasthtmlparser_pure-0.1.0.dist-info/licenses/LICENSE.md +79 -0
- fasthtmlparser_pure-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,1594 @@
|
|
|
1
|
+
"""XPath 1.0 over the flat tag list: the root, elements, comments, text nodes (runs of source text between tags) and
|
|
2
|
+
attributes (positions in the opening tag).
|
|
3
|
+
|
|
4
|
+
All axes (except namespace), predicates, |, the operators and the XPath 1.0 functions are supported, plus
|
|
5
|
+
ends-with(), lower-case() and upper-case(). HTML rules apply: names are case-insensitive, the string-value of an
|
|
6
|
+
element is its visible text, attribute values and text are decoded. Variables are not supported.
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
import math
|
|
10
|
+
|
|
11
|
+
from . import _attrs as at
|
|
12
|
+
from . import _decode as dec
|
|
13
|
+
from . import _text
|
|
14
|
+
from ._chars import SPACE, SPACE_RUNS, equal_fold, is_alpha, is_digit, lower, quote, trim_space, upper, \
|
|
15
|
+
utf16_length
|
|
16
|
+
from ._css import element_at
|
|
17
|
+
from ._parser import COMMENT, NAMES, is_raw_text
|
|
18
|
+
from ._query import Query
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
class XPathError(ValueError):
|
|
22
|
+
"""An invalid XPath expression, or one that cannot be evaluated."""
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
# value types
|
|
26
|
+
TYPE_NODE_SET = 0
|
|
27
|
+
TYPE_NUMBER = 1
|
|
28
|
+
TYPE_STRING = 2
|
|
29
|
+
TYPE_BOOLEAN = 3
|
|
30
|
+
TYPE_NAMES = ("node-set", "number", "string", "boolean")
|
|
31
|
+
|
|
32
|
+
# expressions
|
|
33
|
+
E_LITERAL = 0 # value
|
|
34
|
+
E_NUMBER = 1 # value
|
|
35
|
+
E_AND = 2 # l, r
|
|
36
|
+
E_OR = 3 # l, r
|
|
37
|
+
E_COMPARE = 4 # cmp, l, r
|
|
38
|
+
E_ARITH = 5 # arith, l, r
|
|
39
|
+
E_NEGATE = 6 # e
|
|
40
|
+
E_UNION = 7 # l, r
|
|
41
|
+
E_ATTR_EQUALS = 8 # name, value, negate: @name = 'literal' compared in place
|
|
42
|
+
E_ATTR_EXISTS = 9 # name: [@name]
|
|
43
|
+
E_PATH = 10 # start (expr or None), absolute, steps; attr: a bare @name
|
|
44
|
+
E_FILTER = 11 # primary, preds
|
|
45
|
+
E_FUNCTION = 12 # fn, args
|
|
46
|
+
|
|
47
|
+
OP_EQ = 0
|
|
48
|
+
OP_NEQ = 1
|
|
49
|
+
OP_LT = 2
|
|
50
|
+
OP_LE = 3
|
|
51
|
+
OP_GT = 4
|
|
52
|
+
OP_GE = 5
|
|
53
|
+
|
|
54
|
+
ARITH_ADD = 0
|
|
55
|
+
ARITH_SUB = 1
|
|
56
|
+
ARITH_MUL = 2
|
|
57
|
+
ARITH_DIV = 3
|
|
58
|
+
ARITH_MOD = 4
|
|
59
|
+
|
|
60
|
+
# node tests
|
|
61
|
+
TK_NAME = 0
|
|
62
|
+
TK_PREFIX = 1 # dc:*
|
|
63
|
+
TK_WILDCARD = 2 # *
|
|
64
|
+
TK_NODE = 3 # node()
|
|
65
|
+
TK_TEXT = 4 # text()
|
|
66
|
+
TK_COMMENT = 5 # comment()
|
|
67
|
+
TK_PI = 6 # processing-instruction(): never matches
|
|
68
|
+
TK_CONTAINER = 7 # internal: the root and elements (// before a child or attribute step)
|
|
69
|
+
|
|
70
|
+
AXIS_CHILD = 0
|
|
71
|
+
AXIS_DESCENDANT = 1
|
|
72
|
+
AXIS_DESCENDANT_OR_SELF = 2
|
|
73
|
+
AXIS_SELF = 3
|
|
74
|
+
AXIS_PARENT = 4
|
|
75
|
+
AXIS_ANCESTOR = 5
|
|
76
|
+
AXIS_ANCESTOR_OR_SELF = 6
|
|
77
|
+
AXIS_FOLLOWING_SIBLING = 7
|
|
78
|
+
AXIS_PRECEDING_SIBLING = 8
|
|
79
|
+
AXIS_FOLLOWING = 9
|
|
80
|
+
AXIS_PRECEDING = 10
|
|
81
|
+
AXIS_ATTRIBUTE = 11
|
|
82
|
+
|
|
83
|
+
NAN = float("nan")
|
|
84
|
+
INF = float("inf")
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
class Expr:
|
|
88
|
+
__slots__ = ("op", "type", "pos", "value", "l", "r", "cmp", "arith", "e", "name", "negate", "start", "absolute",
|
|
89
|
+
"steps", "primary", "preds", "fn", "args", "attr")
|
|
90
|
+
|
|
91
|
+
def __init__(self, op, type_, pos, **fields):
|
|
92
|
+
self.op = op
|
|
93
|
+
self.type = type_
|
|
94
|
+
self.pos = pos # depends on the context position or size
|
|
95
|
+
self.value = self.l = self.r = self.cmp = self.arith = self.e = self.name = self.negate = None
|
|
96
|
+
self.start = self.absolute = self.steps = self.primary = self.preds = self.fn = self.args = self.attr = None
|
|
97
|
+
for k, v in fields.items():
|
|
98
|
+
setattr(self, k, v)
|
|
99
|
+
|
|
100
|
+
|
|
101
|
+
class Step:
|
|
102
|
+
__slots__ = ("axis", "test", "preds", "positional")
|
|
103
|
+
|
|
104
|
+
def __init__(self, axis, test, preds):
|
|
105
|
+
self.axis = axis
|
|
106
|
+
self.test = test
|
|
107
|
+
self.preds = preds
|
|
108
|
+
self.positional = any(p.type == TYPE_NUMBER or p.pos for p in preds)
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
class NodeTest:
|
|
112
|
+
__slots__ = ("k", "name", "q")
|
|
113
|
+
|
|
114
|
+
def __init__(self, k, name=""):
|
|
115
|
+
self.k = k
|
|
116
|
+
self.name = name
|
|
117
|
+
self.q = Query(name) if k == TK_NAME else None
|
|
118
|
+
|
|
119
|
+
|
|
120
|
+
ANY_NODE_TEST = NodeTest(TK_NODE)
|
|
121
|
+
CONTAINERS_TEST = NodeTest(TK_CONTAINER)
|
|
122
|
+
|
|
123
|
+
|
|
124
|
+
# ----- the compiler -----
|
|
125
|
+
|
|
126
|
+
T_END = 0
|
|
127
|
+
T_SLASH = 1
|
|
128
|
+
T_DOUBLE_SLASH = 2
|
|
129
|
+
T_LPAREN = 3
|
|
130
|
+
T_RPAREN = 4
|
|
131
|
+
T_LBRACKET = 5
|
|
132
|
+
T_RBRACKET = 6
|
|
133
|
+
T_DOT = 7
|
|
134
|
+
T_DOT_DOT = 8
|
|
135
|
+
T_AT = 9
|
|
136
|
+
T_COMMA = 10
|
|
137
|
+
T_COLON_COLON = 11
|
|
138
|
+
T_PIPE = 12
|
|
139
|
+
T_PLUS = 13
|
|
140
|
+
T_MINUS = 14
|
|
141
|
+
T_EQ = 15
|
|
142
|
+
T_NEQ = 16
|
|
143
|
+
T_LT = 17
|
|
144
|
+
T_LE = 18
|
|
145
|
+
T_GT = 19
|
|
146
|
+
T_GE = 20
|
|
147
|
+
T_STAR = 21 # name test *
|
|
148
|
+
T_MULTIPLY = 22 # operator *
|
|
149
|
+
T_AND = 23
|
|
150
|
+
T_OR = 24
|
|
151
|
+
T_DIV = 25
|
|
152
|
+
T_MOD = 26
|
|
153
|
+
T_NAME = 27
|
|
154
|
+
T_LITERAL = 28
|
|
155
|
+
T_NUMBER = 29
|
|
156
|
+
T_DOLLAR = 30
|
|
157
|
+
|
|
158
|
+
SINGLE = {"(": T_LPAREN, ")": T_RPAREN, "[": T_LBRACKET, "]": T_RBRACKET, "@": T_AT, ",": T_COMMA, "|": T_PIPE,
|
|
159
|
+
"+": T_PLUS, "-": T_MINUS, "=": T_EQ, "$": T_DOLLAR}
|
|
160
|
+
NODE_TYPES = frozenset(("node", "text", "comment", "processing-instruction"))
|
|
161
|
+
OPERATORS = {"and": T_AND, "or": T_OR, "div": T_DIV, "mod": T_MOD}
|
|
162
|
+
OPERAND_ENDS = frozenset((T_RPAREN, T_RBRACKET, T_DOT, T_DOT_DOT, T_STAR, T_NAME, T_LITERAL, T_NUMBER))
|
|
163
|
+
AXES = {
|
|
164
|
+
"child": AXIS_CHILD, "descendant": AXIS_DESCENDANT, "descendant-or-self": AXIS_DESCENDANT_OR_SELF,
|
|
165
|
+
"self": AXIS_SELF, "parent": AXIS_PARENT, "ancestor": AXIS_ANCESTOR, "ancestor-or-self": AXIS_ANCESTOR_OR_SELF,
|
|
166
|
+
"following-sibling": AXIS_FOLLOWING_SIBLING, "preceding-sibling": AXIS_PRECEDING_SIBLING,
|
|
167
|
+
"following": AXIS_FOLLOWING, "preceding": AXIS_PRECEDING, "attribute": AXIS_ATTRIBUTE,
|
|
168
|
+
}
|
|
169
|
+
MANY = 1 << 30
|
|
170
|
+
# name: (min args, max args, type)
|
|
171
|
+
FUNCTIONS = {
|
|
172
|
+
"last": (0, 0, TYPE_NUMBER), "position": (0, 0, TYPE_NUMBER), "count": (1, 1, TYPE_NUMBER),
|
|
173
|
+
"name": (0, 1, TYPE_STRING), "local-name": (0, 1, TYPE_STRING), "string": (0, 1, TYPE_STRING),
|
|
174
|
+
"concat": (2, MANY, TYPE_STRING), "starts-with": (2, 2, TYPE_BOOLEAN), "ends-with": (2, 2, TYPE_BOOLEAN),
|
|
175
|
+
"contains": (2, 2, TYPE_BOOLEAN), "substring-before": (2, 2, TYPE_STRING),
|
|
176
|
+
"substring-after": (2, 2, TYPE_STRING), "substring": (2, 3, TYPE_STRING), "string-length": (0, 1, TYPE_NUMBER),
|
|
177
|
+
"normalize-space": (0, 1, TYPE_STRING), "translate": (3, 3, TYPE_STRING), "lower-case": (1, 1, TYPE_STRING),
|
|
178
|
+
"upper-case": (1, 1, TYPE_STRING), "not": (1, 1, TYPE_BOOLEAN), "true": (0, 0, TYPE_BOOLEAN),
|
|
179
|
+
"false": (0, 0, TYPE_BOOLEAN), "boolean": (1, 1, TYPE_BOOLEAN), "number": (0, 1, TYPE_NUMBER),
|
|
180
|
+
"sum": (1, 1, TYPE_NUMBER), "floor": (1, 1, TYPE_NUMBER), "ceiling": (1, 1, TYPE_NUMBER),
|
|
181
|
+
"round": (1, 1, TYPE_NUMBER),
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
|
|
185
|
+
class Token:
|
|
186
|
+
__slots__ = ("k", "t", "n", "p")
|
|
187
|
+
|
|
188
|
+
def __init__(self, k, t, n, p):
|
|
189
|
+
self.k = k
|
|
190
|
+
self.t = t
|
|
191
|
+
self.n = n
|
|
192
|
+
self.p = p
|
|
193
|
+
|
|
194
|
+
|
|
195
|
+
def _letter(ch):
|
|
196
|
+
return is_alpha(ch) if ch < "\x80" else ch.isalpha()
|
|
197
|
+
|
|
198
|
+
|
|
199
|
+
def _xname_start(ch):
|
|
200
|
+
return ch == "_" or _letter(ch)
|
|
201
|
+
|
|
202
|
+
|
|
203
|
+
def _xname_char(ch):
|
|
204
|
+
if ch < "\x80":
|
|
205
|
+
return is_alpha(ch) or is_digit(ch) or ch in "_-."
|
|
206
|
+
return ch.isalpha() or ch.isdecimal()
|
|
207
|
+
|
|
208
|
+
|
|
209
|
+
def _digit(ch):
|
|
210
|
+
return ch != "" and "0" <= ch <= "9"
|
|
211
|
+
|
|
212
|
+
|
|
213
|
+
class _Compiler:
|
|
214
|
+
def __init__(self, expression):
|
|
215
|
+
self.expression = expression
|
|
216
|
+
self.source = expression
|
|
217
|
+
self.tokens = []
|
|
218
|
+
self.index = 0
|
|
219
|
+
self.tokenize()
|
|
220
|
+
|
|
221
|
+
def parse(self):
|
|
222
|
+
e = self.parse_expr()
|
|
223
|
+
if self.peek(0).k != T_END:
|
|
224
|
+
self.fail(f"unexpected {self.describe(self.peek(0))}")
|
|
225
|
+
return e
|
|
226
|
+
|
|
227
|
+
def fail_at(self, msg, position):
|
|
228
|
+
raise XPathError(f"invalid XPath {quote(self.expression)} at position {position}: {msg}")
|
|
229
|
+
|
|
230
|
+
def fail(self, msg):
|
|
231
|
+
self.fail_at(msg, self.peek(0).p)
|
|
232
|
+
|
|
233
|
+
def tokenize(self):
|
|
234
|
+
s = self.source
|
|
235
|
+
n = len(s)
|
|
236
|
+
i = 0
|
|
237
|
+
tokens = self.tokens
|
|
238
|
+
while True:
|
|
239
|
+
while i < n and s[i] in SPACE:
|
|
240
|
+
i += 1
|
|
241
|
+
if i >= n:
|
|
242
|
+
tokens.append(Token(T_END, "", 0.0, i))
|
|
243
|
+
return
|
|
244
|
+
start = i
|
|
245
|
+
ch = s[i]
|
|
246
|
+
nxt = s[i + 1] if i + 1 < n else ""
|
|
247
|
+
# XPath 1.0 lexical rule: after a token that can end an operand, '*' and and/or/div/mod are operators
|
|
248
|
+
operator_expected = bool(tokens) and tokens[-1].k in OPERAND_ENDS
|
|
249
|
+
kind = T_END
|
|
250
|
+
txt = ""
|
|
251
|
+
number = 0.0
|
|
252
|
+
if ch == "/":
|
|
253
|
+
if nxt == "/":
|
|
254
|
+
kind = T_DOUBLE_SLASH
|
|
255
|
+
i += 2
|
|
256
|
+
else:
|
|
257
|
+
kind = T_SLASH
|
|
258
|
+
i += 1
|
|
259
|
+
elif ch in SINGLE:
|
|
260
|
+
kind = SINGLE[ch]
|
|
261
|
+
i += 1
|
|
262
|
+
elif ch == "*":
|
|
263
|
+
kind = T_MULTIPLY if operator_expected else T_STAR
|
|
264
|
+
i += 1
|
|
265
|
+
elif ch == "!":
|
|
266
|
+
if nxt != "=":
|
|
267
|
+
self.fail_at("'!' must be followed by '='", i)
|
|
268
|
+
kind = T_NEQ
|
|
269
|
+
i += 2
|
|
270
|
+
elif ch == "<" or ch == ">":
|
|
271
|
+
if nxt == "=":
|
|
272
|
+
kind = T_LE if ch == "<" else T_GE
|
|
273
|
+
i += 2
|
|
274
|
+
else:
|
|
275
|
+
kind = T_LT if ch == "<" else T_GT
|
|
276
|
+
i += 1
|
|
277
|
+
elif ch == ":":
|
|
278
|
+
if nxt != ":":
|
|
279
|
+
self.fail_at("unexpected ':'", i)
|
|
280
|
+
kind = T_COLON_COLON
|
|
281
|
+
i += 2
|
|
282
|
+
elif ch == '"' or ch == "'":
|
|
283
|
+
stop = s.find(ch, i + 1)
|
|
284
|
+
if stop < 0:
|
|
285
|
+
self.fail_at("unterminated string literal", i)
|
|
286
|
+
kind = T_LITERAL
|
|
287
|
+
txt = s[i + 1:stop]
|
|
288
|
+
i = stop + 1
|
|
289
|
+
elif ch == "." and nxt == ".":
|
|
290
|
+
kind = T_DOT_DOT
|
|
291
|
+
i += 2
|
|
292
|
+
elif ch == "." and not _digit(nxt):
|
|
293
|
+
kind = T_DOT
|
|
294
|
+
i += 1
|
|
295
|
+
elif _digit(ch) or ch == ".":
|
|
296
|
+
while i < n and _digit(s[i]):
|
|
297
|
+
i += 1
|
|
298
|
+
if i < n and s[i] == ".":
|
|
299
|
+
i += 1
|
|
300
|
+
while i < n and _digit(s[i]):
|
|
301
|
+
i += 1
|
|
302
|
+
kind = T_NUMBER
|
|
303
|
+
number = float(s[start:i])
|
|
304
|
+
elif _xname_start(ch):
|
|
305
|
+
i += 1
|
|
306
|
+
while i < n:
|
|
307
|
+
if _xname_char(s[i]):
|
|
308
|
+
i += 1
|
|
309
|
+
elif s[i] == ":" and i + 1 < n and s[i + 1] != ":" and (_xname_start(s[i + 1]) or s[i + 1] == "*"):
|
|
310
|
+
# a prefixed name (dc:creator) or prefix:*
|
|
311
|
+
i += 2
|
|
312
|
+
if s[i - 1] == "*":
|
|
313
|
+
break
|
|
314
|
+
else:
|
|
315
|
+
break
|
|
316
|
+
kind = T_NAME
|
|
317
|
+
txt = s[start:i]
|
|
318
|
+
if operator_expected:
|
|
319
|
+
op = OPERATORS.get(txt)
|
|
320
|
+
if op is None:
|
|
321
|
+
self.fail_at(f"expected an operator, found '{txt}'", start)
|
|
322
|
+
kind = op
|
|
323
|
+
else:
|
|
324
|
+
self.fail_at(f"unexpected character '{ch}'", i)
|
|
325
|
+
tokens.append(Token(kind, txt, number, start))
|
|
326
|
+
|
|
327
|
+
# ----- parser helpers -----
|
|
328
|
+
|
|
329
|
+
def peek(self, offset):
|
|
330
|
+
i = self.index + offset
|
|
331
|
+
return self.tokens[i if i < len(self.tokens) else len(self.tokens) - 1]
|
|
332
|
+
|
|
333
|
+
def advance(self):
|
|
334
|
+
t = self.tokens[self.index]
|
|
335
|
+
self.index += 1
|
|
336
|
+
return t
|
|
337
|
+
|
|
338
|
+
def accept(self, kind):
|
|
339
|
+
if self.peek(0).k != kind:
|
|
340
|
+
return False
|
|
341
|
+
self.index += 1
|
|
342
|
+
return True
|
|
343
|
+
|
|
344
|
+
def expect(self, kind, what):
|
|
345
|
+
if not self.accept(kind):
|
|
346
|
+
self.fail(f"expected {what}, found {self.describe(self.peek(0))}")
|
|
347
|
+
|
|
348
|
+
def describe(self, t):
|
|
349
|
+
if t.k == T_END:
|
|
350
|
+
return "the end of the expression"
|
|
351
|
+
if t.k == T_NAME or t.k == T_LITERAL:
|
|
352
|
+
return f"'{t.t}'"
|
|
353
|
+
if t.k == T_NUMBER:
|
|
354
|
+
return number_to_string(t.n)
|
|
355
|
+
to = min(len(self.source), t.p + 2)
|
|
356
|
+
return "'" + self.source[t.p:to].rstrip() + "'"
|
|
357
|
+
|
|
358
|
+
# ----- expressions -----
|
|
359
|
+
|
|
360
|
+
@staticmethod
|
|
361
|
+
def attribute_name(e):
|
|
362
|
+
"""Whether the expression is a bare @name (one attribute step, no predicates); its name (lower case), or
|
|
363
|
+
None."""
|
|
364
|
+
if e.op != E_PATH or e.start is not None or e.absolute or len(e.steps) != 1:
|
|
365
|
+
return None
|
|
366
|
+
s = e.steps[0]
|
|
367
|
+
if s.axis != AXIS_ATTRIBUTE or s.preds or s.test.k != TK_NAME:
|
|
368
|
+
return None
|
|
369
|
+
return s.test.name.lower() if s.test.name.isascii() else _ascii_lower(s.test.name)
|
|
370
|
+
|
|
371
|
+
def make_equality(self, op, left, right):
|
|
372
|
+
"""@name = 'literal' is compared in place; everything else by the general rules."""
|
|
373
|
+
name = self.attribute_name(left)
|
|
374
|
+
if name is not None and right.op == E_LITERAL:
|
|
375
|
+
return Expr(E_ATTR_EQUALS, TYPE_BOOLEAN, False, name=name, value=right.value, negate=op == OP_NEQ)
|
|
376
|
+
name = self.attribute_name(right)
|
|
377
|
+
if name is not None and left.op == E_LITERAL:
|
|
378
|
+
return Expr(E_ATTR_EQUALS, TYPE_BOOLEAN, False, name=name, value=left.value, negate=op == OP_NEQ)
|
|
379
|
+
return Expr(E_COMPARE, TYPE_BOOLEAN, left.pos or right.pos, cmp=op, l=left, r=right)
|
|
380
|
+
|
|
381
|
+
@staticmethod
|
|
382
|
+
def optimize(steps):
|
|
383
|
+
"""//x is descendant-or-self::node()/child::x. Without positional predicates on x it is the same as
|
|
384
|
+
descendant::x: one linear scan of the tag list instead of the children of every node."""
|
|
385
|
+
steps = list(steps)
|
|
386
|
+
i = 0
|
|
387
|
+
while i < len(steps) - 1:
|
|
388
|
+
s = steps[i]
|
|
389
|
+
if s.axis == AXIS_DESCENDANT_OR_SELF and s.test is ANY_NODE_TEST and not s.preds:
|
|
390
|
+
nxt = steps[i + 1]
|
|
391
|
+
if nxt.axis == AXIS_CHILD and not nxt.positional:
|
|
392
|
+
steps[i] = Step(AXIS_DESCENDANT, nxt.test, nxt.preds)
|
|
393
|
+
del steps[i + 1]
|
|
394
|
+
elif nxt.axis == AXIS_CHILD or nxt.axis == AXIS_ATTRIBUTE:
|
|
395
|
+
# only the root and elements have children or attributes: skip the text nodes
|
|
396
|
+
steps[i] = Step(AXIS_DESCENDANT_OR_SELF, CONTAINERS_TEST, [])
|
|
397
|
+
i += 1
|
|
398
|
+
return steps
|
|
399
|
+
|
|
400
|
+
@staticmethod
|
|
401
|
+
def can_start_step(t):
|
|
402
|
+
return t.k in (T_DOT, T_DOT_DOT, T_AT, T_STAR, T_NAME)
|
|
403
|
+
|
|
404
|
+
# ----- grammar (XPath 1.0, section 3) -----
|
|
405
|
+
|
|
406
|
+
def parse_expr(self):
|
|
407
|
+
return self.parse_or()
|
|
408
|
+
|
|
409
|
+
def parse_or(self):
|
|
410
|
+
left = self.parse_and()
|
|
411
|
+
while self.accept(T_OR):
|
|
412
|
+
right = self.parse_and()
|
|
413
|
+
left = Expr(E_OR, TYPE_BOOLEAN, left.pos or right.pos, l=left, r=right)
|
|
414
|
+
return left
|
|
415
|
+
|
|
416
|
+
def parse_and(self):
|
|
417
|
+
left = self.parse_equality()
|
|
418
|
+
while self.accept(T_AND):
|
|
419
|
+
right = self.parse_equality()
|
|
420
|
+
left = Expr(E_AND, TYPE_BOOLEAN, left.pos or right.pos, l=left, r=right)
|
|
421
|
+
return left
|
|
422
|
+
|
|
423
|
+
def parse_equality(self):
|
|
424
|
+
left = self.parse_relational()
|
|
425
|
+
while True:
|
|
426
|
+
if self.accept(T_EQ):
|
|
427
|
+
op = OP_EQ
|
|
428
|
+
elif self.accept(T_NEQ):
|
|
429
|
+
op = OP_NEQ
|
|
430
|
+
else:
|
|
431
|
+
return left
|
|
432
|
+
left = self.make_equality(op, left, self.parse_relational())
|
|
433
|
+
|
|
434
|
+
def parse_relational(self):
|
|
435
|
+
left = self.parse_additive()
|
|
436
|
+
while True:
|
|
437
|
+
if self.accept(T_LT):
|
|
438
|
+
op = OP_LT
|
|
439
|
+
elif self.accept(T_LE):
|
|
440
|
+
op = OP_LE
|
|
441
|
+
elif self.accept(T_GT):
|
|
442
|
+
op = OP_GT
|
|
443
|
+
elif self.accept(T_GE):
|
|
444
|
+
op = OP_GE
|
|
445
|
+
else:
|
|
446
|
+
return left
|
|
447
|
+
right = self.parse_additive()
|
|
448
|
+
left = Expr(E_COMPARE, TYPE_BOOLEAN, left.pos or right.pos, cmp=op, l=left, r=right)
|
|
449
|
+
|
|
450
|
+
def parse_additive(self):
|
|
451
|
+
left = self.parse_multiplicative()
|
|
452
|
+
while True:
|
|
453
|
+
if self.accept(T_PLUS):
|
|
454
|
+
op = ARITH_ADD
|
|
455
|
+
elif self.accept(T_MINUS):
|
|
456
|
+
op = ARITH_SUB
|
|
457
|
+
else:
|
|
458
|
+
return left
|
|
459
|
+
right = self.parse_multiplicative()
|
|
460
|
+
left = Expr(E_ARITH, TYPE_NUMBER, left.pos or right.pos, arith=op, l=left, r=right)
|
|
461
|
+
|
|
462
|
+
def parse_multiplicative(self):
|
|
463
|
+
left = self.parse_unary()
|
|
464
|
+
while True:
|
|
465
|
+
if self.accept(T_MULTIPLY):
|
|
466
|
+
op = ARITH_MUL
|
|
467
|
+
elif self.accept(T_DIV):
|
|
468
|
+
op = ARITH_DIV
|
|
469
|
+
elif self.accept(T_MOD):
|
|
470
|
+
op = ARITH_MOD
|
|
471
|
+
else:
|
|
472
|
+
return left
|
|
473
|
+
right = self.parse_unary()
|
|
474
|
+
left = Expr(E_ARITH, TYPE_NUMBER, left.pos or right.pos, arith=op, l=left, r=right)
|
|
475
|
+
|
|
476
|
+
def parse_unary(self):
|
|
477
|
+
if self.accept(T_MINUS):
|
|
478
|
+
operand = self.parse_unary()
|
|
479
|
+
return Expr(E_NEGATE, TYPE_NUMBER, operand.pos, e=operand)
|
|
480
|
+
return self.parse_union()
|
|
481
|
+
|
|
482
|
+
def parse_union(self):
|
|
483
|
+
left = self.parse_path()
|
|
484
|
+
while self.peek(0).k == T_PIPE:
|
|
485
|
+
position = self.advance().p
|
|
486
|
+
right = self.parse_path()
|
|
487
|
+
if left.type != TYPE_NODE_SET or right.type != TYPE_NODE_SET:
|
|
488
|
+
self.fail_at("'|' needs node-sets on both sides", position)
|
|
489
|
+
left = Expr(E_UNION, TYPE_NODE_SET, left.pos or right.pos, l=left, r=right)
|
|
490
|
+
return left
|
|
491
|
+
|
|
492
|
+
def parse_path(self):
|
|
493
|
+
t = self.peek(0)
|
|
494
|
+
is_filter = t.k in (T_LITERAL, T_NUMBER, T_LPAREN, T_DOLLAR) or \
|
|
495
|
+
(t.k == T_NAME and self.peek(1).k == T_LPAREN and t.t not in NODE_TYPES)
|
|
496
|
+
if not is_filter:
|
|
497
|
+
return self.parse_location_path()
|
|
498
|
+
position = t.p
|
|
499
|
+
primary = self.parse_primary()
|
|
500
|
+
predicates = self.parse_predicates()
|
|
501
|
+
if predicates:
|
|
502
|
+
if primary.type != TYPE_NODE_SET:
|
|
503
|
+
self.fail_at("a predicate needs a node-set", position)
|
|
504
|
+
primary = Expr(E_FILTER, TYPE_NODE_SET, primary.pos, primary=primary, preds=predicates)
|
|
505
|
+
k = self.peek(0).k
|
|
506
|
+
if k != T_SLASH and k != T_DOUBLE_SLASH:
|
|
507
|
+
return primary
|
|
508
|
+
if primary.type != TYPE_NODE_SET:
|
|
509
|
+
self.fail_at("'/' needs a node-set on the left", position)
|
|
510
|
+
steps = self.optimize(self.parse_relative_steps([], True))
|
|
511
|
+
return Expr(E_PATH, TYPE_NODE_SET, primary.pos, start=primary, absolute=False, steps=steps)
|
|
512
|
+
|
|
513
|
+
def parse_location_path(self):
|
|
514
|
+
steps = []
|
|
515
|
+
absolute = False
|
|
516
|
+
if self.accept(T_SLASH):
|
|
517
|
+
absolute = True
|
|
518
|
+
if self.can_start_step(self.peek(0)):
|
|
519
|
+
steps = self.parse_relative_steps(steps, False)
|
|
520
|
+
elif self.peek(0).k == T_DOUBLE_SLASH:
|
|
521
|
+
absolute = True
|
|
522
|
+
steps = self.parse_relative_steps(steps, True)
|
|
523
|
+
else:
|
|
524
|
+
if not self.can_start_step(self.peek(0)):
|
|
525
|
+
self.fail(f"unexpected {self.describe(self.peek(0))}")
|
|
526
|
+
steps = self.parse_relative_steps(steps, False)
|
|
527
|
+
path = Expr(E_PATH, TYPE_NODE_SET, False, start=None, absolute=absolute, steps=self.optimize(steps))
|
|
528
|
+
name = self.attribute_name(path)
|
|
529
|
+
if name is not None:
|
|
530
|
+
path.attr = name # read in place where a string is needed
|
|
531
|
+
return path
|
|
532
|
+
|
|
533
|
+
def parse_relative_steps(self, steps, after_slash):
|
|
534
|
+
"""Steps separated by '/' or '//'; after_slash: the next token is a '/' or '//' to read first."""
|
|
535
|
+
if not after_slash:
|
|
536
|
+
steps.append(self.parse_step())
|
|
537
|
+
while True:
|
|
538
|
+
if self.accept(T_SLASH):
|
|
539
|
+
steps.append(self.parse_step())
|
|
540
|
+
elif self.accept(T_DOUBLE_SLASH):
|
|
541
|
+
steps.append(Step(AXIS_DESCENDANT_OR_SELF, ANY_NODE_TEST, []))
|
|
542
|
+
steps.append(self.parse_step())
|
|
543
|
+
else:
|
|
544
|
+
return steps
|
|
545
|
+
|
|
546
|
+
def parse_step(self):
|
|
547
|
+
if self.accept(T_DOT):
|
|
548
|
+
return Step(AXIS_SELF, ANY_NODE_TEST, [])
|
|
549
|
+
if self.accept(T_DOT_DOT):
|
|
550
|
+
return Step(AXIS_PARENT, ANY_NODE_TEST, [])
|
|
551
|
+
axis = AXIS_CHILD
|
|
552
|
+
if self.accept(T_AT):
|
|
553
|
+
axis = AXIS_ATTRIBUTE
|
|
554
|
+
elif self.peek(0).k == T_NAME and self.peek(1).k == T_COLON_COLON:
|
|
555
|
+
name = self.advance()
|
|
556
|
+
a = AXES.get(name.t)
|
|
557
|
+
if a is None:
|
|
558
|
+
if name.t == "namespace":
|
|
559
|
+
self.fail_at("the namespace axis is not supported", name.p)
|
|
560
|
+
self.fail_at(f"unknown axis '{name.t}'", name.p)
|
|
561
|
+
axis = a
|
|
562
|
+
self.advance()
|
|
563
|
+
test = self.parse_node_test()
|
|
564
|
+
return Step(axis, test, self.parse_predicates())
|
|
565
|
+
|
|
566
|
+
def parse_node_test(self):
|
|
567
|
+
if self.accept(T_STAR):
|
|
568
|
+
return NodeTest(TK_WILDCARD)
|
|
569
|
+
t = self.peek(0)
|
|
570
|
+
if t.k != T_NAME:
|
|
571
|
+
self.fail(f"expected a node test, found {self.describe(t)}")
|
|
572
|
+
self.advance()
|
|
573
|
+
name = t.t
|
|
574
|
+
if self.peek(0).k == T_LPAREN and name in NODE_TYPES:
|
|
575
|
+
self.advance()
|
|
576
|
+
if name == "processing-instruction":
|
|
577
|
+
self.accept(T_LITERAL)
|
|
578
|
+
self.expect(T_RPAREN, "')'")
|
|
579
|
+
if name == "node":
|
|
580
|
+
return ANY_NODE_TEST
|
|
581
|
+
if name == "text":
|
|
582
|
+
return NodeTest(TK_TEXT)
|
|
583
|
+
if name == "comment":
|
|
584
|
+
return NodeTest(TK_COMMENT)
|
|
585
|
+
return NodeTest(TK_PI)
|
|
586
|
+
if name.endswith(":*"):
|
|
587
|
+
return NodeTest(TK_PREFIX, name[:-1])
|
|
588
|
+
return NodeTest(TK_NAME, name)
|
|
589
|
+
|
|
590
|
+
def parse_predicates(self):
|
|
591
|
+
predicates = []
|
|
592
|
+
while self.accept(T_LBRACKET):
|
|
593
|
+
p = self.parse_expr()
|
|
594
|
+
self.expect(T_RBRACKET, "']'")
|
|
595
|
+
# [@name]: an existence check instead of a node-set
|
|
596
|
+
name = self.attribute_name(p)
|
|
597
|
+
if name is not None:
|
|
598
|
+
p = Expr(E_ATTR_EXISTS, TYPE_BOOLEAN, False, name=name)
|
|
599
|
+
predicates.append(p)
|
|
600
|
+
return predicates
|
|
601
|
+
|
|
602
|
+
def parse_primary(self):
|
|
603
|
+
t = self.advance()
|
|
604
|
+
if t.k == T_LITERAL:
|
|
605
|
+
return Expr(E_LITERAL, TYPE_STRING, False, value=t.t)
|
|
606
|
+
if t.k == T_NUMBER:
|
|
607
|
+
return Expr(E_NUMBER, TYPE_NUMBER, False, value=t.n)
|
|
608
|
+
if t.k == T_LPAREN:
|
|
609
|
+
e = self.parse_expr()
|
|
610
|
+
self.expect(T_RPAREN, "')'")
|
|
611
|
+
return e
|
|
612
|
+
if t.k == T_DOLLAR:
|
|
613
|
+
self.fail_at("variables are not supported", t.p)
|
|
614
|
+
|
|
615
|
+
# function call
|
|
616
|
+
info = FUNCTIONS.get(t.t)
|
|
617
|
+
if info is None:
|
|
618
|
+
self.fail_at(f"unknown function '{t.t}()'", t.p)
|
|
619
|
+
self.expect(T_LPAREN, "'('")
|
|
620
|
+
args = []
|
|
621
|
+
if not self.accept(T_RPAREN):
|
|
622
|
+
while True:
|
|
623
|
+
args.append(self.parse_expr())
|
|
624
|
+
if not self.accept(T_COMMA):
|
|
625
|
+
break
|
|
626
|
+
self.expect(T_RPAREN, "')'")
|
|
627
|
+
fn = t.t
|
|
628
|
+
if len(args) < info[0] or len(args) > info[1]:
|
|
629
|
+
self.fail_at(f"wrong number of arguments for {fn}()", t.p)
|
|
630
|
+
if fn in ("count", "sum", "name", "local-name") and args and args[0].type != TYPE_NODE_SET:
|
|
631
|
+
self.fail_at(f"{fn}() needs a node-set argument", t.p)
|
|
632
|
+
pos = fn == "position" or fn == "last" or any(a.pos for a in args)
|
|
633
|
+
return Expr(E_FUNCTION, info[2], pos, fn=fn, args=args)
|
|
634
|
+
|
|
635
|
+
|
|
636
|
+
def _ascii_lower(s):
|
|
637
|
+
from ._chars import ascii_lower
|
|
638
|
+
return ascii_lower(s)
|
|
639
|
+
|
|
640
|
+
|
|
641
|
+
def compile_xpath(expression):
|
|
642
|
+
return _Compiler(expression).parse()
|
|
643
|
+
|
|
644
|
+
|
|
645
|
+
def number_to_string(d):
|
|
646
|
+
"""The shortest round-trip digits, written without an exponent (XPath has none), as JavaScript writes a
|
|
647
|
+
number."""
|
|
648
|
+
if d != d:
|
|
649
|
+
return "NaN"
|
|
650
|
+
if d in (INF, -INF):
|
|
651
|
+
return "Infinity" if d > 0 else "-Infinity"
|
|
652
|
+
if d == 0:
|
|
653
|
+
return "0"
|
|
654
|
+
if d == math.floor(d) and abs(d) < 1e15:
|
|
655
|
+
return str(int(d))
|
|
656
|
+
r = repr(abs(d))
|
|
657
|
+
if "e" in r:
|
|
658
|
+
mantissa, exponent = r.split("e")
|
|
659
|
+
exponent = int(exponent)
|
|
660
|
+
else:
|
|
661
|
+
mantissa, exponent = r, 0
|
|
662
|
+
if "." in mantissa:
|
|
663
|
+
int_part, frac = mantissa.split(".")
|
|
664
|
+
else:
|
|
665
|
+
int_part, frac = mantissa, ""
|
|
666
|
+
digits = int_part + frac
|
|
667
|
+
point_at = len(int_part) + exponent
|
|
668
|
+
while len(digits) > 1 and digits.startswith("0"):
|
|
669
|
+
digits = digits[1:]
|
|
670
|
+
point_at -= 1
|
|
671
|
+
digits = digits.rstrip("0")
|
|
672
|
+
n = len(digits)
|
|
673
|
+
out = "-" if d < 0 else ""
|
|
674
|
+
if point_at <= 0:
|
|
675
|
+
return out + "0." + "0" * -point_at + digits
|
|
676
|
+
if point_at >= n:
|
|
677
|
+
return out + digits + "0" * (point_at - n)
|
|
678
|
+
return out + digits[:point_at] + "." + digits[point_at:]
|
|
679
|
+
|
|
680
|
+
|
|
681
|
+
# ----- the data model -----
|
|
682
|
+
|
|
683
|
+
ROOT = 0
|
|
684
|
+
ELEMENT = 1
|
|
685
|
+
COMMENT_NODE = 2
|
|
686
|
+
TEXT = 3
|
|
687
|
+
ATTRIBUTE = 4
|
|
688
|
+
|
|
689
|
+
|
|
690
|
+
class XNode:
|
|
691
|
+
"""tag: element / comment: the tag; text / attribute: the parent element (-1: the root).
|
|
692
|
+
start: text: first char; attribute: name start. length: text: length; attribute: name length.
|
|
693
|
+
value_start: attribute: value start (-1 for no value).
|
|
694
|
+
major, minor: document order and identity: tags and text nodes by their first char; attributes right after
|
|
695
|
+
their element."""
|
|
696
|
+
|
|
697
|
+
__slots__ = ("kind", "tag", "start", "length", "value_start", "value_length", "major", "minor")
|
|
698
|
+
|
|
699
|
+
def __init__(self, kind, tag, major, start=0, length=0, value_start=0, value_length=0):
|
|
700
|
+
self.kind = kind
|
|
701
|
+
self.tag = tag
|
|
702
|
+
self.start = start
|
|
703
|
+
self.length = length
|
|
704
|
+
self.value_start = value_start
|
|
705
|
+
self.value_length = value_length
|
|
706
|
+
self.major = major
|
|
707
|
+
self.minor = start if kind == ATTRIBUTE else 0
|
|
708
|
+
|
|
709
|
+
|
|
710
|
+
_ROOT = XNode(ROOT, -1, -1)
|
|
711
|
+
|
|
712
|
+
|
|
713
|
+
def of_tag(d, i):
|
|
714
|
+
return XNode(COMMENT_NODE if d.keys[i] == COMMENT else ELEMENT, i, d.starts[i])
|
|
715
|
+
|
|
716
|
+
|
|
717
|
+
def _range_start(x):
|
|
718
|
+
"""The first source position the node covers (for following / preceding)."""
|
|
719
|
+
return -1 if x.kind == ROOT else x.major
|
|
720
|
+
|
|
721
|
+
|
|
722
|
+
def _range_end(d, x):
|
|
723
|
+
"""The last source position the node covers."""
|
|
724
|
+
k = x.kind
|
|
725
|
+
if k == ROOT:
|
|
726
|
+
return INF
|
|
727
|
+
if k == ELEMENT or k == COMMENT_NODE:
|
|
728
|
+
return d.ends[x.tag]
|
|
729
|
+
if k == TEXT:
|
|
730
|
+
return x.start + x.length - 1
|
|
731
|
+
return d.starts[x.tag] # attribute: the children of its element follow it
|
|
732
|
+
|
|
733
|
+
|
|
734
|
+
# ----- evaluation -----
|
|
735
|
+
|
|
736
|
+
def _matches_text(test):
|
|
737
|
+
return test.k == TK_NODE or test.k == TK_TEXT
|
|
738
|
+
|
|
739
|
+
|
|
740
|
+
def _matches_tags(test):
|
|
741
|
+
return test.k != TK_TEXT and test.k != TK_PI
|
|
742
|
+
|
|
743
|
+
|
|
744
|
+
def _matches_attribute(test, attribute):
|
|
745
|
+
k = test.k
|
|
746
|
+
if k == TK_NAME:
|
|
747
|
+
return equal_fold(attribute, test.name)
|
|
748
|
+
if k == TK_PREFIX:
|
|
749
|
+
n = len(test.name)
|
|
750
|
+
return len(attribute) >= n and equal_fold(attribute[:n], test.name)
|
|
751
|
+
return k == TK_WILDCARD or k == TK_NODE
|
|
752
|
+
|
|
753
|
+
|
|
754
|
+
def _reverse(axis):
|
|
755
|
+
return axis in (AXIS_ANCESTOR, AXIS_ANCESTOR_OR_SELF, AXIS_PRECEDING, AXIS_PRECEDING_SIBLING)
|
|
756
|
+
|
|
757
|
+
|
|
758
|
+
def _fmod(x, y):
|
|
759
|
+
"""C fmod: the remainder has the sign of x."""
|
|
760
|
+
if x != x or y != y or x in (INF, -INF) or y == 0:
|
|
761
|
+
return NAN
|
|
762
|
+
if y in (INF, -INF):
|
|
763
|
+
return x
|
|
764
|
+
return math.fmod(x, y)
|
|
765
|
+
|
|
766
|
+
|
|
767
|
+
def _float_floor(v):
|
|
768
|
+
if v != v or v in (INF, -INF):
|
|
769
|
+
return v
|
|
770
|
+
r = float(math.floor(v))
|
|
771
|
+
return -0.0 if r == 0 and v < 0 else r
|
|
772
|
+
|
|
773
|
+
|
|
774
|
+
def _float_ceil(v):
|
|
775
|
+
if v != v or v in (INF, -INF):
|
|
776
|
+
return v
|
|
777
|
+
r = float(math.ceil(v))
|
|
778
|
+
return -0.0 if r == 0 and v < 0 else r
|
|
779
|
+
|
|
780
|
+
|
|
781
|
+
def _round(v):
|
|
782
|
+
if v != v or v in (INF, -INF):
|
|
783
|
+
return v
|
|
784
|
+
return _float_floor(v + 0.5)
|
|
785
|
+
|
|
786
|
+
|
|
787
|
+
def _to_boolean(v):
|
|
788
|
+
if v is True or v is False:
|
|
789
|
+
return v
|
|
790
|
+
if isinstance(v, float):
|
|
791
|
+
return v != 0 and v == v
|
|
792
|
+
return len(v) > 0
|
|
793
|
+
|
|
794
|
+
|
|
795
|
+
def _string_to_number(value):
|
|
796
|
+
"""Optional '-', digits with an optional decimal point; anything else is NaN."""
|
|
797
|
+
s = trim_space(value)
|
|
798
|
+
body = s[1:] if s.startswith("-") else s
|
|
799
|
+
if not body or not all(c in "0123456789." for c in body):
|
|
800
|
+
return NAN
|
|
801
|
+
dots = body.count(".")
|
|
802
|
+
if dots > 1 or len(body) == dots:
|
|
803
|
+
return NAN
|
|
804
|
+
return float(s)
|
|
805
|
+
|
|
806
|
+
|
|
807
|
+
class Evaluator:
|
|
808
|
+
"""The evaluation of one expression on one document: values are a node-set (a list of XNode), a float, a str
|
|
809
|
+
or True / False."""
|
|
810
|
+
|
|
811
|
+
__slots__ = ("d", "all")
|
|
812
|
+
|
|
813
|
+
def __init__(self, d):
|
|
814
|
+
self.d = d
|
|
815
|
+
self.all = None
|
|
816
|
+
|
|
817
|
+
# ----- node tests -----
|
|
818
|
+
|
|
819
|
+
def matches_tag_at(self, test, i):
|
|
820
|
+
"""The node test on the tag at index i."""
|
|
821
|
+
d = self.d
|
|
822
|
+
k = test.k
|
|
823
|
+
if k == TK_NAME:
|
|
824
|
+
return test.q.name_matches_at(d, i)
|
|
825
|
+
if k == TK_PREFIX:
|
|
826
|
+
key = d.keys[i]
|
|
827
|
+
name = NAMES[key] if key >= 0 else d.customs[i]
|
|
828
|
+
n = len(test.name)
|
|
829
|
+
return element_at(d, i) and len(name) >= n and equal_fold(name[:n], test.name)
|
|
830
|
+
if k == TK_WILDCARD or k == TK_CONTAINER:
|
|
831
|
+
return element_at(d, i)
|
|
832
|
+
if k == TK_NODE:
|
|
833
|
+
return element_at(d, i) or d.keys[i] == COMMENT
|
|
834
|
+
if k == TK_COMMENT:
|
|
835
|
+
return d.keys[i] == COMMENT
|
|
836
|
+
return False
|
|
837
|
+
|
|
838
|
+
def matches(self, test, x, attribute_axis):
|
|
839
|
+
k = x.kind
|
|
840
|
+
if k == ROOT:
|
|
841
|
+
return test.k == TK_NODE or test.k == TK_CONTAINER
|
|
842
|
+
if k == ELEMENT or k == COMMENT_NODE:
|
|
843
|
+
return self.matches_tag_at(test, x.tag)
|
|
844
|
+
if k == TEXT:
|
|
845
|
+
return _matches_text(test)
|
|
846
|
+
if attribute_axis:
|
|
847
|
+
return _matches_attribute(test, self.d.src[x.start:x.start + x.length])
|
|
848
|
+
return test.k == TK_NODE
|
|
849
|
+
|
|
850
|
+
# ----- navigation -----
|
|
851
|
+
|
|
852
|
+
def add_children(self, x, test, out):
|
|
853
|
+
"""Appends the children of the root or an element that match the test, text nodes included, in document
|
|
854
|
+
order."""
|
|
855
|
+
want_text = _matches_text(test)
|
|
856
|
+
want_tags = _matches_tags(test)
|
|
857
|
+
if not want_text and not want_tags:
|
|
858
|
+
return
|
|
859
|
+
d = self.d
|
|
860
|
+
if x.kind == ROOT:
|
|
861
|
+
first = 0
|
|
862
|
+
end = INF
|
|
863
|
+
child_depth = 0
|
|
864
|
+
p = 0
|
|
865
|
+
text_end = len(d.src)
|
|
866
|
+
parent = -1
|
|
867
|
+
elif x.kind == ELEMENT and d.inner_starts[x.tag] > 0 and d.inner_ends[x.tag] > 0:
|
|
868
|
+
t = x.tag
|
|
869
|
+
first = t + 1
|
|
870
|
+
end = d.ends[t]
|
|
871
|
+
child_depth = d.depths[t] + 1
|
|
872
|
+
p = d.inner_starts[t]
|
|
873
|
+
text_end = d.inner_ends[t] + 1
|
|
874
|
+
parent = t
|
|
875
|
+
else:
|
|
876
|
+
return
|
|
877
|
+
ends = d.ends
|
|
878
|
+
depths = d.depths
|
|
879
|
+
starts = d.starts
|
|
880
|
+
keys = d.keys
|
|
881
|
+
count = len(ends)
|
|
882
|
+
i = first
|
|
883
|
+
while i < count:
|
|
884
|
+
if ends[i] > end:
|
|
885
|
+
break
|
|
886
|
+
if depths[i] == child_depth:
|
|
887
|
+
start = starts[i]
|
|
888
|
+
if want_text and start > p:
|
|
889
|
+
e = start if start < text_end else text_end
|
|
890
|
+
if e > p:
|
|
891
|
+
out.append(XNode(TEXT, parent, p, p, e - p))
|
|
892
|
+
if want_tags and self.matches_tag_at(test, i):
|
|
893
|
+
out.append(XNode(COMMENT_NODE if keys[i] == COMMENT else ELEMENT, i, start))
|
|
894
|
+
p = ends[i] + 1
|
|
895
|
+
i += 1
|
|
896
|
+
if want_text and text_end > p:
|
|
897
|
+
out.append(XNode(TEXT, parent, p, p, text_end - p))
|
|
898
|
+
|
|
899
|
+
def add_descendants(self, x, test, out):
|
|
900
|
+
"""Appends the descendants of the root or an element that match the test, in document order."""
|
|
901
|
+
if _matches_text(test):
|
|
902
|
+
self.add_descendants_with_text(x, test, out)
|
|
903
|
+
return
|
|
904
|
+
if not _matches_tags(test):
|
|
905
|
+
return
|
|
906
|
+
d = self.d
|
|
907
|
+
if x.kind == ROOT:
|
|
908
|
+
first = 0
|
|
909
|
+
end = INF
|
|
910
|
+
elif x.kind == ELEMENT and d.inner_starts[x.tag] > 0 and d.inner_ends[x.tag] > 0:
|
|
911
|
+
first = x.tag + 1
|
|
912
|
+
end = d.ends[x.tag]
|
|
913
|
+
else:
|
|
914
|
+
return
|
|
915
|
+
# tags only: one linear scan of the flat list
|
|
916
|
+
ends = d.ends
|
|
917
|
+
starts = d.starts
|
|
918
|
+
keys = d.keys
|
|
919
|
+
count = len(ends)
|
|
920
|
+
i = first
|
|
921
|
+
if test.k == TK_NAME:
|
|
922
|
+
q = test.q
|
|
923
|
+
qk = q.key
|
|
924
|
+
named = q.tag_name != ""
|
|
925
|
+
customs = d.customs
|
|
926
|
+
while i < count:
|
|
927
|
+
if ends[i] > end:
|
|
928
|
+
break
|
|
929
|
+
# a known name: one int compare on the arrays
|
|
930
|
+
k = keys[i]
|
|
931
|
+
if (k == qk or (k < 0 and named and equal_fold(customs[i], q.tag_name))) if qk >= 0 \
|
|
932
|
+
else q.name_matches_at(d, i):
|
|
933
|
+
out.append(XNode(ELEMENT, i, starts[i]))
|
|
934
|
+
i += 1
|
|
935
|
+
return
|
|
936
|
+
while i < count:
|
|
937
|
+
if ends[i] > end:
|
|
938
|
+
break
|
|
939
|
+
if self.matches_tag_at(test, i):
|
|
940
|
+
out.append(XNode(COMMENT_NODE if keys[i] == COMMENT else ELEMENT, i, starts[i]))
|
|
941
|
+
i += 1
|
|
942
|
+
|
|
943
|
+
def add_descendants_with_text(self, x, test, out):
|
|
944
|
+
children = []
|
|
945
|
+
self.add_children(x, ANY_NODE_TEST, children)
|
|
946
|
+
for child in children:
|
|
947
|
+
if self.matches(test, child, False):
|
|
948
|
+
out.append(child)
|
|
949
|
+
if child.kind == ELEMENT:
|
|
950
|
+
self.add_descendants_with_text(child, test, out)
|
|
951
|
+
|
|
952
|
+
def parent_node(self, x):
|
|
953
|
+
k = x.kind
|
|
954
|
+
if k == ROOT:
|
|
955
|
+
return None
|
|
956
|
+
d = self.d
|
|
957
|
+
if k == TEXT or k == ATTRIBUTE:
|
|
958
|
+
return _ROOT if x.tag < 0 else of_tag(d, x.tag)
|
|
959
|
+
t = x.tag
|
|
960
|
+
p = d.parents[t]
|
|
961
|
+
return of_tag(d, p) if d.depths[t] > 0 and p >= 0 else _ROOT
|
|
962
|
+
|
|
963
|
+
def add_attributes(self, x, test, out):
|
|
964
|
+
if x.kind != ELEMENT:
|
|
965
|
+
return
|
|
966
|
+
s = at.AttrScanner(self.d, x.tag)
|
|
967
|
+
major = self.d.starts[x.tag]
|
|
968
|
+
while s.next():
|
|
969
|
+
if _matches_attribute(test, s.name()):
|
|
970
|
+
out.append(XNode(ATTRIBUTE, x.tag, major, s.name_start, s.name_length, s.value_start,
|
|
971
|
+
s.value_length))
|
|
972
|
+
|
|
973
|
+
def attribute_of(self, x, name):
|
|
974
|
+
"""The raw value of the first attribute with the name (lower case); None when the element has none."""
|
|
975
|
+
if x.kind != ELEMENT:
|
|
976
|
+
return None
|
|
977
|
+
raw = at.attr_raw(self.d, x.tag, name)
|
|
978
|
+
if raw:
|
|
979
|
+
return raw
|
|
980
|
+
return raw if at.has_attribute(self.d, x.tag, name) else None
|
|
981
|
+
|
|
982
|
+
def string_value(self, x):
|
|
983
|
+
"""The root and elements give their visible text; text nodes and attributes their decoded value; comments
|
|
984
|
+
their content."""
|
|
985
|
+
d = self.d
|
|
986
|
+
k = x.kind
|
|
987
|
+
if k == ROOT:
|
|
988
|
+
return _text.clear_tags(d.src)
|
|
989
|
+
if k == ELEMENT:
|
|
990
|
+
return d.text_of(x.tag)
|
|
991
|
+
if k == ATTRIBUTE:
|
|
992
|
+
if x.value_start < 0:
|
|
993
|
+
return ""
|
|
994
|
+
return dec.decode(d.src[x.value_start:x.value_start + x.value_length], True)
|
|
995
|
+
if k == TEXT:
|
|
996
|
+
text = d.src[x.start:x.start + x.length]
|
|
997
|
+
if x.tag >= 0 and is_raw_text(d.keys[x.tag]):
|
|
998
|
+
return dec.normalize_newlines(text)
|
|
999
|
+
return dec.decode(text, False)
|
|
1000
|
+
# comment
|
|
1001
|
+
t = x.tag
|
|
1002
|
+
source = d.src[d.starts[t]:d.ends[t] + 1]
|
|
1003
|
+
if source.startswith("<!--"):
|
|
1004
|
+
source = source[4:]
|
|
1005
|
+
if source.endswith("-->"):
|
|
1006
|
+
source = source[:-3]
|
|
1007
|
+
return source
|
|
1008
|
+
|
|
1009
|
+
def node_name(self, x):
|
|
1010
|
+
"""name() / local-name(): the lower-case tag or attribute name; "" for other nodes."""
|
|
1011
|
+
if x.kind == ELEMENT:
|
|
1012
|
+
return self.d.name_of(x.tag)
|
|
1013
|
+
if x.kind == ATTRIBUTE:
|
|
1014
|
+
return lower(self.d.src[x.start:x.start + x.length])
|
|
1015
|
+
return ""
|
|
1016
|
+
|
|
1017
|
+
# ----- values -----
|
|
1018
|
+
|
|
1019
|
+
def to_number(self, v):
|
|
1020
|
+
if isinstance(v, float):
|
|
1021
|
+
return v
|
|
1022
|
+
if v is True:
|
|
1023
|
+
return 1.0
|
|
1024
|
+
if v is False:
|
|
1025
|
+
return 0.0
|
|
1026
|
+
if isinstance(v, str):
|
|
1027
|
+
return _string_to_number(v)
|
|
1028
|
+
return NAN if not v else _string_to_number(self.string_value(v[0]))
|
|
1029
|
+
|
|
1030
|
+
def to_str(self, v):
|
|
1031
|
+
if isinstance(v, str):
|
|
1032
|
+
return v
|
|
1033
|
+
if v is True:
|
|
1034
|
+
return "true"
|
|
1035
|
+
if v is False:
|
|
1036
|
+
return "false"
|
|
1037
|
+
if isinstance(v, float):
|
|
1038
|
+
return number_to_string(v)
|
|
1039
|
+
return "" if not v else self.string_value(v[0])
|
|
1040
|
+
|
|
1041
|
+
@staticmethod
|
|
1042
|
+
def sort_unique(nodes):
|
|
1043
|
+
"""Puts the nodes in document order without duplicates."""
|
|
1044
|
+
count = len(nodes)
|
|
1045
|
+
if count < 2:
|
|
1046
|
+
return nodes
|
|
1047
|
+
for i in range(1, count):
|
|
1048
|
+
a = nodes[i - 1]
|
|
1049
|
+
b = nodes[i]
|
|
1050
|
+
if a.major > b.major or (a.major == b.major and a.minor >= b.minor):
|
|
1051
|
+
break
|
|
1052
|
+
else:
|
|
1053
|
+
return nodes
|
|
1054
|
+
# stable: ties keep their order
|
|
1055
|
+
nodes = sorted(nodes, key=lambda n: (n.major, n.minor))
|
|
1056
|
+
out = [nodes[0]]
|
|
1057
|
+
last = nodes[0]
|
|
1058
|
+
for n in nodes[1:]:
|
|
1059
|
+
if n.major != last.major or n.minor != last.minor:
|
|
1060
|
+
out.append(n)
|
|
1061
|
+
last = n
|
|
1062
|
+
return out
|
|
1063
|
+
|
|
1064
|
+
def all_nodes(self):
|
|
1065
|
+
if self.all is None:
|
|
1066
|
+
a = []
|
|
1067
|
+
self.add_descendants(_ROOT, ANY_NODE_TEST, a)
|
|
1068
|
+
self.all = a
|
|
1069
|
+
return self.all
|
|
1070
|
+
|
|
1071
|
+
def eval_nodes(self, e, node, position, size):
|
|
1072
|
+
v = self.eval_expr(e, node, position, size)
|
|
1073
|
+
if isinstance(v, list):
|
|
1074
|
+
return v
|
|
1075
|
+
raise XPathError("the XPath expression does not give a node-set")
|
|
1076
|
+
|
|
1077
|
+
def eval_string(self, e, node, position, size):
|
|
1078
|
+
if e.attr is not None:
|
|
1079
|
+
# a bare @name: the string-value of the first such attribute, read in place
|
|
1080
|
+
raw = at.attr_raw(self.d, node.tag, e.attr) if node.kind == ELEMENT else ""
|
|
1081
|
+
return dec.decode(raw, True) if "&" in raw or "\r" in raw else raw
|
|
1082
|
+
return self.to_str(self.eval_expr(e, node, position, size))
|
|
1083
|
+
|
|
1084
|
+
def eval_number(self, e, node, position, size):
|
|
1085
|
+
return self.to_number(self.eval_expr(e, node, position, size))
|
|
1086
|
+
|
|
1087
|
+
def eval_bool(self, e, node, position, size):
|
|
1088
|
+
op = e.op
|
|
1089
|
+
if op == E_LITERAL:
|
|
1090
|
+
return e.value != ""
|
|
1091
|
+
if op == E_AND:
|
|
1092
|
+
return self.eval_bool(e.l, node, position, size) and self.eval_bool(e.r, node, position, size)
|
|
1093
|
+
if op == E_OR:
|
|
1094
|
+
return self.eval_bool(e.l, node, position, size) or self.eval_bool(e.r, node, position, size)
|
|
1095
|
+
if op == E_COMPARE:
|
|
1096
|
+
return self.compare(e.cmp, self.eval_expr(e.l, node, position, size),
|
|
1097
|
+
self.eval_expr(e.r, node, position, size))
|
|
1098
|
+
if op == E_ATTR_EQUALS:
|
|
1099
|
+
# '!=' is true when the attribute exists and differs (a missing attribute is an empty node-set)
|
|
1100
|
+
raw = self.attribute_of(node, e.name)
|
|
1101
|
+
return raw is not None and at.attr_equals(raw, e.value) != e.negate
|
|
1102
|
+
if op == E_ATTR_EXISTS:
|
|
1103
|
+
return self.attribute_of(node, e.name) is not None
|
|
1104
|
+
return _to_boolean(self.eval_expr(e, node, position, size))
|
|
1105
|
+
|
|
1106
|
+
def eval_predicate(self, e, node, position, size):
|
|
1107
|
+
"""A number compares with the position, anything else is converted to boolean."""
|
|
1108
|
+
if e.type == TYPE_BOOLEAN:
|
|
1109
|
+
return self.eval_bool(e, node, position, size)
|
|
1110
|
+
v = self.eval_expr(e, node, position, size)
|
|
1111
|
+
if isinstance(v, float):
|
|
1112
|
+
return v == position
|
|
1113
|
+
return _to_boolean(v)
|
|
1114
|
+
|
|
1115
|
+
def eval_expr(self, e, node, position, size):
|
|
1116
|
+
op = e.op
|
|
1117
|
+
if op == E_LITERAL or op == E_NUMBER:
|
|
1118
|
+
return e.value
|
|
1119
|
+
if op in (E_AND, E_OR, E_COMPARE, E_ATTR_EQUALS, E_ATTR_EXISTS):
|
|
1120
|
+
return self.eval_bool(e, node, position, size)
|
|
1121
|
+
if op == E_ARITH:
|
|
1122
|
+
x = self.eval_number(e.l, node, position, size)
|
|
1123
|
+
y = self.eval_number(e.r, node, position, size)
|
|
1124
|
+
a = e.arith
|
|
1125
|
+
if a == ARITH_ADD:
|
|
1126
|
+
return x + y
|
|
1127
|
+
if a == ARITH_SUB:
|
|
1128
|
+
return x - y
|
|
1129
|
+
if a == ARITH_MUL:
|
|
1130
|
+
return x * y
|
|
1131
|
+
if a == ARITH_DIV:
|
|
1132
|
+
if y == 0:
|
|
1133
|
+
if x != x or x == 0:
|
|
1134
|
+
return NAN
|
|
1135
|
+
return math.copysign(INF, x) * math.copysign(1.0, y)
|
|
1136
|
+
return x / y
|
|
1137
|
+
return _fmod(x, y)
|
|
1138
|
+
if op == E_NEGATE:
|
|
1139
|
+
return -self.eval_number(e.e, node, position, size)
|
|
1140
|
+
if op == E_UNION:
|
|
1141
|
+
a = self.eval_nodes(e.l, node, position, size)
|
|
1142
|
+
b = self.eval_nodes(e.r, node, position, size)
|
|
1143
|
+
return self.sort_unique(a + b)
|
|
1144
|
+
if op == E_PATH:
|
|
1145
|
+
if e.start is not None:
|
|
1146
|
+
current = self.eval_nodes(e.start, node, position, size)
|
|
1147
|
+
elif e.absolute:
|
|
1148
|
+
current = [_ROOT]
|
|
1149
|
+
else:
|
|
1150
|
+
current = [node]
|
|
1151
|
+
for s in e.steps:
|
|
1152
|
+
if not current:
|
|
1153
|
+
break
|
|
1154
|
+
current = self.apply_step(s, current)
|
|
1155
|
+
return current
|
|
1156
|
+
if op == E_FILTER:
|
|
1157
|
+
return self.filter(self.eval_nodes(e.primary, node, position, size), e.preds)
|
|
1158
|
+
return self.eval_function(e, node, position, size)
|
|
1159
|
+
|
|
1160
|
+
def compare(self, op, a, b):
|
|
1161
|
+
if isinstance(a, list):
|
|
1162
|
+
if isinstance(b, list):
|
|
1163
|
+
if not a or not b:
|
|
1164
|
+
return False
|
|
1165
|
+
values_b = [self.string_value(n) for n in b]
|
|
1166
|
+
for x in a:
|
|
1167
|
+
value = self.string_value(x)
|
|
1168
|
+
for other in values_b:
|
|
1169
|
+
if self.compare_atoms(op, value, other):
|
|
1170
|
+
return True
|
|
1171
|
+
return False
|
|
1172
|
+
return self.compare_with_nodes(op, a, b, True)
|
|
1173
|
+
if isinstance(b, list):
|
|
1174
|
+
return self.compare_with_nodes(op, b, a, False)
|
|
1175
|
+
return self.compare_atoms(op, a, b)
|
|
1176
|
+
|
|
1177
|
+
def compare_with_nodes(self, op, nodes, other, nodes_on_left):
|
|
1178
|
+
if other is True or other is False:
|
|
1179
|
+
as_bool = len(nodes) > 0
|
|
1180
|
+
return self.compare_atoms(op, as_bool, other) if nodes_on_left else self.compare_atoms(op, other, as_bool)
|
|
1181
|
+
is_number = isinstance(other, float)
|
|
1182
|
+
for n in nodes:
|
|
1183
|
+
s = self.string_value(n)
|
|
1184
|
+
value = _string_to_number(s) if is_number else s
|
|
1185
|
+
if self.compare_atoms(op, value, other) if nodes_on_left else self.compare_atoms(op, other, value):
|
|
1186
|
+
return True
|
|
1187
|
+
return False
|
|
1188
|
+
|
|
1189
|
+
def compare_atoms(self, op, a, b):
|
|
1190
|
+
if op == OP_EQ or op == OP_NEQ:
|
|
1191
|
+
if a is True or a is False or b is True or b is False:
|
|
1192
|
+
eq = _to_boolean(a) == _to_boolean(b)
|
|
1193
|
+
elif isinstance(a, float) or isinstance(b, float):
|
|
1194
|
+
eq = self.to_number(a) == self.to_number(b)
|
|
1195
|
+
else:
|
|
1196
|
+
eq = self.to_str(a) == self.to_str(b)
|
|
1197
|
+
return eq == (op == OP_EQ)
|
|
1198
|
+
x = self.to_number(a)
|
|
1199
|
+
y = self.to_number(b)
|
|
1200
|
+
if op == OP_LT:
|
|
1201
|
+
return x < y
|
|
1202
|
+
if op == OP_LE:
|
|
1203
|
+
return x <= y
|
|
1204
|
+
if op == OP_GT:
|
|
1205
|
+
return x > y
|
|
1206
|
+
return x >= y
|
|
1207
|
+
|
|
1208
|
+
# ----- steps -----
|
|
1209
|
+
|
|
1210
|
+
def apply_step(self, step, inp):
|
|
1211
|
+
if len(inp) == 1:
|
|
1212
|
+
out = []
|
|
1213
|
+
self.select_from(step, inp[0], out)
|
|
1214
|
+
return out
|
|
1215
|
+
|
|
1216
|
+
# Nested input nodes (//div//a on divs inside divs, //a/ancestor::* on links in one list) give the same
|
|
1217
|
+
# nodes again and again: n nested nodes would collect about n^2 nodes before the duplicates are removed.
|
|
1218
|
+
# When the predicates do not depend on the position, a node passes them or not whichever input node it
|
|
1219
|
+
# comes from, so the input nodes whose results are already collected are skipped: the work stays linear.
|
|
1220
|
+
if not step.positional:
|
|
1221
|
+
if step.axis == AXIS_DESCENDANT or step.axis == AXIS_DESCENDANT_OR_SELF:
|
|
1222
|
+
if not _matches_text(step.test) and self.in_document_order(inp):
|
|
1223
|
+
return self.sort_unique(self.select_descendants_of_nested(step, inp))
|
|
1224
|
+
elif step.axis == AXIS_ANCESTOR or step.axis == AXIS_ANCESTOR_OR_SELF:
|
|
1225
|
+
return self.sort_unique(self.select_shared_ancestors(step, inp))
|
|
1226
|
+
|
|
1227
|
+
out = []
|
|
1228
|
+
for x in inp:
|
|
1229
|
+
self.select_from(step, x, out)
|
|
1230
|
+
return self.sort_unique(out)
|
|
1231
|
+
|
|
1232
|
+
def select_descendants_of_nested(self, step, inp):
|
|
1233
|
+
"""The descendant axes (tags only) on input nodes in document order. A tag that lies in the part of the tag
|
|
1234
|
+
list already scanned for an earlier input node is skipped."""
|
|
1235
|
+
d = self.d
|
|
1236
|
+
ends = d.ends
|
|
1237
|
+
count = len(ends)
|
|
1238
|
+
out = []
|
|
1239
|
+
scanned_to = -1 # the tags before this index were scanned for an earlier input node
|
|
1240
|
+
for x in inp:
|
|
1241
|
+
if x.kind == ELEMENT or x.kind == COMMENT_NODE:
|
|
1242
|
+
t = x.tag
|
|
1243
|
+
if t < scanned_to:
|
|
1244
|
+
continue
|
|
1245
|
+
self.select_from(step, x, out)
|
|
1246
|
+
# where add_descendants stops for this tag
|
|
1247
|
+
if x.kind == ELEMENT and d.inner_starts[t] > 0 and d.inner_ends[t] > 0:
|
|
1248
|
+
k = t + 1
|
|
1249
|
+
end = ends[t]
|
|
1250
|
+
while k < count and ends[k] <= end:
|
|
1251
|
+
k += 1
|
|
1252
|
+
if k > scanned_to:
|
|
1253
|
+
scanned_to = k
|
|
1254
|
+
else:
|
|
1255
|
+
self.select_from(step, x, out)
|
|
1256
|
+
if x.kind == ROOT:
|
|
1257
|
+
scanned_to = INF
|
|
1258
|
+
return out
|
|
1259
|
+
|
|
1260
|
+
def select_shared_ancestors(self, step, inp):
|
|
1261
|
+
"""The walk up from an input node stops at an ancestor already reached from an earlier one, because that
|
|
1262
|
+
walk has gone on to the root. Only the root and elements are marked: they are the only parents."""
|
|
1263
|
+
visited = set()
|
|
1264
|
+
out = []
|
|
1265
|
+
test = step.test
|
|
1266
|
+
for x in inp:
|
|
1267
|
+
start = len(out)
|
|
1268
|
+
current = x
|
|
1269
|
+
if step.axis == AXIS_ANCESTOR_OR_SELF:
|
|
1270
|
+
container = current.kind == ROOT or current.kind == ELEMENT
|
|
1271
|
+
if container and current.major in visited:
|
|
1272
|
+
continue
|
|
1273
|
+
if container:
|
|
1274
|
+
visited.add(current.major)
|
|
1275
|
+
if self.matches(test, current, False):
|
|
1276
|
+
out.append(current)
|
|
1277
|
+
while True:
|
|
1278
|
+
p = self.parent_node(current)
|
|
1279
|
+
if p is None or p.major in visited:
|
|
1280
|
+
break
|
|
1281
|
+
visited.add(p.major)
|
|
1282
|
+
current = p
|
|
1283
|
+
if self.matches(test, current, False):
|
|
1284
|
+
out.append(current)
|
|
1285
|
+
if step.preds and len(out) > start:
|
|
1286
|
+
out[start:] = self.filter(out[start:], step.preds)
|
|
1287
|
+
return out
|
|
1288
|
+
|
|
1289
|
+
def select_from(self, step, x, out):
|
|
1290
|
+
"""Appends the nodes of the axis that pass the test and the predicates, in document order."""
|
|
1291
|
+
reverse = _reverse(step.axis)
|
|
1292
|
+
if not step.preds and not reverse:
|
|
1293
|
+
self.collect(step, x, out)
|
|
1294
|
+
return
|
|
1295
|
+
selected = []
|
|
1296
|
+
self.collect(step, x, selected)
|
|
1297
|
+
selected = self.filter(selected, step.preds)
|
|
1298
|
+
if reverse:
|
|
1299
|
+
selected.reverse()
|
|
1300
|
+
out.extend(selected)
|
|
1301
|
+
|
|
1302
|
+
def collect(self, step, x, out):
|
|
1303
|
+
"""Appends the nodes of the axis that pass the node test, in axis order (reverse axes: nearest first)."""
|
|
1304
|
+
test = step.test
|
|
1305
|
+
axis = step.axis
|
|
1306
|
+
if axis == AXIS_CHILD:
|
|
1307
|
+
self.add_children(x, test, out)
|
|
1308
|
+
elif axis == AXIS_DESCENDANT:
|
|
1309
|
+
self.add_descendants(x, test, out)
|
|
1310
|
+
elif axis == AXIS_DESCENDANT_OR_SELF:
|
|
1311
|
+
if self.matches(test, x, False):
|
|
1312
|
+
out.append(x)
|
|
1313
|
+
self.add_descendants(x, test, out)
|
|
1314
|
+
elif axis == AXIS_SELF:
|
|
1315
|
+
if self.matches(test, x, False):
|
|
1316
|
+
out.append(x)
|
|
1317
|
+
elif axis == AXIS_PARENT:
|
|
1318
|
+
p = self.parent_node(x)
|
|
1319
|
+
if p is not None and self.matches(test, p, False):
|
|
1320
|
+
out.append(p)
|
|
1321
|
+
elif axis == AXIS_ANCESTOR or axis == AXIS_ANCESTOR_OR_SELF:
|
|
1322
|
+
current = x
|
|
1323
|
+
if axis == AXIS_ANCESTOR_OR_SELF and self.matches(test, current, False):
|
|
1324
|
+
out.append(current)
|
|
1325
|
+
while True:
|
|
1326
|
+
current = self.parent_node(current)
|
|
1327
|
+
if current is None:
|
|
1328
|
+
break
|
|
1329
|
+
if self.matches(test, current, False):
|
|
1330
|
+
out.append(current)
|
|
1331
|
+
elif axis == AXIS_FOLLOWING_SIBLING or axis == AXIS_PRECEDING_SIBLING:
|
|
1332
|
+
self.collect_siblings(x, test, out, axis == AXIS_FOLLOWING_SIBLING)
|
|
1333
|
+
elif axis == AXIS_FOLLOWING:
|
|
1334
|
+
self.collect_following(x, test, out)
|
|
1335
|
+
elif axis == AXIS_PRECEDING:
|
|
1336
|
+
self.collect_preceding(x, test, out)
|
|
1337
|
+
elif axis == AXIS_ATTRIBUTE:
|
|
1338
|
+
self.add_attributes(x, test, out)
|
|
1339
|
+
|
|
1340
|
+
@staticmethod
|
|
1341
|
+
def in_document_order(nodes):
|
|
1342
|
+
for i in range(1, len(nodes)):
|
|
1343
|
+
a = nodes[i - 1]
|
|
1344
|
+
b = nodes[i]
|
|
1345
|
+
if a.major > b.major or (a.major == b.major and a.minor >= b.minor):
|
|
1346
|
+
return False
|
|
1347
|
+
return True
|
|
1348
|
+
|
|
1349
|
+
def collect_siblings(self, x, test, out, following):
|
|
1350
|
+
if x.kind == ROOT or x.kind == ATTRIBUTE:
|
|
1351
|
+
return
|
|
1352
|
+
d = self.d
|
|
1353
|
+
if not _matches_text(test) and x.kind != TEXT:
|
|
1354
|
+
# tags only: walk the flat list; deeper tags are inside the siblings, a shallower one ends the parent
|
|
1355
|
+
t = x.tag
|
|
1356
|
+
depths = d.depths
|
|
1357
|
+
depth = depths[t]
|
|
1358
|
+
count = len(depths)
|
|
1359
|
+
step_by = 1 if following else -1
|
|
1360
|
+
i = t + step_by
|
|
1361
|
+
while 0 <= i < count:
|
|
1362
|
+
if depths[i] < depth:
|
|
1363
|
+
break
|
|
1364
|
+
if depths[i] == depth and self.matches_tag_at(test, i):
|
|
1365
|
+
out.append(of_tag(d, i))
|
|
1366
|
+
i += step_by
|
|
1367
|
+
return
|
|
1368
|
+
parent = self.parent_node(x)
|
|
1369
|
+
if parent is None:
|
|
1370
|
+
return
|
|
1371
|
+
siblings = []
|
|
1372
|
+
self.add_children(parent, ANY_NODE_TEST, siblings)
|
|
1373
|
+
index = -1
|
|
1374
|
+
for k, s in enumerate(siblings):
|
|
1375
|
+
if s.major == x.major and s.minor == x.minor:
|
|
1376
|
+
index = k
|
|
1377
|
+
break
|
|
1378
|
+
if index < 0:
|
|
1379
|
+
return
|
|
1380
|
+
if following:
|
|
1381
|
+
for s in siblings[index + 1:]:
|
|
1382
|
+
if self.matches(test, s, False):
|
|
1383
|
+
out.append(s)
|
|
1384
|
+
else:
|
|
1385
|
+
for k in range(index - 1, -1, -1):
|
|
1386
|
+
if self.matches(test, siblings[k], False):
|
|
1387
|
+
out.append(siblings[k])
|
|
1388
|
+
|
|
1389
|
+
def collect_following(self, x, test, out):
|
|
1390
|
+
if x.kind == ROOT:
|
|
1391
|
+
return
|
|
1392
|
+
d = self.d
|
|
1393
|
+
after = _range_end(d, x)
|
|
1394
|
+
if _matches_text(test):
|
|
1395
|
+
for n in self.all_nodes():
|
|
1396
|
+
if _range_start(n) > after and self.matches(test, n, False):
|
|
1397
|
+
out.append(n)
|
|
1398
|
+
return
|
|
1399
|
+
starts = d.starts
|
|
1400
|
+
i = x.tag + 1 if x.kind == ELEMENT or x.kind == COMMENT_NODE else 0
|
|
1401
|
+
count = len(starts)
|
|
1402
|
+
while i < count:
|
|
1403
|
+
if starts[i] > after and self.matches_tag_at(test, i):
|
|
1404
|
+
out.append(of_tag(d, i))
|
|
1405
|
+
i += 1
|
|
1406
|
+
|
|
1407
|
+
def collect_preceding(self, x, test, out):
|
|
1408
|
+
if x.kind == ROOT:
|
|
1409
|
+
return
|
|
1410
|
+
d = self.d
|
|
1411
|
+
before = _range_start(x)
|
|
1412
|
+
if _matches_text(test):
|
|
1413
|
+
a = self.all_nodes()
|
|
1414
|
+
for k in range(len(a) - 1, -1, -1):
|
|
1415
|
+
if _range_end(d, a[k]) < before and self.matches(test, a[k], False):
|
|
1416
|
+
out.append(a[k])
|
|
1417
|
+
return
|
|
1418
|
+
ends = d.ends
|
|
1419
|
+
i = x.tag - 1 if x.kind == ELEMENT or x.kind == COMMENT_NODE else len(ends) - 1
|
|
1420
|
+
while i >= 0:
|
|
1421
|
+
if ends[i] < before and self.matches_tag_at(test, i):
|
|
1422
|
+
out.append(of_tag(d, i))
|
|
1423
|
+
i -= 1
|
|
1424
|
+
|
|
1425
|
+
def filter(self, nodes, predicates):
|
|
1426
|
+
"""Applies the predicates one after another; positions are 1-based in the order of the list."""
|
|
1427
|
+
for p in predicates:
|
|
1428
|
+
size = len(nodes)
|
|
1429
|
+
nodes = [n for k, n in enumerate(nodes) if self.eval_predicate(p, n, k + 1, size)]
|
|
1430
|
+
return nodes
|
|
1431
|
+
|
|
1432
|
+
# ----- functions -----
|
|
1433
|
+
|
|
1434
|
+
def eval_function(self, e, node, position, size):
|
|
1435
|
+
args = e.args
|
|
1436
|
+
fn = e.fn
|
|
1437
|
+
if fn == "last":
|
|
1438
|
+
return float(size)
|
|
1439
|
+
if fn == "position":
|
|
1440
|
+
return float(position)
|
|
1441
|
+
if fn == "count":
|
|
1442
|
+
return float(len(self.eval_nodes(args[0], node, position, size)))
|
|
1443
|
+
if fn == "name" or fn == "local-name":
|
|
1444
|
+
name = ""
|
|
1445
|
+
if not args:
|
|
1446
|
+
name = self.node_name(node)
|
|
1447
|
+
else:
|
|
1448
|
+
s = self.eval_nodes(args[0], node, position, size)
|
|
1449
|
+
if s:
|
|
1450
|
+
name = self.node_name(s[0])
|
|
1451
|
+
if fn == "local-name":
|
|
1452
|
+
colon = name.rfind(":")
|
|
1453
|
+
return name if colon < 0 else name[colon + 1:]
|
|
1454
|
+
return name
|
|
1455
|
+
if fn == "string":
|
|
1456
|
+
return self.string_value(node) if not args else self.eval_string(args[0], node, position, size)
|
|
1457
|
+
if fn == "concat":
|
|
1458
|
+
return "".join(self.eval_string(a, node, position, size) for a in args)
|
|
1459
|
+
if fn == "starts-with":
|
|
1460
|
+
return self.eval_string(args[0], node, position, size).startswith(
|
|
1461
|
+
self.eval_string(args[1], node, position, size))
|
|
1462
|
+
if fn == "ends-with":
|
|
1463
|
+
return self.eval_string(args[0], node, position, size).endswith(
|
|
1464
|
+
self.eval_string(args[1], node, position, size))
|
|
1465
|
+
if fn == "contains":
|
|
1466
|
+
return self.eval_string(args[1], node, position, size) in self.eval_string(args[0], node, position, size)
|
|
1467
|
+
if fn == "substring-before":
|
|
1468
|
+
s = self.eval_string(args[0], node, position, size)
|
|
1469
|
+
i = s.find(self.eval_string(args[1], node, position, size))
|
|
1470
|
+
return "" if i < 0 else s[:i]
|
|
1471
|
+
if fn == "substring-after":
|
|
1472
|
+
s = self.eval_string(args[0], node, position, size)
|
|
1473
|
+
t = self.eval_string(args[1], node, position, size)
|
|
1474
|
+
i = s.find(t)
|
|
1475
|
+
return "" if i < 0 else s[i + len(t):]
|
|
1476
|
+
if fn == "substring":
|
|
1477
|
+
return self.substring(e, node, position, size)
|
|
1478
|
+
if fn == "string-length":
|
|
1479
|
+
# UTF-16 units, as .NET counts
|
|
1480
|
+
return float(utf16_length(self.string_value(node) if not args
|
|
1481
|
+
else self.eval_string(args[0], node, position, size)))
|
|
1482
|
+
if fn == "normalize-space":
|
|
1483
|
+
s = self.string_value(node) if not args else self.eval_string(args[0], node, position, size)
|
|
1484
|
+
return " ".join(w for w in SPACE_RUNS.split(s) if w)
|
|
1485
|
+
if fn == "translate":
|
|
1486
|
+
s = self.eval_string(args[0], node, position, size)
|
|
1487
|
+
frm = self.eval_string(args[1], node, position, size)
|
|
1488
|
+
to = self.eval_string(args[2], node, position, size)
|
|
1489
|
+
mapping = {}
|
|
1490
|
+
for k, ch in enumerate(frm):
|
|
1491
|
+
if ch not in mapping:
|
|
1492
|
+
mapping[ch] = to[k] if k < len(to) else ""
|
|
1493
|
+
if not mapping:
|
|
1494
|
+
return s
|
|
1495
|
+
return "".join(mapping.get(ch, ch) for ch in s)
|
|
1496
|
+
if fn == "lower-case":
|
|
1497
|
+
return lower(self.eval_string(args[0], node, position, size))
|
|
1498
|
+
if fn == "upper-case":
|
|
1499
|
+
return upper(self.eval_string(args[0], node, position, size))
|
|
1500
|
+
if fn == "not":
|
|
1501
|
+
return not self.eval_bool(args[0], node, position, size)
|
|
1502
|
+
if fn == "true":
|
|
1503
|
+
return True
|
|
1504
|
+
if fn == "false":
|
|
1505
|
+
return False
|
|
1506
|
+
if fn == "boolean":
|
|
1507
|
+
return self.eval_bool(args[0], node, position, size)
|
|
1508
|
+
if fn == "number":
|
|
1509
|
+
if not args:
|
|
1510
|
+
return _string_to_number(self.string_value(node))
|
|
1511
|
+
return self.eval_number(args[0], node, position, size)
|
|
1512
|
+
if fn == "sum":
|
|
1513
|
+
total = 0.0
|
|
1514
|
+
for n in self.eval_nodes(args[0], node, position, size):
|
|
1515
|
+
total += _string_to_number(self.string_value(n))
|
|
1516
|
+
return total
|
|
1517
|
+
if fn == "floor":
|
|
1518
|
+
return _float_floor(self.eval_number(args[0], node, position, size))
|
|
1519
|
+
if fn == "ceiling":
|
|
1520
|
+
return _float_ceil(self.eval_number(args[0], node, position, size))
|
|
1521
|
+
if fn == "round":
|
|
1522
|
+
return _round(self.eval_number(args[0], node, position, size))
|
|
1523
|
+
raise XPathError(f"unknown XPath function {fn}")
|
|
1524
|
+
|
|
1525
|
+
def substring(self, e, node, position, size):
|
|
1526
|
+
"""XPath 1.0: the chars at 1-based positions p with round(start) <= p < round(start) + round(length)."""
|
|
1527
|
+
args = e.args
|
|
1528
|
+
s = self.eval_string(args[0], node, position, size)
|
|
1529
|
+
start = _round(self.eval_number(args[1], node, position, size))
|
|
1530
|
+
to = start + _round(self.eval_number(args[2], node, position, size)) if len(args) > 2 else INF
|
|
1531
|
+
if start != start or to != to:
|
|
1532
|
+
return ""
|
|
1533
|
+
n = len(s)
|
|
1534
|
+
if start <= 1:
|
|
1535
|
+
first = 0
|
|
1536
|
+
elif start > n:
|
|
1537
|
+
first = n
|
|
1538
|
+
else:
|
|
1539
|
+
first = int(start) - 1
|
|
1540
|
+
if to >= n + 1:
|
|
1541
|
+
end = n
|
|
1542
|
+
elif to <= 1:
|
|
1543
|
+
end = 0
|
|
1544
|
+
else:
|
|
1545
|
+
end = int(to) - 1
|
|
1546
|
+
if end <= first:
|
|
1547
|
+
return ""
|
|
1548
|
+
return s[first:end]
|
|
1549
|
+
|
|
1550
|
+
|
|
1551
|
+
class XPathMatcher:
|
|
1552
|
+
"""A compiled expression and its evaluation."""
|
|
1553
|
+
|
|
1554
|
+
__slots__ = ("expression", "expr")
|
|
1555
|
+
|
|
1556
|
+
def __init__(self, expression):
|
|
1557
|
+
self.expression = expression
|
|
1558
|
+
self.expr = compile_xpath(expression)
|
|
1559
|
+
|
|
1560
|
+
@property
|
|
1561
|
+
def is_node_set(self):
|
|
1562
|
+
return self.expr.type == TYPE_NODE_SET
|
|
1563
|
+
|
|
1564
|
+
def check_node_set(self):
|
|
1565
|
+
if self.expr.type != TYPE_NODE_SET:
|
|
1566
|
+
raise XPathError(f"the XPath {quote(self.expression)} gives a {TYPE_NAMES[self.expr.type]}, not tags; "
|
|
1567
|
+
"use xpath_value()")
|
|
1568
|
+
|
|
1569
|
+
@staticmethod
|
|
1570
|
+
def context(d, i):
|
|
1571
|
+
return _ROOT if i is None else of_tag(d, i)
|
|
1572
|
+
|
|
1573
|
+
def tags(self, d, i):
|
|
1574
|
+
"""The indexes of the selected tags (elements and comments) in document order."""
|
|
1575
|
+
self.check_node_set()
|
|
1576
|
+
out = []
|
|
1577
|
+
for n in Evaluator(d).eval_expr(self.expr, self.context(d, i), 1, 1):
|
|
1578
|
+
if n.kind == ELEMENT or n.kind == COMMENT_NODE:
|
|
1579
|
+
out.append(n.tag)
|
|
1580
|
+
return out
|
|
1581
|
+
|
|
1582
|
+
def values(self, d, i):
|
|
1583
|
+
ev = Evaluator(d)
|
|
1584
|
+
result = ev.eval_expr(self.expr, self.context(d, i), 1, 1)
|
|
1585
|
+
if not isinstance(result, list):
|
|
1586
|
+
return [ev.to_str(result)]
|
|
1587
|
+
return [ev.string_value(n) for n in result]
|
|
1588
|
+
|
|
1589
|
+
def value(self, d, i):
|
|
1590
|
+
ev = Evaluator(d)
|
|
1591
|
+
result = ev.eval_expr(self.expr, self.context(d, i), 1, 1)
|
|
1592
|
+
if isinstance(result, list):
|
|
1593
|
+
return ev.string_value(result[0]) if result else None
|
|
1594
|
+
return ev.to_str(result)
|