oga 0.2.2-java → 0.2.3-java

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: cac3dd20a675f61df95e40826873ab84368fdb16
4
- data.tar.gz: 65c3ed0c9d23c6bc30ba5fade5e00d1ed86cd93c
3
+ metadata.gz: cab88a36213701cd96d5fc500eb1fa2a6a114f51
4
+ data.tar.gz: ea32fd579cd4c48079c7f9d0ad1ae661f4fd199e
5
5
  SHA512:
6
- metadata.gz: 5eefa66c37fd2bee1560f39eda16b38bd7a59ebf5265afca68b711bc46336ca6fdb47fcaba8d5aa7cfb54e8683a1423d6e84bdff7eb1793b461b1f3e3a977c6a
7
- data.tar.gz: f8705a85b19a5be1a17e4a754e56af34a039250411bebd5345faeebde4def88233d0e6d416a0950160c7d3c8265f7eef51a47c1c6399d648dfa76125bbd55ba5
6
+ metadata.gz: 7195e3bc746ab0c58111d0843bf9e0843cd5ea5e2712b9fdaef5ea487787f29b620bae9faa593eb476819f5bdcdbc69def2501d36ed15f14dd93867c28a8b500
7
+ data.tar.gz: 2c936b7fc7e9e21e1b0ba0ac938abd91513dd019d4ce652ebb4d2a5b9b0e0585d9eddb24e7f65d17cc2231dc6646f512e71098335d82ccf41296e2d9a03f5096
@@ -3,6 +3,15 @@
3
3
  This document contains details of the various releases and their release dates.
4
4
  Dates are in the format `yyyy-mm-dd`.
5
5
 
6
+ ## 0.2.3 - 2015-03-04
7
+
8
+ This release adds support for lexing HTML `<style>` tags similar to how
9
+ `<script>` tags are handled. This ensures that the contents of these tags are
10
+ treated as-is without any HTML entity conversion being applied.
11
+
12
+ See commits 78e40b55c0e5941bee5791a5014260e9c2cf8aad and
13
+ 3b2055a30b128aa679a83332dfdfa68314271b24 for more information.
14
+
6
15
  ## 0.2.2 - 2015-03-03
7
16
 
8
17
  This release fixes a bug where setting the text of an element using
@@ -21,11 +21,11 @@ on `ts` and `te`) so the macro ignores this argument.
21
21
  #define advance_line(amount) \
22
22
  rb_funcall(self, id_advance_line, 1, INT2NUM(amount));
23
23
 
24
- #define inside_html_script_p() \
25
- rb_funcall(self, id_inside_html_script_p, 0) == Qtrue
24
+ #define literal_html_element_p() \
25
+ rb_funcall(self, id_literal_html_element_p, 0) == Qtrue
26
26
 
27
27
  ID id_advance_line;
28
- ID id_inside_html_script_p;
28
+ ID id_literal_html_element_p;
29
29
 
30
30
 
31
31
  #line 29 "ext/c/lexer.rl"
@@ -66,21 +66,21 @@ void liboga_xml_lexer_callback_simple(VALUE self, VALUE name)
66
66
 
67
67
 
68
68
  #line 69 "ext/c/lexer.c"
69
- static const int c_lexer_start = 34;
70
- static const int c_lexer_first_final = 34;
69
+ static const int c_lexer_start = 27;
70
+ static const int c_lexer_first_final = 27;
71
71
  static const int c_lexer_error = 0;
72
72
 
73
- static const int c_lexer_en_proc_ins_body = 40;
74
- static const int c_lexer_en_string_squote = 42;
75
- static const int c_lexer_en_string_dquote = 44;
76
- static const int c_lexer_en_doctype_inline = 46;
77
- static const int c_lexer_en_doctype = 48;
78
- static const int c_lexer_en_xml_decl = 60;
79
- static const int c_lexer_en_element_name = 63;
80
- static const int c_lexer_en_element_head = 65;
81
- static const int c_lexer_en_text = 67;
82
- static const int c_lexer_en_script_text = 71;
83
- static const int c_lexer_en_main = 34;
73
+ static const int c_lexer_en_proc_ins_body = 33;
74
+ static const int c_lexer_en_string_squote = 35;
75
+ static const int c_lexer_en_string_dquote = 37;
76
+ static const int c_lexer_en_doctype_inline = 39;
77
+ static const int c_lexer_en_doctype = 41;
78
+ static const int c_lexer_en_xml_decl = 53;
79
+ static const int c_lexer_en_element_name = 56;
80
+ static const int c_lexer_en_element_head = 58;
81
+ static const int c_lexer_en_text = 60;
82
+ static const int c_lexer_en_literal_html_element = 64;
83
+ static const int c_lexer_en_main = 27;
84
84
 
85
85
 
86
86
  #line 65 "ext/c/lexer.rl"
@@ -146,8 +146,8 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
146
146
 
147
147
  _again:
148
148
  switch ( ( state->cs) ) {
149
- case 34: goto st34;
150
- case 35: goto st35;
149
+ case 27: goto st27;
150
+ case 28: goto st28;
151
151
  case 1: goto st1;
152
152
  case 2: goto st2;
153
153
  case 3: goto st3;
@@ -160,7 +160,7 @@ _again:
160
160
  case 10: goto st10;
161
161
  case 11: goto st11;
162
162
  case 12: goto st12;
163
- case 36: goto st36;
163
+ case 29: goto st29;
164
164
  case 13: goto st13;
165
165
  case 14: goto st14;
166
166
  case 15: goto st15;
@@ -173,11 +173,19 @@ _again:
173
173
  case 22: goto st22;
174
174
  case 23: goto st23;
175
175
  case 24: goto st24;
176
+ case 30: goto st30;
177
+ case 31: goto st31;
178
+ case 32: goto st32;
179
+ case 33: goto st33;
180
+ case 34: goto st34;
181
+ case 35: goto st35;
182
+ case 36: goto st36;
176
183
  case 37: goto st37;
177
184
  case 38: goto st38;
178
185
  case 39: goto st39;
179
186
  case 40: goto st40;
180
187
  case 41: goto st41;
188
+ case 0: goto st0;
181
189
  case 42: goto st42;
182
190
  case 43: goto st43;
183
191
  case 44: goto st44;
@@ -185,7 +193,6 @@ _again:
185
193
  case 46: goto st46;
186
194
  case 47: goto st47;
187
195
  case 48: goto st48;
188
- case 0: goto st0;
189
196
  case 49: goto st49;
190
197
  case 50: goto st50;
191
198
  case 51: goto st51;
@@ -196,29 +203,26 @@ _again:
196
203
  case 56: goto st56;
197
204
  case 57: goto st57;
198
205
  case 58: goto st58;
206
+ case 25: goto st25;
199
207
  case 59: goto st59;
208
+ case 26: goto st26;
200
209
  case 60: goto st60;
201
210
  case 61: goto st61;
202
211
  case 62: goto st62;
203
212
  case 63: goto st63;
204
213
  case 64: goto st64;
205
214
  case 65: goto st65;
206
- case 25: goto st25;
207
215
  case 66: goto st66;
208
- case 26: goto st26;
209
216
  case 67: goto st67;
210
217
  case 68: goto st68;
211
218
  case 69: goto st69;
212
219
  case 70: goto st70;
213
220
  case 71: goto st71;
214
221
  case 72: goto st72;
215
- case 27: goto st27;
216
- case 28: goto st28;
217
- case 29: goto st29;
218
- case 30: goto st30;
219
- case 31: goto st31;
220
- case 32: goto st32;
221
- case 33: goto st33;
222
+ case 73: goto st73;
223
+ case 74: goto st74;
224
+ case 75: goto st75;
225
+ case 76: goto st76;
222
226
  default: break;
223
227
  }
224
228
 
@@ -228,11 +232,11 @@ _resume:
228
232
  switch ( ( state->cs) )
229
233
  {
230
234
  tr0:
231
- ( state->cs) = 34;
232
- #line 358 "ext/ragel/base_lexer.rl"
235
+ ( state->cs) = 27;
236
+ #line 356 "ext/ragel/base_lexer.rl"
233
237
  {{p = ((te))-1;}{
234
238
  p--;
235
- ( state->cs) = 67;
239
+ ( state->cs) = 60;
236
240
  }}
237
241
  goto _again;
238
242
  tr7:
@@ -240,60 +244,60 @@ tr7:
240
244
  {te = p+1;{
241
245
  callback(id_on_comment, data, encoding, ts + 4, te - 3);
242
246
  }}
243
- goto st34;
247
+ goto st27;
244
248
  tr23:
245
249
  #line 88 "ext/ragel/base_lexer.rl"
246
250
  {te = p+1;{
247
251
  callback(id_on_cdata, data, encoding, ts + 9, te - 3);
248
252
  }}
249
- goto st34;
253
+ goto st27;
250
254
  tr26:
251
255
  #line 289 "ext/ragel/base_lexer.rl"
252
256
  {te = p+1;{
253
257
  callback_simple(id_on_element_end);
254
258
  }}
255
- goto st34;
256
- tr40:
257
- ( state->cs) = 34;
258
- #line 358 "ext/ragel/base_lexer.rl"
259
+ goto st27;
260
+ tr32:
261
+ ( state->cs) = 27;
262
+ #line 356 "ext/ragel/base_lexer.rl"
259
263
  {te = p+1;{
260
264
  p--;
261
- ( state->cs) = 67;
265
+ ( state->cs) = 60;
262
266
  }}
263
267
  goto _again;
264
- tr42:
265
- ( state->cs) = 34;
266
- #line 358 "ext/ragel/base_lexer.rl"
268
+ tr34:
269
+ ( state->cs) = 27;
270
+ #line 356 "ext/ragel/base_lexer.rl"
267
271
  {te = p;p--;{
268
272
  p--;
269
- ( state->cs) = 67;
273
+ ( state->cs) = 60;
270
274
  }}
271
275
  goto _again;
272
- tr44:
273
- ( state->cs) = 34;
276
+ tr36:
277
+ ( state->cs) = 27;
274
278
  #line 283 "ext/ragel/base_lexer.rl"
275
279
  {te = p+1;{
276
280
  callback_simple(id_on_element_start);
277
281
  p--;
278
- ( state->cs) = 63;
282
+ ( state->cs) = 56;
279
283
  }}
280
284
  goto _again;
281
- tr46:
282
- ( state->cs) = 34;
285
+ tr38:
286
+ ( state->cs) = 27;
283
287
  #line 192 "ext/ragel/base_lexer.rl"
284
288
  {te = p;p--;{
285
289
  callback_simple(id_on_doctype_start);
286
- ( state->cs) = 48;
290
+ ( state->cs) = 41;
287
291
  }}
288
292
  goto _again;
289
- tr47:
290
- ( state->cs) = 34;
293
+ tr39:
294
+ ( state->cs) = 27;
291
295
  #line 1 "NONE"
292
296
  { switch( ( state->act) ) {
293
297
  case 36:
294
298
  {{p = ((te))-1;}
295
299
  callback_simple(id_on_xml_decl_start);
296
- ( state->cs) = 60;
300
+ ( state->cs) = 53;
297
301
  }
298
302
  break;
299
303
  case 39:
@@ -303,14 +307,14 @@ tr47:
303
307
 
304
308
  mark = te;
305
309
 
306
- ( state->cs) = 40;
310
+ ( state->cs) = 33;
307
311
  }
308
312
  break;
309
313
  }
310
314
  }
311
315
  goto _again;
312
- tr48:
313
- ( state->cs) = 34;
316
+ tr40:
317
+ ( state->cs) = 27;
314
318
  #line 106 "ext/ragel/base_lexer.rl"
315
319
  {te = p;p--;{
316
320
  callback_simple(id_on_proc_ins_start);
@@ -318,46 +322,46 @@ tr48:
318
322
 
319
323
  mark = te;
320
324
 
321
- ( state->cs) = 40;
325
+ ( state->cs) = 33;
322
326
  }}
323
327
  goto _again;
324
- st34:
328
+ st27:
325
329
  #line 1 "NONE"
326
330
  {ts = 0;}
327
331
  if ( ++p == pe )
328
- goto _test_eof34;
329
- case 34:
332
+ goto _test_eof27;
333
+ case 27:
330
334
  #line 1 "NONE"
331
335
  {ts = p;}
332
- #line 333 "ext/c/lexer.c"
336
+ #line 337 "ext/c/lexer.c"
333
337
  if ( (*p) == 60 )
334
- goto tr41;
335
- goto tr40;
336
- tr41:
338
+ goto tr33;
339
+ goto tr32;
340
+ tr33:
337
341
  #line 1 "NONE"
338
342
  {te = p+1;}
339
- goto st35;
340
- st35:
343
+ goto st28;
344
+ st28:
341
345
  if ( ++p == pe )
342
- goto _test_eof35;
343
- case 35:
344
- #line 345 "ext/c/lexer.c"
346
+ goto _test_eof28;
347
+ case 28:
348
+ #line 349 "ext/c/lexer.c"
345
349
  switch( (*p) ) {
346
350
  case 33: goto st1;
347
- case 45: goto tr44;
351
+ case 45: goto tr36;
348
352
  case 47: goto st22;
349
353
  case 63: goto st24;
350
- case 95: goto tr44;
354
+ case 95: goto tr36;
351
355
  }
352
356
  if ( (*p) < 65 ) {
353
357
  if ( 48 <= (*p) && (*p) <= 57 )
354
- goto tr44;
358
+ goto tr36;
355
359
  } else if ( (*p) > 90 ) {
356
360
  if ( 97 <= (*p) && (*p) <= 122 )
357
- goto tr44;
361
+ goto tr36;
358
362
  } else
359
- goto tr44;
360
- goto tr42;
363
+ goto tr36;
364
+ goto tr34;
361
365
  st1:
362
366
  if ( ++p == pe )
363
367
  goto _test_eof1;
@@ -458,19 +462,19 @@ st12:
458
462
  goto _test_eof12;
459
463
  case 12:
460
464
  switch( (*p) ) {
461
- case 9: goto st36;
462
- case 32: goto st36;
465
+ case 9: goto st29;
466
+ case 32: goto st29;
463
467
  }
464
468
  goto tr0;
465
- st36:
469
+ st29:
466
470
  if ( ++p == pe )
467
- goto _test_eof36;
468
- case 36:
471
+ goto _test_eof29;
472
+ case 29:
469
473
  switch( (*p) ) {
470
- case 9: goto st36;
471
- case 32: goto st36;
474
+ case 9: goto st29;
475
+ case 32: goto st29;
472
476
  }
473
- goto tr46;
477
+ goto tr38;
474
478
  st13:
475
479
  if ( ++p == pe )
476
480
  goto _test_eof13;
@@ -579,7 +583,7 @@ case 24:
579
583
  switch( (*p) ) {
580
584
  case 45: goto tr27;
581
585
  case 95: goto tr27;
582
- case 120: goto st38;
586
+ case 120: goto st31;
583
587
  }
584
588
  if ( (*p) < 65 ) {
585
589
  if ( 48 <= (*p) && (*p) <= 57 )
@@ -595,18 +599,18 @@ tr27:
595
599
  {te = p+1;}
596
600
  #line 106 "ext/ragel/base_lexer.rl"
597
601
  {( state->act) = 39;}
598
- goto st37;
599
- tr50:
602
+ goto st30;
603
+ tr42:
600
604
  #line 1 "NONE"
601
605
  {te = p+1;}
602
606
  #line 248 "ext/ragel/base_lexer.rl"
603
607
  {( state->act) = 36;}
604
- goto st37;
605
- st37:
608
+ goto st30;
609
+ st30:
606
610
  if ( ++p == pe )
607
- goto _test_eof37;
608
- case 37:
609
- #line 610 "ext/c/lexer.c"
611
+ goto _test_eof30;
612
+ case 30:
613
+ #line 614 "ext/c/lexer.c"
610
614
  switch( (*p) ) {
611
615
  case 45: goto tr27;
612
616
  case 95: goto tr27;
@@ -619,15 +623,15 @@ case 37:
619
623
  goto tr27;
620
624
  } else
621
625
  goto tr27;
622
- goto tr47;
623
- st38:
626
+ goto tr39;
627
+ st31:
624
628
  if ( ++p == pe )
625
- goto _test_eof38;
626
- case 38:
629
+ goto _test_eof31;
630
+ case 31:
627
631
  switch( (*p) ) {
628
632
  case 45: goto tr27;
629
633
  case 95: goto tr27;
630
- case 109: goto st39;
634
+ case 109: goto st32;
631
635
  }
632
636
  if ( (*p) < 65 ) {
633
637
  if ( 48 <= (*p) && (*p) <= 57 )
@@ -637,15 +641,15 @@ case 38:
637
641
  goto tr27;
638
642
  } else
639
643
  goto tr27;
640
- goto tr48;
641
- st39:
644
+ goto tr40;
645
+ st32:
642
646
  if ( ++p == pe )
643
- goto _test_eof39;
644
- case 39:
647
+ goto _test_eof32;
648
+ case 32:
645
649
  switch( (*p) ) {
646
650
  case 45: goto tr27;
647
651
  case 95: goto tr27;
648
- case 108: goto tr50;
652
+ case 108: goto tr42;
649
653
  }
650
654
  if ( (*p) < 65 ) {
651
655
  if ( 48 <= (*p) && (*p) <= 57 )
@@ -655,17 +659,17 @@ case 39:
655
659
  goto tr27;
656
660
  } else
657
661
  goto tr27;
658
- goto tr48;
659
- tr51:
662
+ goto tr40;
663
+ tr43:
660
664
  #line 125 "ext/ragel/base_lexer.rl"
661
665
  {te = p+1;}
662
- goto st40;
663
- tr53:
666
+ goto st33;
667
+ tr45:
664
668
  #line 125 "ext/ragel/base_lexer.rl"
665
669
  {te = p;p--;}
666
- goto st40;
667
- tr54:
668
- ( state->cs) = 40;
670
+ goto st33;
671
+ tr46:
672
+ ( state->cs) = 33;
669
673
  #line 116 "ext/ragel/base_lexer.rl"
670
674
  {te = p+1;{
671
675
  callback(id_on_text, data, encoding, mark, ts);
@@ -673,37 +677,37 @@ tr54:
673
677
 
674
678
  mark = 0;
675
679
 
676
- ( state->cs) = 34;
680
+ ( state->cs) = 27;
677
681
  }}
678
682
  goto _again;
679
- st40:
683
+ st33:
680
684
  #line 1 "NONE"
681
685
  {ts = 0;}
682
686
  if ( ++p == pe )
683
- goto _test_eof40;
684
- case 40:
687
+ goto _test_eof33;
688
+ case 33:
685
689
  #line 1 "NONE"
686
690
  {ts = p;}
687
- #line 688 "ext/c/lexer.c"
691
+ #line 692 "ext/c/lexer.c"
688
692
  if ( (*p) == 63 )
689
- goto st41;
690
- goto tr51;
691
- st41:
693
+ goto st34;
694
+ goto tr43;
695
+ st34:
692
696
  if ( ++p == pe )
693
- goto _test_eof41;
694
- case 41:
697
+ goto _test_eof34;
698
+ case 34:
695
699
  if ( (*p) == 62 )
696
- goto tr54;
697
- goto tr53;
698
- tr56:
700
+ goto tr46;
701
+ goto tr45;
702
+ tr48:
699
703
  #line 163 "ext/ragel/base_lexer.rl"
700
704
  {te = p+1;{
701
705
  callback_simple(id_on_string_squote);
702
706
 
703
707
  {( state->cs) = ( state->stack)[--( state->top)];goto _again;}
704
708
  }}
705
- goto st42;
706
- tr57:
709
+ goto st35;
710
+ tr49:
707
711
  #line 137 "ext/ragel/base_lexer.rl"
708
712
  {te = p;p--;{
709
713
  callback(id_on_string_body, data, encoding, ts, te);
@@ -715,42 +719,42 @@ tr57:
715
719
  lines = 0;
716
720
  }
717
721
  }}
718
- goto st42;
719
- st42:
722
+ goto st35;
723
+ st35:
720
724
  #line 1 "NONE"
721
725
  {ts = 0;}
722
726
  if ( ++p == pe )
723
- goto _test_eof42;
724
- case 42:
727
+ goto _test_eof35;
728
+ case 35:
725
729
  #line 1 "NONE"
726
730
  {ts = p;}
727
- #line 728 "ext/c/lexer.c"
731
+ #line 732 "ext/c/lexer.c"
728
732
  if ( (*p) == 39 )
729
- goto tr56;
730
- goto tr55;
731
- tr55:
733
+ goto tr48;
734
+ goto tr47;
735
+ tr47:
732
736
  #line 51 "ext/ragel/base_lexer.rl"
733
737
  {
734
738
  if ( (*p) == '\n' ) lines++;
735
739
  }
736
- goto st43;
737
- st43:
740
+ goto st36;
741
+ st36:
738
742
  if ( ++p == pe )
739
- goto _test_eof43;
740
- case 43:
741
- #line 742 "ext/c/lexer.c"
743
+ goto _test_eof36;
744
+ case 36:
745
+ #line 746 "ext/c/lexer.c"
742
746
  if ( (*p) == 39 )
743
- goto tr57;
744
- goto tr55;
745
- tr59:
747
+ goto tr49;
748
+ goto tr47;
749
+ tr51:
746
750
  #line 173 "ext/ragel/base_lexer.rl"
747
751
  {te = p+1;{
748
752
  callback_simple(id_on_string_dquote);
749
753
 
750
754
  {( state->cs) = ( state->stack)[--( state->top)];goto _again;}
751
755
  }}
752
- goto st44;
753
- tr60:
756
+ goto st37;
757
+ tr52:
754
758
  #line 137 "ext/ragel/base_lexer.rl"
755
759
  {te = p;p--;{
756
760
  callback(id_on_string_body, data, encoding, ts, te);
@@ -762,39 +766,39 @@ tr60:
762
766
  lines = 0;
763
767
  }
764
768
  }}
765
- goto st44;
766
- st44:
769
+ goto st37;
770
+ st37:
767
771
  #line 1 "NONE"
768
772
  {ts = 0;}
769
773
  if ( ++p == pe )
770
- goto _test_eof44;
771
- case 44:
774
+ goto _test_eof37;
775
+ case 37:
772
776
  #line 1 "NONE"
773
777
  {ts = p;}
774
- #line 775 "ext/c/lexer.c"
778
+ #line 779 "ext/c/lexer.c"
775
779
  if ( (*p) == 34 )
776
- goto tr59;
777
- goto tr58;
778
- tr58:
780
+ goto tr51;
781
+ goto tr50;
782
+ tr50:
779
783
  #line 51 "ext/ragel/base_lexer.rl"
780
784
  {
781
785
  if ( (*p) == '\n' ) lines++;
782
786
  }
783
- goto st45;
784
- st45:
787
+ goto st38;
788
+ st38:
785
789
  if ( ++p == pe )
786
- goto _test_eof45;
787
- case 45:
788
- #line 789 "ext/c/lexer.c"
790
+ goto _test_eof38;
791
+ case 38:
792
+ #line 793 "ext/c/lexer.c"
789
793
  if ( (*p) == 34 )
790
- goto tr60;
791
- goto tr58;
792
- tr62:
793
- ( state->cs) = 46;
794
+ goto tr52;
795
+ goto tr50;
796
+ tr54:
797
+ ( state->cs) = 39;
794
798
  #line 210 "ext/ragel/base_lexer.rl"
795
- {te = p+1;{ ( state->cs) = 48; }}
799
+ {te = p+1;{ ( state->cs) = 41; }}
796
800
  goto _again;
797
- tr63:
801
+ tr55:
798
802
  #line 199 "ext/ragel/base_lexer.rl"
799
803
  {te = p;p--;{
800
804
  callback(id_on_doctype_inline, data, encoding, ts, te);
@@ -806,67 +810,67 @@ tr63:
806
810
  lines = 0;
807
811
  }
808
812
  }}
809
- goto st46;
810
- st46:
813
+ goto st39;
814
+ st39:
811
815
  #line 1 "NONE"
812
816
  {ts = 0;}
813
817
  if ( ++p == pe )
814
- goto _test_eof46;
815
- case 46:
818
+ goto _test_eof39;
819
+ case 39:
816
820
  #line 1 "NONE"
817
821
  {ts = p;}
818
- #line 819 "ext/c/lexer.c"
822
+ #line 823 "ext/c/lexer.c"
819
823
  if ( (*p) == 93 )
820
- goto tr62;
821
- goto tr61;
822
- tr61:
824
+ goto tr54;
825
+ goto tr53;
826
+ tr53:
823
827
  #line 51 "ext/ragel/base_lexer.rl"
824
828
  {
825
829
  if ( (*p) == '\n' ) lines++;
826
830
  }
827
- goto st47;
828
- st47:
831
+ goto st40;
832
+ st40:
829
833
  if ( ++p == pe )
830
- goto _test_eof47;
831
- case 47:
832
- #line 833 "ext/c/lexer.c"
834
+ goto _test_eof40;
835
+ case 40:
836
+ #line 837 "ext/c/lexer.c"
833
837
  if ( (*p) == 93 )
834
- goto tr63;
835
- goto tr61;
836
- tr64:
838
+ goto tr55;
839
+ goto tr53;
840
+ tr56:
837
841
  #line 229 "ext/ragel/base_lexer.rl"
838
842
  {te = p+1;}
839
- goto st48;
840
- tr65:
843
+ goto st41;
844
+ tr57:
841
845
  #line 154 "ext/ragel/base_lexer.rl"
842
846
  {te = p+1;{
843
847
  callback_simple(id_on_string_dquote);
844
848
 
845
- {( state->stack)[( state->top)++] = 48; goto st44;}
849
+ {( state->stack)[( state->top)++] = 41; goto st37;}
846
850
  }}
847
- goto st48;
848
- tr66:
851
+ goto st41;
852
+ tr58:
849
853
  #line 148 "ext/ragel/base_lexer.rl"
850
854
  {te = p+1;{
851
855
  callback_simple(id_on_string_squote);
852
856
 
853
- {( state->stack)[( state->top)++] = 48; goto st42;}
857
+ {( state->stack)[( state->top)++] = 41; goto st35;}
854
858
  }}
855
- goto st48;
856
- tr68:
857
- ( state->cs) = 48;
859
+ goto st41;
860
+ tr60:
861
+ ( state->cs) = 41;
858
862
  #line 235 "ext/ragel/base_lexer.rl"
859
863
  {te = p+1;{
860
864
  callback_simple(id_on_doctype_end);
861
- ( state->cs) = 34;
865
+ ( state->cs) = 27;
862
866
  }}
863
867
  goto _again;
864
- tr71:
865
- ( state->cs) = 48;
868
+ tr63:
869
+ ( state->cs) = 41;
866
870
  #line 221 "ext/ragel/base_lexer.rl"
867
- {te = p+1;{ ( state->cs) = 46; }}
871
+ {te = p+1;{ ( state->cs) = 39; }}
868
872
  goto _again;
869
- tr72:
873
+ tr64:
870
874
  #line 1 "NONE"
871
875
  { switch( ( state->act) ) {
872
876
  case 9:
@@ -881,491 +885,489 @@ tr72:
881
885
  break;
882
886
  }
883
887
  }
884
- goto st48;
885
- tr73:
888
+ goto st41;
889
+ tr65:
886
890
  #line 231 "ext/ragel/base_lexer.rl"
887
891
  {te = p;p--;{
888
892
  callback(id_on_doctype_name, data, encoding, ts, te);
889
893
  }}
890
- goto st48;
891
- st48:
894
+ goto st41;
895
+ st41:
892
896
  #line 1 "NONE"
893
897
  {ts = 0;}
894
898
  if ( ++p == pe )
895
- goto _test_eof48;
896
- case 48:
899
+ goto _test_eof41;
900
+ case 41:
897
901
  #line 1 "NONE"
898
902
  {ts = p;}
899
- #line 900 "ext/c/lexer.c"
903
+ #line 904 "ext/c/lexer.c"
900
904
  switch( (*p) ) {
901
- case 9: goto tr64;
902
- case 32: goto tr64;
903
- case 34: goto tr65;
904
- case 39: goto tr66;
905
- case 45: goto tr67;
906
- case 62: goto tr68;
907
- case 80: goto st50;
908
- case 83: goto st55;
909
- case 91: goto tr71;
910
- case 95: goto tr67;
905
+ case 9: goto tr56;
906
+ case 32: goto tr56;
907
+ case 34: goto tr57;
908
+ case 39: goto tr58;
909
+ case 45: goto tr59;
910
+ case 62: goto tr60;
911
+ case 80: goto st43;
912
+ case 83: goto st48;
913
+ case 91: goto tr63;
914
+ case 95: goto tr59;
911
915
  }
912
916
  if ( (*p) < 65 ) {
913
917
  if ( 48 <= (*p) && (*p) <= 57 )
914
- goto tr67;
918
+ goto tr59;
915
919
  } else if ( (*p) > 90 ) {
916
920
  if ( 97 <= (*p) && (*p) <= 122 )
917
- goto tr67;
921
+ goto tr59;
918
922
  } else
919
- goto tr67;
923
+ goto tr59;
920
924
  goto st0;
921
925
  st0:
922
926
  ( state->cs) = 0;
923
927
  goto _out;
924
- tr67:
928
+ tr59:
925
929
  #line 1 "NONE"
926
930
  {te = p+1;}
927
931
  #line 231 "ext/ragel/base_lexer.rl"
928
932
  {( state->act) = 14;}
929
- goto st49;
930
- tr78:
933
+ goto st42;
934
+ tr70:
931
935
  #line 1 "NONE"
932
936
  {te = p+1;}
933
937
  #line 216 "ext/ragel/base_lexer.rl"
934
938
  {( state->act) = 9;}
935
- goto st49;
936
- st49:
939
+ goto st42;
940
+ st42:
937
941
  if ( ++p == pe )
938
- goto _test_eof49;
939
- case 49:
940
- #line 941 "ext/c/lexer.c"
942
+ goto _test_eof42;
943
+ case 42:
944
+ #line 945 "ext/c/lexer.c"
941
945
  switch( (*p) ) {
942
- case 45: goto tr67;
943
- case 95: goto tr67;
946
+ case 45: goto tr59;
947
+ case 95: goto tr59;
944
948
  }
945
949
  if ( (*p) < 65 ) {
946
950
  if ( 48 <= (*p) && (*p) <= 57 )
947
- goto tr67;
951
+ goto tr59;
948
952
  } else if ( (*p) > 90 ) {
949
953
  if ( 97 <= (*p) && (*p) <= 122 )
950
- goto tr67;
954
+ goto tr59;
951
955
  } else
952
- goto tr67;
953
- goto tr72;
954
- st50:
956
+ goto tr59;
957
+ goto tr64;
958
+ st43:
955
959
  if ( ++p == pe )
956
- goto _test_eof50;
957
- case 50:
960
+ goto _test_eof43;
961
+ case 43:
958
962
  switch( (*p) ) {
959
- case 45: goto tr67;
960
- case 85: goto st51;
961
- case 95: goto tr67;
963
+ case 45: goto tr59;
964
+ case 85: goto st44;
965
+ case 95: goto tr59;
962
966
  }
963
967
  if ( (*p) < 65 ) {
964
968
  if ( 48 <= (*p) && (*p) <= 57 )
965
- goto tr67;
969
+ goto tr59;
966
970
  } else if ( (*p) > 90 ) {
967
971
  if ( 97 <= (*p) && (*p) <= 122 )
968
- goto tr67;
972
+ goto tr59;
969
973
  } else
970
- goto tr67;
971
- goto tr73;
972
- st51:
974
+ goto tr59;
975
+ goto tr65;
976
+ st44:
973
977
  if ( ++p == pe )
974
- goto _test_eof51;
975
- case 51:
978
+ goto _test_eof44;
979
+ case 44:
976
980
  switch( (*p) ) {
977
- case 45: goto tr67;
978
- case 66: goto st52;
979
- case 95: goto tr67;
981
+ case 45: goto tr59;
982
+ case 66: goto st45;
983
+ case 95: goto tr59;
980
984
  }
981
985
  if ( (*p) < 65 ) {
982
986
  if ( 48 <= (*p) && (*p) <= 57 )
983
- goto tr67;
987
+ goto tr59;
984
988
  } else if ( (*p) > 90 ) {
985
989
  if ( 97 <= (*p) && (*p) <= 122 )
986
- goto tr67;
990
+ goto tr59;
987
991
  } else
988
- goto tr67;
989
- goto tr73;
990
- st52:
992
+ goto tr59;
993
+ goto tr65;
994
+ st45:
991
995
  if ( ++p == pe )
992
- goto _test_eof52;
993
- case 52:
996
+ goto _test_eof45;
997
+ case 45:
994
998
  switch( (*p) ) {
995
- case 45: goto tr67;
996
- case 76: goto st53;
997
- case 95: goto tr67;
999
+ case 45: goto tr59;
1000
+ case 76: goto st46;
1001
+ case 95: goto tr59;
998
1002
  }
999
1003
  if ( (*p) < 65 ) {
1000
1004
  if ( 48 <= (*p) && (*p) <= 57 )
1001
- goto tr67;
1005
+ goto tr59;
1002
1006
  } else if ( (*p) > 90 ) {
1003
1007
  if ( 97 <= (*p) && (*p) <= 122 )
1004
- goto tr67;
1008
+ goto tr59;
1005
1009
  } else
1006
- goto tr67;
1007
- goto tr73;
1008
- st53:
1010
+ goto tr59;
1011
+ goto tr65;
1012
+ st46:
1009
1013
  if ( ++p == pe )
1010
- goto _test_eof53;
1011
- case 53:
1014
+ goto _test_eof46;
1015
+ case 46:
1012
1016
  switch( (*p) ) {
1013
- case 45: goto tr67;
1014
- case 73: goto st54;
1015
- case 95: goto tr67;
1017
+ case 45: goto tr59;
1018
+ case 73: goto st47;
1019
+ case 95: goto tr59;
1016
1020
  }
1017
1021
  if ( (*p) < 65 ) {
1018
1022
  if ( 48 <= (*p) && (*p) <= 57 )
1019
- goto tr67;
1023
+ goto tr59;
1020
1024
  } else if ( (*p) > 90 ) {
1021
1025
  if ( 97 <= (*p) && (*p) <= 122 )
1022
- goto tr67;
1026
+ goto tr59;
1023
1027
  } else
1024
- goto tr67;
1025
- goto tr73;
1026
- st54:
1028
+ goto tr59;
1029
+ goto tr65;
1030
+ st47:
1027
1031
  if ( ++p == pe )
1028
- goto _test_eof54;
1029
- case 54:
1032
+ goto _test_eof47;
1033
+ case 47:
1030
1034
  switch( (*p) ) {
1031
- case 45: goto tr67;
1032
- case 67: goto tr78;
1033
- case 95: goto tr67;
1035
+ case 45: goto tr59;
1036
+ case 67: goto tr70;
1037
+ case 95: goto tr59;
1034
1038
  }
1035
1039
  if ( (*p) < 65 ) {
1036
1040
  if ( 48 <= (*p) && (*p) <= 57 )
1037
- goto tr67;
1041
+ goto tr59;
1038
1042
  } else if ( (*p) > 90 ) {
1039
1043
  if ( 97 <= (*p) && (*p) <= 122 )
1040
- goto tr67;
1044
+ goto tr59;
1041
1045
  } else
1042
- goto tr67;
1043
- goto tr73;
1044
- st55:
1046
+ goto tr59;
1047
+ goto tr65;
1048
+ st48:
1045
1049
  if ( ++p == pe )
1046
- goto _test_eof55;
1047
- case 55:
1050
+ goto _test_eof48;
1051
+ case 48:
1048
1052
  switch( (*p) ) {
1049
- case 45: goto tr67;
1050
- case 89: goto st56;
1051
- case 95: goto tr67;
1053
+ case 45: goto tr59;
1054
+ case 89: goto st49;
1055
+ case 95: goto tr59;
1052
1056
  }
1053
1057
  if ( (*p) < 65 ) {
1054
1058
  if ( 48 <= (*p) && (*p) <= 57 )
1055
- goto tr67;
1059
+ goto tr59;
1056
1060
  } else if ( (*p) > 90 ) {
1057
1061
  if ( 97 <= (*p) && (*p) <= 122 )
1058
- goto tr67;
1062
+ goto tr59;
1059
1063
  } else
1060
- goto tr67;
1061
- goto tr73;
1062
- st56:
1064
+ goto tr59;
1065
+ goto tr65;
1066
+ st49:
1063
1067
  if ( ++p == pe )
1064
- goto _test_eof56;
1065
- case 56:
1068
+ goto _test_eof49;
1069
+ case 49:
1066
1070
  switch( (*p) ) {
1067
- case 45: goto tr67;
1068
- case 83: goto st57;
1069
- case 95: goto tr67;
1071
+ case 45: goto tr59;
1072
+ case 83: goto st50;
1073
+ case 95: goto tr59;
1070
1074
  }
1071
1075
  if ( (*p) < 65 ) {
1072
1076
  if ( 48 <= (*p) && (*p) <= 57 )
1073
- goto tr67;
1077
+ goto tr59;
1074
1078
  } else if ( (*p) > 90 ) {
1075
1079
  if ( 97 <= (*p) && (*p) <= 122 )
1076
- goto tr67;
1080
+ goto tr59;
1077
1081
  } else
1078
- goto tr67;
1079
- goto tr73;
1080
- st57:
1082
+ goto tr59;
1083
+ goto tr65;
1084
+ st50:
1081
1085
  if ( ++p == pe )
1082
- goto _test_eof57;
1083
- case 57:
1086
+ goto _test_eof50;
1087
+ case 50:
1084
1088
  switch( (*p) ) {
1085
- case 45: goto tr67;
1086
- case 84: goto st58;
1087
- case 95: goto tr67;
1089
+ case 45: goto tr59;
1090
+ case 84: goto st51;
1091
+ case 95: goto tr59;
1088
1092
  }
1089
1093
  if ( (*p) < 65 ) {
1090
1094
  if ( 48 <= (*p) && (*p) <= 57 )
1091
- goto tr67;
1095
+ goto tr59;
1092
1096
  } else if ( (*p) > 90 ) {
1093
1097
  if ( 97 <= (*p) && (*p) <= 122 )
1094
- goto tr67;
1098
+ goto tr59;
1095
1099
  } else
1096
- goto tr67;
1097
- goto tr73;
1098
- st58:
1100
+ goto tr59;
1101
+ goto tr65;
1102
+ st51:
1099
1103
  if ( ++p == pe )
1100
- goto _test_eof58;
1101
- case 58:
1104
+ goto _test_eof51;
1105
+ case 51:
1102
1106
  switch( (*p) ) {
1103
- case 45: goto tr67;
1104
- case 69: goto st59;
1105
- case 95: goto tr67;
1107
+ case 45: goto tr59;
1108
+ case 69: goto st52;
1109
+ case 95: goto tr59;
1106
1110
  }
1107
1111
  if ( (*p) < 65 ) {
1108
1112
  if ( 48 <= (*p) && (*p) <= 57 )
1109
- goto tr67;
1113
+ goto tr59;
1110
1114
  } else if ( (*p) > 90 ) {
1111
1115
  if ( 97 <= (*p) && (*p) <= 122 )
1112
- goto tr67;
1116
+ goto tr59;
1113
1117
  } else
1114
- goto tr67;
1115
- goto tr73;
1116
- st59:
1118
+ goto tr59;
1119
+ goto tr65;
1120
+ st52:
1117
1121
  if ( ++p == pe )
1118
- goto _test_eof59;
1119
- case 59:
1122
+ goto _test_eof52;
1123
+ case 52:
1120
1124
  switch( (*p) ) {
1121
- case 45: goto tr67;
1122
- case 77: goto tr78;
1123
- case 95: goto tr67;
1125
+ case 45: goto tr59;
1126
+ case 77: goto tr70;
1127
+ case 95: goto tr59;
1124
1128
  }
1125
1129
  if ( (*p) < 65 ) {
1126
1130
  if ( 48 <= (*p) && (*p) <= 57 )
1127
- goto tr67;
1131
+ goto tr59;
1128
1132
  } else if ( (*p) > 90 ) {
1129
1133
  if ( 97 <= (*p) && (*p) <= 122 )
1130
- goto tr67;
1134
+ goto tr59;
1131
1135
  } else
1132
- goto tr67;
1133
- goto tr73;
1134
- tr83:
1136
+ goto tr59;
1137
+ goto tr65;
1138
+ tr75:
1135
1139
  #line 268 "ext/ragel/base_lexer.rl"
1136
1140
  {te = p+1;}
1137
- goto st60;
1138
- tr84:
1141
+ goto st53;
1142
+ tr76:
1139
1143
  #line 154 "ext/ragel/base_lexer.rl"
1140
1144
  {te = p+1;{
1141
1145
  callback_simple(id_on_string_dquote);
1142
1146
 
1143
- {( state->stack)[( state->top)++] = 60; goto st44;}
1147
+ {( state->stack)[( state->top)++] = 53; goto st37;}
1144
1148
  }}
1145
- goto st60;
1146
- tr85:
1149
+ goto st53;
1150
+ tr77:
1147
1151
  #line 148 "ext/ragel/base_lexer.rl"
1148
1152
  {te = p+1;{
1149
1153
  callback_simple(id_on_string_squote);
1150
1154
 
1151
- {( state->stack)[( state->top)++] = 60; goto st42;}
1155
+ {( state->stack)[( state->top)++] = 53; goto st35;}
1152
1156
  }}
1153
- goto st60;
1154
- tr88:
1157
+ goto st53;
1158
+ tr80:
1155
1159
  #line 261 "ext/ragel/base_lexer.rl"
1156
1160
  {te = p;p--;{
1157
1161
  callback(id_on_attribute, data, encoding, ts, te);
1158
1162
  }}
1159
- goto st60;
1160
- tr89:
1163
+ goto st53;
1164
+ tr81:
1161
1165
  #line 268 "ext/ragel/base_lexer.rl"
1162
1166
  {te = p;p--;}
1163
- goto st60;
1164
- tr90:
1165
- ( state->cs) = 60;
1167
+ goto st53;
1168
+ tr82:
1169
+ ( state->cs) = 53;
1166
1170
  #line 255 "ext/ragel/base_lexer.rl"
1167
1171
  {te = p+1;{
1168
1172
  callback_simple(id_on_xml_decl_end);
1169
- ( state->cs) = 34;
1173
+ ( state->cs) = 27;
1170
1174
  }}
1171
1175
  goto _again;
1172
- st60:
1176
+ st53:
1173
1177
  #line 1 "NONE"
1174
1178
  {ts = 0;}
1175
1179
  if ( ++p == pe )
1176
- goto _test_eof60;
1177
- case 60:
1180
+ goto _test_eof53;
1181
+ case 53:
1178
1182
  #line 1 "NONE"
1179
1183
  {ts = p;}
1180
- #line 1181 "ext/c/lexer.c"
1184
+ #line 1185 "ext/c/lexer.c"
1181
1185
  switch( (*p) ) {
1182
- case 34: goto tr84;
1183
- case 39: goto tr85;
1184
- case 45: goto st61;
1185
- case 63: goto st62;
1186
- case 95: goto st61;
1186
+ case 34: goto tr76;
1187
+ case 39: goto tr77;
1188
+ case 45: goto st54;
1189
+ case 63: goto st55;
1190
+ case 95: goto st54;
1187
1191
  }
1188
1192
  if ( (*p) < 65 ) {
1189
1193
  if ( 48 <= (*p) && (*p) <= 57 )
1190
- goto st61;
1194
+ goto st54;
1191
1195
  } else if ( (*p) > 90 ) {
1192
1196
  if ( 97 <= (*p) && (*p) <= 122 )
1193
- goto st61;
1197
+ goto st54;
1194
1198
  } else
1195
- goto st61;
1196
- goto tr83;
1197
- st61:
1199
+ goto st54;
1200
+ goto tr75;
1201
+ st54:
1198
1202
  if ( ++p == pe )
1199
- goto _test_eof61;
1200
- case 61:
1203
+ goto _test_eof54;
1204
+ case 54:
1201
1205
  switch( (*p) ) {
1202
- case 45: goto st61;
1203
- case 95: goto st61;
1206
+ case 45: goto st54;
1207
+ case 95: goto st54;
1204
1208
  }
1205
1209
  if ( (*p) < 65 ) {
1206
1210
  if ( 48 <= (*p) && (*p) <= 57 )
1207
- goto st61;
1211
+ goto st54;
1208
1212
  } else if ( (*p) > 90 ) {
1209
1213
  if ( 97 <= (*p) && (*p) <= 122 )
1210
- goto st61;
1214
+ goto st54;
1211
1215
  } else
1212
- goto st61;
1213
- goto tr88;
1214
- st62:
1216
+ goto st54;
1217
+ goto tr80;
1218
+ st55:
1215
1219
  if ( ++p == pe )
1216
- goto _test_eof62;
1217
- case 62:
1220
+ goto _test_eof55;
1221
+ case 55:
1218
1222
  if ( (*p) == 62 )
1219
- goto tr90;
1220
- goto tr89;
1221
- tr92:
1222
- ( state->cs) = 63;
1223
+ goto tr82;
1224
+ goto tr81;
1225
+ tr84:
1226
+ ( state->cs) = 56;
1223
1227
  #line 299 "ext/ragel/base_lexer.rl"
1224
1228
  {te = p;p--;{
1225
1229
  callback(id_on_element_name, data, encoding, ts, te);
1226
- ( state->cs) = 65;
1230
+ ( state->cs) = 58;
1227
1231
  }}
1228
1232
  goto _again;
1229
- tr93:
1233
+ tr85:
1230
1234
  #line 295 "ext/ragel/base_lexer.rl"
1231
1235
  {te = p+1;{
1232
1236
  callback(id_on_element_ns, data, encoding, ts, te - 1);
1233
1237
  }}
1234
- goto st63;
1235
- st63:
1238
+ goto st56;
1239
+ st56:
1236
1240
  #line 1 "NONE"
1237
1241
  {ts = 0;}
1238
1242
  if ( ++p == pe )
1239
- goto _test_eof63;
1240
- case 63:
1243
+ goto _test_eof56;
1244
+ case 56:
1241
1245
  #line 1 "NONE"
1242
1246
  {ts = p;}
1243
- #line 1244 "ext/c/lexer.c"
1247
+ #line 1248 "ext/c/lexer.c"
1244
1248
  switch( (*p) ) {
1245
- case 45: goto st64;
1246
- case 95: goto st64;
1249
+ case 45: goto st57;
1250
+ case 95: goto st57;
1247
1251
  }
1248
1252
  if ( (*p) < 65 ) {
1249
1253
  if ( 48 <= (*p) && (*p) <= 57 )
1250
- goto st64;
1254
+ goto st57;
1251
1255
  } else if ( (*p) > 90 ) {
1252
1256
  if ( 97 <= (*p) && (*p) <= 122 )
1253
- goto st64;
1257
+ goto st57;
1254
1258
  } else
1255
- goto st64;
1259
+ goto st57;
1256
1260
  goto st0;
1257
- st64:
1261
+ st57:
1258
1262
  if ( ++p == pe )
1259
- goto _test_eof64;
1260
- case 64:
1263
+ goto _test_eof57;
1264
+ case 57:
1261
1265
  switch( (*p) ) {
1262
- case 45: goto st64;
1263
- case 58: goto tr93;
1264
- case 95: goto st64;
1266
+ case 45: goto st57;
1267
+ case 58: goto tr85;
1268
+ case 95: goto st57;
1265
1269
  }
1266
1270
  if ( (*p) < 65 ) {
1267
1271
  if ( 48 <= (*p) && (*p) <= 57 )
1268
- goto st64;
1272
+ goto st57;
1269
1273
  } else if ( (*p) > 90 ) {
1270
1274
  if ( 97 <= (*p) && (*p) <= 122 )
1271
- goto st64;
1275
+ goto st57;
1272
1276
  } else
1273
- goto st64;
1274
- goto tr92;
1277
+ goto st57;
1278
+ goto tr84;
1275
1279
  tr29:
1276
1280
  #line 310 "ext/ragel/base_lexer.rl"
1277
1281
  {te = p+1;{
1278
1282
  callback_simple(id_advance_line);
1279
1283
  }}
1280
- goto st65;
1284
+ goto st58;
1281
1285
  tr31:
1282
- ( state->cs) = 65;
1283
- #line 344 "ext/ragel/base_lexer.rl"
1286
+ ( state->cs) = 58;
1287
+ #line 342 "ext/ragel/base_lexer.rl"
1284
1288
  {te = p+1;{
1285
1289
  callback_simple(id_on_element_end);
1286
- ( state->cs) = 34;
1290
+ ( state->cs) = 27;
1287
1291
  }}
1288
1292
  goto _again;
1289
- tr94:
1293
+ tr86:
1290
1294
  #line 308 "ext/ragel/base_lexer.rl"
1291
1295
  {te = p+1;}
1292
- goto st65;
1293
- tr96:
1296
+ goto st58;
1297
+ tr88:
1294
1298
  #line 154 "ext/ragel/base_lexer.rl"
1295
1299
  {te = p+1;{
1296
1300
  callback_simple(id_on_string_dquote);
1297
1301
 
1298
- {( state->stack)[( state->top)++] = 65; goto st44;}
1302
+ {( state->stack)[( state->top)++] = 58; goto st37;}
1299
1303
  }}
1300
- goto st65;
1301
- tr97:
1304
+ goto st58;
1305
+ tr89:
1302
1306
  #line 148 "ext/ragel/base_lexer.rl"
1303
1307
  {te = p+1;{
1304
1308
  callback_simple(id_on_string_squote);
1305
1309
 
1306
- {( state->stack)[( state->top)++] = 65; goto st42;}
1310
+ {( state->stack)[( state->top)++] = 58; goto st35;}
1307
1311
  }}
1308
- goto st65;
1309
- tr100:
1310
- ( state->cs) = 65;
1312
+ goto st58;
1313
+ tr92:
1314
+ ( state->cs) = 58;
1311
1315
  #line 328 "ext/ragel/base_lexer.rl"
1312
1316
  {te = p+1;{
1313
1317
  callback_simple(id_on_element_open_end);
1314
1318
 
1315
- if ( inside_html_script_p() )
1319
+ if ( literal_html_element_p() )
1316
1320
  {
1317
- mark = ts + 1;
1318
-
1319
- ( state->cs) = 71;
1321
+ ( state->cs) = 64;
1320
1322
  }
1321
1323
  else
1322
1324
  {
1323
- ( state->cs) = 34;
1325
+ ( state->cs) = 27;
1324
1326
  }
1325
1327
  }}
1326
1328
  goto _again;
1327
- tr101:
1329
+ tr93:
1328
1330
  #line 319 "ext/ragel/base_lexer.rl"
1329
1331
  {te = p;p--;{
1330
1332
  callback(id_on_attribute, data, encoding, ts, te);
1331
1333
  }}
1332
- goto st65;
1333
- tr102:
1334
+ goto st58;
1335
+ tr94:
1334
1336
  #line 315 "ext/ragel/base_lexer.rl"
1335
1337
  {te = p+1;{
1336
1338
  callback(id_on_attribute_ns, data, encoding, ts, te - 1);
1337
1339
  }}
1338
- goto st65;
1339
- st65:
1340
+ goto st58;
1341
+ st58:
1340
1342
  #line 1 "NONE"
1341
1343
  {ts = 0;}
1342
1344
  if ( ++p == pe )
1343
- goto _test_eof65;
1344
- case 65:
1345
+ goto _test_eof58;
1346
+ case 58:
1345
1347
  #line 1 "NONE"
1346
1348
  {ts = p;}
1347
- #line 1348 "ext/c/lexer.c"
1349
+ #line 1350 "ext/c/lexer.c"
1348
1350
  switch( (*p) ) {
1349
- case 9: goto tr94;
1351
+ case 9: goto tr86;
1350
1352
  case 10: goto tr29;
1351
1353
  case 13: goto st25;
1352
- case 32: goto tr94;
1353
- case 34: goto tr96;
1354
- case 39: goto tr97;
1355
- case 45: goto st66;
1354
+ case 32: goto tr86;
1355
+ case 34: goto tr88;
1356
+ case 39: goto tr89;
1357
+ case 45: goto st59;
1356
1358
  case 47: goto st26;
1357
- case 61: goto tr94;
1358
- case 62: goto tr100;
1359
- case 95: goto st66;
1359
+ case 61: goto tr86;
1360
+ case 62: goto tr92;
1361
+ case 95: goto st59;
1360
1362
  }
1361
1363
  if ( (*p) < 65 ) {
1362
1364
  if ( 48 <= (*p) && (*p) <= 57 )
1363
- goto st66;
1365
+ goto st59;
1364
1366
  } else if ( (*p) > 90 ) {
1365
1367
  if ( 97 <= (*p) && (*p) <= 122 )
1366
- goto st66;
1368
+ goto st59;
1367
1369
  } else
1368
- goto st66;
1370
+ goto st59;
1369
1371
  goto st0;
1370
1372
  st25:
1371
1373
  if ( ++p == pe )
@@ -1374,24 +1376,24 @@ case 25:
1374
1376
  if ( (*p) == 10 )
1375
1377
  goto tr29;
1376
1378
  goto st0;
1377
- st66:
1379
+ st59:
1378
1380
  if ( ++p == pe )
1379
- goto _test_eof66;
1380
- case 66:
1381
+ goto _test_eof59;
1382
+ case 59:
1381
1383
  switch( (*p) ) {
1382
- case 45: goto st66;
1383
- case 58: goto tr102;
1384
- case 95: goto st66;
1384
+ case 45: goto st59;
1385
+ case 58: goto tr94;
1386
+ case 95: goto st59;
1385
1387
  }
1386
1388
  if ( (*p) < 65 ) {
1387
1389
  if ( 48 <= (*p) && (*p) <= 57 )
1388
- goto st66;
1390
+ goto st59;
1389
1391
  } else if ( (*p) > 90 ) {
1390
1392
  if ( 97 <= (*p) && (*p) <= 122 )
1391
- goto st66;
1393
+ goto st59;
1392
1394
  } else
1393
- goto st66;
1394
- goto tr101;
1395
+ goto st59;
1396
+ goto tr93;
1395
1397
  st26:
1396
1398
  if ( ++p == pe )
1397
1399
  goto _test_eof26;
@@ -1399,9 +1401,9 @@ case 26:
1399
1401
  if ( (*p) == 62 )
1400
1402
  goto tr31;
1401
1403
  goto st0;
1402
- tr105:
1403
- ( state->cs) = 67;
1404
- #line 373 "ext/ragel/base_lexer.rl"
1404
+ tr97:
1405
+ ( state->cs) = 60;
1406
+ #line 371 "ext/ragel/base_lexer.rl"
1405
1407
  {te = p;p--;{
1406
1408
  callback(id_on_text, data, encoding, ts, te);
1407
1409
 
@@ -1412,12 +1414,12 @@ tr105:
1412
1414
  lines = 0;
1413
1415
  }
1414
1416
 
1415
- ( state->cs) = 34;
1417
+ ( state->cs) = 27;
1416
1418
  }}
1417
1419
  goto _again;
1418
- tr107:
1419
- ( state->cs) = 67;
1420
- #line 387 "ext/ragel/base_lexer.rl"
1420
+ tr99:
1421
+ ( state->cs) = 60;
1422
+ #line 385 "ext/ragel/base_lexer.rl"
1421
1423
  {te = p+1;{
1422
1424
  callback(id_on_text, data, encoding, ts, mark);
1423
1425
 
@@ -1431,12 +1433,12 @@ tr107:
1431
1433
  lines = 0;
1432
1434
  }
1433
1435
 
1434
- ( state->cs) = 34;
1436
+ ( state->cs) = 27;
1435
1437
  }}
1436
1438
  goto _again;
1437
- tr108:
1438
- ( state->cs) = 67;
1439
- #line 373 "ext/ragel/base_lexer.rl"
1439
+ tr100:
1440
+ ( state->cs) = 60;
1441
+ #line 371 "ext/ragel/base_lexer.rl"
1440
1442
  {te = p+1;{
1441
1443
  callback(id_on_text, data, encoding, ts, te);
1442
1444
 
@@ -1447,103 +1449,134 @@ tr108:
1447
1449
  lines = 0;
1448
1450
  }
1449
1451
 
1450
- ( state->cs) = 34;
1452
+ ( state->cs) = 27;
1451
1453
  }}
1452
1454
  goto _again;
1453
- st67:
1455
+ st60:
1454
1456
  #line 1 "NONE"
1455
1457
  {ts = 0;}
1456
1458
  if ( ++p == pe )
1457
- goto _test_eof67;
1458
- case 67:
1459
+ goto _test_eof60;
1460
+ case 60:
1459
1461
  #line 1 "NONE"
1460
1462
  {ts = p;}
1461
- #line 1462 "ext/c/lexer.c"
1463
+ #line 1464 "ext/c/lexer.c"
1462
1464
  if ( (*p) == 60 )
1463
- goto tr104;
1464
- goto tr103;
1465
- tr103:
1465
+ goto tr96;
1466
+ goto tr95;
1467
+ tr95:
1466
1468
  #line 51 "ext/ragel/base_lexer.rl"
1467
1469
  {
1468
1470
  if ( (*p) == '\n' ) lines++;
1469
1471
  }
1470
- goto st68;
1471
- st68:
1472
+ goto st61;
1473
+ st61:
1472
1474
  if ( ++p == pe )
1473
- goto _test_eof68;
1474
- case 68:
1475
- #line 1476 "ext/c/lexer.c"
1475
+ goto _test_eof61;
1476
+ case 61:
1477
+ #line 1478 "ext/c/lexer.c"
1476
1478
  if ( (*p) == 60 )
1477
- goto tr106;
1478
- goto tr103;
1479
- tr106:
1479
+ goto tr98;
1480
+ goto tr95;
1481
+ tr98:
1480
1482
  #line 51 "ext/ragel/base_lexer.rl"
1481
1483
  {
1482
1484
  if ( (*p) == '\n' ) lines++;
1483
1485
  }
1484
- #line 387 "ext/ragel/base_lexer.rl"
1486
+ #line 385 "ext/ragel/base_lexer.rl"
1485
1487
  { mark = p; }
1486
- goto st69;
1487
- st69:
1488
+ goto st62;
1489
+ st62:
1488
1490
  if ( ++p == pe )
1489
- goto _test_eof69;
1490
- case 69:
1491
- #line 1492 "ext/c/lexer.c"
1491
+ goto _test_eof62;
1492
+ case 62:
1493
+ #line 1494 "ext/c/lexer.c"
1492
1494
  switch( (*p) ) {
1493
- case 33: goto tr107;
1494
- case 45: goto tr107;
1495
- case 60: goto tr106;
1496
- case 63: goto tr107;
1497
- case 95: goto tr107;
1495
+ case 33: goto tr99;
1496
+ case 45: goto tr99;
1497
+ case 60: goto tr98;
1498
+ case 63: goto tr99;
1499
+ case 95: goto tr99;
1498
1500
  }
1499
1501
  if ( (*p) < 65 ) {
1500
1502
  if ( 47 <= (*p) && (*p) <= 57 )
1501
- goto tr107;
1503
+ goto tr99;
1502
1504
  } else if ( (*p) > 90 ) {
1503
1505
  if ( 97 <= (*p) && (*p) <= 122 )
1504
- goto tr107;
1506
+ goto tr99;
1505
1507
  } else
1506
- goto tr107;
1507
- goto tr103;
1508
- tr104:
1508
+ goto tr99;
1509
+ goto tr95;
1510
+ tr96:
1509
1511
  #line 51 "ext/ragel/base_lexer.rl"
1510
1512
  {
1511
1513
  if ( (*p) == '\n' ) lines++;
1512
1514
  }
1513
- #line 387 "ext/ragel/base_lexer.rl"
1515
+ #line 385 "ext/ragel/base_lexer.rl"
1514
1516
  { mark = p; }
1515
- goto st70;
1516
- st70:
1517
+ goto st63;
1518
+ st63:
1517
1519
  if ( ++p == pe )
1518
- goto _test_eof70;
1519
- case 70:
1520
- #line 1521 "ext/c/lexer.c"
1520
+ goto _test_eof63;
1521
+ case 63:
1522
+ #line 1523 "ext/c/lexer.c"
1521
1523
  switch( (*p) ) {
1522
- case 33: goto tr108;
1523
- case 45: goto tr108;
1524
- case 60: goto tr106;
1525
- case 63: goto tr108;
1526
- case 95: goto tr108;
1524
+ case 33: goto tr100;
1525
+ case 45: goto tr100;
1526
+ case 60: goto tr98;
1527
+ case 63: goto tr100;
1528
+ case 95: goto tr100;
1527
1529
  }
1528
1530
  if ( (*p) < 65 ) {
1529
1531
  if ( 47 <= (*p) && (*p) <= 57 )
1530
- goto tr108;
1532
+ goto tr100;
1531
1533
  } else if ( (*p) > 90 ) {
1532
1534
  if ( 97 <= (*p) && (*p) <= 122 )
1533
- goto tr108;
1535
+ goto tr100;
1534
1536
  } else
1535
- goto tr108;
1536
- goto tr103;
1537
- tr32:
1538
- #line 425 "ext/ragel/base_lexer.rl"
1539
- {{p = ((te))-1;}}
1540
- goto st71;
1541
- tr39:
1542
- ( state->cs) = 71;
1543
- #line 408 "ext/ragel/base_lexer.rl"
1537
+ goto tr100;
1538
+ goto tr95;
1539
+ tr103:
1540
+ #line 1 "NONE"
1541
+ { switch( ( state->act) ) {
1542
+ case 0:
1543
+ {{goto st0;}}
1544
+ break;
1545
+ case 33:
1546
+ {{p = ((te))-1;}
1547
+ callback(id_on_text, data, encoding, ts, te);
1548
+
1549
+ if ( lines > 0 )
1550
+ {
1551
+ advance_line(lines);
1552
+
1553
+ lines = 0;
1554
+ }
1555
+ }
1556
+ break;
1557
+ }
1558
+ }
1559
+ goto st64;
1560
+ tr104:
1561
+ #line 409 "ext/ragel/base_lexer.rl"
1562
+ {te = p;p--;{
1563
+ callback(id_on_text, data, encoding, ts, te);
1564
+
1565
+ if ( lines > 0 )
1566
+ {
1567
+ advance_line(lines);
1568
+
1569
+ lines = 0;
1570
+ }
1571
+ }}
1572
+ goto st64;
1573
+ tr113:
1574
+ ( state->cs) = 64;
1575
+ #line 420 "ext/ragel/base_lexer.rl"
1544
1576
  {te = p+1;{
1545
- callback(id_on_text, data, encoding, mark, ts);
1577
+ callback(id_on_text, data, encoding, ts, mark);
1546
1578
 
1579
+ p = mark - 1;
1547
1580
  mark = 0;
1548
1581
 
1549
1582
  if ( lines > 0 )
@@ -1553,38 +1586,141 @@ tr39:
1553
1586
  lines = 0;
1554
1587
  }
1555
1588
 
1556
- callback_simple(id_on_element_end);
1557
-
1558
- ( state->cs) = 34;
1589
+ ( state->cs) = 27;
1559
1590
  }}
1560
1591
  goto _again;
1592
+ st64:
1593
+ #line 1 "NONE"
1594
+ {ts = 0;}
1595
+ #line 1 "NONE"
1596
+ {( state->act) = 0;}
1597
+ if ( ++p == pe )
1598
+ goto _test_eof64;
1599
+ case 64:
1600
+ #line 1 "NONE"
1601
+ {ts = p;}
1602
+ #line 1603 "ext/c/lexer.c"
1603
+ if ( (*p) == 60 )
1604
+ goto tr102;
1605
+ goto tr101;
1606
+ tr101:
1607
+ #line 1 "NONE"
1608
+ {te = p+1;}
1609
+ #line 51 "ext/ragel/base_lexer.rl"
1610
+ {
1611
+ if ( (*p) == '\n' ) lines++;
1612
+ }
1613
+ #line 409 "ext/ragel/base_lexer.rl"
1614
+ {( state->act) = 33;}
1615
+ goto st65;
1616
+ st65:
1617
+ if ( ++p == pe )
1618
+ goto _test_eof65;
1619
+ case 65:
1620
+ #line 1621 "ext/c/lexer.c"
1621
+ if ( (*p) == 60 )
1622
+ goto tr102;
1623
+ goto tr101;
1624
+ tr102:
1625
+ #line 51 "ext/ragel/base_lexer.rl"
1626
+ {
1627
+ if ( (*p) == '\n' ) lines++;
1628
+ }
1629
+ #line 420 "ext/ragel/base_lexer.rl"
1630
+ { mark = p; }
1631
+ goto st66;
1632
+ st66:
1633
+ if ( ++p == pe )
1634
+ goto _test_eof66;
1635
+ case 66:
1636
+ #line 1637 "ext/c/lexer.c"
1637
+ switch( (*p) ) {
1638
+ case 47: goto tr105;
1639
+ case 60: goto tr102;
1640
+ }
1641
+ goto tr101;
1642
+ tr105:
1643
+ #line 51 "ext/ragel/base_lexer.rl"
1644
+ {
1645
+ if ( (*p) == '\n' ) lines++;
1646
+ }
1647
+ goto st67;
1648
+ st67:
1649
+ if ( ++p == pe )
1650
+ goto _test_eof67;
1651
+ case 67:
1652
+ #line 1653 "ext/c/lexer.c"
1653
+ switch( (*p) ) {
1654
+ case 60: goto tr102;
1655
+ case 115: goto tr106;
1656
+ }
1657
+ goto tr101;
1658
+ tr106:
1659
+ #line 51 "ext/ragel/base_lexer.rl"
1660
+ {
1661
+ if ( (*p) == '\n' ) lines++;
1662
+ }
1663
+ goto st68;
1664
+ st68:
1665
+ if ( ++p == pe )
1666
+ goto _test_eof68;
1667
+ case 68:
1668
+ #line 1669 "ext/c/lexer.c"
1669
+ switch( (*p) ) {
1670
+ case 60: goto tr102;
1671
+ case 99: goto tr107;
1672
+ case 116: goto tr108;
1673
+ }
1674
+ goto tr101;
1675
+ tr107:
1676
+ #line 51 "ext/ragel/base_lexer.rl"
1677
+ {
1678
+ if ( (*p) == '\n' ) lines++;
1679
+ }
1680
+ goto st69;
1681
+ st69:
1682
+ if ( ++p == pe )
1683
+ goto _test_eof69;
1684
+ case 69:
1685
+ #line 1686 "ext/c/lexer.c"
1686
+ switch( (*p) ) {
1687
+ case 60: goto tr102;
1688
+ case 114: goto tr109;
1689
+ }
1690
+ goto tr101;
1561
1691
  tr109:
1562
1692
  #line 51 "ext/ragel/base_lexer.rl"
1563
1693
  {
1564
1694
  if ( (*p) == '\n' ) lines++;
1565
1695
  }
1566
- #line 425 "ext/ragel/base_lexer.rl"
1567
- {te = p+1;}
1568
- goto st71;
1569
- tr111:
1570
- #line 425 "ext/ragel/base_lexer.rl"
1571
- {te = p;p--;}
1696
+ goto st70;
1697
+ st70:
1698
+ if ( ++p == pe )
1699
+ goto _test_eof70;
1700
+ case 70:
1701
+ #line 1702 "ext/c/lexer.c"
1702
+ switch( (*p) ) {
1703
+ case 60: goto tr102;
1704
+ case 105: goto tr110;
1705
+ }
1706
+ goto tr101;
1707
+ tr110:
1708
+ #line 51 "ext/ragel/base_lexer.rl"
1709
+ {
1710
+ if ( (*p) == '\n' ) lines++;
1711
+ }
1572
1712
  goto st71;
1573
1713
  st71:
1574
- #line 1 "NONE"
1575
- {ts = 0;}
1576
1714
  if ( ++p == pe )
1577
1715
  goto _test_eof71;
1578
1716
  case 71:
1579
- #line 1 "NONE"
1580
- {ts = p;}
1581
- #line 1582 "ext/c/lexer.c"
1582
- if ( (*p) == 60 )
1583
- goto tr110;
1584
- goto tr109;
1585
- tr110:
1586
- #line 1 "NONE"
1587
- {te = p+1;}
1717
+ #line 1718 "ext/c/lexer.c"
1718
+ switch( (*p) ) {
1719
+ case 60: goto tr102;
1720
+ case 112: goto tr111;
1721
+ }
1722
+ goto tr101;
1723
+ tr111:
1588
1724
  #line 51 "ext/ragel/base_lexer.rl"
1589
1725
  {
1590
1726
  if ( (*p) == '\n' ) lines++;
@@ -1594,62 +1730,79 @@ st72:
1594
1730
  if ( ++p == pe )
1595
1731
  goto _test_eof72;
1596
1732
  case 72:
1597
- #line 1598 "ext/c/lexer.c"
1598
- if ( (*p) == 47 )
1599
- goto st27;
1600
- goto tr111;
1601
- st27:
1602
- if ( ++p == pe )
1603
- goto _test_eof27;
1604
- case 27:
1605
- if ( (*p) == 115 )
1606
- goto st28;
1607
- goto tr32;
1608
- st28:
1609
- if ( ++p == pe )
1610
- goto _test_eof28;
1611
- case 28:
1612
- if ( (*p) == 99 )
1613
- goto st29;
1614
- goto tr32;
1615
- st29:
1616
- if ( ++p == pe )
1617
- goto _test_eof29;
1618
- case 29:
1619
- if ( (*p) == 114 )
1620
- goto st30;
1621
- goto tr32;
1622
- st30:
1733
+ #line 1734 "ext/c/lexer.c"
1734
+ switch( (*p) ) {
1735
+ case 60: goto tr102;
1736
+ case 116: goto tr112;
1737
+ }
1738
+ goto tr101;
1739
+ tr112:
1740
+ #line 51 "ext/ragel/base_lexer.rl"
1741
+ {
1742
+ if ( (*p) == '\n' ) lines++;
1743
+ }
1744
+ goto st73;
1745
+ st73:
1623
1746
  if ( ++p == pe )
1624
- goto _test_eof30;
1625
- case 30:
1626
- if ( (*p) == 105 )
1627
- goto st31;
1628
- goto tr32;
1629
- st31:
1747
+ goto _test_eof73;
1748
+ case 73:
1749
+ #line 1750 "ext/c/lexer.c"
1750
+ switch( (*p) ) {
1751
+ case 60: goto tr102;
1752
+ case 62: goto tr113;
1753
+ }
1754
+ goto tr101;
1755
+ tr108:
1756
+ #line 51 "ext/ragel/base_lexer.rl"
1757
+ {
1758
+ if ( (*p) == '\n' ) lines++;
1759
+ }
1760
+ goto st74;
1761
+ st74:
1630
1762
  if ( ++p == pe )
1631
- goto _test_eof31;
1632
- case 31:
1633
- if ( (*p) == 112 )
1634
- goto st32;
1635
- goto tr32;
1636
- st32:
1763
+ goto _test_eof74;
1764
+ case 74:
1765
+ #line 1766 "ext/c/lexer.c"
1766
+ switch( (*p) ) {
1767
+ case 60: goto tr102;
1768
+ case 121: goto tr114;
1769
+ }
1770
+ goto tr101;
1771
+ tr114:
1772
+ #line 51 "ext/ragel/base_lexer.rl"
1773
+ {
1774
+ if ( (*p) == '\n' ) lines++;
1775
+ }
1776
+ goto st75;
1777
+ st75:
1637
1778
  if ( ++p == pe )
1638
- goto _test_eof32;
1639
- case 32:
1640
- if ( (*p) == 116 )
1641
- goto st33;
1642
- goto tr32;
1643
- st33:
1779
+ goto _test_eof75;
1780
+ case 75:
1781
+ #line 1782 "ext/c/lexer.c"
1782
+ switch( (*p) ) {
1783
+ case 60: goto tr102;
1784
+ case 108: goto tr115;
1785
+ }
1786
+ goto tr101;
1787
+ tr115:
1788
+ #line 51 "ext/ragel/base_lexer.rl"
1789
+ {
1790
+ if ( (*p) == '\n' ) lines++;
1791
+ }
1792
+ goto st76;
1793
+ st76:
1644
1794
  if ( ++p == pe )
1645
- goto _test_eof33;
1646
- case 33:
1647
- if ( (*p) == 62 )
1648
- goto tr39;
1649
- goto tr32;
1795
+ goto _test_eof76;
1796
+ case 76:
1797
+ #line 1798 "ext/c/lexer.c"
1798
+ switch( (*p) ) {
1799
+ case 60: goto tr102;
1800
+ case 101: goto tr112;
1650
1801
  }
1651
- _test_eof34: ( state->cs) = 34; goto _test_eof;
1652
- _test_eof35: ( state->cs) = 35; goto _test_eof;
1802
+ goto tr101;
1803
+ }
1804
+ _test_eof27: ( state->cs) = 27; goto _test_eof;
1805
+ _test_eof28: ( state->cs) = 28; goto _test_eof;
1653
1806
  _test_eof1: ( state->cs) = 1; goto _test_eof;
1654
1807
  _test_eof2: ( state->cs) = 2; goto _test_eof;
1655
1808
  _test_eof3: ( state->cs) = 3; goto _test_eof;
@@ -1662,7 +1815,7 @@ case 33:
1662
1815
  _test_eof10: ( state->cs) = 10; goto _test_eof;
1663
1816
  _test_eof11: ( state->cs) = 11; goto _test_eof;
1664
1817
  _test_eof12: ( state->cs) = 12; goto _test_eof;
1665
- _test_eof36: ( state->cs) = 36; goto _test_eof;
1818
+ _test_eof29: ( state->cs) = 29; goto _test_eof;
1666
1819
  _test_eof13: ( state->cs) = 13; goto _test_eof;
1667
1820
  _test_eof14: ( state->cs) = 14; goto _test_eof;
1668
1821
  _test_eof15: ( state->cs) = 15; goto _test_eof;
@@ -1675,6 +1828,13 @@ case 33:
1675
1828
  _test_eof22: ( state->cs) = 22; goto _test_eof;
1676
1829
  _test_eof23: ( state->cs) = 23; goto _test_eof;
1677
1830
  _test_eof24: ( state->cs) = 24; goto _test_eof;
1831
+ _test_eof30: ( state->cs) = 30; goto _test_eof;
1832
+ _test_eof31: ( state->cs) = 31; goto _test_eof;
1833
+ _test_eof32: ( state->cs) = 32; goto _test_eof;
1834
+ _test_eof33: ( state->cs) = 33; goto _test_eof;
1835
+ _test_eof34: ( state->cs) = 34; goto _test_eof;
1836
+ _test_eof35: ( state->cs) = 35; goto _test_eof;
1837
+ _test_eof36: ( state->cs) = 36; goto _test_eof;
1678
1838
  _test_eof37: ( state->cs) = 37; goto _test_eof;
1679
1839
  _test_eof38: ( state->cs) = 38; goto _test_eof;
1680
1840
  _test_eof39: ( state->cs) = 39; goto _test_eof;
@@ -1697,35 +1857,32 @@ case 33:
1697
1857
  _test_eof56: ( state->cs) = 56; goto _test_eof;
1698
1858
  _test_eof57: ( state->cs) = 57; goto _test_eof;
1699
1859
  _test_eof58: ( state->cs) = 58; goto _test_eof;
1860
+ _test_eof25: ( state->cs) = 25; goto _test_eof;
1700
1861
  _test_eof59: ( state->cs) = 59; goto _test_eof;
1862
+ _test_eof26: ( state->cs) = 26; goto _test_eof;
1701
1863
  _test_eof60: ( state->cs) = 60; goto _test_eof;
1702
1864
  _test_eof61: ( state->cs) = 61; goto _test_eof;
1703
1865
  _test_eof62: ( state->cs) = 62; goto _test_eof;
1704
1866
  _test_eof63: ( state->cs) = 63; goto _test_eof;
1705
1867
  _test_eof64: ( state->cs) = 64; goto _test_eof;
1706
1868
  _test_eof65: ( state->cs) = 65; goto _test_eof;
1707
- _test_eof25: ( state->cs) = 25; goto _test_eof;
1708
1869
  _test_eof66: ( state->cs) = 66; goto _test_eof;
1709
- _test_eof26: ( state->cs) = 26; goto _test_eof;
1710
1870
  _test_eof67: ( state->cs) = 67; goto _test_eof;
1711
1871
  _test_eof68: ( state->cs) = 68; goto _test_eof;
1712
1872
  _test_eof69: ( state->cs) = 69; goto _test_eof;
1713
1873
  _test_eof70: ( state->cs) = 70; goto _test_eof;
1714
1874
  _test_eof71: ( state->cs) = 71; goto _test_eof;
1715
1875
  _test_eof72: ( state->cs) = 72; goto _test_eof;
1716
- _test_eof27: ( state->cs) = 27; goto _test_eof;
1717
- _test_eof28: ( state->cs) = 28; goto _test_eof;
1718
- _test_eof29: ( state->cs) = 29; goto _test_eof;
1719
- _test_eof30: ( state->cs) = 30; goto _test_eof;
1720
- _test_eof31: ( state->cs) = 31; goto _test_eof;
1721
- _test_eof32: ( state->cs) = 32; goto _test_eof;
1722
- _test_eof33: ( state->cs) = 33; goto _test_eof;
1876
+ _test_eof73: ( state->cs) = 73; goto _test_eof;
1877
+ _test_eof74: ( state->cs) = 74; goto _test_eof;
1878
+ _test_eof75: ( state->cs) = 75; goto _test_eof;
1879
+ _test_eof76: ( state->cs) = 76; goto _test_eof;
1723
1880
 
1724
1881
  _test_eof: {}
1725
1882
  if ( p == eof )
1726
1883
  {
1727
1884
  switch ( ( state->cs) ) {
1728
- case 35: goto tr42;
1885
+ case 28: goto tr34;
1729
1886
  case 1: goto tr0;
1730
1887
  case 2: goto tr0;
1731
1888
  case 3: goto tr0;
@@ -1738,7 +1895,7 @@ case 33:
1738
1895
  case 10: goto tr0;
1739
1896
  case 11: goto tr0;
1740
1897
  case 12: goto tr0;
1741
- case 36: goto tr46;
1898
+ case 29: goto tr38;
1742
1899
  case 13: goto tr0;
1743
1900
  case 14: goto tr0;
1744
1901
  case 15: goto tr0;
@@ -1751,39 +1908,43 @@ case 33:
1751
1908
  case 22: goto tr0;
1752
1909
  case 23: goto tr0;
1753
1910
  case 24: goto tr0;
1754
- case 37: goto tr47;
1755
- case 38: goto tr48;
1756
- case 39: goto tr48;
1757
- case 41: goto tr53;
1758
- case 43: goto tr57;
1759
- case 45: goto tr60;
1760
- case 47: goto tr63;
1761
- case 49: goto tr72;
1762
- case 50: goto tr73;
1763
- case 51: goto tr73;
1764
- case 52: goto tr73;
1765
- case 53: goto tr73;
1766
- case 54: goto tr73;
1767
- case 55: goto tr73;
1768
- case 56: goto tr73;
1769
- case 57: goto tr73;
1770
- case 58: goto tr73;
1771
- case 59: goto tr73;
1772
- case 61: goto tr88;
1773
- case 62: goto tr89;
1774
- case 64: goto tr92;
1775
- case 66: goto tr101;
1776
- case 68: goto tr105;
1777
- case 69: goto tr105;
1778
- case 70: goto tr105;
1779
- case 72: goto tr111;
1780
- case 27: goto tr32;
1781
- case 28: goto tr32;
1782
- case 29: goto tr32;
1783
- case 30: goto tr32;
1784
- case 31: goto tr32;
1785
- case 32: goto tr32;
1786
- case 33: goto tr32;
1911
+ case 30: goto tr39;
1912
+ case 31: goto tr40;
1913
+ case 32: goto tr40;
1914
+ case 34: goto tr45;
1915
+ case 36: goto tr49;
1916
+ case 38: goto tr52;
1917
+ case 40: goto tr55;
1918
+ case 42: goto tr64;
1919
+ case 43: goto tr65;
1920
+ case 44: goto tr65;
1921
+ case 45: goto tr65;
1922
+ case 46: goto tr65;
1923
+ case 47: goto tr65;
1924
+ case 48: goto tr65;
1925
+ case 49: goto tr65;
1926
+ case 50: goto tr65;
1927
+ case 51: goto tr65;
1928
+ case 52: goto tr65;
1929
+ case 54: goto tr80;
1930
+ case 55: goto tr81;
1931
+ case 57: goto tr84;
1932
+ case 59: goto tr93;
1933
+ case 61: goto tr97;
1934
+ case 62: goto tr97;
1935
+ case 63: goto tr97;
1936
+ case 65: goto tr103;
1937
+ case 66: goto tr104;
1938
+ case 67: goto tr104;
1939
+ case 68: goto tr104;
1940
+ case 69: goto tr104;
1941
+ case 70: goto tr104;
1942
+ case 71: goto tr104;
1943
+ case 72: goto tr104;
1944
+ case 73: goto tr104;
1945
+ case 74: goto tr104;
1946
+ case 75: goto tr104;
1947
+ case 76: goto tr104;
1787
1948
  }
1788
1949
  }
1789
1950
 
@@ -1843,8 +2004,8 @@ void Init_liboga_xml_lexer()
1843
2004
  VALUE mXML = rb_const_get(mOga, rb_intern("XML"));
1844
2005
  VALUE cLexer = rb_define_class_under(mXML, "Lexer", rb_cObject);
1845
2006
 
1846
- id_advance_line = rb_intern("advance_line");
1847
- id_inside_html_script_p = rb_intern("inside_html_script?");
2007
+ id_advance_line = rb_intern("advance_line");
2008
+ id_literal_html_element_p = rb_intern("literal_html_element?");
1848
2009
 
1849
2010
  rb_define_method(cLexer, "advance_native", oga_xml_lexer_advance, 1);
1850
2011
  rb_define_method(cLexer, "reset_native", oga_xml_lexer_reset, 0);