fast-xml 1.0.1 → 1.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (22) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +145 -37
  3. data/ext/fastxml/ccan/build_assert/build_assert.h +40 -0
  4. data/ext/fastxml/ccan/check_type/check_type.h +63 -0
  5. data/ext/fastxml/ccan/container_of/container_of.h +142 -0
  6. data/ext/fastxml/ccan/list/list.h +773 -0
  7. data/ext/fastxml/ccan/str/str.h +16 -0
  8. data/ext/fastxml/fastxml.c +35 -2
  9. data/ext/fastxml/xh.c +19 -8
  10. data/ext/fastxml/xh.h +2 -1
  11. data/ext/fastxml/xh_config.h +3 -0
  12. data/ext/fastxml/xh_core.h +1 -5
  13. data/ext/fastxml/xh_log.h +37 -27
  14. data/ext/fastxml/xh_param.c +3 -11
  15. data/ext/fastxml/xh_param.h +1 -1
  16. data/ext/fastxml/xh_reader.c +528 -0
  17. data/ext/fastxml/xh_reader.h +43 -0
  18. data/ext/fastxml/xh_ruby_hash.h +384 -0
  19. data/ext/fastxml/xh_x2h.c +1002 -0
  20. data/ext/fastxml/xh_x2h.h +133 -0
  21. data/lib/fastxml/version.rb +1 -1
  22. metadata +13 -3
data/ext/fastxml/xh_x2h.c ADDED
@@ -0,0 +1,1002 @@
1
+ #include "xh_config.h"
2
+ #include "xh_core.h"
3
+ #include "xh_ruby_hash.h"
4
+
5
+ static const char DEF_CONTENT_KEY[] = "content";
6
+
7
+ #define _NEW_STRING(s, l, utf8) \
8
+ ((utf8) ? rb_utf8_str_new((const char *) (s), l) : rb_str_new((const char *) (s), l))
9
+
10
+ #define NEW_STRING(s, l) \
11
+ _NEW_STRING(s, l, ctx->opts.utf8)
12
+
13
+ #define CAT_STRING(v, s, l) \
14
+ rb_str_cat((v), (const char *) (s), (l));
15
+
16
+ #define SAVE_VALUE(lv, v , s, l) \
17
+ xh_log_trace2("save value: [%.*s]", l, s); \
18
+ if ( RTEST(v) ) { \
19
+ xh_log_trace0("add to array"); \
20
+ /* get array if value is reference to array */ \
21
+ if ( RB_TYPE_P(v, RUBY_T_ARRAY) ) { \
22
+ av = v; \
23
+ } \
24
+ /* create a new array and move value to array */ \
25
+ else { \
26
+ av = rb_ary_new(); \
27
+ *(lv) = av; \
28
+ rb_ary_push(av, v); \
29
+ (v) = *(lv); \
30
+ } \
31
+ /* add value to array */ \
32
+ rb_ary_push(av, NEW_STRING((s), (l))); \
33
+ (lv) = (VALUE *) &RARRAY_CONST_PTR(av)[RARRAY_LEN(av) - 1]; \
34
+ } \
35
+ else { \
36
+ xh_log_trace0("set string"); \
37
+ *(lv) = NEW_STRING(s, l); \
38
+ } \
39
+
40
+ #define _OPEN_TAG(s, l) \
41
+ val = *lval; \
42
+ /* if content exists that move to hash with 'content' key */ \
43
+ if ( RB_TYPE_P(val, RUBY_T_STRING) || RB_TYPE_P(val, RUBY_T_ARRAY)) {\
44
+ *lval = hash_new(); \
45
+ if (RB_TYPE_P(val, RUBY_T_HASH) || RB_TYPE_P(val, RUBY_T_ARRAY) || (RB_TYPE_P(val, RUBY_T_STRING) && RSTRING_LEN(val))) {\
46
+ (void) hash_store(*lval, (const char *) content_key, content_key_len, val);\
47
+ } \
48
+ val = *lval; \
49
+ } \
50
+ /* fetch existen or create empty hash entry */ \
51
+ lval = hash_fetch(val, (const char *) s, l, Qnil); \
52
+ /* save as empty string */ \
53
+ val = *lval; \
54
+ xh_log_trace0("save as empty string"); \
55
+ SAVE_VALUE(lval, val, "", 0) \
56
+ if (++depth >= ctx->opts.max_depth) goto MAX_DEPTH_EXCEEDED; \
57
+ nodes[depth].lval = lval; \
58
+ nodes[depth].flags = XH_X2H_NODE_FLAG_NONE; \
59
+ if (depth > 1 && ctx->opts.force_array.enable && !RB_TYPE_P(val, RUBY_T_ARRAY) \
60
+ && (ctx->opts.force_array.always || xh_x2h_match_node(s, l, ctx->opts.force_array.expr))\
61
+ ) { \
62
+ nodes[depth].flags |= XH_X2H_NODE_FLAG_FORCE_ARRAY; \
63
+ } \
64
+ (s) = NULL;
65
+
66
+ #define OPEN_TAG(s, l) \
67
+ xh_log_trace2("new tag: [%.*s]", l, s); \
68
+ if (real_depth == 0) { \
69
+ if (flags & XH_X2H_ROOT_FOUND) goto INVALID_XML; \
70
+ flags |= XH_X2H_ROOT_FOUND; \
71
+ } \
72
+ if (XH_X2H_FILTER_SEARCH(flags)) { \
73
+ xh_x2h_xpath_update(ctx->xpath, s, l); \
74
+ if (xh_x2h_match_node(ctx->xpath, xh_strlen(ctx->xpath), ctx->opts.filter.expr)) {\
75
+ xh_log_trace2("match node: [%.*s]", l, s); \
76
+ ctx->hash = hash_new(); \
77
+ nodes[0].lval = lval = &ctx->hash; \
78
+ depth = 0; \
79
+ flags |= XH_X2H_FILTER_MATCHED; \
80
+ } \
81
+ } \
82
+ if (!XH_X2H_FILTER_SEARCH(flags)) { \
83
+ _OPEN_TAG(s, l) \
84
+ } \
85
+ real_depth++;
86
+
87
+ #define _CLOSE_TAG \
88
+ val = *nodes[depth].lval; \
89
+ if (ctx->opts.force_content && RB_TYPE_P(val, RUBY_T_STRING)) { \
90
+ lval = nodes[depth].lval; \
91
+ *lval = hash_new(); \
92
+ (void) hash_store(*lval, (const char *) content_key, content_key_len, val);\
93
+ val = *lval; \
94
+ } \
95
+ if ((nodes[depth].flags & XH_X2H_NODE_FLAG_FORCE_ARRAY) \
96
+ && (RB_TYPE_P(val, RUBY_T_STRING) || !RB_TYPE_P(val, RUBY_T_ARRAY))\
97
+ ) { \
98
+ lval = nodes[depth].lval; \
99
+ av = rb_ary_new(); \
100
+ *lval = av; \
101
+ rb_ary_push(av, val); \
102
+ } \
103
+ lval = nodes[--depth].lval;
104
+
105
+ #define CLOSE_TAG \
106
+ xh_log_trace0("close tag"); \
107
+ if (real_depth == 0) goto INVALID_XML; \
108
+ if (!XH_X2H_FILTER_SEARCH(flags)) { \
109
+ _CLOSE_TAG \
110
+ } \
111
+ if ((flags & XH_X2H_FILTER_MATCHED) && depth == 0) { \
112
+ xh_log_trace0("match node finished"); \
113
+ val = *nodes[0].lval; \
114
+ if (ctx->opts.block_given) { \
115
+ rb_yield(val); \
116
+ } \
117
+ else { \
118
+ rb_ary_push(ctx->result, val); \
119
+ } \
120
+ flags ^= XH_X2H_FILTER_MATCHED; \
121
+ } \
122
+ if ((flags & (XH_X2H_FILTER_ENABLED | XH_X2H_FILTER_MATCHED)) == XH_X2H_FILTER_ENABLED) {\
123
+ xh_x2h_xpath_update(ctx->xpath, NULL, 0); \
124
+ } \
125
+ real_depth--;
126
+
127
+ #define NEW_NODE_ATTRIBUTE(k, kl, v, vl) \
128
+ if (!XH_X2H_FILTER_SEARCH(flags)) { \
129
+ _OPEN_TAG(k, kl) \
130
+ _NEW_TEXT(v, vl) \
131
+ _CLOSE_TAG \
132
+ }
133
+
134
+ #define NEW_XML_DECL_ATTRIBUTE(k, kl, v, vl) \
135
+ xh_log_trace4("new xml decl attr name: [%.*s] value: [%.*s]", kl, k, vl, v);\
136
+ /* save encoding parameter to converter context if param found */ \
137
+ if ((kl) == (sizeof("encoding") - 1) && \
138
+ xh_strncmp((k), XH_CHAR_CAST "encoding", sizeof("encoding") - 1) == 0) {\
139
+ xh_str_range_copy(ctx->encoding, XH_CHAR_CAST (v), vl, XH_PARAM_LEN);\
140
+ } \
141
+ (k) = (v) = NULL;
142
+
143
+ #define NEW_ATTRIBUTE(k, kl, v, vl) NEW_NODE_ATTRIBUTE(k, kl, v, vl)
144
+
145
+ #define _NEW_TEXT(s, l) \
146
+ val = *lval; \
147
+ if ( !RB_TYPE_P(val, RUBY_T_STRING) ) { \
148
+ xh_log_trace0("add to array"); \
149
+ /* add content to array*/ \
150
+ if ( RB_TYPE_P(val, RUBY_T_ARRAY) ) { \
151
+ av = val; \
152
+ rb_ary_push(av, NEW_STRING(s, l)); \
153
+ } \
154
+ /* save content to hash with "content" key */ \
155
+ else { \
156
+ xh_log_trace0("save to hash"); \
157
+ lval = hash_fetch(val, (const char *) content_key, content_key_len, Qnil);\
158
+ val = *lval; \
159
+ SAVE_VALUE(lval, val, s, l) \
160
+ lval = nodes[depth].lval; \
161
+ } \
162
+ } \
163
+ else if (RSTRING_LEN(val) && !ctx->opts.merge_text) { \
164
+ xh_log_trace0("create a new array"); \
165
+ xh_log_trace1("create a new array val: %s", StringValueCStr(val));\
166
+ /* content already exists, create a new array and move*/ \
167
+ /* old and new content to array */ \
168
+ *lval = av = rb_ary_new(); \
169
+ rb_ary_push(av, val); \
170
+ rb_ary_push(av, NEW_STRING(s, l)); \
171
+ } \
172
+ else { \
173
+ xh_log_trace0("concat"); \
174
+ /* concatenate with previous string */ \
175
+ CAT_STRING(val, s, l) \
176
+ } \
177
+
178
+ #define NEW_TEXT(s, l) \
179
+ xh_log_trace2("new text: [%.*s]", l, s); \
180
+ if (real_depth == 0) goto INVALID_XML; \
181
+ if (!XH_X2H_FILTER_SEARCH(flags)) { \
182
+ _NEW_TEXT(s, l) \
183
+ }
184
+
185
+ #define NEW_COMMENT(s, l) (s) = NULL;
186
+
187
+ #define NEW_CDATA(s, l) NEW_TEXT(s, l)
188
+
189
+ #define CHECK_EOF_WITH_CHUNK(loop) \
190
+ if (cur >= eof || *cur == '\0') { \
191
+ eof = cur; \
192
+ if (terminate) goto XH_PPCAT(loop, _FINISH); \
193
+ ctx->state = XH_PPCAT(loop, _START); \
194
+ goto CHUNK_FINISH; \
195
+ } \
196
+
197
+ #define CHECK_EOF_WITHOUT_CHUNK(loop) \
198
+ if (cur >= eof || *cur == '\0') goto XH_PPCAT(loop, _FINISH); \
199
+
200
+ #define CHECK_EOF(loop) CHECK_EOF_WITH_CHUNK(loop)
201
+
202
+ #define DO(loop) \
203
+ XH_PPCAT(loop, _START): \
204
+ CHECK_EOF(loop) \
205
+ c = *cur++; \
206
+ xh_log_trace3("'%c'=[0x%X] %s start", c, c, XH_STRINGIZE(loop)); \
207
+ switch (c) {
208
+
209
+ #define _DO(loop) \
210
+ XH_PPCAT(loop, _START): \
211
+ CHECK_EOF_WITHOUT_CHUNK(loop) \
212
+ c = *cur++; \
213
+ xh_log_trace3("'%c'=[0x%X] %s start", c, c, XH_STRINGIZE(loop)); \
214
+ switch (c) {
215
+
216
+ #define END(loop) \
217
+ } \
218
+ xh_log_trace1(" %s end", XH_STRINGIZE(loop)); \
219
+ goto XH_PPCAT(loop, _START); \
220
+ XH_PPCAT(loop, _FINISH):
221
+
222
+ #define EXPECT_ANY(desc) \
223
+ default: xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
224
+
225
+ #define EXPECT_CHAR(desc, c1) \
226
+ case c1: xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
227
+
228
+ #define EXPECT_BLANK_WO_CR(desc) \
229
+ case ' ': case '\t': case '\n': \
230
+ xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
231
+
232
+ #define EXPECT_BLANK(desc) \
233
+ case ' ': case '\t': case '\n': case '\r': \
234
+ xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
235
+
236
+ #define EXPECT_DIGIT(desc) \
237
+ case '0': case '1': case '2': case '3': case '4': \
238
+ case '5': case '6': case '7': case '8': case '9': \
239
+ xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
240
+
241
+ #define EXPECT_HEX_CHAR_LC(desc) \
242
+ case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': \
243
+ xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
244
+
245
+ #define EXPECT_HEX_CHAR_UC(desc) \
246
+ case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': \
247
+ xh_log_trace3("'%c'=[0x%X] - %s expected", c, c, desc);
248
+
249
+ #define SKIP_BLANK \
250
+ EXPECT_BLANK("skip blank") break;
251
+
252
+ #define SCAN2(loop, c1, c2) \
253
+ DO(XH_PPCAT(loop, _1)) EXPECT_CHAR(XH_STRINGIZE(c1), c1) \
254
+ DO(XH_PPCAT(loop, _2)) EXPECT_CHAR(XH_STRINGIZE(c2), c2)
255
+
256
+ #define END2(loop, stop) \
257
+ EXPECT_ANY("wrong character") goto stop; \
258
+ END(XH_PPCAT(loop, _2)) goto stop; \
259
+ EXPECT_ANY("wrong character") goto stop; \
260
+ END(XH_PPCAT(loop, _1))
261
+
262
+ #define SCAN3(loop, c1, c2, c3) \
263
+ DO(XH_PPCAT(loop, _1)) EXPECT_CHAR(STRINGIZE(c1), c1) \
264
+ DO(XH_PPCAT(loop, _2)) EXPECT_CHAR(STRINGIZE(c2), c2) \
265
+ DO(XH_PPCAT(loop, _3)) EXPECT_CHAR(STRINGIZE(c3), c3)
266
+
267
+ #define END3(loop, stop) \
268
+ EXPECT_ANY("wrong character") goto stop; \
269
+ END(XH_PPCAT(loop, _3)) goto stop; \
270
+ EXPECT_ANY("wrong character") goto stop; \
271
+ END(XH_PPCAT(loop, _2)) goto stop; \
272
+ EXPECT_ANY("wrong character") goto stop; \
273
+ END(XH_PPCAT(loop, _1))
274
+
275
+ #define SCAN5(loop, c1, c2, c3, c4, c5) \
276
+ SCAN3(XH_PPCAT(loop, _1), c1, c2, c3) \
277
+ SCAN2(XH_PPCAT(loop, _2), c4, c5)
278
+
279
+ #define END5(loop, stop) \
280
+ END2(XH_PPCAT(loop, _2), stop) \
281
+ END3(XH_PPCAT(loop, _1), stop)
282
+
283
+ #define SCAN6(loop, c1, c2, c3, c4, c5, c6) \
284
+ SCAN3(XH_PPCAT(loop, _1), c1, c2, c3) \
285
+ SCAN3(XH_PPCAT(loop, _2), c4, c5, c6)
286
+
287
+ #define END6(loop, stop) \
288
+ END3(XH_PPCAT(loop, _2), stop) \
289
+ END3(XH_PPCAT(loop, _1), stop)
290
+
291
+ #define SEARCH_END_TAG \
292
+ EXPECT_CHAR("end tag", '>') \
293
+ goto PARSE_CONTENT; \
294
+ EXPECT_CHAR("self closing tag", '/') \
295
+ CLOSE_TAG \
296
+ DO(SEARCH_END_TAG) \
297
+ EXPECT_CHAR("end tag", '>') \
298
+ goto PARSE_CONTENT; \
299
+ EXPECT_ANY("wrong character") \
300
+ goto INVALID_XML; \
301
+ END(SEARCH_END_TAG) \
302
+ goto INVALID_XML;
303
+
304
+ #define SEARCH_NODE_ATTRIBUTE_VALUE(loop, top_loop, quot) \
305
+ EXPECT_CHAR("start attr value", quot) \
306
+ content = cur; \
307
+ flags &= ~XH_X2H_NEED_NORMALIZE; \
308
+ DO(XH_PPCAT(loop, _END_ATTR_VALUE)) \
309
+ EXPECT_CHAR("attr value end", quot) \
310
+ if (flags & XH_X2H_NEED_NORMALIZE) { \
311
+ NORMALIZE_TEXT(loop, content, cur - content - 1) \
312
+ NEW_ATTRIBUTE(node, end - node, enc, enc_len) \
313
+ } \
314
+ else { \
315
+ NEW_ATTRIBUTE(node, end - node, content, cur - content - 1)\
316
+ } \
317
+ goto top_loop; \
318
+ EXPECT_CHAR("CR", '\r') \
319
+ flags |= XH_X2H_NORMALIZE_LINE_FEED; \
320
+ break; \
321
+ EXPECT_CHAR("reference", '&') \
322
+ flags |= XH_X2H_NORMALIZE_REF; \
323
+ break; \
324
+ END(XH_PPCAT(loop, _END_ATTR_VALUE)) \
325
+ goto INVALID_XML;
326
+
327
+ #define SEARCH_XML_DECL_ATTRIBUTE_VALUE(loop, top_loop, quot) \
328
+ EXPECT_CHAR("start attr value", quot) \
329
+ content = cur; \
330
+ DO(XH_PPCAT(loop, _END_ATTR_VALUE)) \
331
+ EXPECT_CHAR("attr value end", quot) \
332
+ NEW_ATTRIBUTE(node, end - node, content, cur - content - 1)\
333
+ goto top_loop; \
334
+ END(XH_PPCAT(loop, _END_ATTR_VALUE)) \
335
+ goto INVALID_XML;
336
+
337
+ #define SEARCH_ATTRIBUTE_VALUE(loop, top_loop, quot) SEARCH_NODE_ATTRIBUTE_VALUE(loop, top_loop, quot)
338
+
339
+ #define SEARCH_ATTRIBUTES(loop, search_end_tag) \
340
+ XH_PPCAT(loop, _SEARCH_ATTRIBUTES_LOOP): \
341
+ DO(XH_PPCAT(loop, _SEARCH_ATTR)) \
342
+ search_end_tag \
343
+ \
344
+ SKIP_BLANK \
345
+ \
346
+ EXPECT_ANY("start attr name") \
347
+ node = cur - 1; \
348
+ \
349
+ DO(XH_PPCAT(loop, _PARSE_ATTR_NAME)) \
350
+ EXPECT_BLANK("end attr name") \
351
+ end = cur - 1; \
352
+ xh_log_trace2("attr name: [%.*s]", end - node, node);\
353
+ \
354
+ DO(XH_PPCAT(loop, _ATTR_SKIP_BLANK)) \
355
+ EXPECT_CHAR("search attr value", '=') \
356
+ goto XH_PPCAT(loop, _SEARCH_ATTRIBUTE_VALUE);\
357
+ SKIP_BLANK \
358
+ EXPECT_ANY("wrong character") \
359
+ goto INVALID_XML; \
360
+ END(XH_PPCAT(loop, _ATTR_SKIP_BLANK)) \
361
+ goto INVALID_XML; \
362
+ EXPECT_CHAR("end attr name", '=') \
363
+ end = cur - 1; \
364
+ xh_log_trace2("attr name: [%.*s]", end - node, node);\
365
+ \
366
+ XH_PPCAT(loop, _SEARCH_ATTRIBUTE_VALUE): \
367
+ DO(XH_PPCAT(loop, _PARSE_ATTR_VALUE)) \
368
+ SEARCH_ATTRIBUTE_VALUE(XH_PPCAT(loop, _1), XH_PPCAT(loop, _SEARCH_ATTRIBUTES_LOOP), '"')\
369
+ SEARCH_ATTRIBUTE_VALUE(XH_PPCAT(loop, _2), XH_PPCAT(loop, _SEARCH_ATTRIBUTES_LOOP), '\'')\
370
+ SKIP_BLANK \
371
+ EXPECT_ANY("wrong character") \
372
+ goto INVALID_XML; \
373
+ END(XH_PPCAT(loop, _PARSE_ATTR_VALUE)) \
374
+ goto INVALID_XML; \
375
+ END(XH_PPCAT(loop, _PARSE_ATTR_NAME)) \
376
+ goto INVALID_XML; \
377
+ END(XH_PPCAT(loop, _SEARCH_ATTR)) \
378
+ goto INVALID_XML;
379
+
380
+ #define PARSE_XML_DECLARATION \
381
+ SCAN3(XML_DECL, 'x', 'm', 'l') \
382
+ DO(XML_DECL_ATTR) \
383
+ EXPECT_BLANK("blank") \
384
+ SEARCH_ATTRIBUTES(XML_DECL_ATTR, SEARCH_END_XML_DECLARATION)\
385
+ goto INVALID_XML; \
386
+ EXPECT_ANY("wrong character") \
387
+ goto INVALID_XML; \
388
+ END(XML_DECL_ATTR) \
389
+ goto INVALID_XML; \
390
+ END3(XML_DECL, INVALID_XML) \
391
+ goto INVALID_XML;
392
+
393
+ #define SEARCH_END_XML_DECLARATION \
394
+ EXPECT_CHAR("end tag", '?') \
395
+ DO(XML_DECL_SEARCH_END_TAG2) \
396
+ EXPECT_CHAR("end tag", '>') \
397
+ goto XML_DECL_FOUND; \
398
+ EXPECT_ANY("wrong character") \
399
+ goto INVALID_XML; \
400
+ END(XML_DECL_SEARCH_END_TAG2) \
401
+ goto INVALID_XML;
402
+
403
+ #define PARSE_COMMENT \
404
+ DO(COMMENT1) \
405
+ EXPECT_CHAR("-", '-') \
406
+ content = NULL; \
407
+ DO(END_COMMENT1) \
408
+ SKIP_BLANK \
409
+ EXPECT_CHAR("1st -", '-') \
410
+ if (content == NULL) content = end = cur - 1; \
411
+ DO(END_COMMENT2) \
412
+ EXPECT_CHAR("2nd -", '-') \
413
+ DO(END_COMMENT3) \
414
+ EXPECT_CHAR(">", '>') \
415
+ NEW_COMMENT(content, end - content) \
416
+ goto PARSE_CONTENT; \
417
+ EXPECT_CHAR("2nd -", '-') \
418
+ end = cur - 2; \
419
+ goto END_COMMENT3_START; \
420
+ EXPECT_ANY("any character") \
421
+ end = cur - 1; \
422
+ goto END_COMMENT1_START; \
423
+ END(END_COMMENT3) \
424
+ EXPECT_BLANK("skip blank") \
425
+ end = cur - 1; \
426
+ goto END_COMMENT1_START; \
427
+ EXPECT_ANY("any character") \
428
+ end = cur; \
429
+ goto END_COMMENT1_START; \
430
+ END(END_COMMENT2) \
431
+ EXPECT_ANY("any char") \
432
+ if (content == NULL) content = cur - 1; \
433
+ end = cur; \
434
+ END(END_COMMENT1) \
435
+ goto INVALID_XML; \
436
+ \
437
+ EXPECT_ANY("wrong character") \
438
+ goto INVALID_XML; \
439
+ \
440
+ END(COMMENT1) \
441
+ goto INVALID_XML;
442
+
443
+ #define PARSE_CDATA \
444
+ SCAN6(CDATA, 'C', 'D', 'A', 'T', 'A', '[') \
445
+ content = end = cur; \
446
+ DO(END_CDATA1) \
447
+ EXPECT_CHAR("1st ]", ']') \
448
+ DO(END_CDATA2) \
449
+ EXPECT_CHAR("2nd ]", ']') \
450
+ DO(END_CDATA3) \
451
+ EXPECT_CHAR(">", '>') \
452
+ end = cur - 3; \
453
+ NEW_CDATA(content, end - content) \
454
+ goto PARSE_CONTENT; \
455
+ EXPECT_CHAR("2nd ]", ']') \
456
+ goto END_CDATA3_START; \
457
+ EXPECT_ANY("any character") \
458
+ goto END_CDATA1_START; \
459
+ END(END_CDATA3) \
460
+ EXPECT_ANY("any character") \
461
+ goto END_CDATA1_START; \
462
+ END(END_CDATA2) \
463
+ ; \
464
+ END(END_CDATA1) \
465
+ goto INVALID_XML; \
466
+ END6(CDATA, INVALID_XML)
467
+
468
+ #define PARSE_CDATA_WITH_TRIM \
469
+ SCAN6(CDATA_WITH_TRIM, 'C', 'D', 'A', 'T', 'A', '[') \
470
+ content = NULL; \
471
+ DO(END_CDATA_WITH_TRIM1) \
472
+ SKIP_BLANK \
473
+ EXPECT_CHAR("1st ]", ']') \
474
+ if (content == NULL) content = end = cur - 1; \
475
+ DO(END_CDATA_WITH_TRIM2) \
476
+ EXPECT_CHAR("2nd ]", ']') \
477
+ DO(END_CDATA_WITH_TRIM3) \
478
+ EXPECT_CHAR(">", '>') \
479
+ NEW_CDATA(content, end - content) \
480
+ goto PARSE_CONTENT; \
481
+ EXPECT_CHAR("2nd ]", ']') \
482
+ end = cur - 2; \
483
+ goto END_CDATA_WITH_TRIM3_START; \
484
+ EXPECT_ANY("any character") \
485
+ end = cur - 1; \
486
+ goto END_CDATA_WITH_TRIM1_START; \
487
+ END(END_CDATA_WITH_TRIM3) \
488
+ EXPECT_BLANK("skip blank") \
489
+ end = cur - 1; \
490
+ goto END_CDATA_WITH_TRIM1_START; \
491
+ EXPECT_ANY("any character") \
492
+ end = cur; \
493
+ goto END_CDATA_WITH_TRIM1_START; \
494
+ END(END_CDATA_WITH_TRIM2) \
495
+ EXPECT_ANY("any char") \
496
+ if (content == NULL) content = cur - 1; \
497
+ end = cur; \
498
+ END(END_CDATA_WITH_TRIM1) \
499
+ goto INVALID_XML; \
500
+ END6(CDATA_WITH_TRIM, INVALID_XML)
501
+
502
+ #define NORMALIZE_REFERENCE(loop) \
503
+ _DO(XH_PPCAT(loop, _REFERENCE)) \
504
+ EXPECT_CHAR("char reference", '#') \
505
+ _DO(XH_PPCAT(loop, _CHAR_REFERENCE)) \
506
+ EXPECT_CHAR("hex", 'x') \
507
+ code = 0; \
508
+ _DO(XH_PPCAT(loop, _HEX_CHAR_REFERENCE_LOOP)) \
509
+ EXPECT_DIGIT("hex digit") \
510
+ code = code * 16 + (c - '0'); \
511
+ break; \
512
+ EXPECT_HEX_CHAR_LC("hex a-f") \
513
+ code = code * 16 + (c - 'a') + 10; \
514
+ break; \
515
+ EXPECT_HEX_CHAR_UC("hex A-F") \
516
+ code = code * 16 + (c - 'A') + 10; \
517
+ break; \
518
+ EXPECT_CHAR("reference end", ';') \
519
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
520
+ END(XH_PPCAT(loop, _HEX_CHAR_REFERENCE_LOOP)) \
521
+ goto INVALID_REF; \
522
+ EXPECT_DIGIT("digit") \
523
+ code = (c - '0'); \
524
+ _DO(XH_PPCAT(loop, _CHAR_REFERENCE_LOOP)) \
525
+ EXPECT_DIGIT("digit") \
526
+ code = code * 10 + (c - '0'); \
527
+ break; \
528
+ EXPECT_CHAR("reference end", ';') \
529
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
530
+ END(XH_PPCAT(loop, _CHAR_REFERENCE_LOOP)) \
531
+ goto INVALID_REF; \
532
+ EXPECT_ANY("any char") \
533
+ goto INVALID_REF; \
534
+ END(XH_PPCAT(loop, _CHAR_REFERENCE)) \
535
+ goto INVALID_REF; \
536
+ EXPECT_CHAR("amp or apos", 'a') \
537
+ if (xh_str_equal3(cur, 'm', 'p', ';')) { \
538
+ code = '&'; \
539
+ cur += 3; \
540
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
541
+ } \
542
+ if (xh_str_equal4(cur, 'p', 'o', 's', ';')) { \
543
+ code = '\''; \
544
+ cur += 4; \
545
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
546
+ } \
547
+ goto INVALID_REF; \
548
+ EXPECT_CHAR("lt", 'l') \
549
+ if (xh_str_equal2(cur, 't', ';')) { \
550
+ code = '<'; \
551
+ cur += 2; \
552
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
553
+ } \
554
+ goto INVALID_REF; \
555
+ EXPECT_CHAR("gt", 'g') \
556
+ if (xh_str_equal2(cur, 't', ';')) { \
557
+ code = '>'; \
558
+ cur += 2; \
559
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
560
+ } \
561
+ goto INVALID_REF; \
562
+ EXPECT_CHAR("quot", 'q') \
563
+ if (xh_str_equal4(cur, 'u', 'o', 't', ';')) { \
564
+ code = '"'; \
565
+ cur += 4; \
566
+ goto XH_PPCAT(loop, _REFEFENCE_VALUE); \
567
+ } \
568
+ goto INVALID_REF; \
569
+ EXPECT_ANY("any char") \
570
+ goto INVALID_REF; \
571
+ END(XH_PPCAT(loop, _REFERENCE)) \
572
+ goto INVALID_REF; \
573
+ XH_PPCAT(loop, _REFEFENCE_VALUE): \
574
+ xh_log_trace1("parse reference value: %lu", code); \
575
+ if (code == 0 || code > 0x10FFFF) goto INVALID_REF; \
576
+ if (code >= 0x80) { \
577
+ if (code < 0x800) { \
578
+ *enc_cur++ = (code >> 6) | 0xC0; bits = 0; \
579
+ } \
580
+ else if (code < 0x10000) { \
581
+ *enc_cur++ = (code >> 12) | 0xE0; bits = 6; \
582
+ } \
583
+ else if (code < 0x110000) { \
584
+ *enc_cur++ = (code >> 18) | 0xF0; bits = 12; \
585
+ } \
586
+ else { \
587
+ goto INVALID_REF; \
588
+ } \
589
+ for (; bits >= 0; bits-= 6) { \
590
+ *enc_cur++ = ((code >> bits) & 0x3F) | 0x80; \
591
+ } \
592
+ } \
593
+ else { \
594
+ *enc_cur++ = (xh_char_t) code; \
595
+ }
596
+
597
+ #define NORMALIZE_LINE_FEED(loop) \
598
+ _DO(XH_PPCAT(loop, _NORMALIZE_LINE_FEED)) \
599
+ EXPECT_CHAR("LF", '\n') \
600
+ goto XH_PPCAT(loop, _NORMALIZE_LINE_FEED_END); \
601
+ EXPECT_ANY("any char") \
602
+ cur--; \
603
+ goto XH_PPCAT(loop, _NORMALIZE_LINE_FEED_END); \
604
+ END(XH_PPCAT(loop, _NORMALIZE_LINE_FEED)) \
605
+ XH_PPCAT(loop, _NORMALIZE_LINE_FEED_END): \
606
+ *enc_cur++ = '\n';
607
+
608
+ #define NORMALIZE_TEXT(loop, s, l) \
609
+ enc_len = l; \
610
+ if (enc_len) { \
611
+ old_cur = cur; \
612
+ old_eof = eof; \
613
+ cur = s; \
614
+ eof = cur + enc_len; \
615
+ if (ctx->tmp == NULL) { \
616
+ xh_log_trace1("malloc() %lu", enc_len); \
617
+ if ((ctx->tmp = malloc(enc_len)) == NULL) goto MALLOC; \
618
+ ctx->tmp_size = enc_len; \
619
+ } \
620
+ else if (enc_len > ctx->tmp_size) { \
621
+ xh_log_trace1("realloc() %lu", enc_len); \
622
+ if ((enc = realloc(ctx->tmp, enc_len)) == NULL) goto MALLOC;\
623
+ ctx->tmp = enc; \
624
+ ctx->tmp_size = enc_len; \
625
+ } \
626
+ enc = enc_cur = ctx->tmp; \
627
+ memcpy(enc, cur, enc_len); \
628
+ _DO(XH_PPCAT(loop, _NORMALIZE_TEXT)) \
629
+ EXPECT_CHAR("reference", '&') \
630
+ NORMALIZE_REFERENCE(loop) \
631
+ break; \
632
+ EXPECT_CHAR("CR", '\r') \
633
+ NORMALIZE_LINE_FEED(loop) \
634
+ break; \
635
+ EXPECT_ANY("any char") \
636
+ *enc_cur++ = c; \
637
+ END(XH_PPCAT(loop, _NORMALIZE_TEXT)) \
638
+ enc_len = enc_cur - enc; \
639
+ cur = old_cur; \
640
+ eof = old_eof; \
641
+ } \
642
+ else { \
643
+ enc = s; \
644
+ }
645
+
646
+ XH_INLINE void
647
+ xh_x2h_xpath_update(xh_char_t *xpath, xh_char_t *name, size_t name_len)
648
+ {
649
+ size_t len;
650
+
651
+ len = xh_strlen(xpath);
652
+ if (name != NULL) {
653
+ if ((len + name_len + 1) > XH_X2H_XPATH_MAX_LEN)
654
+ rb_raise(xh_parse_error_class, "XPath too long");
655
+
656
+ xpath[len++] = '/';
657
+ for (;name_len--;) xpath[len++] = *name++;
658
+ }
659
+ else if (len == 0) {
660
+ rb_raise(xh_parse_error_class, "Can't update xpath, something wrong!");
661
+ }
662
+ else {
663
+ for (;--len && xpath[len] != '/';) {/* void */}
664
+ }
665
+ xpath[len] = '\0';
666
+
667
+ xh_log_trace1("xpath: [%s]", xpath);
668
+ }
669
+
670
+ XH_INLINE xh_bool_t
671
+ xh_x2h_match_node(xh_char_t *name, size_t name_len, VALUE expr)
672
+ {
673
+ size_t i, l;
674
+ VALUE ary;
675
+ VALUE str;
676
+ xh_char_t *expr_str;
677
+ size_t expr_len;
678
+
679
+ xh_log_trace2("match node: [%.*s]", name_len, name);
680
+
681
+ str = _NEW_STRING(name, name_len, TRUE);
682
+
683
+ if ( RB_TYPE_P(expr, RUBY_T_REGEXP) ) {
684
+ if (rb_reg_search(expr, str, 0, 0) >= 0) return TRUE;
685
+ }
686
+ else if ( RB_TYPE_P(expr, RUBY_T_ARRAY) ) {
687
+ l = RARRAY_LEN(expr);
688
+ ary = expr;
689
+ for (i = 0; i < l; i++) {
690
+ expr = RARRAY_AREF(ary, i);
691
+ if ( RB_TYPE_P(expr, RUBY_T_REGEXP) ) {
692
+ if (rb_reg_search(expr, str, 0, 0) >= 0) return TRUE;
693
+ }
694
+ else {
695
+ expr_str = XH_CHAR_CAST RSTRING_PTR(expr);
696
+ expr_len = RSTRING_LEN(expr);
697
+ if (name_len == expr_len && !xh_strncmp(name, expr_str, name_len)) {
698
+ return TRUE;
699
+ }
700
+ }
701
+ }
702
+ } else {
703
+ xh_log_trace0("match string");
704
+ expr_str = XH_CHAR_CAST RSTRING_PTR(expr);
705
+ expr_len = RSTRING_LEN(expr);
706
+ xh_log_trace2("expr: [%.*s]", expr_len, expr_str);
707
+ if (name_len == expr_len && !xh_strncmp(name, expr_str, name_len)) {
708
+ xh_log_trace0("match TRUE");
709
+ return TRUE;
710
+ }
711
+ }
712
+
713
+ return FALSE;
714
+ }
715
+
716
+ static void
717
+ xh_x2h_parse_chunk(xh_x2h_ctx_t *ctx, xh_char_t **buf, size_t *bytesleft, xh_bool_t terminate)
718
+ {
719
+ xh_char_t c, *cur, *node, *end, *content, *eof, *enc,
720
+ *enc_cur, *old_cur, *old_eof, *content_key;
721
+ unsigned int depth, real_depth, code, flags;
722
+ int bits;
723
+ VALUE *lval, val;
724
+ xh_x2h_node_t *nodes;
725
+ VALUE av;
726
+ size_t enc_len, content_key_len;
727
+
728
+ cur = *buf;
729
+ eof = cur + *bytesleft;
730
+ nodes = ctx->nodes;
731
+ depth = ctx->depth;
732
+ real_depth = ctx->real_depth;
733
+ flags = ctx->flags;
734
+ node = ctx->node;
735
+ end = ctx->end;
736
+ content = ctx->content;
737
+ code = ctx->code;
738
+ lval = ctx->lval;
739
+ enc = enc_cur = old_eof = old_cur = NULL;
740
+ c = '\0';
741
+
742
+ if (ctx->opts.content[0] == '\0') {
743
+ content_key = (xh_char_t *) DEF_CONTENT_KEY;
744
+ content_key_len = sizeof(DEF_CONTENT_KEY) - 1;
745
+ }
746
+ else {
747
+ content_key = ctx->opts.content;
748
+ content_key_len = xh_strlen(ctx->opts.content);
749
+ }
750
+
751
+ #define XH_X2H_PROCESS_STATE(st) case st: goto st;
752
+ switch (ctx->state) {
753
+ case PARSER_ST_NONE: break;
754
+ XH_X2H_PARSER_STATE_LIST
755
+ case XML_DECL_FOUND: break;
756
+ case PARSER_ST_DONE: goto DONE;
757
+ }
758
+ #undef XH_X2H_PROCESS_STATE
759
+
760
+ PARSE_CONTENT:
761
+ content = NULL;
762
+ flags &= ~(XH_X2H_NEED_NORMALIZE | XH_X2H_IS_NOT_BLANK);
763
+ DO(CONTENT)
764
+ EXPECT_CHAR("new element", '<')
765
+ if (content != NULL) {
766
+ if (flags & XH_X2H_IS_NOT_BLANK) {
767
+ if (flags & XH_X2H_NEED_NORMALIZE) {
768
+ NORMALIZE_TEXT(TEXT1, content, end - content)
769
+ NEW_TEXT(enc, enc_len)
770
+ }
771
+ else {
772
+ NEW_TEXT(content, end - content)
773
+ }
774
+ }
775
+ content = NULL;
776
+ }
777
+ DO(PARSE_ELEMENT)
778
+ EXPECT_CHAR("xml declaration", '?')
779
+ if (real_depth != 0) goto INVALID_XML;
780
+ #undef NEW_ATTRIBUTE
781
+ #define NEW_ATTRIBUTE(k, kl, v, vl) NEW_XML_DECL_ATTRIBUTE(k, kl, v, vl)
782
+ #undef SEARCH_ATTRIBUTE_VALUE
783
+ #define SEARCH_ATTRIBUTE_VALUE(loop, top_loop, quot) SEARCH_XML_DECL_ATTRIBUTE_VALUE(loop, top_loop, quot)
784
+ PARSE_XML_DECLARATION
785
+ #undef NEW_ATTRIBUTE
786
+ #define NEW_ATTRIBUTE(k, kl, v, vl) NEW_NODE_ATTRIBUTE(k, kl, v, vl)
787
+ #undef SEARCH_ATTRIBUTE_VALUE
788
+ #define SEARCH_ATTRIBUTE_VALUE(loop, top_loop, quot) SEARCH_NODE_ATTRIBUTE_VALUE(loop, top_loop, quot)
789
+ EXPECT_CHAR("comment", '!')
790
+ DO(XML_COMMENT_NODE_OR_CDATA)
791
+ EXPECT_CHAR("comment", '-')
792
+ PARSE_COMMENT
793
+ EXPECT_CHAR("cdata", '[')
794
+ if (ctx->opts.trim) {
795
+ PARSE_CDATA_WITH_TRIM
796
+ ;
797
+ }
798
+ else {
799
+ PARSE_CDATA
800
+ ;
801
+ }
802
+ EXPECT_ANY("wrong character")
803
+ goto INVALID_XML;
804
+ END(XML_COMMENT_NODE_OR_CDATA)
805
+ goto INVALID_XML;
806
+ EXPECT_CHAR("closing tag", '/')
807
+ //node = cur;
808
+ DO(PARSE_CLOSING_TAG)
809
+ EXPECT_CHAR("end tag name", '>')
810
+ CLOSE_TAG
811
+ goto PARSE_CONTENT;
812
+ EXPECT_BLANK("end tag name")
813
+ DO(SEARCH_CLOSING_END_TAG)
814
+ EXPECT_CHAR("end tag", '>')
815
+ CLOSE_TAG
816
+ goto PARSE_CONTENT;
817
+ SKIP_BLANK
818
+ EXPECT_ANY("wrong character")
819
+ goto INVALID_XML;
820
+ END(SEARCH_CLOSING_END_TAG)
821
+ goto INVALID_XML;
822
+ END(PARSE_CLOSING_TAG)
823
+ goto INVALID_XML;
824
+ EXPECT_ANY("opening tag")
825
+ node = cur - 1;
826
+ DO(PARSE_OPENING_TAG)
827
+ EXPECT_CHAR("end tag", '>')
828
+ OPEN_TAG(node, cur - node - 1)
829
+ goto PARSE_CONTENT;
830
+ EXPECT_CHAR("self closing tag", '/')
831
+ OPEN_TAG(node, cur - node - 1)
832
+ CLOSE_TAG
833
+
834
+ DO(SEARCH_OPENING_END_TAG)
835
+ EXPECT_CHAR("end tag", '>')
836
+ goto PARSE_CONTENT;
837
+ EXPECT_ANY("wrong character")
838
+ goto INVALID_XML;
839
+ END(SEARCH_OPENING_END_TAG)
840
+ goto INVALID_XML;
841
+ EXPECT_BLANK("end tag name")
842
+ OPEN_TAG(node, cur - node - 1)
843
+
844
+ SEARCH_ATTRIBUTES(NODE, SEARCH_END_TAG)
845
+
846
+ goto PARSE_CONTENT;
847
+ END(PARSE_OPENING_TAG);
848
+ goto INVALID_XML;
849
+ END(PARSE_ELEMENT)
850
+
851
+ EXPECT_CHAR("wrong symbol", '>')
852
+ goto INVALID_XML;
853
+ EXPECT_BLANK_WO_CR("blank")
854
+ if (!ctx->opts.trim)
855
+ goto START_CONTENT;
856
+ break;
857
+ EXPECT_CHAR("CR", '\r')
858
+ if (content != NULL) {
859
+ flags |= XH_X2H_NORMALIZE_LINE_FEED;
860
+ }
861
+ if (!ctx->opts.trim)
862
+ goto START_CONTENT;
863
+ break;
864
+ EXPECT_CHAR("reference", '&')
865
+ flags |= XH_X2H_NORMALIZE_REF;
866
+ EXPECT_ANY("any char")
867
+ flags |= XH_X2H_IS_NOT_BLANK;
868
+ START_CONTENT:
869
+ if (content == NULL) content = cur - 1;
870
+ end = cur;
871
+ END(CONTENT)
872
+
873
+ if (content != NULL) {
874
+ if (flags & XH_X2H_IS_NOT_BLANK) {
875
+ if (flags & XH_X2H_NEED_NORMALIZE) {
876
+ NORMALIZE_TEXT(TEXT2, content, end - content)
877
+ NEW_TEXT(enc, enc_len)
878
+ }
879
+ else {
880
+ NEW_TEXT(content, end - content)
881
+ }
882
+ }
883
+ content = NULL;
884
+ }
885
+
886
+ if (real_depth != 0 || !(flags & XH_X2H_ROOT_FOUND)) goto INVALID_XML;
887
+
888
+ ctx->state = PARSER_ST_DONE;
889
+ *bytesleft = eof - cur;
890
+ *buf = cur;
891
+ return;
892
+
893
+ XML_DECL_FOUND:
894
+ ctx->state = XML_DECL_FOUND;
895
+ CHUNK_FINISH:
896
+ ctx->content = content;
897
+ ctx->node = node;
898
+ ctx->end = end;
899
+ ctx->depth = depth;
900
+ ctx->real_depth = real_depth;
901
+ ctx->flags = flags;
902
+ ctx->code = code;
903
+ ctx->lval = lval;
904
+ *bytesleft = eof - cur;
905
+ *buf = cur;
906
+ return;
907
+
908
+ MAX_DEPTH_EXCEEDED:
909
+ rb_raise(xh_parse_error_class, "Maximum depth exceeded");
910
+ INVALID_XML:
911
+ rb_raise(xh_parse_error_class, "Invalid XML");
912
+ INVALID_REF:
913
+ rb_raise(xh_parse_error_class, "Invalid reference");
914
+ MALLOC:
915
+ rb_raise(rb_eNoMemError, "Memory allocation error");
916
+ DONE:
917
+ rb_raise(xh_parse_error_class, "Parsing is done");
918
+ }
919
+
920
+ static void
921
+ xh_x2h_parse(xh_x2h_ctx_t *ctx, xh_reader_t *reader)
922
+ {
923
+ xh_char_t *buf, *preserve;
924
+ size_t len, off;
925
+ xh_bool_t eof;
926
+
927
+ do {
928
+ preserve = ctx->node != NULL ? ctx->node : ctx->content;
929
+
930
+ len = reader->read(reader, &buf, preserve, &off);
931
+ eof = (len == 0);
932
+ if (off) {
933
+ if (ctx->node != NULL) ctx->node -= off;
934
+ if (ctx->content != NULL) ctx->content -= off;
935
+ if (ctx->end != NULL) ctx->end -= off;
936
+ }
937
+
938
+ xh_log_trace2("read buf: %.*s", len, buf);
939
+
940
+ do {
941
+ xh_log_trace2("parse buf: %.*s", len, buf);
942
+
943
+ xh_x2h_parse_chunk(ctx, &buf, &len, eof);
944
+
945
+ if (ctx->state == XML_DECL_FOUND && ctx->opts.encoding[0] == '\0' && ctx->encoding[0] != '\0') {
946
+ reader->switch_encoding(reader, ctx->encoding, &buf, &len);
947
+ }
948
+ } while (len > 0);
949
+ } while (!eof);
950
+
951
+ if (ctx->state != PARSER_ST_DONE)
952
+ rb_raise(xh_parse_error_class, "Invalid XML");
953
+ }
954
+
955
+ static VALUE
956
+ xh_x2h_exec(VALUE arg)
957
+ {
958
+ xh_x2h_ctx_t *ctx = (xh_x2h_ctx_t *) arg;
959
+
960
+ if (ctx->opts.filter.enable) {
961
+ ctx->flags |= XH_X2H_FILTER_ENABLED;
962
+ if (!ctx->opts.block_given)
963
+ ctx->result = rb_ary_new();
964
+ }
965
+ else {
966
+ ctx->result = hash_new();
967
+ ctx->nodes[0].lval = ctx->lval = &ctx->result;
968
+ }
969
+
970
+ xh_reader_init(&ctx->reader, ctx->input, ctx->opts.encoding, ctx->opts.buf_size);
971
+
972
+ xh_x2h_parse(ctx, &ctx->reader);
973
+
974
+ return Qnil;
975
+ }
976
+
977
+ VALUE
978
+ xh_x2h(xh_x2h_ctx_t *ctx)
979
+ {
980
+ VALUE result;
981
+ int state;
982
+
983
+ result = rb_protect(xh_x2h_exec, (VALUE) ctx, &state);
984
+
985
+ if (state) {
986
+ xh_reader_destroy(&ctx->reader);
987
+ rb_exc_raise(rb_errinfo());
988
+ }
989
+
990
+ xh_reader_destroy(&ctx->reader);
991
+
992
+ result = ctx->result;
993
+ if (ctx->opts.filter.enable) {
994
+ if (ctx->opts.block_given)
995
+ result = Qnil;
996
+ }
997
+ else if (!ctx->opts.keep_root) {
998
+ result = hash_first_value(result);
999
+ }
1000
+
1001
+ return result;
1002
+ }