oga 0.3.1 → 0.3.2

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: 4445e4b345d7892e11706b1901c3a19b3ad8e4b1
4
- data.tar.gz: 886eb1880fecd4e068498ff5328d2cf0bc24f50c
3
+ metadata.gz: 0377d24ecf7ad22488c342e769083cd45be29033
4
+ data.tar.gz: 108998ff40fdbba079743849264773998d2a2543
5
5
  SHA512:
6
- metadata.gz: 0ae267cf2e6572b51691bca870f7b825f6cdde8cee6804cb056dff81a0cfc01618d274aff0d402b7e9e59c61ec1211d0df1e6cceaea8f077bdeb86d8b4b46c54
7
- data.tar.gz: d99c0848e4906c3059c314da523c963aca4b77a257380da98e86dc87c11485fa3620247e2d1df005c92077503dc36acd0097e855bff0ec08cf65b885447a3bf4
6
+ metadata.gz: 109d74d22335a88fc180279ea7c81c65a2f3b6e33f319722c71baa806d92bf215fac9d9d22b5e3e14f92cb4b9fa62d8b279156af20bef747ca5fb0d77f4a9f9b
7
+ data.tar.gz: 088710d99712c155c789afae19c6dccf20a1482395280a566d9e884a9c47fdaf2dbe49ee201b890c6c98f9788f7c0f7d5b92f557b5bfd640920830f1161e0b7b
@@ -26,9 +26,10 @@ on `ts` and `te`) so the macro ignores this argument.
26
26
 
27
27
  ID id_advance_line;
28
28
  ID id_literal_html_element_p;
29
+ ID id_html;
29
30
 
30
31
 
31
- #line 29 "ext/c/lexer.rl"
32
+ #line 30 "ext/c/lexer.rl"
32
33
 
33
34
  /**
34
35
  * Calls a method defined in the Ruby side of the lexer. The String value is
@@ -65,25 +66,29 @@ void liboga_xml_lexer_callback_simple(VALUE self, VALUE name)
65
66
  }
66
67
 
67
68
 
68
- #line 69 "ext/c/lexer.c"
69
- static const int c_lexer_start = 26;
70
- static const int c_lexer_first_final = 26;
69
+ #line 70 "ext/c/lexer.c"
70
+ static const int c_lexer_start = 22;
71
+ static const int c_lexer_first_final = 22;
71
72
  static const int c_lexer_error = 0;
72
73
 
73
- static const int c_lexer_en_proc_ins_body = 32;
74
- static const int c_lexer_en_string_squote = 34;
75
- static const int c_lexer_en_string_dquote = 36;
76
- static const int c_lexer_en_doctype_inline = 38;
77
- static const int c_lexer_en_doctype = 40;
78
- static const int c_lexer_en_xml_decl = 52;
79
- static const int c_lexer_en_element_name = 55;
80
- static const int c_lexer_en_element_head = 57;
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 = 26;
84
-
85
-
86
- #line 65 "ext/c/lexer.rl"
74
+ static const int c_lexer_en_comment_body = 28;
75
+ static const int c_lexer_en_cdata_body = 31;
76
+ static const int c_lexer_en_proc_ins_body = 34;
77
+ static const int c_lexer_en_string_squote = 37;
78
+ static const int c_lexer_en_string_dquote = 39;
79
+ static const int c_lexer_en_doctype_inline = 41;
80
+ static const int c_lexer_en_doctype = 43;
81
+ static const int c_lexer_en_xml_decl = 55;
82
+ static const int c_lexer_en_element_name = 58;
83
+ static const int c_lexer_en_html_attribute_value = 60;
84
+ static const int c_lexer_en_xml_attribute_value = 62;
85
+ static const int c_lexer_en_element_head = 63;
86
+ static const int c_lexer_en_text = 66;
87
+ static const int c_lexer_en_literal_html_element = 70;
88
+ static const int c_lexer_en_main = 22;
89
+
90
+
91
+ #line 66 "ext/c/lexer.rl"
87
92
 
88
93
  /**
89
94
  * Lexes the String specifies as the method argument. Token values have the
@@ -97,6 +102,9 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
97
102
  OgaLexerState *state;
98
103
  int lines;
99
104
 
105
+ /* Whether or not HTML mode is enabled */
106
+ int html_p = rb_funcall(self, id_html, 0) == Qtrue;
107
+
100
108
  /* Make sure that all data passed back to Ruby has the proper encoding. */
101
109
  rb_encoding *encoding = rb_enc_get(data_block);
102
110
 
@@ -112,8 +120,12 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
112
120
  ID id_advance_line = rb_intern("advance_line");
113
121
  ID id_on_attribute = rb_intern("on_attribute");
114
122
  ID id_on_attribute_ns = rb_intern("on_attribute_ns");
115
- ID id_on_cdata = rb_intern("on_cdata");
116
- ID id_on_comment = rb_intern("on_comment");
123
+ ID id_on_cdata_start = rb_intern("on_cdata_start");
124
+ ID id_on_cdata_body = rb_intern("on_cdata_body");
125
+ ID id_on_cdata_end = rb_intern("on_cdata_end");
126
+ ID id_on_comment_start = rb_intern("on_comment_start");
127
+ ID id_on_comment_body = rb_intern("on_comment_body");
128
+ ID id_on_comment_end = rb_intern("on_comment_end");
117
129
  ID id_on_doctype_end = rb_intern("on_doctype_end");
118
130
  ID id_on_doctype_inline = rb_intern("on_doctype_inline");
119
131
  ID id_on_doctype_name = rb_intern("on_doctype_name");
@@ -127,6 +139,7 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
127
139
  ID id_on_proc_ins_end = rb_intern("on_proc_ins_end");
128
140
  ID id_on_proc_ins_name = rb_intern("on_proc_ins_name");
129
141
  ID id_on_proc_ins_start = rb_intern("on_proc_ins_start");
142
+ ID id_on_proc_ins_body = rb_intern("on_proc_ins_body");
130
143
  ID id_on_string_body = rb_intern("on_string_body");
131
144
  ID id_on_string_dquote = rb_intern("on_string_dquote");
132
145
  ID id_on_string_squote = rb_intern("on_string_squote");
@@ -139,7 +152,7 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
139
152
  lines = state->lines;
140
153
 
141
154
 
142
- #line 143 "ext/c/lexer.c"
155
+ #line 156 "ext/c/lexer.c"
143
156
  {
144
157
  if ( p == pe )
145
158
  goto _test_eof;
@@ -147,8 +160,8 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
147
160
 
148
161
  _again:
149
162
  switch ( ( state->cs) ) {
150
- case 26: goto st26;
151
- case 27: goto st27;
163
+ case 22: goto st22;
164
+ case 23: goto st23;
152
165
  case 1: goto st1;
153
166
  case 2: goto st2;
154
167
  case 3: goto st3;
@@ -158,27 +171,27 @@ _again:
158
171
  case 7: goto st7;
159
172
  case 8: goto st8;
160
173
  case 9: goto st9;
174
+ case 24: goto st24;
161
175
  case 10: goto st10;
162
176
  case 11: goto st11;
163
177
  case 12: goto st12;
164
- case 28: goto st28;
165
178
  case 13: goto st13;
166
179
  case 14: goto st14;
167
180
  case 15: goto st15;
168
181
  case 16: goto st16;
169
182
  case 17: goto st17;
170
183
  case 18: goto st18;
171
- case 19: goto st19;
172
- case 20: goto st20;
173
- case 21: goto st21;
174
- case 22: goto st22;
175
- case 23: goto st23;
176
- case 24: goto st24;
184
+ case 25: goto st25;
185
+ case 26: goto st26;
186
+ case 27: goto st27;
187
+ case 28: goto st28;
177
188
  case 29: goto st29;
178
189
  case 30: goto st30;
190
+ case 19: goto st19;
179
191
  case 31: goto st31;
180
192
  case 32: goto st32;
181
193
  case 33: goto st33;
194
+ case 20: goto st20;
182
195
  case 34: goto st34;
183
196
  case 35: goto st35;
184
197
  case 36: goto st36;
@@ -186,10 +199,10 @@ _again:
186
199
  case 38: goto st38;
187
200
  case 39: goto st39;
188
201
  case 40: goto st40;
189
- case 0: goto st0;
190
202
  case 41: goto st41;
191
203
  case 42: goto st42;
192
204
  case 43: goto st43;
205
+ case 0: goto st0;
193
206
  case 44: goto st44;
194
207
  case 45: goto st45;
195
208
  case 46: goto st46;
@@ -206,13 +219,13 @@ _again:
206
219
  case 57: goto st57;
207
220
  case 58: goto st58;
208
221
  case 59: goto st59;
209
- case 25: goto st25;
210
222
  case 60: goto st60;
211
223
  case 61: goto st61;
212
224
  case 62: goto st62;
213
225
  case 63: goto st63;
214
226
  case 64: goto st64;
215
227
  case 65: goto st65;
228
+ case 21: goto st21;
216
229
  case 66: goto st66;
217
230
  case 67: goto st67;
218
231
  case 68: goto st68;
@@ -224,6 +237,12 @@ _again:
224
237
  case 74: goto st74;
225
238
  case 75: goto st75;
226
239
  case 76: goto st76;
240
+ case 77: goto st77;
241
+ case 78: goto st78;
242
+ case 79: goto st79;
243
+ case 80: goto st80;
244
+ case 81: goto st81;
245
+ case 82: goto st82;
227
246
  default: break;
228
247
  }
229
248
 
@@ -233,145 +252,147 @@ _resume:
233
252
  switch ( ( state->cs) )
234
253
  {
235
254
  tr0:
236
- ( state->cs) = 26;
237
- #line 356 "ext/ragel/base_lexer.rl"
255
+ ( state->cs) = 22;
256
+ #line 471 "ext/ragel/base_lexer.rl"
238
257
  {{p = ((te))-1;}{
239
258
  p--;
240
- ( state->cs) = 60;
259
+ ( state->cs) = 66;
241
260
  }}
242
261
  goto _again;
243
- tr7:
244
- #line 72 "ext/ragel/base_lexer.rl"
262
+ tr4:
263
+ ( state->cs) = 22;
264
+ #line 74 "ext/ragel/base_lexer.rl"
245
265
  {te = p+1;{
246
- callback(id_on_comment, data, encoding, ts + 4, te - 3);
266
+ callback_simple(id_on_comment_start);
267
+
268
+ ( state->cs) = 28;
247
269
  }}
248
- goto st26;
249
- tr23:
250
- #line 88 "ext/ragel/base_lexer.rl"
270
+ goto _again;
271
+ tr17:
272
+ ( state->cs) = 22;
273
+ #line 113 "ext/ragel/base_lexer.rl"
251
274
  {te = p+1;{
252
- callback(id_on_cdata, data, encoding, ts + 9, te - 3);
275
+ callback_simple(id_on_cdata_start);
276
+
277
+ ( state->cs) = 31;
253
278
  }}
254
- goto st26;
255
- tr26:
256
- #line 289 "ext/ragel/base_lexer.rl"
279
+ goto _again;
280
+ tr20:
281
+ #line 357 "ext/ragel/base_lexer.rl"
257
282
  {te = p+1;{
258
283
  callback_simple(id_on_element_end);
259
284
  }}
260
- goto st26;
261
- tr31:
262
- ( state->cs) = 26;
263
- #line 356 "ext/ragel/base_lexer.rl"
285
+ goto st22;
286
+ tr29:
287
+ ( state->cs) = 22;
288
+ #line 471 "ext/ragel/base_lexer.rl"
264
289
  {te = p+1;{
265
290
  p--;
266
- ( state->cs) = 60;
291
+ ( state->cs) = 66;
267
292
  }}
268
293
  goto _again;
269
- tr33:
270
- ( state->cs) = 26;
271
- #line 356 "ext/ragel/base_lexer.rl"
294
+ tr31:
295
+ ( state->cs) = 22;
296
+ #line 471 "ext/ragel/base_lexer.rl"
272
297
  {te = p;p--;{
273
298
  p--;
274
- ( state->cs) = 60;
299
+ ( state->cs) = 66;
275
300
  }}
276
301
  goto _again;
277
- tr35:
278
- ( state->cs) = 26;
279
- #line 283 "ext/ragel/base_lexer.rl"
302
+ tr33:
303
+ ( state->cs) = 22;
304
+ #line 351 "ext/ragel/base_lexer.rl"
280
305
  {te = p+1;{
281
306
  callback_simple(id_on_element_start);
282
307
  p--;
283
- ( state->cs) = 55;
308
+ ( state->cs) = 58;
284
309
  }}
285
310
  goto _again;
286
- tr37:
287
- ( state->cs) = 26;
288
- #line 192 "ext/ragel/base_lexer.rl"
311
+ tr35:
312
+ ( state->cs) = 22;
313
+ #line 245 "ext/ragel/base_lexer.rl"
289
314
  {te = p;p--;{
290
315
  callback_simple(id_on_doctype_start);
291
- ( state->cs) = 40;
316
+ ( state->cs) = 43;
292
317
  }}
293
318
  goto _again;
294
- tr38:
295
- ( state->cs) = 26;
319
+ tr36:
320
+ ( state->cs) = 22;
296
321
  #line 1 "NONE"
297
322
  { switch( ( state->act) ) {
298
- case 36:
323
+ case 45:
299
324
  {{p = ((te))-1;}
300
325
  callback_simple(id_on_xml_decl_start);
301
- ( state->cs) = 52;
326
+ ( state->cs) = 55;
302
327
  }
303
328
  break;
304
- case 39:
329
+ case 48:
305
330
  {{p = ((te))-1;}
306
331
  callback_simple(id_on_proc_ins_start);
307
332
  callback(id_on_proc_ins_name, data, encoding, ts + 2, te);
308
333
 
309
- mark = te;
310
-
311
- ( state->cs) = 32;
334
+ ( state->cs) = 34;
312
335
  }
313
336
  break;
314
337
  }
315
338
  }
316
339
  goto _again;
317
- tr39:
318
- ( state->cs) = 26;
319
- #line 106 "ext/ragel/base_lexer.rl"
340
+ tr37:
341
+ ( state->cs) = 22;
342
+ #line 155 "ext/ragel/base_lexer.rl"
320
343
  {te = p;p--;{
321
344
  callback_simple(id_on_proc_ins_start);
322
345
  callback(id_on_proc_ins_name, data, encoding, ts + 2, te);
323
346
 
324
- mark = te;
325
-
326
- ( state->cs) = 32;
347
+ ( state->cs) = 34;
327
348
  }}
328
349
  goto _again;
329
- st26:
350
+ st22:
330
351
  #line 1 "NONE"
331
352
  {ts = 0;}
332
353
  if ( ++p == pe )
333
- goto _test_eof26;
334
- case 26:
354
+ goto _test_eof22;
355
+ case 22:
335
356
  #line 1 "NONE"
336
357
  {ts = p;}
337
- #line 338 "ext/c/lexer.c"
358
+ #line 359 "ext/c/lexer.c"
338
359
  if ( (*p) == 60 )
339
- goto tr32;
340
- goto tr31;
341
- tr32:
360
+ goto tr30;
361
+ goto tr29;
362
+ tr30:
342
363
  #line 1 "NONE"
343
364
  {te = p+1;}
344
- goto st27;
345
- st27:
365
+ goto st23;
366
+ st23:
346
367
  if ( ++p == pe )
347
- goto _test_eof27;
348
- case 27:
349
- #line 350 "ext/c/lexer.c"
368
+ goto _test_eof23;
369
+ case 23:
370
+ #line 371 "ext/c/lexer.c"
350
371
  switch( (*p) ) {
351
372
  case 33: goto st1;
352
- case 45: goto tr35;
353
- case 47: goto st22;
354
- case 63: goto st24;
355
- case 95: goto tr35;
373
+ case 45: goto tr33;
374
+ case 47: goto st16;
375
+ case 63: goto st18;
376
+ case 95: goto tr33;
356
377
  }
357
378
  if ( (*p) < 65 ) {
358
379
  if ( 48 <= (*p) && (*p) <= 57 )
359
- goto tr35;
380
+ goto tr33;
360
381
  } else if ( (*p) > 90 ) {
361
382
  if ( 97 <= (*p) && (*p) <= 122 )
362
- goto tr35;
383
+ goto tr33;
363
384
  } else
364
- goto tr35;
365
- goto tr33;
385
+ goto tr33;
386
+ goto tr31;
366
387
  st1:
367
388
  if ( ++p == pe )
368
389
  goto _test_eof1;
369
390
  case 1:
370
391
  switch( (*p) ) {
371
392
  case 45: goto st2;
372
- case 68: goto st6;
373
- case 91: goto st13;
374
- case 100: goto st6;
393
+ case 68: goto st3;
394
+ case 91: goto st10;
395
+ case 100: goto st3;
375
396
  }
376
397
  goto tr0;
377
398
  st2:
@@ -379,38 +400,42 @@ st2:
379
400
  goto _test_eof2;
380
401
  case 2:
381
402
  if ( (*p) == 45 )
382
- goto st3;
403
+ goto tr4;
383
404
  goto tr0;
384
405
  st3:
385
406
  if ( ++p == pe )
386
407
  goto _test_eof3;
387
408
  case 3:
388
- if ( (*p) == 45 )
389
- goto st4;
390
- goto st3;
409
+ switch( (*p) ) {
410
+ case 79: goto st4;
411
+ case 111: goto st4;
412
+ }
413
+ goto tr0;
391
414
  st4:
392
415
  if ( ++p == pe )
393
416
  goto _test_eof4;
394
417
  case 4:
395
- if ( (*p) == 45 )
396
- goto st5;
397
- goto st3;
418
+ switch( (*p) ) {
419
+ case 67: goto st5;
420
+ case 99: goto st5;
421
+ }
422
+ goto tr0;
398
423
  st5:
399
424
  if ( ++p == pe )
400
425
  goto _test_eof5;
401
426
  case 5:
402
427
  switch( (*p) ) {
403
- case 45: goto st5;
404
- case 62: goto tr7;
428
+ case 84: goto st6;
429
+ case 116: goto st6;
405
430
  }
406
- goto st3;
431
+ goto tr0;
407
432
  st6:
408
433
  if ( ++p == pe )
409
434
  goto _test_eof6;
410
435
  case 6:
411
436
  switch( (*p) ) {
412
- case 79: goto st7;
413
- case 111: goto st7;
437
+ case 89: goto st7;
438
+ case 121: goto st7;
414
439
  }
415
440
  goto tr0;
416
441
  st7:
@@ -418,8 +443,8 @@ st7:
418
443
  goto _test_eof7;
419
444
  case 7:
420
445
  switch( (*p) ) {
421
- case 67: goto st8;
422
- case 99: goto st8;
446
+ case 80: goto st8;
447
+ case 112: goto st8;
423
448
  }
424
449
  goto tr0;
425
450
  st8:
@@ -427,8 +452,8 @@ st8:
427
452
  goto _test_eof8;
428
453
  case 8:
429
454
  switch( (*p) ) {
430
- case 84: goto st9;
431
- case 116: goto st9;
455
+ case 69: goto st9;
456
+ case 101: goto st9;
432
457
  }
433
458
  goto tr0;
434
459
  st9:
@@ -436,327 +461,421 @@ st9:
436
461
  goto _test_eof9;
437
462
  case 9:
438
463
  switch( (*p) ) {
439
- case 89: goto st10;
440
- case 121: goto st10;
464
+ case 9: goto st24;
465
+ case 32: goto st24;
441
466
  }
442
467
  goto tr0;
468
+ st24:
469
+ if ( ++p == pe )
470
+ goto _test_eof24;
471
+ case 24:
472
+ switch( (*p) ) {
473
+ case 9: goto st24;
474
+ case 32: goto st24;
475
+ }
476
+ goto tr35;
443
477
  st10:
444
478
  if ( ++p == pe )
445
479
  goto _test_eof10;
446
480
  case 10:
447
- switch( (*p) ) {
448
- case 80: goto st11;
449
- case 112: goto st11;
450
- }
481
+ if ( (*p) == 67 )
482
+ goto st11;
451
483
  goto tr0;
452
484
  st11:
453
485
  if ( ++p == pe )
454
486
  goto _test_eof11;
455
487
  case 11:
456
- switch( (*p) ) {
457
- case 69: goto st12;
458
- case 101: goto st12;
459
- }
488
+ if ( (*p) == 68 )
489
+ goto st12;
460
490
  goto tr0;
461
491
  st12:
462
492
  if ( ++p == pe )
463
493
  goto _test_eof12;
464
494
  case 12:
465
- switch( (*p) ) {
466
- case 9: goto st28;
467
- case 32: goto st28;
468
- }
495
+ if ( (*p) == 65 )
496
+ goto st13;
469
497
  goto tr0;
470
- st28:
471
- if ( ++p == pe )
472
- goto _test_eof28;
473
- case 28:
474
- switch( (*p) ) {
475
- case 9: goto st28;
476
- case 32: goto st28;
477
- }
478
- goto tr37;
479
498
  st13:
480
499
  if ( ++p == pe )
481
500
  goto _test_eof13;
482
501
  case 13:
483
- if ( (*p) == 67 )
502
+ if ( (*p) == 84 )
484
503
  goto st14;
485
504
  goto tr0;
486
505
  st14:
487
506
  if ( ++p == pe )
488
507
  goto _test_eof14;
489
508
  case 14:
490
- if ( (*p) == 68 )
509
+ if ( (*p) == 65 )
491
510
  goto st15;
492
511
  goto tr0;
493
512
  st15:
494
513
  if ( ++p == pe )
495
514
  goto _test_eof15;
496
515
  case 15:
497
- if ( (*p) == 65 )
498
- goto st16;
516
+ if ( (*p) == 91 )
517
+ goto tr17;
499
518
  goto tr0;
500
519
  st16:
501
520
  if ( ++p == pe )
502
521
  goto _test_eof16;
503
522
  case 16:
504
- if ( (*p) == 84 )
505
- goto st17;
506
- goto tr0;
507
- st17:
508
- if ( ++p == pe )
509
- goto _test_eof17;
510
- case 17:
511
- if ( (*p) == 65 )
512
- goto st18;
513
- goto tr0;
514
- st18:
515
- if ( ++p == pe )
516
- goto _test_eof18;
517
- case 18:
518
- if ( (*p) == 91 )
519
- goto st19;
520
- goto tr0;
521
- st19:
522
- if ( ++p == pe )
523
- goto _test_eof19;
524
- case 19:
525
- if ( (*p) == 93 )
526
- goto st20;
527
- goto st19;
528
- st20:
529
- if ( ++p == pe )
530
- goto _test_eof20;
531
- case 20:
532
- if ( (*p) == 93 )
533
- goto st21;
534
- goto st19;
535
- st21:
536
- if ( ++p == pe )
537
- goto _test_eof21;
538
- case 21:
539
- switch( (*p) ) {
540
- case 62: goto tr23;
541
- case 93: goto st21;
542
- }
543
- goto st19;
544
- st22:
545
- if ( ++p == pe )
546
- goto _test_eof22;
547
- case 22:
548
523
  switch( (*p) ) {
549
- case 45: goto st23;
550
- case 95: goto st23;
524
+ case 45: goto st17;
525
+ case 95: goto st17;
551
526
  }
552
527
  if ( (*p) < 65 ) {
553
528
  if ( 48 <= (*p) && (*p) <= 57 )
554
- goto st23;
529
+ goto st17;
555
530
  } else if ( (*p) > 90 ) {
556
531
  if ( 97 <= (*p) && (*p) <= 122 )
557
- goto st23;
532
+ goto st17;
558
533
  } else
559
- goto st23;
534
+ goto st17;
560
535
  goto tr0;
561
- st23:
536
+ st17:
562
537
  if ( ++p == pe )
563
- goto _test_eof23;
564
- case 23:
538
+ goto _test_eof17;
539
+ case 17:
565
540
  switch( (*p) ) {
566
- case 45: goto st23;
567
- case 58: goto st22;
568
- case 62: goto tr26;
569
- case 95: goto st23;
541
+ case 45: goto st17;
542
+ case 58: goto st16;
543
+ case 62: goto tr20;
544
+ case 95: goto st17;
570
545
  }
571
546
  if ( (*p) < 65 ) {
572
547
  if ( 48 <= (*p) && (*p) <= 57 )
573
- goto st23;
548
+ goto st17;
574
549
  } else if ( (*p) > 90 ) {
575
550
  if ( 97 <= (*p) && (*p) <= 122 )
576
- goto st23;
551
+ goto st17;
577
552
  } else
578
- goto st23;
553
+ goto st17;
579
554
  goto tr0;
580
- st24:
555
+ st18:
581
556
  if ( ++p == pe )
582
- goto _test_eof24;
583
- case 24:
557
+ goto _test_eof18;
558
+ case 18:
584
559
  switch( (*p) ) {
585
- case 45: goto tr27;
586
- case 95: goto tr27;
587
- case 120: goto st30;
560
+ case 45: goto tr21;
561
+ case 95: goto tr21;
562
+ case 120: goto st26;
588
563
  }
589
564
  if ( (*p) < 65 ) {
590
565
  if ( 48 <= (*p) && (*p) <= 57 )
591
- goto tr27;
566
+ goto tr21;
592
567
  } else if ( (*p) > 90 ) {
593
568
  if ( 97 <= (*p) && (*p) <= 122 )
594
- goto tr27;
569
+ goto tr21;
595
570
  } else
596
- goto tr27;
571
+ goto tr21;
597
572
  goto tr0;
598
- tr27:
573
+ tr21:
599
574
  #line 1 "NONE"
600
575
  {te = p+1;}
601
- #line 106 "ext/ragel/base_lexer.rl"
602
- {( state->act) = 39;}
603
- goto st29;
604
- tr41:
576
+ #line 155 "ext/ragel/base_lexer.rl"
577
+ {( state->act) = 48;}
578
+ goto st25;
579
+ tr39:
605
580
  #line 1 "NONE"
606
581
  {te = p+1;}
607
- #line 248 "ext/ragel/base_lexer.rl"
608
- {( state->act) = 36;}
609
- goto st29;
610
- st29:
582
+ #line 301 "ext/ragel/base_lexer.rl"
583
+ {( state->act) = 45;}
584
+ goto st25;
585
+ st25:
611
586
  if ( ++p == pe )
612
- goto _test_eof29;
613
- case 29:
614
- #line 615 "ext/c/lexer.c"
587
+ goto _test_eof25;
588
+ case 25:
589
+ #line 590 "ext/c/lexer.c"
615
590
  switch( (*p) ) {
616
- case 45: goto tr27;
617
- case 95: goto tr27;
591
+ case 45: goto tr21;
592
+ case 95: goto tr21;
618
593
  }
619
594
  if ( (*p) < 65 ) {
620
595
  if ( 48 <= (*p) && (*p) <= 57 )
621
- goto tr27;
596
+ goto tr21;
622
597
  } else if ( (*p) > 90 ) {
623
598
  if ( 97 <= (*p) && (*p) <= 122 )
624
- goto tr27;
599
+ goto tr21;
625
600
  } else
626
- goto tr27;
627
- goto tr38;
628
- st30:
601
+ goto tr21;
602
+ goto tr36;
603
+ st26:
629
604
  if ( ++p == pe )
630
- goto _test_eof30;
631
- case 30:
605
+ goto _test_eof26;
606
+ case 26:
632
607
  switch( (*p) ) {
633
- case 45: goto tr27;
634
- case 95: goto tr27;
635
- case 109: goto st31;
608
+ case 45: goto tr21;
609
+ case 95: goto tr21;
610
+ case 109: goto st27;
636
611
  }
637
612
  if ( (*p) < 65 ) {
638
613
  if ( 48 <= (*p) && (*p) <= 57 )
639
- goto tr27;
614
+ goto tr21;
640
615
  } else if ( (*p) > 90 ) {
641
616
  if ( 97 <= (*p) && (*p) <= 122 )
642
- goto tr27;
617
+ goto tr21;
643
618
  } else
644
- goto tr27;
645
- goto tr39;
646
- st31:
619
+ goto tr21;
620
+ goto tr37;
621
+ st27:
647
622
  if ( ++p == pe )
648
- goto _test_eof31;
649
- case 31:
623
+ goto _test_eof27;
624
+ case 27:
650
625
  switch( (*p) ) {
651
- case 45: goto tr27;
652
- case 95: goto tr27;
653
- case 108: goto tr41;
626
+ case 45: goto tr21;
627
+ case 95: goto tr21;
628
+ case 108: goto tr39;
654
629
  }
655
630
  if ( (*p) < 65 ) {
656
631
  if ( 48 <= (*p) && (*p) <= 57 )
657
- goto tr27;
632
+ goto tr21;
658
633
  } else if ( (*p) > 90 ) {
659
634
  if ( 97 <= (*p) && (*p) <= 122 )
660
- goto tr27;
635
+ goto tr21;
661
636
  } else
662
- goto tr27;
663
- goto tr39;
664
- tr42:
665
- #line 125 "ext/ragel/base_lexer.rl"
666
- {te = p+1;}
667
- goto st32;
668
- tr44:
669
- #line 125 "ext/ragel/base_lexer.rl"
670
- {te = p;p--;}
671
- goto st32;
672
- tr45:
673
- ( state->cs) = 32;
674
- #line 116 "ext/ragel/base_lexer.rl"
675
- {te = p+1;{
676
- callback(id_on_text, data, encoding, mark, ts);
677
- callback_simple(id_on_proc_ins_end);
637
+ goto tr21;
638
+ goto tr37;
639
+ tr23:
640
+ #line 81 "ext/ragel/base_lexer.rl"
641
+ {{p = ((te))-1;}{
642
+ callback(id_on_comment_body, data, encoding, ts, te);
678
643
 
679
- mark = 0;
644
+ if ( lines > 0 )
645
+ {
646
+ advance_line(lines);
680
647
 
681
- ( state->cs) = 26;
648
+ lines = 0;
649
+ }
682
650
  }}
683
- goto _again;
684
- st32:
685
- #line 1 "NONE"
686
- {ts = 0;}
687
- if ( ++p == pe )
688
- goto _test_eof32;
689
- case 32:
690
- #line 1 "NONE"
691
- {ts = p;}
692
- #line 693 "ext/c/lexer.c"
693
- if ( (*p) == 63 )
694
- goto st33;
695
- goto tr42;
696
- st33:
697
- if ( ++p == pe )
698
- goto _test_eof33;
699
- case 33:
700
- if ( (*p) == 62 )
701
- goto tr45;
702
- goto tr44;
703
- tr47:
704
- #line 163 "ext/ragel/base_lexer.rl"
651
+ goto st28;
652
+ tr24:
653
+ ( state->cs) = 28;
654
+ #line 92 "ext/ragel/base_lexer.rl"
705
655
  {te = p+1;{
706
- callback_simple(id_on_string_squote);
656
+ callback_simple(id_on_comment_end);
707
657
 
708
- {( state->cs) = ( state->stack)[--( state->top)];goto _again;}
658
+ ( state->cs) = 22;
709
659
  }}
710
- goto st34;
711
- tr48:
712
- #line 137 "ext/ragel/base_lexer.rl"
660
+ goto _again;
661
+ tr42:
662
+ #line 81 "ext/ragel/base_lexer.rl"
713
663
  {te = p;p--;{
714
- callback(id_on_string_body, data, encoding, ts, te);
664
+ callback(id_on_comment_body, data, encoding, ts, te);
715
665
 
716
- if ( lines > 0 )
717
- {
718
- advance_line(lines);
666
+ if ( lines > 0 )
667
+ {
668
+ advance_line(lines);
719
669
 
720
- lines = 0;
721
- }
722
- }}
723
- goto st34;
724
- st34:
670
+ lines = 0;
671
+ }
672
+ }}
673
+ goto st28;
674
+ st28:
725
675
  #line 1 "NONE"
726
676
  {ts = 0;}
727
677
  if ( ++p == pe )
728
- goto _test_eof34;
729
- case 34:
678
+ goto _test_eof28;
679
+ case 28:
730
680
  #line 1 "NONE"
731
681
  {ts = p;}
732
- #line 733 "ext/c/lexer.c"
733
- if ( (*p) == 39 )
734
- goto tr47;
735
- goto tr46;
736
- tr46:
682
+ #line 683 "ext/c/lexer.c"
683
+ if ( (*p) == 45 )
684
+ goto tr41;
685
+ goto tr40;
686
+ tr40:
737
687
  #line 51 "ext/ragel/base_lexer.rl"
738
688
  {
739
689
  if ( (*p) == '\n' ) lines++;
740
690
  }
741
- goto st35;
742
- st35:
691
+ goto st29;
692
+ st29:
743
693
  if ( ++p == pe )
744
- goto _test_eof35;
745
- case 35:
746
- #line 747 "ext/c/lexer.c"
747
- if ( (*p) == 39 )
748
- goto tr48;
749
- goto tr46;
750
- tr50:
751
- #line 173 "ext/ragel/base_lexer.rl"
752
- {te = p+1;{
753
- callback_simple(id_on_string_dquote);
754
-
755
- {( state->cs) = ( state->stack)[--( state->top)];goto _again;}
756
- }}
757
- goto st36;
694
+ goto _test_eof29;
695
+ case 29:
696
+ #line 697 "ext/c/lexer.c"
697
+ if ( (*p) == 45 )
698
+ goto tr42;
699
+ goto tr40;
700
+ tr41:
701
+ #line 1 "NONE"
702
+ {te = p+1;}
703
+ #line 51 "ext/ragel/base_lexer.rl"
704
+ {
705
+ if ( (*p) == '\n' ) lines++;
706
+ }
707
+ goto st30;
708
+ st30:
709
+ if ( ++p == pe )
710
+ goto _test_eof30;
711
+ case 30:
712
+ #line 713 "ext/c/lexer.c"
713
+ if ( (*p) == 45 )
714
+ goto st19;
715
+ goto tr42;
716
+ st19:
717
+ if ( ++p == pe )
718
+ goto _test_eof19;
719
+ case 19:
720
+ if ( (*p) == 62 )
721
+ goto tr24;
722
+ goto tr23;
723
+ tr25:
724
+ #line 120 "ext/ragel/base_lexer.rl"
725
+ {{p = ((te))-1;}{
726
+ callback(id_on_cdata_body, data, encoding, ts, te);
727
+
728
+ if ( lines > 0 )
729
+ {
730
+ advance_line(lines);
731
+
732
+ lines = 0;
733
+ }
734
+ }}
735
+ goto st31;
736
+ tr26:
737
+ ( state->cs) = 31;
738
+ #line 131 "ext/ragel/base_lexer.rl"
739
+ {te = p+1;{
740
+ callback_simple(id_on_cdata_end);
741
+
742
+ ( state->cs) = 22;
743
+ }}
744
+ goto _again;
745
+ tr46:
746
+ #line 120 "ext/ragel/base_lexer.rl"
747
+ {te = p;p--;{
748
+ callback(id_on_cdata_body, data, encoding, ts, te);
749
+
750
+ if ( lines > 0 )
751
+ {
752
+ advance_line(lines);
753
+
754
+ lines = 0;
755
+ }
756
+ }}
757
+ goto st31;
758
+ st31:
759
+ #line 1 "NONE"
760
+ {ts = 0;}
761
+ if ( ++p == pe )
762
+ goto _test_eof31;
763
+ case 31:
764
+ #line 1 "NONE"
765
+ {ts = p;}
766
+ #line 767 "ext/c/lexer.c"
767
+ if ( (*p) == 93 )
768
+ goto tr45;
769
+ goto tr44;
770
+ tr44:
771
+ #line 51 "ext/ragel/base_lexer.rl"
772
+ {
773
+ if ( (*p) == '\n' ) lines++;
774
+ }
775
+ goto st32;
776
+ st32:
777
+ if ( ++p == pe )
778
+ goto _test_eof32;
779
+ case 32:
780
+ #line 781 "ext/c/lexer.c"
781
+ if ( (*p) == 93 )
782
+ goto tr46;
783
+ goto tr44;
784
+ tr45:
785
+ #line 1 "NONE"
786
+ {te = p+1;}
787
+ #line 51 "ext/ragel/base_lexer.rl"
788
+ {
789
+ if ( (*p) == '\n' ) lines++;
790
+ }
791
+ goto st33;
792
+ st33:
793
+ if ( ++p == pe )
794
+ goto _test_eof33;
795
+ case 33:
796
+ #line 797 "ext/c/lexer.c"
797
+ if ( (*p) == 93 )
798
+ goto st20;
799
+ goto tr46;
800
+ st20:
801
+ if ( ++p == pe )
802
+ goto _test_eof20;
803
+ case 20:
804
+ if ( (*p) == 62 )
805
+ goto tr26;
806
+ goto tr25;
807
+ tr50:
808
+ #line 163 "ext/ragel/base_lexer.rl"
809
+ {te = p;p--;{
810
+ callback(id_on_proc_ins_body, data, encoding, ts, te);
811
+
812
+ if ( lines > 0 )
813
+ {
814
+ advance_line(lines);
815
+
816
+ lines = 0;
817
+ }
818
+ }}
819
+ goto st34;
758
820
  tr51:
759
- #line 137 "ext/ragel/base_lexer.rl"
821
+ ( state->cs) = 34;
822
+ #line 174 "ext/ragel/base_lexer.rl"
823
+ {te = p+1;{
824
+ callback_simple(id_on_proc_ins_end);
825
+
826
+ ( state->cs) = 22;
827
+ }}
828
+ goto _again;
829
+ st34:
830
+ #line 1 "NONE"
831
+ {ts = 0;}
832
+ if ( ++p == pe )
833
+ goto _test_eof34;
834
+ case 34:
835
+ #line 1 "NONE"
836
+ {ts = p;}
837
+ #line 838 "ext/c/lexer.c"
838
+ if ( (*p) == 63 )
839
+ goto tr49;
840
+ goto tr48;
841
+ tr48:
842
+ #line 51 "ext/ragel/base_lexer.rl"
843
+ {
844
+ if ( (*p) == '\n' ) lines++;
845
+ }
846
+ goto st35;
847
+ st35:
848
+ if ( ++p == pe )
849
+ goto _test_eof35;
850
+ case 35:
851
+ #line 852 "ext/c/lexer.c"
852
+ if ( (*p) == 63 )
853
+ goto tr50;
854
+ goto tr48;
855
+ tr49:
856
+ #line 51 "ext/ragel/base_lexer.rl"
857
+ {
858
+ if ( (*p) == '\n' ) lines++;
859
+ }
860
+ goto st36;
861
+ st36:
862
+ if ( ++p == pe )
863
+ goto _test_eof36;
864
+ case 36:
865
+ #line 866 "ext/c/lexer.c"
866
+ if ( (*p) == 62 )
867
+ goto tr51;
868
+ goto tr50;
869
+ tr53:
870
+ #line 216 "ext/ragel/base_lexer.rl"
871
+ {te = p+1;{
872
+ callback_simple(id_on_string_squote);
873
+
874
+ {( state->cs) = ( state->stack)[--( state->top)];goto _again;}
875
+ }}
876
+ goto st37;
877
+ tr54:
878
+ #line 190 "ext/ragel/base_lexer.rl"
760
879
  {te = p;p--;{
761
880
  callback(id_on_string_body, data, encoding, ts, te);
762
881
 
@@ -767,40 +886,87 @@ tr51:
767
886
  lines = 0;
768
887
  }
769
888
  }}
770
- goto st36;
771
- st36:
889
+ goto st37;
890
+ st37:
772
891
  #line 1 "NONE"
773
892
  {ts = 0;}
774
893
  if ( ++p == pe )
775
- goto _test_eof36;
776
- case 36:
894
+ goto _test_eof37;
895
+ case 37:
896
+ #line 1 "NONE"
897
+ {ts = p;}
898
+ #line 899 "ext/c/lexer.c"
899
+ if ( (*p) == 39 )
900
+ goto tr53;
901
+ goto tr52;
902
+ tr52:
903
+ #line 51 "ext/ragel/base_lexer.rl"
904
+ {
905
+ if ( (*p) == '\n' ) lines++;
906
+ }
907
+ goto st38;
908
+ st38:
909
+ if ( ++p == pe )
910
+ goto _test_eof38;
911
+ case 38:
912
+ #line 913 "ext/c/lexer.c"
913
+ if ( (*p) == 39 )
914
+ goto tr54;
915
+ goto tr52;
916
+ tr56:
917
+ #line 226 "ext/ragel/base_lexer.rl"
918
+ {te = p+1;{
919
+ callback_simple(id_on_string_dquote);
920
+
921
+ {( state->cs) = ( state->stack)[--( state->top)];goto _again;}
922
+ }}
923
+ goto st39;
924
+ tr57:
925
+ #line 190 "ext/ragel/base_lexer.rl"
926
+ {te = p;p--;{
927
+ callback(id_on_string_body, data, encoding, ts, te);
928
+
929
+ if ( lines > 0 )
930
+ {
931
+ advance_line(lines);
932
+
933
+ lines = 0;
934
+ }
935
+ }}
936
+ goto st39;
937
+ st39:
938
+ #line 1 "NONE"
939
+ {ts = 0;}
940
+ if ( ++p == pe )
941
+ goto _test_eof39;
942
+ case 39:
777
943
  #line 1 "NONE"
778
944
  {ts = p;}
779
- #line 780 "ext/c/lexer.c"
945
+ #line 946 "ext/c/lexer.c"
780
946
  if ( (*p) == 34 )
781
- goto tr50;
782
- goto tr49;
783
- tr49:
947
+ goto tr56;
948
+ goto tr55;
949
+ tr55:
784
950
  #line 51 "ext/ragel/base_lexer.rl"
785
951
  {
786
952
  if ( (*p) == '\n' ) lines++;
787
953
  }
788
- goto st37;
789
- st37:
954
+ goto st40;
955
+ st40:
790
956
  if ( ++p == pe )
791
- goto _test_eof37;
792
- case 37:
793
- #line 794 "ext/c/lexer.c"
957
+ goto _test_eof40;
958
+ case 40:
959
+ #line 960 "ext/c/lexer.c"
794
960
  if ( (*p) == 34 )
795
- goto tr51;
796
- goto tr49;
797
- tr53:
798
- ( state->cs) = 38;
799
- #line 210 "ext/ragel/base_lexer.rl"
800
- {te = p+1;{ ( state->cs) = 40; }}
961
+ goto tr57;
962
+ goto tr55;
963
+ tr59:
964
+ ( state->cs) = 41;
965
+ #line 263 "ext/ragel/base_lexer.rl"
966
+ {te = p+1;{ ( state->cs) = 43; }}
801
967
  goto _again;
802
- tr54:
803
- #line 199 "ext/ragel/base_lexer.rl"
968
+ tr60:
969
+ #line 252 "ext/ragel/base_lexer.rl"
804
970
  {te = p;p--;{
805
971
  callback(id_on_doctype_inline, data, encoding, ts, te);
806
972
 
@@ -811,606 +977,746 @@ tr54:
811
977
  lines = 0;
812
978
  }
813
979
  }}
814
- goto st38;
815
- st38:
980
+ goto st41;
981
+ st41:
816
982
  #line 1 "NONE"
817
983
  {ts = 0;}
818
984
  if ( ++p == pe )
819
- goto _test_eof38;
820
- case 38:
985
+ goto _test_eof41;
986
+ case 41:
821
987
  #line 1 "NONE"
822
988
  {ts = p;}
823
- #line 824 "ext/c/lexer.c"
989
+ #line 990 "ext/c/lexer.c"
824
990
  if ( (*p) == 93 )
825
- goto tr53;
826
- goto tr52;
827
- tr52:
991
+ goto tr59;
992
+ goto tr58;
993
+ tr58:
828
994
  #line 51 "ext/ragel/base_lexer.rl"
829
995
  {
830
996
  if ( (*p) == '\n' ) lines++;
831
997
  }
832
- goto st39;
833
- st39:
998
+ goto st42;
999
+ st42:
834
1000
  if ( ++p == pe )
835
- goto _test_eof39;
836
- case 39:
837
- #line 838 "ext/c/lexer.c"
1001
+ goto _test_eof42;
1002
+ case 42:
1003
+ #line 1004 "ext/c/lexer.c"
838
1004
  if ( (*p) == 93 )
839
- goto tr54;
840
- goto tr52;
841
- tr55:
842
- #line 229 "ext/ragel/base_lexer.rl"
1005
+ goto tr60;
1006
+ goto tr58;
1007
+ tr61:
1008
+ #line 282 "ext/ragel/base_lexer.rl"
843
1009
  {te = p+1;}
844
- goto st40;
845
- tr56:
846
- #line 154 "ext/ragel/base_lexer.rl"
1010
+ goto st43;
1011
+ tr62:
1012
+ #line 207 "ext/ragel/base_lexer.rl"
847
1013
  {te = p+1;{
848
1014
  callback_simple(id_on_string_dquote);
849
1015
 
850
- {( state->stack)[( state->top)++] = 40; goto st36;}
1016
+ {( state->stack)[( state->top)++] = 43; goto st39;}
851
1017
  }}
852
- goto st40;
853
- tr57:
854
- #line 148 "ext/ragel/base_lexer.rl"
1018
+ goto st43;
1019
+ tr63:
1020
+ #line 201 "ext/ragel/base_lexer.rl"
855
1021
  {te = p+1;{
856
1022
  callback_simple(id_on_string_squote);
857
1023
 
858
- {( state->stack)[( state->top)++] = 40; goto st34;}
1024
+ {( state->stack)[( state->top)++] = 43; goto st37;}
859
1025
  }}
860
- goto st40;
861
- tr59:
862
- ( state->cs) = 40;
863
- #line 235 "ext/ragel/base_lexer.rl"
1026
+ goto st43;
1027
+ tr65:
1028
+ ( state->cs) = 43;
1029
+ #line 288 "ext/ragel/base_lexer.rl"
864
1030
  {te = p+1;{
865
1031
  callback_simple(id_on_doctype_end);
866
- ( state->cs) = 26;
1032
+ ( state->cs) = 22;
867
1033
  }}
868
1034
  goto _again;
869
- tr62:
870
- ( state->cs) = 40;
871
- #line 221 "ext/ragel/base_lexer.rl"
872
- {te = p+1;{ ( state->cs) = 38; }}
1035
+ tr68:
1036
+ ( state->cs) = 43;
1037
+ #line 274 "ext/ragel/base_lexer.rl"
1038
+ {te = p+1;{ ( state->cs) = 41; }}
873
1039
  goto _again;
874
- tr63:
1040
+ tr69:
875
1041
  #line 1 "NONE"
876
1042
  { switch( ( state->act) ) {
877
- case 9:
1043
+ case 13:
878
1044
  {{p = ((te))-1;}
879
1045
  callback(id_on_doctype_type, data, encoding, ts, te);
880
1046
  }
881
1047
  break;
882
- case 14:
1048
+ case 18:
883
1049
  {{p = ((te))-1;}
884
1050
  callback(id_on_doctype_name, data, encoding, ts, te);
885
1051
  }
886
1052
  break;
887
1053
  }
888
1054
  }
889
- goto st40;
890
- tr64:
891
- #line 231 "ext/ragel/base_lexer.rl"
1055
+ goto st43;
1056
+ tr70:
1057
+ #line 284 "ext/ragel/base_lexer.rl"
892
1058
  {te = p;p--;{
893
1059
  callback(id_on_doctype_name, data, encoding, ts, te);
894
1060
  }}
895
- goto st40;
896
- st40:
1061
+ goto st43;
1062
+ st43:
897
1063
  #line 1 "NONE"
898
1064
  {ts = 0;}
899
1065
  if ( ++p == pe )
900
- goto _test_eof40;
901
- case 40:
1066
+ goto _test_eof43;
1067
+ case 43:
902
1068
  #line 1 "NONE"
903
1069
  {ts = p;}
904
- #line 905 "ext/c/lexer.c"
1070
+ #line 1071 "ext/c/lexer.c"
905
1071
  switch( (*p) ) {
906
- case 9: goto tr55;
907
- case 32: goto tr55;
908
- case 34: goto tr56;
909
- case 39: goto tr57;
910
- case 45: goto tr58;
911
- case 62: goto tr59;
912
- case 80: goto st42;
913
- case 83: goto st47;
914
- case 91: goto tr62;
915
- case 95: goto tr58;
1072
+ case 9: goto tr61;
1073
+ case 32: goto tr61;
1074
+ case 34: goto tr62;
1075
+ case 39: goto tr63;
1076
+ case 45: goto tr64;
1077
+ case 62: goto tr65;
1078
+ case 80: goto st45;
1079
+ case 83: goto st50;
1080
+ case 91: goto tr68;
1081
+ case 95: goto tr64;
916
1082
  }
917
1083
  if ( (*p) < 65 ) {
918
1084
  if ( 48 <= (*p) && (*p) <= 57 )
919
- goto tr58;
1085
+ goto tr64;
920
1086
  } else if ( (*p) > 90 ) {
921
1087
  if ( 97 <= (*p) && (*p) <= 122 )
922
- goto tr58;
1088
+ goto tr64;
923
1089
  } else
924
- goto tr58;
1090
+ goto tr64;
925
1091
  goto st0;
926
1092
  st0:
927
1093
  ( state->cs) = 0;
928
1094
  goto _out;
929
- tr58:
1095
+ tr64:
930
1096
  #line 1 "NONE"
931
1097
  {te = p+1;}
932
- #line 231 "ext/ragel/base_lexer.rl"
933
- {( state->act) = 14;}
934
- goto st41;
935
- tr69:
1098
+ #line 284 "ext/ragel/base_lexer.rl"
1099
+ {( state->act) = 18;}
1100
+ goto st44;
1101
+ tr75:
936
1102
  #line 1 "NONE"
937
1103
  {te = p+1;}
938
- #line 216 "ext/ragel/base_lexer.rl"
939
- {( state->act) = 9;}
940
- goto st41;
941
- st41:
942
- if ( ++p == pe )
943
- goto _test_eof41;
944
- case 41:
945
- #line 946 "ext/c/lexer.c"
946
- switch( (*p) ) {
947
- case 45: goto tr58;
948
- case 95: goto tr58;
949
- }
950
- if ( (*p) < 65 ) {
951
- if ( 48 <= (*p) && (*p) <= 57 )
952
- goto tr58;
953
- } else if ( (*p) > 90 ) {
954
- if ( 97 <= (*p) && (*p) <= 122 )
955
- goto tr58;
956
- } else
957
- goto tr58;
958
- goto tr63;
959
- st42:
960
- if ( ++p == pe )
961
- goto _test_eof42;
962
- case 42:
963
- switch( (*p) ) {
964
- case 45: goto tr58;
965
- case 85: goto st43;
966
- case 95: goto tr58;
967
- }
968
- if ( (*p) < 65 ) {
969
- if ( 48 <= (*p) && (*p) <= 57 )
970
- goto tr58;
971
- } else if ( (*p) > 90 ) {
972
- if ( 97 <= (*p) && (*p) <= 122 )
973
- goto tr58;
974
- } else
975
- goto tr58;
976
- goto tr64;
977
- st43:
978
- if ( ++p == pe )
979
- goto _test_eof43;
980
- case 43:
981
- switch( (*p) ) {
982
- case 45: goto tr58;
983
- case 66: goto st44;
984
- case 95: goto tr58;
985
- }
986
- if ( (*p) < 65 ) {
987
- if ( 48 <= (*p) && (*p) <= 57 )
988
- goto tr58;
989
- } else if ( (*p) > 90 ) {
990
- if ( 97 <= (*p) && (*p) <= 122 )
991
- goto tr58;
992
- } else
993
- goto tr58;
994
- goto tr64;
1104
+ #line 269 "ext/ragel/base_lexer.rl"
1105
+ {( state->act) = 13;}
1106
+ goto st44;
995
1107
  st44:
996
1108
  if ( ++p == pe )
997
1109
  goto _test_eof44;
998
1110
  case 44:
1111
+ #line 1112 "ext/c/lexer.c"
999
1112
  switch( (*p) ) {
1000
- case 45: goto tr58;
1001
- case 76: goto st45;
1002
- case 95: goto tr58;
1113
+ case 45: goto tr64;
1114
+ case 95: goto tr64;
1003
1115
  }
1004
1116
  if ( (*p) < 65 ) {
1005
1117
  if ( 48 <= (*p) && (*p) <= 57 )
1006
- goto tr58;
1118
+ goto tr64;
1007
1119
  } else if ( (*p) > 90 ) {
1008
1120
  if ( 97 <= (*p) && (*p) <= 122 )
1009
- goto tr58;
1121
+ goto tr64;
1010
1122
  } else
1011
- goto tr58;
1012
- goto tr64;
1123
+ goto tr64;
1124
+ goto tr69;
1013
1125
  st45:
1014
1126
  if ( ++p == pe )
1015
1127
  goto _test_eof45;
1016
1128
  case 45:
1017
1129
  switch( (*p) ) {
1018
- case 45: goto tr58;
1019
- case 73: goto st46;
1020
- case 95: goto tr58;
1130
+ case 45: goto tr64;
1131
+ case 85: goto st46;
1132
+ case 95: goto tr64;
1021
1133
  }
1022
1134
  if ( (*p) < 65 ) {
1023
1135
  if ( 48 <= (*p) && (*p) <= 57 )
1024
- goto tr58;
1136
+ goto tr64;
1025
1137
  } else if ( (*p) > 90 ) {
1026
1138
  if ( 97 <= (*p) && (*p) <= 122 )
1027
- goto tr58;
1139
+ goto tr64;
1028
1140
  } else
1029
- goto tr58;
1030
- goto tr64;
1141
+ goto tr64;
1142
+ goto tr70;
1031
1143
  st46:
1032
1144
  if ( ++p == pe )
1033
1145
  goto _test_eof46;
1034
1146
  case 46:
1035
1147
  switch( (*p) ) {
1036
- case 45: goto tr58;
1037
- case 67: goto tr69;
1038
- case 95: goto tr58;
1148
+ case 45: goto tr64;
1149
+ case 66: goto st47;
1150
+ case 95: goto tr64;
1039
1151
  }
1040
1152
  if ( (*p) < 65 ) {
1041
1153
  if ( 48 <= (*p) && (*p) <= 57 )
1042
- goto tr58;
1154
+ goto tr64;
1043
1155
  } else if ( (*p) > 90 ) {
1044
1156
  if ( 97 <= (*p) && (*p) <= 122 )
1045
- goto tr58;
1157
+ goto tr64;
1046
1158
  } else
1047
- goto tr58;
1048
- goto tr64;
1159
+ goto tr64;
1160
+ goto tr70;
1049
1161
  st47:
1050
1162
  if ( ++p == pe )
1051
1163
  goto _test_eof47;
1052
1164
  case 47:
1053
1165
  switch( (*p) ) {
1054
- case 45: goto tr58;
1055
- case 89: goto st48;
1056
- case 95: goto tr58;
1166
+ case 45: goto tr64;
1167
+ case 76: goto st48;
1168
+ case 95: goto tr64;
1057
1169
  }
1058
1170
  if ( (*p) < 65 ) {
1059
1171
  if ( 48 <= (*p) && (*p) <= 57 )
1060
- goto tr58;
1172
+ goto tr64;
1061
1173
  } else if ( (*p) > 90 ) {
1062
1174
  if ( 97 <= (*p) && (*p) <= 122 )
1063
- goto tr58;
1175
+ goto tr64;
1064
1176
  } else
1065
- goto tr58;
1066
- goto tr64;
1177
+ goto tr64;
1178
+ goto tr70;
1067
1179
  st48:
1068
1180
  if ( ++p == pe )
1069
1181
  goto _test_eof48;
1070
1182
  case 48:
1071
1183
  switch( (*p) ) {
1072
- case 45: goto tr58;
1073
- case 83: goto st49;
1074
- case 95: goto tr58;
1184
+ case 45: goto tr64;
1185
+ case 73: goto st49;
1186
+ case 95: goto tr64;
1075
1187
  }
1076
1188
  if ( (*p) < 65 ) {
1077
1189
  if ( 48 <= (*p) && (*p) <= 57 )
1078
- goto tr58;
1190
+ goto tr64;
1079
1191
  } else if ( (*p) > 90 ) {
1080
1192
  if ( 97 <= (*p) && (*p) <= 122 )
1081
- goto tr58;
1193
+ goto tr64;
1082
1194
  } else
1083
- goto tr58;
1084
- goto tr64;
1195
+ goto tr64;
1196
+ goto tr70;
1085
1197
  st49:
1086
1198
  if ( ++p == pe )
1087
1199
  goto _test_eof49;
1088
1200
  case 49:
1089
1201
  switch( (*p) ) {
1090
- case 45: goto tr58;
1091
- case 84: goto st50;
1092
- case 95: goto tr58;
1202
+ case 45: goto tr64;
1203
+ case 67: goto tr75;
1204
+ case 95: goto tr64;
1093
1205
  }
1094
1206
  if ( (*p) < 65 ) {
1095
1207
  if ( 48 <= (*p) && (*p) <= 57 )
1096
- goto tr58;
1208
+ goto tr64;
1097
1209
  } else if ( (*p) > 90 ) {
1098
1210
  if ( 97 <= (*p) && (*p) <= 122 )
1099
- goto tr58;
1211
+ goto tr64;
1100
1212
  } else
1101
- goto tr58;
1102
- goto tr64;
1213
+ goto tr64;
1214
+ goto tr70;
1103
1215
  st50:
1104
1216
  if ( ++p == pe )
1105
1217
  goto _test_eof50;
1106
1218
  case 50:
1107
1219
  switch( (*p) ) {
1108
- case 45: goto tr58;
1109
- case 69: goto st51;
1110
- case 95: goto tr58;
1220
+ case 45: goto tr64;
1221
+ case 89: goto st51;
1222
+ case 95: goto tr64;
1111
1223
  }
1112
1224
  if ( (*p) < 65 ) {
1113
1225
  if ( 48 <= (*p) && (*p) <= 57 )
1114
- goto tr58;
1226
+ goto tr64;
1115
1227
  } else if ( (*p) > 90 ) {
1116
1228
  if ( 97 <= (*p) && (*p) <= 122 )
1117
- goto tr58;
1229
+ goto tr64;
1118
1230
  } else
1119
- goto tr58;
1120
- goto tr64;
1231
+ goto tr64;
1232
+ goto tr70;
1121
1233
  st51:
1122
1234
  if ( ++p == pe )
1123
1235
  goto _test_eof51;
1124
1236
  case 51:
1125
1237
  switch( (*p) ) {
1126
- case 45: goto tr58;
1127
- case 77: goto tr69;
1128
- case 95: goto tr58;
1238
+ case 45: goto tr64;
1239
+ case 83: goto st52;
1240
+ case 95: goto tr64;
1241
+ }
1242
+ if ( (*p) < 65 ) {
1243
+ if ( 48 <= (*p) && (*p) <= 57 )
1244
+ goto tr64;
1245
+ } else if ( (*p) > 90 ) {
1246
+ if ( 97 <= (*p) && (*p) <= 122 )
1247
+ goto tr64;
1248
+ } else
1249
+ goto tr64;
1250
+ goto tr70;
1251
+ st52:
1252
+ if ( ++p == pe )
1253
+ goto _test_eof52;
1254
+ case 52:
1255
+ switch( (*p) ) {
1256
+ case 45: goto tr64;
1257
+ case 84: goto st53;
1258
+ case 95: goto tr64;
1259
+ }
1260
+ if ( (*p) < 65 ) {
1261
+ if ( 48 <= (*p) && (*p) <= 57 )
1262
+ goto tr64;
1263
+ } else if ( (*p) > 90 ) {
1264
+ if ( 97 <= (*p) && (*p) <= 122 )
1265
+ goto tr64;
1266
+ } else
1267
+ goto tr64;
1268
+ goto tr70;
1269
+ st53:
1270
+ if ( ++p == pe )
1271
+ goto _test_eof53;
1272
+ case 53:
1273
+ switch( (*p) ) {
1274
+ case 45: goto tr64;
1275
+ case 69: goto st54;
1276
+ case 95: goto tr64;
1277
+ }
1278
+ if ( (*p) < 65 ) {
1279
+ if ( 48 <= (*p) && (*p) <= 57 )
1280
+ goto tr64;
1281
+ } else if ( (*p) > 90 ) {
1282
+ if ( 97 <= (*p) && (*p) <= 122 )
1283
+ goto tr64;
1284
+ } else
1285
+ goto tr64;
1286
+ goto tr70;
1287
+ st54:
1288
+ if ( ++p == pe )
1289
+ goto _test_eof54;
1290
+ case 54:
1291
+ switch( (*p) ) {
1292
+ case 45: goto tr64;
1293
+ case 77: goto tr75;
1294
+ case 95: goto tr64;
1129
1295
  }
1130
1296
  if ( (*p) < 65 ) {
1131
1297
  if ( 48 <= (*p) && (*p) <= 57 )
1132
- goto tr58;
1298
+ goto tr64;
1133
1299
  } else if ( (*p) > 90 ) {
1134
1300
  if ( 97 <= (*p) && (*p) <= 122 )
1135
- goto tr58;
1301
+ goto tr64;
1136
1302
  } else
1137
- goto tr58;
1138
- goto tr64;
1139
- tr74:
1140
- #line 268 "ext/ragel/base_lexer.rl"
1303
+ goto tr64;
1304
+ goto tr70;
1305
+ tr80:
1306
+ #line 51 "ext/ragel/base_lexer.rl"
1307
+ {
1308
+ if ( (*p) == '\n' ) lines++;
1309
+ }
1310
+ #line 336 "ext/ragel/base_lexer.rl"
1141
1311
  {te = p+1;}
1142
- goto st52;
1143
- tr75:
1144
- #line 154 "ext/ragel/base_lexer.rl"
1312
+ goto st55;
1313
+ tr81:
1314
+ #line 207 "ext/ragel/base_lexer.rl"
1145
1315
  {te = p+1;{
1146
1316
  callback_simple(id_on_string_dquote);
1147
1317
 
1148
- {( state->stack)[( state->top)++] = 52; goto st36;}
1318
+ {( state->stack)[( state->top)++] = 55; goto st39;}
1149
1319
  }}
1150
- goto st52;
1151
- tr76:
1152
- #line 148 "ext/ragel/base_lexer.rl"
1320
+ #line 51 "ext/ragel/base_lexer.rl"
1321
+ {
1322
+ if ( (*p) == '\n' ) lines++;
1323
+ }
1324
+ goto st55;
1325
+ tr82:
1326
+ #line 201 "ext/ragel/base_lexer.rl"
1153
1327
  {te = p+1;{
1154
1328
  callback_simple(id_on_string_squote);
1155
1329
 
1156
- {( state->stack)[( state->top)++] = 52; goto st34;}
1330
+ {( state->stack)[( state->top)++] = 55; goto st37;}
1157
1331
  }}
1158
- goto st52;
1159
- tr79:
1160
- #line 261 "ext/ragel/base_lexer.rl"
1332
+ #line 51 "ext/ragel/base_lexer.rl"
1333
+ {
1334
+ if ( (*p) == '\n' ) lines++;
1335
+ }
1336
+ goto st55;
1337
+ tr85:
1338
+ #line 322 "ext/ragel/base_lexer.rl"
1161
1339
  {te = p;p--;{
1340
+ if ( lines > 0 )
1341
+ {
1342
+ advance_line(lines);
1343
+
1344
+ lines = 0;
1345
+ }
1346
+
1162
1347
  callback(id_on_attribute, data, encoding, ts, te);
1163
1348
  }}
1164
- goto st52;
1165
- tr80:
1166
- #line 268 "ext/ragel/base_lexer.rl"
1349
+ goto st55;
1350
+ tr87:
1351
+ #line 336 "ext/ragel/base_lexer.rl"
1167
1352
  {te = p;p--;}
1168
- goto st52;
1169
- tr81:
1170
- ( state->cs) = 52;
1171
- #line 255 "ext/ragel/base_lexer.rl"
1353
+ goto st55;
1354
+ tr88:
1355
+ ( state->cs) = 55;
1356
+ #line 308 "ext/ragel/base_lexer.rl"
1172
1357
  {te = p+1;{
1358
+ if ( lines > 0 )
1359
+ {
1360
+ advance_line(lines);
1361
+
1362
+ lines = 0;
1363
+ }
1364
+
1173
1365
  callback_simple(id_on_xml_decl_end);
1174
- ( state->cs) = 26;
1366
+
1367
+ ( state->cs) = 22;
1175
1368
  }}
1176
1369
  goto _again;
1177
- st52:
1370
+ st55:
1178
1371
  #line 1 "NONE"
1179
1372
  {ts = 0;}
1180
1373
  if ( ++p == pe )
1181
- goto _test_eof52;
1182
- case 52:
1374
+ goto _test_eof55;
1375
+ case 55:
1183
1376
  #line 1 "NONE"
1184
1377
  {ts = p;}
1185
- #line 1186 "ext/c/lexer.c"
1378
+ #line 1379 "ext/c/lexer.c"
1186
1379
  switch( (*p) ) {
1187
- case 34: goto tr75;
1188
- case 39: goto tr76;
1189
- case 45: goto st53;
1190
- case 63: goto st54;
1191
- case 95: goto st53;
1380
+ case 34: goto tr81;
1381
+ case 39: goto tr82;
1382
+ case 45: goto tr83;
1383
+ case 63: goto tr84;
1384
+ case 95: goto tr83;
1192
1385
  }
1193
1386
  if ( (*p) < 65 ) {
1194
1387
  if ( 48 <= (*p) && (*p) <= 57 )
1195
- goto st53;
1388
+ goto tr83;
1196
1389
  } else if ( (*p) > 90 ) {
1197
1390
  if ( 97 <= (*p) && (*p) <= 122 )
1198
- goto st53;
1391
+ goto tr83;
1199
1392
  } else
1200
- goto st53;
1201
- goto tr74;
1202
- st53:
1393
+ goto tr83;
1394
+ goto tr80;
1395
+ tr83:
1396
+ #line 51 "ext/ragel/base_lexer.rl"
1397
+ {
1398
+ if ( (*p) == '\n' ) lines++;
1399
+ }
1400
+ goto st56;
1401
+ st56:
1203
1402
  if ( ++p == pe )
1204
- goto _test_eof53;
1205
- case 53:
1403
+ goto _test_eof56;
1404
+ case 56:
1405
+ #line 1406 "ext/c/lexer.c"
1206
1406
  switch( (*p) ) {
1207
- case 45: goto st53;
1208
- case 95: goto st53;
1407
+ case 45: goto st56;
1408
+ case 95: goto st56;
1209
1409
  }
1210
1410
  if ( (*p) < 65 ) {
1211
1411
  if ( 48 <= (*p) && (*p) <= 57 )
1212
- goto st53;
1412
+ goto st56;
1213
1413
  } else if ( (*p) > 90 ) {
1214
1414
  if ( 97 <= (*p) && (*p) <= 122 )
1215
- goto st53;
1415
+ goto st56;
1216
1416
  } else
1217
- goto st53;
1218
- goto tr79;
1219
- st54:
1417
+ goto st56;
1418
+ goto tr85;
1419
+ tr84:
1420
+ #line 51 "ext/ragel/base_lexer.rl"
1421
+ {
1422
+ if ( (*p) == '\n' ) lines++;
1423
+ }
1424
+ goto st57;
1425
+ st57:
1220
1426
  if ( ++p == pe )
1221
- goto _test_eof54;
1222
- case 54:
1427
+ goto _test_eof57;
1428
+ case 57:
1429
+ #line 1430 "ext/c/lexer.c"
1223
1430
  if ( (*p) == 62 )
1224
- goto tr81;
1225
- goto tr80;
1226
- tr83:
1227
- ( state->cs) = 55;
1228
- #line 299 "ext/ragel/base_lexer.rl"
1431
+ goto tr88;
1432
+ goto tr87;
1433
+ tr90:
1434
+ ( state->cs) = 58;
1435
+ #line 367 "ext/ragel/base_lexer.rl"
1229
1436
  {te = p;p--;{
1230
1437
  callback(id_on_element_name, data, encoding, ts, te);
1231
- ( state->cs) = 57;
1438
+ ( state->cs) = 63;
1232
1439
  }}
1233
1440
  goto _again;
1234
- tr84:
1235
- #line 295 "ext/ragel/base_lexer.rl"
1441
+ tr91:
1442
+ #line 363 "ext/ragel/base_lexer.rl"
1236
1443
  {te = p+1;{
1237
1444
  callback(id_on_element_ns, data, encoding, ts, te - 1);
1238
1445
  }}
1239
- goto st55;
1240
- st55:
1446
+ goto st58;
1447
+ st58:
1241
1448
  #line 1 "NONE"
1242
1449
  {ts = 0;}
1243
1450
  if ( ++p == pe )
1244
- goto _test_eof55;
1245
- case 55:
1451
+ goto _test_eof58;
1452
+ case 58:
1246
1453
  #line 1 "NONE"
1247
1454
  {ts = p;}
1248
- #line 1249 "ext/c/lexer.c"
1455
+ #line 1456 "ext/c/lexer.c"
1249
1456
  switch( (*p) ) {
1250
- case 45: goto st56;
1251
- case 95: goto st56;
1457
+ case 45: goto st59;
1458
+ case 95: goto st59;
1252
1459
  }
1253
1460
  if ( (*p) < 65 ) {
1254
1461
  if ( 48 <= (*p) && (*p) <= 57 )
1255
- goto st56;
1462
+ goto st59;
1256
1463
  } else if ( (*p) > 90 ) {
1257
1464
  if ( 97 <= (*p) && (*p) <= 122 )
1258
- goto st56;
1465
+ goto st59;
1259
1466
  } else
1260
- goto st56;
1467
+ goto st59;
1261
1468
  goto st0;
1262
- st56:
1469
+ st59:
1470
+ if ( ++p == pe )
1471
+ goto _test_eof59;
1472
+ case 59:
1473
+ switch( (*p) ) {
1474
+ case 45: goto st59;
1475
+ case 58: goto tr91;
1476
+ case 95: goto st59;
1477
+ }
1478
+ if ( (*p) < 65 ) {
1479
+ if ( 48 <= (*p) && (*p) <= 57 )
1480
+ goto st59;
1481
+ } else if ( (*p) > 90 ) {
1482
+ if ( 97 <= (*p) && (*p) <= 122 )
1483
+ goto st59;
1484
+ } else
1485
+ goto st59;
1486
+ goto tr90;
1487
+ tr93:
1488
+ ( state->cs) = 60;
1489
+ #line 373 "ext/ragel/base_lexer.rl"
1490
+ {te = p+1;{
1491
+ p--;
1492
+ ( state->cs) = 63;
1493
+ }}
1494
+ goto _again;
1495
+ tr94:
1496
+ ( state->cs) = 60;
1497
+ #line 387 "ext/ragel/base_lexer.rl"
1498
+ {te = p+1;{
1499
+ p--;
1500
+ ( state->cs) = 62;
1501
+ }}
1502
+ goto _again;
1503
+ tr95:
1504
+ #line 394 "ext/ragel/base_lexer.rl"
1505
+ {te = p;p--;{
1506
+ callback_simple(id_on_string_squote);
1507
+
1508
+ callback(id_on_string_body, data, encoding, ts, te);
1509
+
1510
+ callback_simple(id_on_string_squote);
1511
+ }}
1512
+ goto st60;
1513
+ st60:
1514
+ #line 1 "NONE"
1515
+ {ts = 0;}
1516
+ if ( ++p == pe )
1517
+ goto _test_eof60;
1518
+ case 60:
1519
+ #line 1 "NONE"
1520
+ {ts = p;}
1521
+ #line 1522 "ext/c/lexer.c"
1522
+ switch( (*p) ) {
1523
+ case 13: goto tr93;
1524
+ case 32: goto tr93;
1525
+ case 34: goto tr94;
1526
+ case 39: goto tr94;
1527
+ case 96: goto tr93;
1528
+ }
1529
+ if ( (*p) > 10 ) {
1530
+ if ( 60 <= (*p) && (*p) <= 62 )
1531
+ goto tr93;
1532
+ } else if ( (*p) >= 9 )
1533
+ goto tr93;
1534
+ goto st61;
1535
+ st61:
1536
+ if ( ++p == pe )
1537
+ goto _test_eof61;
1538
+ case 61:
1539
+ switch( (*p) ) {
1540
+ case 13: goto tr95;
1541
+ case 32: goto tr95;
1542
+ case 34: goto tr95;
1543
+ case 39: goto tr95;
1544
+ case 96: goto tr95;
1545
+ }
1546
+ if ( (*p) > 10 ) {
1547
+ if ( 60 <= (*p) && (*p) <= 62 )
1548
+ goto tr95;
1549
+ } else if ( (*p) >= 9 )
1550
+ goto tr95;
1551
+ goto st61;
1552
+ tr96:
1553
+ ( state->cs) = 62;
1554
+ #line 373 "ext/ragel/base_lexer.rl"
1555
+ {te = p+1;{
1556
+ p--;
1557
+ ( state->cs) = 63;
1558
+ }}
1559
+ goto _again;
1560
+ tr97:
1561
+ #line 207 "ext/ragel/base_lexer.rl"
1562
+ {te = p+1;{
1563
+ callback_simple(id_on_string_dquote);
1564
+
1565
+ {( state->stack)[( state->top)++] = 62; goto st39;}
1566
+ }}
1567
+ goto st62;
1568
+ tr98:
1569
+ #line 201 "ext/ragel/base_lexer.rl"
1570
+ {te = p+1;{
1571
+ callback_simple(id_on_string_squote);
1572
+
1573
+ {( state->stack)[( state->top)++] = 62; goto st37;}
1574
+ }}
1575
+ goto st62;
1576
+ st62:
1577
+ #line 1 "NONE"
1578
+ {ts = 0;}
1263
1579
  if ( ++p == pe )
1264
- goto _test_eof56;
1265
- case 56:
1580
+ goto _test_eof62;
1581
+ case 62:
1582
+ #line 1 "NONE"
1583
+ {ts = p;}
1584
+ #line 1585 "ext/c/lexer.c"
1266
1585
  switch( (*p) ) {
1267
- case 45: goto st56;
1268
- case 58: goto tr84;
1269
- case 95: goto st56;
1586
+ case 34: goto tr97;
1587
+ case 39: goto tr98;
1270
1588
  }
1271
- if ( (*p) < 65 ) {
1272
- if ( 48 <= (*p) && (*p) <= 57 )
1273
- goto st56;
1274
- } else if ( (*p) > 90 ) {
1275
- if ( 97 <= (*p) && (*p) <= 122 )
1276
- goto st56;
1277
- } else
1278
- goto st56;
1279
- goto tr83;
1280
- tr29:
1281
- ( state->cs) = 57;
1282
- #line 342 "ext/ragel/base_lexer.rl"
1589
+ goto tr96;
1590
+ tr27:
1591
+ ( state->cs) = 63;
1592
+ #line 457 "ext/ragel/base_lexer.rl"
1283
1593
  {te = p+1;{
1284
1594
  callback_simple(id_on_element_end);
1285
- ( state->cs) = 26;
1595
+ ( state->cs) = 22;
1286
1596
  }}
1287
1597
  goto _again;
1288
- tr85:
1289
- #line 308 "ext/ragel/base_lexer.rl"
1598
+ tr99:
1599
+ #line 415 "ext/ragel/base_lexer.rl"
1290
1600
  {te = p+1;}
1291
- goto st57;
1292
- tr86:
1293
- #line 310 "ext/ragel/base_lexer.rl"
1601
+ goto st63;
1602
+ tr100:
1603
+ #line 417 "ext/ragel/base_lexer.rl"
1294
1604
  {te = p+1;{
1295
1605
  callback_simple(id_advance_line);
1296
1606
  }}
1297
- goto st57;
1298
- tr88:
1299
- #line 154 "ext/ragel/base_lexer.rl"
1300
- {te = p+1;{
1301
- callback_simple(id_on_string_dquote);
1302
-
1303
- {( state->stack)[( state->top)++] = 57; goto st36;}
1304
- }}
1305
- goto st57;
1306
- tr89:
1307
- #line 148 "ext/ragel/base_lexer.rl"
1607
+ goto st63;
1608
+ tr104:
1609
+ ( state->cs) = 63;
1610
+ #line 431 "ext/ragel/base_lexer.rl"
1308
1611
  {te = p+1;{
1309
- callback_simple(id_on_string_squote);
1310
-
1311
- {( state->stack)[( state->top)++] = 57; goto st34;}
1312
- }}
1313
- goto st57;
1314
- tr92:
1315
- ( state->cs) = 57;
1316
- #line 328 "ext/ragel/base_lexer.rl"
1612
+ if ( html_p )
1613
+ {
1614
+ ( state->cs) = 60;
1615
+ }
1616
+ else
1617
+ {
1618
+ ( state->cs) = 62;
1619
+ }
1620
+ }}
1621
+ goto _again;
1622
+ tr105:
1623
+ ( state->cs) = 63;
1624
+ #line 443 "ext/ragel/base_lexer.rl"
1317
1625
  {te = p+1;{
1318
1626
  callback_simple(id_on_element_open_end);
1319
1627
 
1320
1628
  if ( literal_html_element_p() )
1321
1629
  {
1322
- ( state->cs) = 64;
1630
+ ( state->cs) = 70;
1323
1631
  }
1324
1632
  else
1325
1633
  {
1326
- ( state->cs) = 26;
1634
+ ( state->cs) = 22;
1327
1635
  }
1328
1636
  }}
1329
1637
  goto _again;
1330
- tr93:
1331
- #line 310 "ext/ragel/base_lexer.rl"
1638
+ tr106:
1639
+ #line 417 "ext/ragel/base_lexer.rl"
1332
1640
  {te = p;p--;{
1333
1641
  callback_simple(id_advance_line);
1334
1642
  }}
1335
- goto st57;
1336
- tr94:
1337
- #line 319 "ext/ragel/base_lexer.rl"
1643
+ goto st63;
1644
+ tr107:
1645
+ #line 426 "ext/ragel/base_lexer.rl"
1338
1646
  {te = p;p--;{
1339
1647
  callback(id_on_attribute, data, encoding, ts, te);
1340
1648
  }}
1341
- goto st57;
1342
- tr95:
1343
- #line 315 "ext/ragel/base_lexer.rl"
1649
+ goto st63;
1650
+ tr108:
1651
+ #line 422 "ext/ragel/base_lexer.rl"
1344
1652
  {te = p+1;{
1345
1653
  callback(id_on_attribute_ns, data, encoding, ts, te - 1);
1346
1654
  }}
1347
- goto st57;
1348
- st57:
1655
+ goto st63;
1656
+ st63:
1349
1657
  #line 1 "NONE"
1350
1658
  {ts = 0;}
1351
1659
  if ( ++p == pe )
1352
- goto _test_eof57;
1353
- case 57:
1660
+ goto _test_eof63;
1661
+ case 63:
1354
1662
  #line 1 "NONE"
1355
1663
  {ts = p;}
1356
- #line 1357 "ext/c/lexer.c"
1664
+ #line 1665 "ext/c/lexer.c"
1357
1665
  switch( (*p) ) {
1358
- case 9: goto tr85;
1359
- case 10: goto tr86;
1360
- case 13: goto st58;
1361
- case 32: goto tr85;
1362
- case 34: goto tr88;
1363
- case 39: goto tr89;
1364
- case 45: goto st59;
1365
- case 47: goto st25;
1366
- case 61: goto tr85;
1367
- case 62: goto tr92;
1368
- case 95: goto st59;
1666
+ case 9: goto tr99;
1667
+ case 10: goto tr100;
1668
+ case 13: goto st64;
1669
+ case 32: goto tr99;
1670
+ case 45: goto st65;
1671
+ case 47: goto st21;
1672
+ case 61: goto tr104;
1673
+ case 62: goto tr105;
1674
+ case 95: goto st65;
1369
1675
  }
1370
1676
  if ( (*p) < 65 ) {
1371
1677
  if ( 48 <= (*p) && (*p) <= 57 )
1372
- goto st59;
1678
+ goto st65;
1373
1679
  } else if ( (*p) > 90 ) {
1374
1680
  if ( 97 <= (*p) && (*p) <= 122 )
1375
- goto st59;
1681
+ goto st65;
1376
1682
  } else
1377
- goto st59;
1683
+ goto st65;
1378
1684
  goto st0;
1379
- st58:
1685
+ st64:
1380
1686
  if ( ++p == pe )
1381
- goto _test_eof58;
1382
- case 58:
1687
+ goto _test_eof64;
1688
+ case 64:
1383
1689
  if ( (*p) == 10 )
1384
- goto tr86;
1385
- goto tr93;
1386
- st59:
1690
+ goto tr100;
1691
+ goto tr106;
1692
+ st65:
1387
1693
  if ( ++p == pe )
1388
- goto _test_eof59;
1389
- case 59:
1694
+ goto _test_eof65;
1695
+ case 65:
1390
1696
  switch( (*p) ) {
1391
- case 45: goto st59;
1392
- case 58: goto tr95;
1393
- case 95: goto st59;
1697
+ case 45: goto st65;
1698
+ case 58: goto tr108;
1699
+ case 95: goto st65;
1394
1700
  }
1395
1701
  if ( (*p) < 65 ) {
1396
1702
  if ( 48 <= (*p) && (*p) <= 57 )
1397
- goto st59;
1703
+ goto st65;
1398
1704
  } else if ( (*p) > 90 ) {
1399
1705
  if ( 97 <= (*p) && (*p) <= 122 )
1400
- goto st59;
1706
+ goto st65;
1401
1707
  } else
1402
- goto st59;
1403
- goto tr94;
1404
- st25:
1708
+ goto st65;
1709
+ goto tr107;
1710
+ st21:
1405
1711
  if ( ++p == pe )
1406
- goto _test_eof25;
1407
- case 25:
1712
+ goto _test_eof21;
1713
+ case 21:
1408
1714
  if ( (*p) == 62 )
1409
- goto tr29;
1715
+ goto tr27;
1410
1716
  goto st0;
1411
- tr98:
1412
- ( state->cs) = 60;
1413
- #line 371 "ext/ragel/base_lexer.rl"
1717
+ tr111:
1718
+ ( state->cs) = 66;
1719
+ #line 486 "ext/ragel/base_lexer.rl"
1414
1720
  {te = p;p--;{
1415
1721
  callback(id_on_text, data, encoding, ts, te);
1416
1722
 
@@ -1421,12 +1727,12 @@ tr98:
1421
1727
  lines = 0;
1422
1728
  }
1423
1729
 
1424
- ( state->cs) = 26;
1730
+ ( state->cs) = 22;
1425
1731
  }}
1426
1732
  goto _again;
1427
- tr100:
1428
- ( state->cs) = 60;
1429
- #line 385 "ext/ragel/base_lexer.rl"
1733
+ tr113:
1734
+ ( state->cs) = 66;
1735
+ #line 500 "ext/ragel/base_lexer.rl"
1430
1736
  {te = p+1;{
1431
1737
  callback(id_on_text, data, encoding, ts, mark);
1432
1738
 
@@ -1440,12 +1746,12 @@ tr100:
1440
1746
  lines = 0;
1441
1747
  }
1442
1748
 
1443
- ( state->cs) = 26;
1749
+ ( state->cs) = 22;
1444
1750
  }}
1445
1751
  goto _again;
1446
- tr101:
1447
- ( state->cs) = 60;
1448
- #line 371 "ext/ragel/base_lexer.rl"
1752
+ tr114:
1753
+ ( state->cs) = 66;
1754
+ #line 486 "ext/ragel/base_lexer.rl"
1449
1755
  {te = p+1;{
1450
1756
  callback(id_on_text, data, encoding, ts, te);
1451
1757
 
@@ -1456,100 +1762,100 @@ tr101:
1456
1762
  lines = 0;
1457
1763
  }
1458
1764
 
1459
- ( state->cs) = 26;
1765
+ ( state->cs) = 22;
1460
1766
  }}
1461
1767
  goto _again;
1462
- st60:
1768
+ st66:
1463
1769
  #line 1 "NONE"
1464
1770
  {ts = 0;}
1465
1771
  if ( ++p == pe )
1466
- goto _test_eof60;
1467
- case 60:
1772
+ goto _test_eof66;
1773
+ case 66:
1468
1774
  #line 1 "NONE"
1469
1775
  {ts = p;}
1470
- #line 1471 "ext/c/lexer.c"
1776
+ #line 1777 "ext/c/lexer.c"
1471
1777
  if ( (*p) == 60 )
1472
- goto tr97;
1473
- goto tr96;
1474
- tr96:
1778
+ goto tr110;
1779
+ goto tr109;
1780
+ tr109:
1475
1781
  #line 51 "ext/ragel/base_lexer.rl"
1476
1782
  {
1477
1783
  if ( (*p) == '\n' ) lines++;
1478
1784
  }
1479
- goto st61;
1480
- st61:
1785
+ goto st67;
1786
+ st67:
1481
1787
  if ( ++p == pe )
1482
- goto _test_eof61;
1483
- case 61:
1484
- #line 1485 "ext/c/lexer.c"
1788
+ goto _test_eof67;
1789
+ case 67:
1790
+ #line 1791 "ext/c/lexer.c"
1485
1791
  if ( (*p) == 60 )
1486
- goto tr99;
1487
- goto tr96;
1488
- tr99:
1792
+ goto tr112;
1793
+ goto tr109;
1794
+ tr112:
1489
1795
  #line 51 "ext/ragel/base_lexer.rl"
1490
1796
  {
1491
1797
  if ( (*p) == '\n' ) lines++;
1492
1798
  }
1493
- #line 385 "ext/ragel/base_lexer.rl"
1799
+ #line 500 "ext/ragel/base_lexer.rl"
1494
1800
  { mark = p; }
1495
- goto st62;
1496
- st62:
1801
+ goto st68;
1802
+ st68:
1497
1803
  if ( ++p == pe )
1498
- goto _test_eof62;
1499
- case 62:
1500
- #line 1501 "ext/c/lexer.c"
1804
+ goto _test_eof68;
1805
+ case 68:
1806
+ #line 1807 "ext/c/lexer.c"
1501
1807
  switch( (*p) ) {
1502
- case 33: goto tr100;
1503
- case 45: goto tr100;
1504
- case 60: goto tr99;
1505
- case 63: goto tr100;
1506
- case 95: goto tr100;
1808
+ case 33: goto tr113;
1809
+ case 45: goto tr113;
1810
+ case 60: goto tr112;
1811
+ case 63: goto tr113;
1812
+ case 95: goto tr113;
1507
1813
  }
1508
1814
  if ( (*p) < 65 ) {
1509
1815
  if ( 47 <= (*p) && (*p) <= 57 )
1510
- goto tr100;
1816
+ goto tr113;
1511
1817
  } else if ( (*p) > 90 ) {
1512
1818
  if ( 97 <= (*p) && (*p) <= 122 )
1513
- goto tr100;
1819
+ goto tr113;
1514
1820
  } else
1515
- goto tr100;
1516
- goto tr96;
1517
- tr97:
1821
+ goto tr113;
1822
+ goto tr109;
1823
+ tr110:
1518
1824
  #line 51 "ext/ragel/base_lexer.rl"
1519
1825
  {
1520
1826
  if ( (*p) == '\n' ) lines++;
1521
1827
  }
1522
- #line 385 "ext/ragel/base_lexer.rl"
1828
+ #line 500 "ext/ragel/base_lexer.rl"
1523
1829
  { mark = p; }
1524
- goto st63;
1525
- st63:
1830
+ goto st69;
1831
+ st69:
1526
1832
  if ( ++p == pe )
1527
- goto _test_eof63;
1528
- case 63:
1529
- #line 1530 "ext/c/lexer.c"
1833
+ goto _test_eof69;
1834
+ case 69:
1835
+ #line 1836 "ext/c/lexer.c"
1530
1836
  switch( (*p) ) {
1531
- case 33: goto tr101;
1532
- case 45: goto tr101;
1533
- case 60: goto tr99;
1534
- case 63: goto tr101;
1535
- case 95: goto tr101;
1837
+ case 33: goto tr114;
1838
+ case 45: goto tr114;
1839
+ case 60: goto tr112;
1840
+ case 63: goto tr114;
1841
+ case 95: goto tr114;
1536
1842
  }
1537
1843
  if ( (*p) < 65 ) {
1538
1844
  if ( 47 <= (*p) && (*p) <= 57 )
1539
- goto tr101;
1845
+ goto tr114;
1540
1846
  } else if ( (*p) > 90 ) {
1541
1847
  if ( 97 <= (*p) && (*p) <= 122 )
1542
- goto tr101;
1848
+ goto tr114;
1543
1849
  } else
1544
- goto tr101;
1545
- goto tr96;
1546
- tr104:
1850
+ goto tr114;
1851
+ goto tr109;
1852
+ tr117:
1547
1853
  #line 1 "NONE"
1548
1854
  { switch( ( state->act) ) {
1549
1855
  case 0:
1550
1856
  {{goto st0;}}
1551
1857
  break;
1552
- case 33:
1858
+ case 42:
1553
1859
  {{p = ((te))-1;}
1554
1860
  callback(id_on_text, data, encoding, ts, te);
1555
1861
 
@@ -1563,9 +1869,9 @@ tr104:
1563
1869
  break;
1564
1870
  }
1565
1871
  }
1566
- goto st64;
1567
- tr105:
1568
- #line 409 "ext/ragel/base_lexer.rl"
1872
+ goto st70;
1873
+ tr118:
1874
+ #line 524 "ext/ragel/base_lexer.rl"
1569
1875
  {te = p;p--;{
1570
1876
  callback(id_on_text, data, encoding, ts, te);
1571
1877
 
@@ -1576,10 +1882,10 @@ tr105:
1576
1882
  lines = 0;
1577
1883
  }
1578
1884
  }}
1579
- goto st64;
1580
- tr114:
1581
- ( state->cs) = 64;
1582
- #line 420 "ext/ragel/base_lexer.rl"
1885
+ goto st70;
1886
+ tr127:
1887
+ ( state->cs) = 70;
1888
+ #line 535 "ext/ragel/base_lexer.rl"
1583
1889
  {te = p+1;{
1584
1890
  callback(id_on_text, data, encoding, ts, mark);
1585
1891
 
@@ -1593,223 +1899,223 @@ tr114:
1593
1899
  lines = 0;
1594
1900
  }
1595
1901
 
1596
- ( state->cs) = 26;
1902
+ ( state->cs) = 22;
1597
1903
  }}
1598
1904
  goto _again;
1599
- st64:
1905
+ st70:
1600
1906
  #line 1 "NONE"
1601
1907
  {ts = 0;}
1602
1908
  #line 1 "NONE"
1603
1909
  {( state->act) = 0;}
1604
1910
  if ( ++p == pe )
1605
- goto _test_eof64;
1606
- case 64:
1911
+ goto _test_eof70;
1912
+ case 70:
1607
1913
  #line 1 "NONE"
1608
1914
  {ts = p;}
1609
- #line 1610 "ext/c/lexer.c"
1915
+ #line 1916 "ext/c/lexer.c"
1610
1916
  if ( (*p) == 60 )
1611
- goto tr103;
1612
- goto tr102;
1613
- tr102:
1917
+ goto tr116;
1918
+ goto tr115;
1919
+ tr115:
1614
1920
  #line 1 "NONE"
1615
1921
  {te = p+1;}
1616
1922
  #line 51 "ext/ragel/base_lexer.rl"
1617
1923
  {
1618
1924
  if ( (*p) == '\n' ) lines++;
1619
1925
  }
1620
- #line 409 "ext/ragel/base_lexer.rl"
1621
- {( state->act) = 33;}
1622
- goto st65;
1623
- st65:
1926
+ #line 524 "ext/ragel/base_lexer.rl"
1927
+ {( state->act) = 42;}
1928
+ goto st71;
1929
+ st71:
1624
1930
  if ( ++p == pe )
1625
- goto _test_eof65;
1626
- case 65:
1627
- #line 1628 "ext/c/lexer.c"
1931
+ goto _test_eof71;
1932
+ case 71:
1933
+ #line 1934 "ext/c/lexer.c"
1628
1934
  if ( (*p) == 60 )
1629
- goto tr103;
1630
- goto tr102;
1631
- tr103:
1935
+ goto tr116;
1936
+ goto tr115;
1937
+ tr116:
1632
1938
  #line 51 "ext/ragel/base_lexer.rl"
1633
1939
  {
1634
1940
  if ( (*p) == '\n' ) lines++;
1635
1941
  }
1636
- #line 420 "ext/ragel/base_lexer.rl"
1942
+ #line 535 "ext/ragel/base_lexer.rl"
1637
1943
  { mark = p; }
1638
- goto st66;
1639
- st66:
1944
+ goto st72;
1945
+ st72:
1640
1946
  if ( ++p == pe )
1641
- goto _test_eof66;
1642
- case 66:
1643
- #line 1644 "ext/c/lexer.c"
1947
+ goto _test_eof72;
1948
+ case 72:
1949
+ #line 1950 "ext/c/lexer.c"
1644
1950
  switch( (*p) ) {
1645
- case 47: goto tr106;
1646
- case 60: goto tr103;
1951
+ case 47: goto tr119;
1952
+ case 60: goto tr116;
1647
1953
  }
1648
- goto tr102;
1649
- tr106:
1954
+ goto tr115;
1955
+ tr119:
1650
1956
  #line 51 "ext/ragel/base_lexer.rl"
1651
1957
  {
1652
1958
  if ( (*p) == '\n' ) lines++;
1653
1959
  }
1654
- goto st67;
1655
- st67:
1960
+ goto st73;
1961
+ st73:
1656
1962
  if ( ++p == pe )
1657
- goto _test_eof67;
1658
- case 67:
1659
- #line 1660 "ext/c/lexer.c"
1963
+ goto _test_eof73;
1964
+ case 73:
1965
+ #line 1966 "ext/c/lexer.c"
1660
1966
  switch( (*p) ) {
1661
- case 60: goto tr103;
1662
- case 115: goto tr107;
1967
+ case 60: goto tr116;
1968
+ case 115: goto tr120;
1663
1969
  }
1664
- goto tr102;
1665
- tr107:
1970
+ goto tr115;
1971
+ tr120:
1666
1972
  #line 51 "ext/ragel/base_lexer.rl"
1667
1973
  {
1668
1974
  if ( (*p) == '\n' ) lines++;
1669
1975
  }
1670
- goto st68;
1671
- st68:
1976
+ goto st74;
1977
+ st74:
1672
1978
  if ( ++p == pe )
1673
- goto _test_eof68;
1674
- case 68:
1675
- #line 1676 "ext/c/lexer.c"
1979
+ goto _test_eof74;
1980
+ case 74:
1981
+ #line 1982 "ext/c/lexer.c"
1676
1982
  switch( (*p) ) {
1677
- case 60: goto tr103;
1678
- case 99: goto tr108;
1679
- case 116: goto tr109;
1983
+ case 60: goto tr116;
1984
+ case 99: goto tr121;
1985
+ case 116: goto tr122;
1680
1986
  }
1681
- goto tr102;
1682
- tr108:
1987
+ goto tr115;
1988
+ tr121:
1683
1989
  #line 51 "ext/ragel/base_lexer.rl"
1684
1990
  {
1685
1991
  if ( (*p) == '\n' ) lines++;
1686
1992
  }
1687
- goto st69;
1688
- st69:
1993
+ goto st75;
1994
+ st75:
1689
1995
  if ( ++p == pe )
1690
- goto _test_eof69;
1691
- case 69:
1692
- #line 1693 "ext/c/lexer.c"
1996
+ goto _test_eof75;
1997
+ case 75:
1998
+ #line 1999 "ext/c/lexer.c"
1693
1999
  switch( (*p) ) {
1694
- case 60: goto tr103;
1695
- case 114: goto tr110;
2000
+ case 60: goto tr116;
2001
+ case 114: goto tr123;
1696
2002
  }
1697
- goto tr102;
1698
- tr110:
2003
+ goto tr115;
2004
+ tr123:
1699
2005
  #line 51 "ext/ragel/base_lexer.rl"
1700
2006
  {
1701
2007
  if ( (*p) == '\n' ) lines++;
1702
2008
  }
1703
- goto st70;
1704
- st70:
2009
+ goto st76;
2010
+ st76:
1705
2011
  if ( ++p == pe )
1706
- goto _test_eof70;
1707
- case 70:
1708
- #line 1709 "ext/c/lexer.c"
2012
+ goto _test_eof76;
2013
+ case 76:
2014
+ #line 2015 "ext/c/lexer.c"
1709
2015
  switch( (*p) ) {
1710
- case 60: goto tr103;
1711
- case 105: goto tr111;
2016
+ case 60: goto tr116;
2017
+ case 105: goto tr124;
1712
2018
  }
1713
- goto tr102;
1714
- tr111:
2019
+ goto tr115;
2020
+ tr124:
1715
2021
  #line 51 "ext/ragel/base_lexer.rl"
1716
2022
  {
1717
2023
  if ( (*p) == '\n' ) lines++;
1718
2024
  }
1719
- goto st71;
1720
- st71:
2025
+ goto st77;
2026
+ st77:
1721
2027
  if ( ++p == pe )
1722
- goto _test_eof71;
1723
- case 71:
1724
- #line 1725 "ext/c/lexer.c"
2028
+ goto _test_eof77;
2029
+ case 77:
2030
+ #line 2031 "ext/c/lexer.c"
1725
2031
  switch( (*p) ) {
1726
- case 60: goto tr103;
1727
- case 112: goto tr112;
2032
+ case 60: goto tr116;
2033
+ case 112: goto tr125;
1728
2034
  }
1729
- goto tr102;
1730
- tr112:
2035
+ goto tr115;
2036
+ tr125:
1731
2037
  #line 51 "ext/ragel/base_lexer.rl"
1732
2038
  {
1733
2039
  if ( (*p) == '\n' ) lines++;
1734
2040
  }
1735
- goto st72;
1736
- st72:
2041
+ goto st78;
2042
+ st78:
1737
2043
  if ( ++p == pe )
1738
- goto _test_eof72;
1739
- case 72:
1740
- #line 1741 "ext/c/lexer.c"
2044
+ goto _test_eof78;
2045
+ case 78:
2046
+ #line 2047 "ext/c/lexer.c"
1741
2047
  switch( (*p) ) {
1742
- case 60: goto tr103;
1743
- case 116: goto tr113;
2048
+ case 60: goto tr116;
2049
+ case 116: goto tr126;
1744
2050
  }
1745
- goto tr102;
1746
- tr113:
2051
+ goto tr115;
2052
+ tr126:
1747
2053
  #line 51 "ext/ragel/base_lexer.rl"
1748
2054
  {
1749
2055
  if ( (*p) == '\n' ) lines++;
1750
2056
  }
1751
- goto st73;
1752
- st73:
2057
+ goto st79;
2058
+ st79:
1753
2059
  if ( ++p == pe )
1754
- goto _test_eof73;
1755
- case 73:
1756
- #line 1757 "ext/c/lexer.c"
2060
+ goto _test_eof79;
2061
+ case 79:
2062
+ #line 2063 "ext/c/lexer.c"
1757
2063
  switch( (*p) ) {
1758
- case 60: goto tr103;
1759
- case 62: goto tr114;
2064
+ case 60: goto tr116;
2065
+ case 62: goto tr127;
1760
2066
  }
1761
- goto tr102;
1762
- tr109:
2067
+ goto tr115;
2068
+ tr122:
1763
2069
  #line 51 "ext/ragel/base_lexer.rl"
1764
2070
  {
1765
2071
  if ( (*p) == '\n' ) lines++;
1766
2072
  }
1767
- goto st74;
1768
- st74:
2073
+ goto st80;
2074
+ st80:
1769
2075
  if ( ++p == pe )
1770
- goto _test_eof74;
1771
- case 74:
1772
- #line 1773 "ext/c/lexer.c"
2076
+ goto _test_eof80;
2077
+ case 80:
2078
+ #line 2079 "ext/c/lexer.c"
1773
2079
  switch( (*p) ) {
1774
- case 60: goto tr103;
1775
- case 121: goto tr115;
2080
+ case 60: goto tr116;
2081
+ case 121: goto tr128;
1776
2082
  }
1777
- goto tr102;
1778
- tr115:
2083
+ goto tr115;
2084
+ tr128:
1779
2085
  #line 51 "ext/ragel/base_lexer.rl"
1780
2086
  {
1781
2087
  if ( (*p) == '\n' ) lines++;
1782
2088
  }
1783
- goto st75;
1784
- st75:
2089
+ goto st81;
2090
+ st81:
1785
2091
  if ( ++p == pe )
1786
- goto _test_eof75;
1787
- case 75:
1788
- #line 1789 "ext/c/lexer.c"
2092
+ goto _test_eof81;
2093
+ case 81:
2094
+ #line 2095 "ext/c/lexer.c"
1789
2095
  switch( (*p) ) {
1790
- case 60: goto tr103;
1791
- case 108: goto tr116;
2096
+ case 60: goto tr116;
2097
+ case 108: goto tr129;
1792
2098
  }
1793
- goto tr102;
1794
- tr116:
2099
+ goto tr115;
2100
+ tr129:
1795
2101
  #line 51 "ext/ragel/base_lexer.rl"
1796
2102
  {
1797
2103
  if ( (*p) == '\n' ) lines++;
1798
2104
  }
1799
- goto st76;
1800
- st76:
2105
+ goto st82;
2106
+ st82:
1801
2107
  if ( ++p == pe )
1802
- goto _test_eof76;
1803
- case 76:
1804
- #line 1805 "ext/c/lexer.c"
2108
+ goto _test_eof82;
2109
+ case 82:
2110
+ #line 2111 "ext/c/lexer.c"
1805
2111
  switch( (*p) ) {
1806
- case 60: goto tr103;
1807
- case 101: goto tr113;
2112
+ case 60: goto tr116;
2113
+ case 101: goto tr126;
1808
2114
  }
1809
- goto tr102;
2115
+ goto tr115;
1810
2116
  }
1811
- _test_eof26: ( state->cs) = 26; goto _test_eof;
1812
- _test_eof27: ( state->cs) = 27; goto _test_eof;
2117
+ _test_eof22: ( state->cs) = 22; goto _test_eof;
2118
+ _test_eof23: ( state->cs) = 23; goto _test_eof;
1813
2119
  _test_eof1: ( state->cs) = 1; goto _test_eof;
1814
2120
  _test_eof2: ( state->cs) = 2; goto _test_eof;
1815
2121
  _test_eof3: ( state->cs) = 3; goto _test_eof;
@@ -1819,27 +2125,27 @@ case 76:
1819
2125
  _test_eof7: ( state->cs) = 7; goto _test_eof;
1820
2126
  _test_eof8: ( state->cs) = 8; goto _test_eof;
1821
2127
  _test_eof9: ( state->cs) = 9; goto _test_eof;
2128
+ _test_eof24: ( state->cs) = 24; goto _test_eof;
1822
2129
  _test_eof10: ( state->cs) = 10; goto _test_eof;
1823
2130
  _test_eof11: ( state->cs) = 11; goto _test_eof;
1824
2131
  _test_eof12: ( state->cs) = 12; goto _test_eof;
1825
- _test_eof28: ( state->cs) = 28; goto _test_eof;
1826
2132
  _test_eof13: ( state->cs) = 13; goto _test_eof;
1827
2133
  _test_eof14: ( state->cs) = 14; goto _test_eof;
1828
2134
  _test_eof15: ( state->cs) = 15; goto _test_eof;
1829
2135
  _test_eof16: ( state->cs) = 16; goto _test_eof;
1830
2136
  _test_eof17: ( state->cs) = 17; goto _test_eof;
1831
2137
  _test_eof18: ( state->cs) = 18; goto _test_eof;
1832
- _test_eof19: ( state->cs) = 19; goto _test_eof;
1833
- _test_eof20: ( state->cs) = 20; goto _test_eof;
1834
- _test_eof21: ( state->cs) = 21; goto _test_eof;
1835
- _test_eof22: ( state->cs) = 22; goto _test_eof;
1836
- _test_eof23: ( state->cs) = 23; goto _test_eof;
1837
- _test_eof24: ( state->cs) = 24; goto _test_eof;
2138
+ _test_eof25: ( state->cs) = 25; goto _test_eof;
2139
+ _test_eof26: ( state->cs) = 26; goto _test_eof;
2140
+ _test_eof27: ( state->cs) = 27; goto _test_eof;
2141
+ _test_eof28: ( state->cs) = 28; goto _test_eof;
1838
2142
  _test_eof29: ( state->cs) = 29; goto _test_eof;
1839
2143
  _test_eof30: ( state->cs) = 30; goto _test_eof;
2144
+ _test_eof19: ( state->cs) = 19; goto _test_eof;
1840
2145
  _test_eof31: ( state->cs) = 31; goto _test_eof;
1841
2146
  _test_eof32: ( state->cs) = 32; goto _test_eof;
1842
2147
  _test_eof33: ( state->cs) = 33; goto _test_eof;
2148
+ _test_eof20: ( state->cs) = 20; goto _test_eof;
1843
2149
  _test_eof34: ( state->cs) = 34; goto _test_eof;
1844
2150
  _test_eof35: ( state->cs) = 35; goto _test_eof;
1845
2151
  _test_eof36: ( state->cs) = 36; goto _test_eof;
@@ -1866,13 +2172,13 @@ case 76:
1866
2172
  _test_eof57: ( state->cs) = 57; goto _test_eof;
1867
2173
  _test_eof58: ( state->cs) = 58; goto _test_eof;
1868
2174
  _test_eof59: ( state->cs) = 59; goto _test_eof;
1869
- _test_eof25: ( state->cs) = 25; goto _test_eof;
1870
2175
  _test_eof60: ( state->cs) = 60; goto _test_eof;
1871
2176
  _test_eof61: ( state->cs) = 61; goto _test_eof;
1872
2177
  _test_eof62: ( state->cs) = 62; goto _test_eof;
1873
2178
  _test_eof63: ( state->cs) = 63; goto _test_eof;
1874
2179
  _test_eof64: ( state->cs) = 64; goto _test_eof;
1875
2180
  _test_eof65: ( state->cs) = 65; goto _test_eof;
2181
+ _test_eof21: ( state->cs) = 21; goto _test_eof;
1876
2182
  _test_eof66: ( state->cs) = 66; goto _test_eof;
1877
2183
  _test_eof67: ( state->cs) = 67; goto _test_eof;
1878
2184
  _test_eof68: ( state->cs) = 68; goto _test_eof;
@@ -1884,12 +2190,18 @@ case 76:
1884
2190
  _test_eof74: ( state->cs) = 74; goto _test_eof;
1885
2191
  _test_eof75: ( state->cs) = 75; goto _test_eof;
1886
2192
  _test_eof76: ( state->cs) = 76; goto _test_eof;
2193
+ _test_eof77: ( state->cs) = 77; goto _test_eof;
2194
+ _test_eof78: ( state->cs) = 78; goto _test_eof;
2195
+ _test_eof79: ( state->cs) = 79; goto _test_eof;
2196
+ _test_eof80: ( state->cs) = 80; goto _test_eof;
2197
+ _test_eof81: ( state->cs) = 81; goto _test_eof;
2198
+ _test_eof82: ( state->cs) = 82; goto _test_eof;
1887
2199
 
1888
2200
  _test_eof: {}
1889
2201
  if ( p == eof )
1890
2202
  {
1891
2203
  switch ( ( state->cs) ) {
1892
- case 27: goto tr33;
2204
+ case 23: goto tr31;
1893
2205
  case 1: goto tr0;
1894
2206
  case 2: goto tr0;
1895
2207
  case 3: goto tr0;
@@ -1899,67 +2211,69 @@ case 76:
1899
2211
  case 7: goto tr0;
1900
2212
  case 8: goto tr0;
1901
2213
  case 9: goto tr0;
2214
+ case 24: goto tr35;
1902
2215
  case 10: goto tr0;
1903
2216
  case 11: goto tr0;
1904
2217
  case 12: goto tr0;
1905
- case 28: goto tr37;
1906
2218
  case 13: goto tr0;
1907
2219
  case 14: goto tr0;
1908
2220
  case 15: goto tr0;
1909
2221
  case 16: goto tr0;
1910
2222
  case 17: goto tr0;
1911
2223
  case 18: goto tr0;
1912
- case 19: goto tr0;
1913
- case 20: goto tr0;
1914
- case 21: goto tr0;
1915
- case 22: goto tr0;
1916
- case 23: goto tr0;
1917
- case 24: goto tr0;
1918
- case 29: goto tr38;
1919
- case 30: goto tr39;
1920
- case 31: goto tr39;
1921
- case 33: goto tr44;
1922
- case 35: goto tr48;
1923
- case 37: goto tr51;
1924
- case 39: goto tr54;
1925
- case 41: goto tr63;
1926
- case 42: goto tr64;
1927
- case 43: goto tr64;
1928
- case 44: goto tr64;
1929
- case 45: goto tr64;
1930
- case 46: goto tr64;
1931
- case 47: goto tr64;
1932
- case 48: goto tr64;
1933
- case 49: goto tr64;
1934
- case 50: goto tr64;
1935
- case 51: goto tr64;
1936
- case 53: goto tr79;
1937
- case 54: goto tr80;
1938
- case 56: goto tr83;
1939
- case 58: goto tr93;
1940
- case 59: goto tr94;
1941
- case 61: goto tr98;
1942
- case 62: goto tr98;
1943
- case 63: goto tr98;
1944
- case 65: goto tr104;
1945
- case 66: goto tr105;
1946
- case 67: goto tr105;
1947
- case 68: goto tr105;
1948
- case 69: goto tr105;
1949
- case 70: goto tr105;
1950
- case 71: goto tr105;
1951
- case 72: goto tr105;
1952
- case 73: goto tr105;
1953
- case 74: goto tr105;
1954
- case 75: goto tr105;
1955
- case 76: goto tr105;
2224
+ case 25: goto tr36;
2225
+ case 26: goto tr37;
2226
+ case 27: goto tr37;
2227
+ case 29: goto tr42;
2228
+ case 30: goto tr42;
2229
+ case 19: goto tr23;
2230
+ case 32: goto tr46;
2231
+ case 33: goto tr46;
2232
+ case 20: goto tr25;
2233
+ case 35: goto tr50;
2234
+ case 36: goto tr50;
2235
+ case 38: goto tr54;
2236
+ case 40: goto tr57;
2237
+ case 42: goto tr60;
2238
+ case 44: goto tr69;
2239
+ case 45: goto tr70;
2240
+ case 46: goto tr70;
2241
+ case 47: goto tr70;
2242
+ case 48: goto tr70;
2243
+ case 49: goto tr70;
2244
+ case 50: goto tr70;
2245
+ case 51: goto tr70;
2246
+ case 52: goto tr70;
2247
+ case 53: goto tr70;
2248
+ case 54: goto tr70;
2249
+ case 56: goto tr85;
2250
+ case 57: goto tr87;
2251
+ case 59: goto tr90;
2252
+ case 61: goto tr95;
2253
+ case 64: goto tr106;
2254
+ case 65: goto tr107;
2255
+ case 67: goto tr111;
2256
+ case 68: goto tr111;
2257
+ case 69: goto tr111;
2258
+ case 71: goto tr117;
2259
+ case 72: goto tr118;
2260
+ case 73: goto tr118;
2261
+ case 74: goto tr118;
2262
+ case 75: goto tr118;
2263
+ case 76: goto tr118;
2264
+ case 77: goto tr118;
2265
+ case 78: goto tr118;
2266
+ case 79: goto tr118;
2267
+ case 80: goto tr118;
2268
+ case 81: goto tr118;
2269
+ case 82: goto tr118;
1956
2270
  }
1957
2271
  }
1958
2272
 
1959
2273
  _out: {}
1960
2274
  }
1961
2275
 
1962
- #line 120 "ext/c/lexer.rl"
2276
+ #line 129 "ext/c/lexer.rl"
1963
2277
 
1964
2278
  state->lines = lines;
1965
2279
 
@@ -2003,7 +2317,7 @@ VALUE oga_xml_lexer_allocate(VALUE klass)
2003
2317
  }
2004
2318
 
2005
2319
 
2006
- #line 169 "ext/c/lexer.rl"
2320
+ #line 178 "ext/c/lexer.rl"
2007
2321
 
2008
2322
 
2009
2323
  void Init_liboga_xml_lexer()
@@ -2014,6 +2328,7 @@ void Init_liboga_xml_lexer()
2014
2328
 
2015
2329
  id_advance_line = rb_intern("advance_line");
2016
2330
  id_literal_html_element_p = rb_intern("literal_html_element?");
2331
+ id_html = rb_intern("html");
2017
2332
 
2018
2333
  rb_define_method(cLexer, "advance_native", oga_xml_lexer_advance, 1);
2019
2334
  rb_define_method(cLexer, "reset_native", oga_xml_lexer_reset, 0);