oga 0.1.3 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +57 -0
- data/doc/changelog.md +128 -0
- data/doc/css/common.css +5 -4
- data/doc/css_selectors.md +935 -0
- data/doc/manually_creating_documents.md +67 -0
- data/doc/xml_namespaces.md +63 -0
- data/ext/c/lexer.c +745 -628
- data/ext/c/lexer.h +8 -0
- data/ext/c/lexer.rl +44 -7
- data/ext/java/org/liboga/xml/Lexer.java +351 -232
- data/ext/java/org/liboga/xml/Lexer.rl +29 -8
- data/ext/ragel/base_lexer.rl +68 -18
- data/lib/oga.rb +4 -1
- data/lib/oga/css/lexer.rb +743 -0
- data/lib/oga/css/parser.rb +828 -0
- data/lib/oga/version.rb +1 -1
- data/lib/oga/xml/attribute.rb +3 -1
- data/lib/oga/xml/element.rb +15 -1
- data/lib/oga/xml/entities.rb +60 -0
- data/lib/oga/xml/html_void_elements.rb +2 -0
- data/lib/oga/xml/lexer.rb +36 -28
- data/lib/oga/xml/node_set.rb +22 -0
- data/lib/oga/xml/parser.rb +149 -128
- data/lib/oga/xml/querying.rb +24 -0
- data/lib/oga/xml/sax_parser.rb +55 -1
- data/lib/oga/xml/text.rb +6 -1
- data/lib/oga/xpath/evaluator.rb +138 -101
- data/lib/oga/xpath/lexer.rb +1205 -1294
- data/lib/oga/xpath/parser.rb +228 -204
- metadata +9 -4
- data/lib/oga/xpath/node.rb +0 -10
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
# Manually Creating Documents
|
|
2
|
+
|
|
3
|
+
Besides being able to parse documents, Oga also allows you to create documents
|
|
4
|
+
manually. This can be useful if you want to dynamically generate XML/HTML.
|
|
5
|
+
|
|
6
|
+
Documents can be greated in two ways:
|
|
7
|
+
|
|
8
|
+
1. Full blown documents (using {Oga::XML::Document})
|
|
9
|
+
2. XML fragments (using just {Oga::XML::Element} and the likes)
|
|
10
|
+
|
|
11
|
+
For example, lets create a document with a specific encoding and a single
|
|
12
|
+
element:
|
|
13
|
+
|
|
14
|
+
xml_decl = Oga::XML::XmlDeclaration.new(:encoding => 'UTF-16')
|
|
15
|
+
document = Oga::XML::Document.new(:xml_declaration => xml_decl)
|
|
16
|
+
element = Oga::XML::Element.new(:name => 'example')
|
|
17
|
+
|
|
18
|
+
document.children << element
|
|
19
|
+
|
|
20
|
+
If you now serialize this back to XML (by calling `document.to_xml`) you'd get
|
|
21
|
+
the following XML:
|
|
22
|
+
|
|
23
|
+
<?xml version="1.0" encoding="UTF-16" ?>
|
|
24
|
+
<example />
|
|
25
|
+
|
|
26
|
+
You can also serialize elements on their own:
|
|
27
|
+
|
|
28
|
+
element.to_xml
|
|
29
|
+
|
|
30
|
+
This would output:
|
|
31
|
+
|
|
32
|
+
<example />
|
|
33
|
+
|
|
34
|
+
## Adding/Removing Attributes
|
|
35
|
+
|
|
36
|
+
The easiest way to add (or remove) attributes is by using {Oga::XML::Element#set}
|
|
37
|
+
and {Oga::XML::Element#unset}. For example, to add an attribute:
|
|
38
|
+
|
|
39
|
+
element = Oga::XML::Element.new(:name => 'example')
|
|
40
|
+
|
|
41
|
+
element.set('class', 'foo')
|
|
42
|
+
|
|
43
|
+
element.to_xml # => "<example class=\"foo\" />"
|
|
44
|
+
|
|
45
|
+
And to remove an attribute:
|
|
46
|
+
|
|
47
|
+
element.unset('class')
|
|
48
|
+
|
|
49
|
+
## Modifying Text
|
|
50
|
+
|
|
51
|
+
Modifying text of elements can be done in two ways:
|
|
52
|
+
|
|
53
|
+
1. Adding {Oga::XML::Text} instances to the list of child nodes of an
|
|
54
|
+
{Oga::XML::Element} instance
|
|
55
|
+
2. Using {Oga::XML::Element#inner\_text=}
|
|
56
|
+
|
|
57
|
+
The second option is the easiest and recommended way of doing this. Usage is
|
|
58
|
+
quite simple:
|
|
59
|
+
|
|
60
|
+
element = Oga::XML::Element.new(:name => 'p')
|
|
61
|
+
|
|
62
|
+
element.inner_text = 'Hello'
|
|
63
|
+
|
|
64
|
+
element.to_xml => "<p>Hello</p>"
|
|
65
|
+
|
|
66
|
+
Special characters such as `&` and `<` are escaped automatically when calling
|
|
67
|
+
{Oga::XML::Element#to_xml}.
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
# XML Namespaces
|
|
2
|
+
|
|
3
|
+
Oga fully supports registering XML namespaces and querying elements using these
|
|
4
|
+
namespaces, including alternative default namespaces.
|
|
5
|
+
|
|
6
|
+
Namespaces can be registered in two ways:
|
|
7
|
+
|
|
8
|
+
1. Namespaces defined in the document itself (e.g. `xmlns:foo="..."`)
|
|
9
|
+
2. By using {Oga::XML::Element#register\_namespace}
|
|
10
|
+
|
|
11
|
+
Note that manually registering namespaces does not alter the input document when
|
|
12
|
+
serialized back to XML. To do so you'll have to manually add the corresponding
|
|
13
|
+
attributes using {Oga::XML::Element#set}.
|
|
14
|
+
|
|
15
|
+
## Document Namespaces
|
|
16
|
+
|
|
17
|
+
Documents can contain two types of namespaces:
|
|
18
|
+
|
|
19
|
+
1. Named namespaces
|
|
20
|
+
2. Default namespaces
|
|
21
|
+
|
|
22
|
+
The first are registered as following:
|
|
23
|
+
|
|
24
|
+
<root xmlns:foo="http://foo.com">
|
|
25
|
+
|
|
26
|
+
</root>
|
|
27
|
+
|
|
28
|
+
Here we register a new namespace with prefix "foo" and URI "http://foo.com".
|
|
29
|
+
|
|
30
|
+
Default namespaces are registered in a similar fashion, except they come without
|
|
31
|
+
a prefix:
|
|
32
|
+
|
|
33
|
+
<root xmlns="http://foo.com">
|
|
34
|
+
|
|
35
|
+
</root>
|
|
36
|
+
|
|
37
|
+
## Manually Registered Namespaces
|
|
38
|
+
|
|
39
|
+
If you ever want to register a namespace yourself, without having to first
|
|
40
|
+
change the input document, you can do so as following:
|
|
41
|
+
|
|
42
|
+
element = Oga::XML::Element.new(:name => 'root')
|
|
43
|
+
|
|
44
|
+
element.register_namespace('foo', 'http://foo.com')
|
|
45
|
+
|
|
46
|
+
Trying to register an already existing namespace will result in `ArgumentError`
|
|
47
|
+
being raised.
|
|
48
|
+
|
|
49
|
+
## Listing Namespaces
|
|
50
|
+
|
|
51
|
+
To query all the namespaces available to an element you can use
|
|
52
|
+
{Oga::XML::Element#available\_namespaces}. This method returns a Hash
|
|
53
|
+
containing all {Oga::XML::Namespace} instances available to the element. The
|
|
54
|
+
keys are the namespace prefixes, the values the Namespace instances. Inner
|
|
55
|
+
namespaces overwrite outer namespaces.
|
|
56
|
+
|
|
57
|
+
Example:
|
|
58
|
+
|
|
59
|
+
element = Oga::XML::Element.new(:name => 'root')
|
|
60
|
+
|
|
61
|
+
element.register_namespace('foo', 'http://foo.com')
|
|
62
|
+
|
|
63
|
+
element.available_namespaces # => {"foo" => Namespace(name: "foo", uri: "http://foo.com")}
|
data/ext/c/lexer.c
CHANGED
|
@@ -24,8 +24,11 @@ on `ts` and `te`) so the macro ignores this argument.
|
|
|
24
24
|
#define oga_ivar_set(owner, name, value) \
|
|
25
25
|
rb_ivar_set(owner, rb_intern(name), value)
|
|
26
26
|
|
|
27
|
+
#define advance_line(amount) \
|
|
28
|
+
rb_funcall(self, rb_intern("advance_line"), 1, INT2NUM(amount));
|
|
27
29
|
|
|
28
|
-
|
|
30
|
+
|
|
31
|
+
#line 29 "ext/c/lexer.rl"
|
|
29
32
|
|
|
30
33
|
/**
|
|
31
34
|
* Calls a method defined in the Ruby side of the lexer. The String value is
|
|
@@ -65,21 +68,23 @@ void liboga_xml_lexer_callback_simple(VALUE self, const char *name)
|
|
|
65
68
|
}
|
|
66
69
|
|
|
67
70
|
|
|
68
|
-
#line
|
|
69
|
-
static const int c_lexer_start =
|
|
70
|
-
static const int c_lexer_first_final =
|
|
71
|
+
#line 72 "ext/c/lexer.c"
|
|
72
|
+
static const int c_lexer_start = 29;
|
|
73
|
+
static const int c_lexer_first_final = 29;
|
|
71
74
|
static const int c_lexer_error = 0;
|
|
72
75
|
|
|
73
|
-
static const int c_lexer_en_proc_ins_body =
|
|
74
|
-
static const int
|
|
75
|
-
static const int
|
|
76
|
-
static const int
|
|
77
|
-
static const int
|
|
78
|
-
static const int
|
|
79
|
-
static const int
|
|
76
|
+
static const int c_lexer_en_proc_ins_body = 35;
|
|
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 = 41;
|
|
80
|
+
static const int c_lexer_en_xml_decl = 53;
|
|
81
|
+
static const int c_lexer_en_element_name = 56;
|
|
82
|
+
static const int c_lexer_en_element_head = 58;
|
|
83
|
+
static const int c_lexer_en_text = 60;
|
|
84
|
+
static const int c_lexer_en_main = 29;
|
|
80
85
|
|
|
81
86
|
|
|
82
|
-
#line
|
|
87
|
+
#line 68 "ext/c/lexer.rl"
|
|
83
88
|
|
|
84
89
|
/**
|
|
85
90
|
* Lexes the String specifies as the method argument. Token values have the
|
|
@@ -90,10 +95,14 @@ static const int c_lexer_en_main = 35;
|
|
|
90
95
|
*/
|
|
91
96
|
VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
|
|
92
97
|
{
|
|
98
|
+
OgaLexerState *state;
|
|
99
|
+
|
|
93
100
|
/* Make sure that all data passed back to Ruby has the proper encoding. */
|
|
94
101
|
rb_encoding *encoding = rb_enc_get(data_block);
|
|
95
102
|
|
|
96
|
-
char *data_str_val =
|
|
103
|
+
char *data_str_val = StringValueCStr(data_block);
|
|
104
|
+
|
|
105
|
+
Data_Get_Struct(self, OgaLexerState, state);
|
|
97
106
|
|
|
98
107
|
const char *p = data_str_val;
|
|
99
108
|
const char *pe = data_str_val + strlen(data_str_val);
|
|
@@ -102,20 +111,19 @@ VALUE oga_xml_lexer_advance(VALUE self, VALUE data_block)
|
|
|
102
111
|
const char *te = 0;
|
|
103
112
|
const char *mark = 0;
|
|
104
113
|
|
|
105
|
-
int
|
|
106
|
-
int cs = NUM2INT(oga_ivar_get(self, "@cs"));
|
|
114
|
+
int lines = state->lines;
|
|
107
115
|
|
|
108
116
|
|
|
109
|
-
#line
|
|
117
|
+
#line 118 "ext/c/lexer.c"
|
|
110
118
|
{
|
|
111
119
|
if ( p == pe )
|
|
112
120
|
goto _test_eof;
|
|
113
121
|
goto _resume;
|
|
114
122
|
|
|
115
123
|
_again:
|
|
116
|
-
switch ( cs ) {
|
|
117
|
-
case
|
|
118
|
-
case
|
|
124
|
+
switch ( ( state->cs) ) {
|
|
125
|
+
case 29: goto st29;
|
|
126
|
+
case 30: goto st30;
|
|
119
127
|
case 1: goto st1;
|
|
120
128
|
case 2: goto st2;
|
|
121
129
|
case 3: goto st3;
|
|
@@ -128,7 +136,7 @@ _again:
|
|
|
128
136
|
case 10: goto st10;
|
|
129
137
|
case 11: goto st11;
|
|
130
138
|
case 12: goto st12;
|
|
131
|
-
case
|
|
139
|
+
case 31: goto st31;
|
|
132
140
|
case 13: goto st13;
|
|
133
141
|
case 14: goto st14;
|
|
134
142
|
case 15: goto st15;
|
|
@@ -141,15 +149,19 @@ _again:
|
|
|
141
149
|
case 22: goto st22;
|
|
142
150
|
case 23: goto st23;
|
|
143
151
|
case 24: goto st24;
|
|
152
|
+
case 32: goto st32;
|
|
153
|
+
case 33: goto st33;
|
|
154
|
+
case 34: goto st34;
|
|
155
|
+
case 35: goto st35;
|
|
156
|
+
case 36: goto st36;
|
|
157
|
+
case 37: goto st37;
|
|
144
158
|
case 38: goto st38;
|
|
145
159
|
case 39: goto st39;
|
|
146
160
|
case 40: goto st40;
|
|
147
161
|
case 41: goto st41;
|
|
162
|
+
case 0: goto st0;
|
|
148
163
|
case 42: goto st42;
|
|
149
164
|
case 43: goto st43;
|
|
150
|
-
case 0: goto st0;
|
|
151
|
-
case 25: goto st25;
|
|
152
|
-
case 26: goto st26;
|
|
153
165
|
case 44: goto st44;
|
|
154
166
|
case 45: goto st45;
|
|
155
167
|
case 46: goto st46;
|
|
@@ -159,168 +171,160 @@ _again:
|
|
|
159
171
|
case 50: goto st50;
|
|
160
172
|
case 51: goto st51;
|
|
161
173
|
case 52: goto st52;
|
|
174
|
+
case 25: goto st25;
|
|
175
|
+
case 26: goto st26;
|
|
162
176
|
case 53: goto st53;
|
|
163
177
|
case 54: goto st54;
|
|
164
|
-
case 27: goto st27;
|
|
165
|
-
case 28: goto st28;
|
|
166
178
|
case 55: goto st55;
|
|
167
179
|
case 56: goto st56;
|
|
168
|
-
case 29: goto st29;
|
|
169
180
|
case 57: goto st57;
|
|
170
|
-
case 30: goto st30;
|
|
171
181
|
case 58: goto st58;
|
|
182
|
+
case 27: goto st27;
|
|
172
183
|
case 59: goto st59;
|
|
184
|
+
case 28: goto st28;
|
|
173
185
|
case 60: goto st60;
|
|
174
186
|
case 61: goto st61;
|
|
175
187
|
case 62: goto st62;
|
|
176
|
-
case 31: goto st31;
|
|
177
|
-
case 32: goto st32;
|
|
178
|
-
case 33: goto st33;
|
|
179
188
|
case 63: goto st63;
|
|
180
|
-
case 34: goto st34;
|
|
181
|
-
case 64: goto st64;
|
|
182
|
-
case 65: goto st65;
|
|
183
|
-
case 66: goto st66;
|
|
184
|
-
case 67: goto st67;
|
|
185
189
|
default: break;
|
|
186
190
|
}
|
|
187
191
|
|
|
188
192
|
if ( ++p == pe )
|
|
189
193
|
goto _test_eof;
|
|
190
194
|
_resume:
|
|
191
|
-
switch ( cs )
|
|
195
|
+
switch ( ( state->cs) )
|
|
192
196
|
{
|
|
193
197
|
tr0:
|
|
194
|
-
cs =
|
|
195
|
-
#line
|
|
198
|
+
( state->cs) = 29;
|
|
199
|
+
#line 324 "ext/ragel/base_lexer.rl"
|
|
196
200
|
{{p = ((te))-1;}{
|
|
197
201
|
p--;
|
|
198
|
-
cs =
|
|
202
|
+
( state->cs) = 60;
|
|
199
203
|
}}
|
|
200
204
|
goto _again;
|
|
201
205
|
tr7:
|
|
202
|
-
#line
|
|
206
|
+
#line 61 "ext/ragel/base_lexer.rl"
|
|
203
207
|
{te = p+1;{
|
|
204
208
|
callback("on_comment", data, encoding, ts + 4, te - 3);
|
|
205
209
|
}}
|
|
206
|
-
goto
|
|
210
|
+
goto st29;
|
|
207
211
|
tr23:
|
|
208
|
-
#line
|
|
212
|
+
#line 77 "ext/ragel/base_lexer.rl"
|
|
209
213
|
{te = p+1;{
|
|
210
214
|
callback("on_cdata", data, encoding, ts + 9, te - 3);
|
|
211
215
|
}}
|
|
212
|
-
goto
|
|
216
|
+
goto st29;
|
|
213
217
|
tr26:
|
|
214
|
-
#line
|
|
218
|
+
#line 265 "ext/ragel/base_lexer.rl"
|
|
215
219
|
{te = p+1;{
|
|
216
220
|
callback_simple("on_element_end");
|
|
217
221
|
}}
|
|
218
|
-
goto
|
|
219
|
-
|
|
220
|
-
cs =
|
|
221
|
-
#line
|
|
222
|
+
goto st29;
|
|
223
|
+
tr34:
|
|
224
|
+
( state->cs) = 29;
|
|
225
|
+
#line 324 "ext/ragel/base_lexer.rl"
|
|
222
226
|
{te = p+1;{
|
|
223
227
|
p--;
|
|
224
|
-
cs =
|
|
228
|
+
( state->cs) = 60;
|
|
225
229
|
}}
|
|
226
230
|
goto _again;
|
|
227
|
-
|
|
228
|
-
cs =
|
|
229
|
-
#line
|
|
231
|
+
tr36:
|
|
232
|
+
( state->cs) = 29;
|
|
233
|
+
#line 324 "ext/ragel/base_lexer.rl"
|
|
230
234
|
{te = p;p--;{
|
|
231
235
|
p--;
|
|
232
|
-
cs =
|
|
236
|
+
( state->cs) = 60;
|
|
233
237
|
}}
|
|
234
238
|
goto _again;
|
|
235
|
-
|
|
236
|
-
cs =
|
|
237
|
-
#line
|
|
239
|
+
tr38:
|
|
240
|
+
( state->cs) = 29;
|
|
241
|
+
#line 259 "ext/ragel/base_lexer.rl"
|
|
238
242
|
{te = p+1;{
|
|
239
243
|
callback_simple("on_element_start");
|
|
240
244
|
p--;
|
|
241
|
-
cs =
|
|
245
|
+
( state->cs) = 56;
|
|
242
246
|
}}
|
|
243
247
|
goto _again;
|
|
244
|
-
|
|
245
|
-
cs =
|
|
246
|
-
#line
|
|
248
|
+
tr40:
|
|
249
|
+
( state->cs) = 29;
|
|
250
|
+
#line 181 "ext/ragel/base_lexer.rl"
|
|
247
251
|
{te = p;p--;{
|
|
248
252
|
callback_simple("on_doctype_start");
|
|
249
|
-
cs =
|
|
253
|
+
( state->cs) = 41;
|
|
250
254
|
}}
|
|
251
255
|
goto _again;
|
|
252
|
-
|
|
253
|
-
cs =
|
|
256
|
+
tr41:
|
|
257
|
+
( state->cs) = 29;
|
|
254
258
|
#line 1 "NONE"
|
|
255
|
-
{ switch( act ) {
|
|
256
|
-
case
|
|
259
|
+
{ switch( ( state->act) ) {
|
|
260
|
+
case 32:
|
|
257
261
|
{{p = ((te))-1;}
|
|
258
262
|
callback_simple("on_xml_decl_start");
|
|
259
|
-
cs =
|
|
263
|
+
( state->cs) = 53;
|
|
260
264
|
}
|
|
261
265
|
break;
|
|
262
|
-
case
|
|
266
|
+
case 35:
|
|
263
267
|
{{p = ((te))-1;}
|
|
264
268
|
callback_simple("on_proc_ins_start");
|
|
265
269
|
callback("on_proc_ins_name", data, encoding, ts + 2, te);
|
|
266
270
|
|
|
267
271
|
mark = te;
|
|
268
272
|
|
|
269
|
-
cs =
|
|
273
|
+
( state->cs) = 35;
|
|
270
274
|
}
|
|
271
275
|
break;
|
|
272
276
|
}
|
|
273
277
|
}
|
|
274
278
|
goto _again;
|
|
275
|
-
|
|
276
|
-
cs =
|
|
277
|
-
#line
|
|
279
|
+
tr42:
|
|
280
|
+
( state->cs) = 29;
|
|
281
|
+
#line 95 "ext/ragel/base_lexer.rl"
|
|
278
282
|
{te = p;p--;{
|
|
279
283
|
callback_simple("on_proc_ins_start");
|
|
280
284
|
callback("on_proc_ins_name", data, encoding, ts + 2, te);
|
|
281
285
|
|
|
282
286
|
mark = te;
|
|
283
287
|
|
|
284
|
-
cs =
|
|
288
|
+
( state->cs) = 35;
|
|
285
289
|
}}
|
|
286
290
|
goto _again;
|
|
287
|
-
|
|
291
|
+
st29:
|
|
288
292
|
#line 1 "NONE"
|
|
289
293
|
{ts = 0;}
|
|
290
294
|
if ( ++p == pe )
|
|
291
|
-
goto
|
|
292
|
-
case
|
|
295
|
+
goto _test_eof29;
|
|
296
|
+
case 29:
|
|
293
297
|
#line 1 "NONE"
|
|
294
298
|
{ts = p;}
|
|
295
|
-
#line
|
|
299
|
+
#line 300 "ext/c/lexer.c"
|
|
296
300
|
if ( (*p) == 60 )
|
|
297
|
-
goto
|
|
298
|
-
goto
|
|
299
|
-
|
|
301
|
+
goto tr35;
|
|
302
|
+
goto tr34;
|
|
303
|
+
tr35:
|
|
300
304
|
#line 1 "NONE"
|
|
301
305
|
{te = p+1;}
|
|
302
|
-
goto
|
|
303
|
-
|
|
306
|
+
goto st30;
|
|
307
|
+
st30:
|
|
304
308
|
if ( ++p == pe )
|
|
305
|
-
goto
|
|
306
|
-
case
|
|
307
|
-
#line
|
|
309
|
+
goto _test_eof30;
|
|
310
|
+
case 30:
|
|
311
|
+
#line 312 "ext/c/lexer.c"
|
|
308
312
|
switch( (*p) ) {
|
|
309
313
|
case 33: goto st1;
|
|
310
|
-
case 45: goto
|
|
314
|
+
case 45: goto tr38;
|
|
311
315
|
case 47: goto st22;
|
|
312
316
|
case 63: goto st24;
|
|
313
|
-
case 95: goto
|
|
317
|
+
case 95: goto tr38;
|
|
314
318
|
}
|
|
315
319
|
if ( (*p) < 65 ) {
|
|
316
320
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
317
|
-
goto
|
|
321
|
+
goto tr38;
|
|
318
322
|
} else if ( (*p) > 90 ) {
|
|
319
323
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
320
|
-
goto
|
|
324
|
+
goto tr38;
|
|
321
325
|
} else
|
|
322
|
-
goto
|
|
323
|
-
goto
|
|
326
|
+
goto tr38;
|
|
327
|
+
goto tr36;
|
|
324
328
|
st1:
|
|
325
329
|
if ( ++p == pe )
|
|
326
330
|
goto _test_eof1;
|
|
@@ -421,19 +425,19 @@ st12:
|
|
|
421
425
|
goto _test_eof12;
|
|
422
426
|
case 12:
|
|
423
427
|
switch( (*p) ) {
|
|
424
|
-
case 9: goto
|
|
425
|
-
case 32: goto
|
|
428
|
+
case 9: goto st31;
|
|
429
|
+
case 32: goto st31;
|
|
426
430
|
}
|
|
427
431
|
goto tr0;
|
|
428
|
-
|
|
432
|
+
st31:
|
|
429
433
|
if ( ++p == pe )
|
|
430
|
-
goto
|
|
431
|
-
case
|
|
434
|
+
goto _test_eof31;
|
|
435
|
+
case 31:
|
|
432
436
|
switch( (*p) ) {
|
|
433
|
-
case 9: goto
|
|
434
|
-
case 32: goto
|
|
437
|
+
case 9: goto st31;
|
|
438
|
+
case 32: goto st31;
|
|
435
439
|
}
|
|
436
|
-
goto
|
|
440
|
+
goto tr40;
|
|
437
441
|
st13:
|
|
438
442
|
if ( ++p == pe )
|
|
439
443
|
goto _test_eof13;
|
|
@@ -542,7 +546,7 @@ case 24:
|
|
|
542
546
|
switch( (*p) ) {
|
|
543
547
|
case 45: goto tr27;
|
|
544
548
|
case 95: goto tr27;
|
|
545
|
-
case 120: goto
|
|
549
|
+
case 120: goto st33;
|
|
546
550
|
}
|
|
547
551
|
if ( (*p) < 65 ) {
|
|
548
552
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
@@ -556,20 +560,20 @@ case 24:
|
|
|
556
560
|
tr27:
|
|
557
561
|
#line 1 "NONE"
|
|
558
562
|
{te = p+1;}
|
|
559
|
-
#line
|
|
560
|
-
{act =
|
|
561
|
-
goto
|
|
562
|
-
|
|
563
|
+
#line 95 "ext/ragel/base_lexer.rl"
|
|
564
|
+
{( state->act) = 35;}
|
|
565
|
+
goto st32;
|
|
566
|
+
tr44:
|
|
563
567
|
#line 1 "NONE"
|
|
564
568
|
{te = p+1;}
|
|
565
|
-
#line
|
|
566
|
-
{act =
|
|
567
|
-
goto
|
|
568
|
-
|
|
569
|
+
#line 224 "ext/ragel/base_lexer.rl"
|
|
570
|
+
{( state->act) = 32;}
|
|
571
|
+
goto st32;
|
|
572
|
+
st32:
|
|
569
573
|
if ( ++p == pe )
|
|
570
|
-
goto
|
|
571
|
-
case
|
|
572
|
-
#line
|
|
574
|
+
goto _test_eof32;
|
|
575
|
+
case 32:
|
|
576
|
+
#line 577 "ext/c/lexer.c"
|
|
573
577
|
switch( (*p) ) {
|
|
574
578
|
case 45: goto tr27;
|
|
575
579
|
case 95: goto tr27;
|
|
@@ -582,15 +586,15 @@ case 38:
|
|
|
582
586
|
goto tr27;
|
|
583
587
|
} else
|
|
584
588
|
goto tr27;
|
|
585
|
-
goto
|
|
586
|
-
|
|
589
|
+
goto tr41;
|
|
590
|
+
st33:
|
|
587
591
|
if ( ++p == pe )
|
|
588
|
-
goto
|
|
589
|
-
case
|
|
592
|
+
goto _test_eof33;
|
|
593
|
+
case 33:
|
|
590
594
|
switch( (*p) ) {
|
|
591
595
|
case 45: goto tr27;
|
|
592
596
|
case 95: goto tr27;
|
|
593
|
-
case 109: goto
|
|
597
|
+
case 109: goto st34;
|
|
594
598
|
}
|
|
595
599
|
if ( (*p) < 65 ) {
|
|
596
600
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
@@ -600,15 +604,15 @@ case 39:
|
|
|
600
604
|
goto tr27;
|
|
601
605
|
} else
|
|
602
606
|
goto tr27;
|
|
603
|
-
goto
|
|
604
|
-
|
|
607
|
+
goto tr42;
|
|
608
|
+
st34:
|
|
605
609
|
if ( ++p == pe )
|
|
606
|
-
goto
|
|
607
|
-
case
|
|
610
|
+
goto _test_eof34;
|
|
611
|
+
case 34:
|
|
608
612
|
switch( (*p) ) {
|
|
609
613
|
case 45: goto tr27;
|
|
610
614
|
case 95: goto tr27;
|
|
611
|
-
case 108: goto
|
|
615
|
+
case 108: goto tr44;
|
|
612
616
|
}
|
|
613
617
|
if ( (*p) < 65 ) {
|
|
614
618
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
@@ -618,710 +622,799 @@ case 40:
|
|
|
618
622
|
goto tr27;
|
|
619
623
|
} else
|
|
620
624
|
goto tr27;
|
|
621
|
-
goto
|
|
622
|
-
|
|
623
|
-
#line
|
|
625
|
+
goto tr42;
|
|
626
|
+
tr45:
|
|
627
|
+
#line 114 "ext/ragel/base_lexer.rl"
|
|
624
628
|
{te = p+1;}
|
|
625
|
-
goto
|
|
626
|
-
|
|
627
|
-
#line
|
|
629
|
+
goto st35;
|
|
630
|
+
tr47:
|
|
631
|
+
#line 114 "ext/ragel/base_lexer.rl"
|
|
628
632
|
{te = p;p--;}
|
|
629
|
-
goto
|
|
630
|
-
|
|
631
|
-
cs =
|
|
632
|
-
#line
|
|
633
|
+
goto st35;
|
|
634
|
+
tr48:
|
|
635
|
+
( state->cs) = 35;
|
|
636
|
+
#line 105 "ext/ragel/base_lexer.rl"
|
|
633
637
|
{te = p+1;{
|
|
634
638
|
callback("on_text", data, encoding, mark, ts);
|
|
635
639
|
callback_simple("on_proc_ins_end");
|
|
636
640
|
|
|
637
|
-
|
|
641
|
+
mark = 0;
|
|
642
|
+
|
|
643
|
+
( state->cs) = 29;
|
|
638
644
|
}}
|
|
639
645
|
goto _again;
|
|
640
|
-
|
|
646
|
+
st35:
|
|
641
647
|
#line 1 "NONE"
|
|
642
648
|
{ts = 0;}
|
|
643
649
|
if ( ++p == pe )
|
|
644
|
-
goto
|
|
645
|
-
case
|
|
650
|
+
goto _test_eof35;
|
|
651
|
+
case 35:
|
|
646
652
|
#line 1 "NONE"
|
|
647
653
|
{ts = p;}
|
|
648
|
-
#line
|
|
654
|
+
#line 655 "ext/c/lexer.c"
|
|
649
655
|
if ( (*p) == 63 )
|
|
650
|
-
goto
|
|
651
|
-
goto
|
|
652
|
-
|
|
656
|
+
goto st36;
|
|
657
|
+
goto tr45;
|
|
658
|
+
st36:
|
|
653
659
|
if ( ++p == pe )
|
|
654
|
-
goto
|
|
655
|
-
case
|
|
660
|
+
goto _test_eof36;
|
|
661
|
+
case 36:
|
|
656
662
|
if ( (*p) == 62 )
|
|
657
|
-
goto
|
|
658
|
-
goto
|
|
659
|
-
|
|
660
|
-
#line
|
|
663
|
+
goto tr48;
|
|
664
|
+
goto tr47;
|
|
665
|
+
tr50:
|
|
666
|
+
#line 152 "ext/ragel/base_lexer.rl"
|
|
661
667
|
{te = p+1;{
|
|
662
|
-
|
|
668
|
+
callback_simple("on_string_squote");
|
|
669
|
+
|
|
670
|
+
{( state->cs) = ( state->stack)[--( state->top)];goto _again;}
|
|
671
|
+
}}
|
|
672
|
+
goto st37;
|
|
673
|
+
tr51:
|
|
674
|
+
#line 126 "ext/ragel/base_lexer.rl"
|
|
675
|
+
{te = p;p--;{
|
|
676
|
+
callback("on_string_body", data, encoding, ts, te);
|
|
677
|
+
|
|
678
|
+
if ( lines > 0 )
|
|
679
|
+
{
|
|
680
|
+
advance_line(lines);
|
|
681
|
+
|
|
682
|
+
lines = 0;
|
|
683
|
+
}
|
|
663
684
|
}}
|
|
664
|
-
goto
|
|
665
|
-
|
|
666
|
-
#line
|
|
685
|
+
goto st37;
|
|
686
|
+
st37:
|
|
687
|
+
#line 1 "NONE"
|
|
688
|
+
{ts = 0;}
|
|
689
|
+
if ( ++p == pe )
|
|
690
|
+
goto _test_eof37;
|
|
691
|
+
case 37:
|
|
692
|
+
#line 1 "NONE"
|
|
693
|
+
{ts = p;}
|
|
694
|
+
#line 695 "ext/c/lexer.c"
|
|
695
|
+
if ( (*p) == 39 )
|
|
696
|
+
goto tr50;
|
|
697
|
+
goto tr49;
|
|
698
|
+
tr49:
|
|
699
|
+
#line 40 "ext/ragel/base_lexer.rl"
|
|
700
|
+
{
|
|
701
|
+
if ( (*p) == '\n' ) lines++;
|
|
702
|
+
}
|
|
703
|
+
goto st38;
|
|
704
|
+
st38:
|
|
705
|
+
if ( ++p == pe )
|
|
706
|
+
goto _test_eof38;
|
|
707
|
+
case 38:
|
|
708
|
+
#line 709 "ext/c/lexer.c"
|
|
709
|
+
if ( (*p) == 39 )
|
|
710
|
+
goto tr51;
|
|
711
|
+
goto tr49;
|
|
712
|
+
tr53:
|
|
713
|
+
#line 162 "ext/ragel/base_lexer.rl"
|
|
714
|
+
{te = p+1;{
|
|
715
|
+
callback_simple("on_string_dquote");
|
|
716
|
+
|
|
717
|
+
{( state->cs) = ( state->stack)[--( state->top)];goto _again;}
|
|
718
|
+
}}
|
|
719
|
+
goto st39;
|
|
720
|
+
tr54:
|
|
721
|
+
#line 126 "ext/ragel/base_lexer.rl"
|
|
722
|
+
{te = p;p--;{
|
|
723
|
+
callback("on_string_body", data, encoding, ts, te);
|
|
724
|
+
|
|
725
|
+
if ( lines > 0 )
|
|
726
|
+
{
|
|
727
|
+
advance_line(lines);
|
|
728
|
+
|
|
729
|
+
lines = 0;
|
|
730
|
+
}
|
|
731
|
+
}}
|
|
732
|
+
goto st39;
|
|
733
|
+
st39:
|
|
734
|
+
#line 1 "NONE"
|
|
735
|
+
{ts = 0;}
|
|
736
|
+
if ( ++p == pe )
|
|
737
|
+
goto _test_eof39;
|
|
738
|
+
case 39:
|
|
739
|
+
#line 1 "NONE"
|
|
740
|
+
{ts = p;}
|
|
741
|
+
#line 742 "ext/c/lexer.c"
|
|
742
|
+
if ( (*p) == 34 )
|
|
743
|
+
goto tr53;
|
|
744
|
+
goto tr52;
|
|
745
|
+
tr52:
|
|
746
|
+
#line 40 "ext/ragel/base_lexer.rl"
|
|
747
|
+
{
|
|
748
|
+
if ( (*p) == '\n' ) lines++;
|
|
749
|
+
}
|
|
750
|
+
goto st40;
|
|
751
|
+
st40:
|
|
752
|
+
if ( ++p == pe )
|
|
753
|
+
goto _test_eof40;
|
|
754
|
+
case 40:
|
|
755
|
+
#line 756 "ext/c/lexer.c"
|
|
756
|
+
if ( (*p) == 34 )
|
|
757
|
+
goto tr54;
|
|
758
|
+
goto tr52;
|
|
759
|
+
tr30:
|
|
760
|
+
#line 195 "ext/ragel/base_lexer.rl"
|
|
667
761
|
{te = p+1;{
|
|
668
762
|
callback("on_doctype_inline", data, encoding, ts + 1, te - 1);
|
|
669
763
|
}}
|
|
670
|
-
goto
|
|
671
|
-
|
|
672
|
-
#line
|
|
764
|
+
goto st41;
|
|
765
|
+
tr55:
|
|
766
|
+
#line 205 "ext/ragel/base_lexer.rl"
|
|
673
767
|
{te = p+1;}
|
|
674
|
-
goto
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
768
|
+
goto st41;
|
|
769
|
+
tr56:
|
|
770
|
+
#line 143 "ext/ragel/base_lexer.rl"
|
|
771
|
+
{te = p+1;{
|
|
772
|
+
callback_simple("on_string_dquote");
|
|
773
|
+
|
|
774
|
+
{( state->stack)[( state->top)++] = 41; goto st39;}
|
|
775
|
+
}}
|
|
776
|
+
goto st41;
|
|
777
|
+
tr57:
|
|
778
|
+
#line 137 "ext/ragel/base_lexer.rl"
|
|
779
|
+
{te = p+1;{
|
|
780
|
+
callback_simple("on_string_squote");
|
|
781
|
+
|
|
782
|
+
{( state->stack)[( state->top)++] = 41; goto st37;}
|
|
783
|
+
}}
|
|
784
|
+
goto st41;
|
|
785
|
+
tr59:
|
|
786
|
+
( state->cs) = 41;
|
|
787
|
+
#line 211 "ext/ragel/base_lexer.rl"
|
|
678
788
|
{te = p+1;{
|
|
679
789
|
callback_simple("on_doctype_end");
|
|
680
|
-
cs =
|
|
790
|
+
( state->cs) = 29;
|
|
681
791
|
}}
|
|
682
792
|
goto _again;
|
|
683
|
-
|
|
793
|
+
tr63:
|
|
684
794
|
#line 1 "NONE"
|
|
685
|
-
{ switch( act ) {
|
|
686
|
-
case
|
|
795
|
+
{ switch( ( state->act) ) {
|
|
796
|
+
case 7:
|
|
687
797
|
{{p = ((te))-1;}
|
|
688
798
|
callback("on_doctype_type", data, encoding, ts, te);
|
|
689
799
|
}
|
|
690
800
|
break;
|
|
691
|
-
case
|
|
801
|
+
case 12:
|
|
692
802
|
{{p = ((te))-1;}
|
|
693
803
|
callback("on_doctype_name", data, encoding, ts, te);
|
|
694
804
|
}
|
|
695
805
|
break;
|
|
696
806
|
}
|
|
697
807
|
}
|
|
698
|
-
goto
|
|
699
|
-
|
|
700
|
-
#line
|
|
808
|
+
goto st41;
|
|
809
|
+
tr64:
|
|
810
|
+
#line 207 "ext/ragel/base_lexer.rl"
|
|
701
811
|
{te = p;p--;{
|
|
702
812
|
callback("on_doctype_name", data, encoding, ts, te);
|
|
703
813
|
}}
|
|
704
|
-
goto
|
|
705
|
-
|
|
814
|
+
goto st41;
|
|
815
|
+
st41:
|
|
706
816
|
#line 1 "NONE"
|
|
707
817
|
{ts = 0;}
|
|
708
818
|
if ( ++p == pe )
|
|
709
|
-
goto
|
|
710
|
-
case
|
|
819
|
+
goto _test_eof41;
|
|
820
|
+
case 41:
|
|
711
821
|
#line 1 "NONE"
|
|
712
822
|
{ts = p;}
|
|
713
|
-
#line
|
|
823
|
+
#line 824 "ext/c/lexer.c"
|
|
714
824
|
switch( (*p) ) {
|
|
715
|
-
case 9: goto
|
|
716
|
-
case 32: goto
|
|
717
|
-
case 34: goto
|
|
718
|
-
case 39: goto
|
|
719
|
-
case 45: goto
|
|
720
|
-
case 62: goto
|
|
721
|
-
case 80: goto
|
|
722
|
-
case 83: goto
|
|
723
|
-
case 91: goto
|
|
724
|
-
case 95: goto
|
|
825
|
+
case 9: goto tr55;
|
|
826
|
+
case 32: goto tr55;
|
|
827
|
+
case 34: goto tr56;
|
|
828
|
+
case 39: goto tr57;
|
|
829
|
+
case 45: goto tr58;
|
|
830
|
+
case 62: goto tr59;
|
|
831
|
+
case 80: goto st43;
|
|
832
|
+
case 83: goto st48;
|
|
833
|
+
case 91: goto st25;
|
|
834
|
+
case 95: goto tr58;
|
|
725
835
|
}
|
|
726
836
|
if ( (*p) < 65 ) {
|
|
727
837
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
728
|
-
goto
|
|
838
|
+
goto tr58;
|
|
729
839
|
} else if ( (*p) > 90 ) {
|
|
730
840
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
731
|
-
goto
|
|
841
|
+
goto tr58;
|
|
732
842
|
} else
|
|
733
|
-
goto
|
|
843
|
+
goto tr58;
|
|
734
844
|
goto st0;
|
|
735
845
|
st0:
|
|
736
|
-
cs = 0;
|
|
846
|
+
( state->cs) = 0;
|
|
737
847
|
goto _out;
|
|
738
|
-
|
|
739
|
-
if ( ++p == pe )
|
|
740
|
-
goto _test_eof25;
|
|
741
|
-
case 25:
|
|
742
|
-
if ( (*p) == 34 )
|
|
743
|
-
goto tr30;
|
|
744
|
-
goto st25;
|
|
745
|
-
st26:
|
|
746
|
-
if ( ++p == pe )
|
|
747
|
-
goto _test_eof26;
|
|
748
|
-
case 26:
|
|
749
|
-
if ( (*p) == 39 )
|
|
750
|
-
goto tr30;
|
|
751
|
-
goto st26;
|
|
752
|
-
tr60:
|
|
848
|
+
tr58:
|
|
753
849
|
#line 1 "NONE"
|
|
754
850
|
{te = p+1;}
|
|
755
|
-
#line
|
|
756
|
-
{act =
|
|
757
|
-
goto
|
|
758
|
-
|
|
851
|
+
#line 207 "ext/ragel/base_lexer.rl"
|
|
852
|
+
{( state->act) = 12;}
|
|
853
|
+
goto st42;
|
|
854
|
+
tr69:
|
|
759
855
|
#line 1 "NONE"
|
|
760
856
|
{te = p+1;}
|
|
761
|
-
#line
|
|
762
|
-
{act =
|
|
763
|
-
goto
|
|
857
|
+
#line 189 "ext/ragel/base_lexer.rl"
|
|
858
|
+
{( state->act) = 7;}
|
|
859
|
+
goto st42;
|
|
860
|
+
st42:
|
|
861
|
+
if ( ++p == pe )
|
|
862
|
+
goto _test_eof42;
|
|
863
|
+
case 42:
|
|
864
|
+
#line 865 "ext/c/lexer.c"
|
|
865
|
+
switch( (*p) ) {
|
|
866
|
+
case 45: goto tr58;
|
|
867
|
+
case 95: goto tr58;
|
|
868
|
+
}
|
|
869
|
+
if ( (*p) < 65 ) {
|
|
870
|
+
if ( 48 <= (*p) && (*p) <= 57 )
|
|
871
|
+
goto tr58;
|
|
872
|
+
} else if ( (*p) > 90 ) {
|
|
873
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
874
|
+
goto tr58;
|
|
875
|
+
} else
|
|
876
|
+
goto tr58;
|
|
877
|
+
goto tr63;
|
|
878
|
+
st43:
|
|
879
|
+
if ( ++p == pe )
|
|
880
|
+
goto _test_eof43;
|
|
881
|
+
case 43:
|
|
882
|
+
switch( (*p) ) {
|
|
883
|
+
case 45: goto tr58;
|
|
884
|
+
case 85: goto st44;
|
|
885
|
+
case 95: goto tr58;
|
|
886
|
+
}
|
|
887
|
+
if ( (*p) < 65 ) {
|
|
888
|
+
if ( 48 <= (*p) && (*p) <= 57 )
|
|
889
|
+
goto tr58;
|
|
890
|
+
} else if ( (*p) > 90 ) {
|
|
891
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
892
|
+
goto tr58;
|
|
893
|
+
} else
|
|
894
|
+
goto tr58;
|
|
895
|
+
goto tr64;
|
|
764
896
|
st44:
|
|
765
897
|
if ( ++p == pe )
|
|
766
898
|
goto _test_eof44;
|
|
767
899
|
case 44:
|
|
768
|
-
#line 769 "ext/c/lexer.c"
|
|
769
900
|
switch( (*p) ) {
|
|
770
|
-
case 45: goto
|
|
771
|
-
case
|
|
901
|
+
case 45: goto tr58;
|
|
902
|
+
case 66: goto st45;
|
|
903
|
+
case 95: goto tr58;
|
|
772
904
|
}
|
|
773
905
|
if ( (*p) < 65 ) {
|
|
774
906
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
775
|
-
goto
|
|
907
|
+
goto tr58;
|
|
776
908
|
} else if ( (*p) > 90 ) {
|
|
777
909
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
778
|
-
goto
|
|
910
|
+
goto tr58;
|
|
779
911
|
} else
|
|
780
|
-
goto
|
|
781
|
-
goto
|
|
912
|
+
goto tr58;
|
|
913
|
+
goto tr64;
|
|
782
914
|
st45:
|
|
783
915
|
if ( ++p == pe )
|
|
784
916
|
goto _test_eof45;
|
|
785
917
|
case 45:
|
|
786
918
|
switch( (*p) ) {
|
|
787
|
-
case 45: goto
|
|
788
|
-
case
|
|
789
|
-
case 95: goto
|
|
919
|
+
case 45: goto tr58;
|
|
920
|
+
case 76: goto st46;
|
|
921
|
+
case 95: goto tr58;
|
|
790
922
|
}
|
|
791
923
|
if ( (*p) < 65 ) {
|
|
792
924
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
793
|
-
goto
|
|
925
|
+
goto tr58;
|
|
794
926
|
} else if ( (*p) > 90 ) {
|
|
795
927
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
796
|
-
goto
|
|
928
|
+
goto tr58;
|
|
797
929
|
} else
|
|
798
|
-
goto
|
|
799
|
-
goto
|
|
930
|
+
goto tr58;
|
|
931
|
+
goto tr64;
|
|
800
932
|
st46:
|
|
801
933
|
if ( ++p == pe )
|
|
802
934
|
goto _test_eof46;
|
|
803
935
|
case 46:
|
|
804
936
|
switch( (*p) ) {
|
|
805
|
-
case 45: goto
|
|
806
|
-
case
|
|
807
|
-
case 95: goto
|
|
937
|
+
case 45: goto tr58;
|
|
938
|
+
case 73: goto st47;
|
|
939
|
+
case 95: goto tr58;
|
|
808
940
|
}
|
|
809
941
|
if ( (*p) < 65 ) {
|
|
810
942
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
811
|
-
goto
|
|
943
|
+
goto tr58;
|
|
812
944
|
} else if ( (*p) > 90 ) {
|
|
813
945
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
814
|
-
goto
|
|
946
|
+
goto tr58;
|
|
815
947
|
} else
|
|
816
|
-
goto
|
|
817
|
-
goto
|
|
948
|
+
goto tr58;
|
|
949
|
+
goto tr64;
|
|
818
950
|
st47:
|
|
819
951
|
if ( ++p == pe )
|
|
820
952
|
goto _test_eof47;
|
|
821
953
|
case 47:
|
|
822
954
|
switch( (*p) ) {
|
|
823
|
-
case 45: goto
|
|
824
|
-
case
|
|
825
|
-
case 95: goto
|
|
955
|
+
case 45: goto tr58;
|
|
956
|
+
case 67: goto tr69;
|
|
957
|
+
case 95: goto tr58;
|
|
826
958
|
}
|
|
827
959
|
if ( (*p) < 65 ) {
|
|
828
960
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
829
|
-
goto
|
|
961
|
+
goto tr58;
|
|
830
962
|
} else if ( (*p) > 90 ) {
|
|
831
963
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
832
|
-
goto
|
|
964
|
+
goto tr58;
|
|
833
965
|
} else
|
|
834
|
-
goto
|
|
835
|
-
goto
|
|
966
|
+
goto tr58;
|
|
967
|
+
goto tr64;
|
|
836
968
|
st48:
|
|
837
969
|
if ( ++p == pe )
|
|
838
970
|
goto _test_eof48;
|
|
839
971
|
case 48:
|
|
840
972
|
switch( (*p) ) {
|
|
841
|
-
case 45: goto
|
|
842
|
-
case
|
|
843
|
-
case 95: goto
|
|
973
|
+
case 45: goto tr58;
|
|
974
|
+
case 89: goto st49;
|
|
975
|
+
case 95: goto tr58;
|
|
844
976
|
}
|
|
845
977
|
if ( (*p) < 65 ) {
|
|
846
978
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
847
|
-
goto
|
|
979
|
+
goto tr58;
|
|
848
980
|
} else if ( (*p) > 90 ) {
|
|
849
981
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
850
|
-
goto
|
|
982
|
+
goto tr58;
|
|
851
983
|
} else
|
|
852
|
-
goto
|
|
853
|
-
goto
|
|
984
|
+
goto tr58;
|
|
985
|
+
goto tr64;
|
|
854
986
|
st49:
|
|
855
987
|
if ( ++p == pe )
|
|
856
988
|
goto _test_eof49;
|
|
857
989
|
case 49:
|
|
858
990
|
switch( (*p) ) {
|
|
859
|
-
case 45: goto
|
|
860
|
-
case
|
|
861
|
-
case 95: goto
|
|
991
|
+
case 45: goto tr58;
|
|
992
|
+
case 83: goto st50;
|
|
993
|
+
case 95: goto tr58;
|
|
862
994
|
}
|
|
863
995
|
if ( (*p) < 65 ) {
|
|
864
996
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
865
|
-
goto
|
|
997
|
+
goto tr58;
|
|
866
998
|
} else if ( (*p) > 90 ) {
|
|
867
999
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
868
|
-
goto
|
|
1000
|
+
goto tr58;
|
|
869
1001
|
} else
|
|
870
|
-
goto
|
|
871
|
-
goto
|
|
1002
|
+
goto tr58;
|
|
1003
|
+
goto tr64;
|
|
872
1004
|
st50:
|
|
873
1005
|
if ( ++p == pe )
|
|
874
1006
|
goto _test_eof50;
|
|
875
1007
|
case 50:
|
|
876
1008
|
switch( (*p) ) {
|
|
877
|
-
case 45: goto
|
|
878
|
-
case
|
|
879
|
-
case 95: goto
|
|
1009
|
+
case 45: goto tr58;
|
|
1010
|
+
case 84: goto st51;
|
|
1011
|
+
case 95: goto tr58;
|
|
880
1012
|
}
|
|
881
1013
|
if ( (*p) < 65 ) {
|
|
882
1014
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
883
|
-
goto
|
|
1015
|
+
goto tr58;
|
|
884
1016
|
} else if ( (*p) > 90 ) {
|
|
885
1017
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
886
|
-
goto
|
|
1018
|
+
goto tr58;
|
|
887
1019
|
} else
|
|
888
|
-
goto
|
|
889
|
-
goto
|
|
1020
|
+
goto tr58;
|
|
1021
|
+
goto tr64;
|
|
890
1022
|
st51:
|
|
891
1023
|
if ( ++p == pe )
|
|
892
1024
|
goto _test_eof51;
|
|
893
1025
|
case 51:
|
|
894
1026
|
switch( (*p) ) {
|
|
895
|
-
case 45: goto
|
|
896
|
-
case
|
|
897
|
-
case 95: goto
|
|
1027
|
+
case 45: goto tr58;
|
|
1028
|
+
case 69: goto st52;
|
|
1029
|
+
case 95: goto tr58;
|
|
898
1030
|
}
|
|
899
1031
|
if ( (*p) < 65 ) {
|
|
900
1032
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
901
|
-
goto
|
|
1033
|
+
goto tr58;
|
|
902
1034
|
} else if ( (*p) > 90 ) {
|
|
903
1035
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
904
|
-
goto
|
|
1036
|
+
goto tr58;
|
|
905
1037
|
} else
|
|
906
|
-
goto
|
|
907
|
-
goto
|
|
1038
|
+
goto tr58;
|
|
1039
|
+
goto tr64;
|
|
908
1040
|
st52:
|
|
909
1041
|
if ( ++p == pe )
|
|
910
1042
|
goto _test_eof52;
|
|
911
1043
|
case 52:
|
|
912
1044
|
switch( (*p) ) {
|
|
913
|
-
case 45: goto
|
|
914
|
-
case
|
|
915
|
-
case 95: goto
|
|
1045
|
+
case 45: goto tr58;
|
|
1046
|
+
case 77: goto tr69;
|
|
1047
|
+
case 95: goto tr58;
|
|
916
1048
|
}
|
|
917
1049
|
if ( (*p) < 65 ) {
|
|
918
1050
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
919
|
-
goto
|
|
1051
|
+
goto tr58;
|
|
920
1052
|
} else if ( (*p) > 90 ) {
|
|
921
1053
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
922
|
-
goto
|
|
1054
|
+
goto tr58;
|
|
923
1055
|
} else
|
|
924
|
-
goto
|
|
925
|
-
goto
|
|
926
|
-
|
|
927
|
-
if ( ++p == pe )
|
|
928
|
-
goto _test_eof53;
|
|
929
|
-
case 53:
|
|
930
|
-
switch( (*p) ) {
|
|
931
|
-
case 45: goto tr60;
|
|
932
|
-
case 69: goto st54;
|
|
933
|
-
case 95: goto tr60;
|
|
934
|
-
}
|
|
935
|
-
if ( (*p) < 65 ) {
|
|
936
|
-
if ( 48 <= (*p) && (*p) <= 57 )
|
|
937
|
-
goto tr60;
|
|
938
|
-
} else if ( (*p) > 90 ) {
|
|
939
|
-
if ( 97 <= (*p) && (*p) <= 122 )
|
|
940
|
-
goto tr60;
|
|
941
|
-
} else
|
|
942
|
-
goto tr60;
|
|
943
|
-
goto tr66;
|
|
944
|
-
st54:
|
|
945
|
-
if ( ++p == pe )
|
|
946
|
-
goto _test_eof54;
|
|
947
|
-
case 54:
|
|
948
|
-
switch( (*p) ) {
|
|
949
|
-
case 45: goto tr60;
|
|
950
|
-
case 77: goto tr71;
|
|
951
|
-
case 95: goto tr60;
|
|
952
|
-
}
|
|
953
|
-
if ( (*p) < 65 ) {
|
|
954
|
-
if ( 48 <= (*p) && (*p) <= 57 )
|
|
955
|
-
goto tr60;
|
|
956
|
-
} else if ( (*p) > 90 ) {
|
|
957
|
-
if ( 97 <= (*p) && (*p) <= 122 )
|
|
958
|
-
goto tr60;
|
|
959
|
-
} else
|
|
960
|
-
goto tr60;
|
|
961
|
-
goto tr66;
|
|
962
|
-
st27:
|
|
1056
|
+
goto tr58;
|
|
1057
|
+
goto tr64;
|
|
1058
|
+
st25:
|
|
963
1059
|
if ( ++p == pe )
|
|
964
|
-
goto
|
|
965
|
-
case
|
|
966
|
-
goto
|
|
967
|
-
|
|
1060
|
+
goto _test_eof25;
|
|
1061
|
+
case 25:
|
|
1062
|
+
goto st26;
|
|
1063
|
+
st26:
|
|
968
1064
|
if ( ++p == pe )
|
|
969
|
-
goto
|
|
970
|
-
case
|
|
1065
|
+
goto _test_eof26;
|
|
1066
|
+
case 26:
|
|
971
1067
|
if ( (*p) == 93 )
|
|
972
|
-
goto
|
|
973
|
-
goto
|
|
974
|
-
|
|
975
|
-
#line
|
|
976
|
-
{
|
|
977
|
-
goto
|
|
978
|
-
|
|
979
|
-
#line
|
|
1068
|
+
goto tr30;
|
|
1069
|
+
goto st26;
|
|
1070
|
+
tr74:
|
|
1071
|
+
#line 244 "ext/ragel/base_lexer.rl"
|
|
1072
|
+
{te = p+1;}
|
|
1073
|
+
goto st53;
|
|
1074
|
+
tr75:
|
|
1075
|
+
#line 143 "ext/ragel/base_lexer.rl"
|
|
980
1076
|
{te = p+1;{
|
|
981
|
-
|
|
1077
|
+
callback_simple("on_string_dquote");
|
|
1078
|
+
|
|
1079
|
+
{( state->stack)[( state->top)++] = 53; goto st39;}
|
|
982
1080
|
}}
|
|
983
|
-
goto
|
|
1081
|
+
goto st53;
|
|
984
1082
|
tr76:
|
|
985
|
-
#line
|
|
986
|
-
{te = p+1;
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
goto
|
|
992
|
-
|
|
993
|
-
#line
|
|
1083
|
+
#line 137 "ext/ragel/base_lexer.rl"
|
|
1084
|
+
{te = p+1;{
|
|
1085
|
+
callback_simple("on_string_squote");
|
|
1086
|
+
|
|
1087
|
+
{( state->stack)[( state->top)++] = 53; goto st37;}
|
|
1088
|
+
}}
|
|
1089
|
+
goto st53;
|
|
1090
|
+
tr79:
|
|
1091
|
+
#line 237 "ext/ragel/base_lexer.rl"
|
|
994
1092
|
{te = p;p--;{
|
|
995
1093
|
callback("on_attribute", data, encoding, ts, te);
|
|
996
1094
|
}}
|
|
997
|
-
goto
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1095
|
+
goto st53;
|
|
1096
|
+
tr80:
|
|
1097
|
+
#line 244 "ext/ragel/base_lexer.rl"
|
|
1098
|
+
{te = p;p--;}
|
|
1099
|
+
goto st53;
|
|
1100
|
+
tr81:
|
|
1101
|
+
( state->cs) = 53;
|
|
1102
|
+
#line 231 "ext/ragel/base_lexer.rl"
|
|
1001
1103
|
{te = p+1;{
|
|
1002
1104
|
callback_simple("on_xml_decl_end");
|
|
1003
|
-
cs =
|
|
1105
|
+
( state->cs) = 29;
|
|
1004
1106
|
}}
|
|
1005
1107
|
goto _again;
|
|
1006
|
-
|
|
1108
|
+
st53:
|
|
1007
1109
|
#line 1 "NONE"
|
|
1008
1110
|
{ts = 0;}
|
|
1009
1111
|
if ( ++p == pe )
|
|
1010
|
-
goto
|
|
1011
|
-
case
|
|
1112
|
+
goto _test_eof53;
|
|
1113
|
+
case 53:
|
|
1012
1114
|
#line 1 "NONE"
|
|
1013
1115
|
{ts = p;}
|
|
1014
|
-
#line
|
|
1116
|
+
#line 1117 "ext/c/lexer.c"
|
|
1015
1117
|
switch( (*p) ) {
|
|
1016
|
-
case 34: goto
|
|
1017
|
-
case 39: goto
|
|
1018
|
-
case 45: goto
|
|
1019
|
-
case 63: goto
|
|
1020
|
-
case 95: goto
|
|
1118
|
+
case 34: goto tr75;
|
|
1119
|
+
case 39: goto tr76;
|
|
1120
|
+
case 45: goto st54;
|
|
1121
|
+
case 63: goto st55;
|
|
1122
|
+
case 95: goto st54;
|
|
1021
1123
|
}
|
|
1022
1124
|
if ( (*p) < 65 ) {
|
|
1023
1125
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
1024
|
-
goto
|
|
1126
|
+
goto st54;
|
|
1025
1127
|
} else if ( (*p) > 90 ) {
|
|
1026
1128
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
1027
|
-
goto
|
|
1129
|
+
goto st54;
|
|
1028
1130
|
} else
|
|
1029
|
-
goto
|
|
1030
|
-
goto
|
|
1031
|
-
|
|
1032
|
-
#line 1 "NONE"
|
|
1033
|
-
{te = p+1;}
|
|
1034
|
-
goto st56;
|
|
1035
|
-
st56:
|
|
1036
|
-
if ( ++p == pe )
|
|
1037
|
-
goto _test_eof56;
|
|
1038
|
-
case 56:
|
|
1039
|
-
#line 1040 "ext/c/lexer.c"
|
|
1040
|
-
if ( (*p) == 34 )
|
|
1041
|
-
goto tr36;
|
|
1042
|
-
goto st29;
|
|
1043
|
-
st29:
|
|
1044
|
-
if ( ++p == pe )
|
|
1045
|
-
goto _test_eof29;
|
|
1046
|
-
case 29:
|
|
1047
|
-
if ( (*p) == 34 )
|
|
1048
|
-
goto tr36;
|
|
1049
|
-
goto st29;
|
|
1050
|
-
tr78:
|
|
1051
|
-
#line 1 "NONE"
|
|
1052
|
-
{te = p+1;}
|
|
1053
|
-
goto st57;
|
|
1054
|
-
st57:
|
|
1055
|
-
if ( ++p == pe )
|
|
1056
|
-
goto _test_eof57;
|
|
1057
|
-
case 57:
|
|
1058
|
-
#line 1059 "ext/c/lexer.c"
|
|
1059
|
-
if ( (*p) == 39 )
|
|
1060
|
-
goto tr36;
|
|
1061
|
-
goto st30;
|
|
1062
|
-
st30:
|
|
1063
|
-
if ( ++p == pe )
|
|
1064
|
-
goto _test_eof30;
|
|
1065
|
-
case 30:
|
|
1066
|
-
if ( (*p) == 39 )
|
|
1067
|
-
goto tr36;
|
|
1068
|
-
goto st30;
|
|
1069
|
-
st58:
|
|
1131
|
+
goto st54;
|
|
1132
|
+
goto tr74;
|
|
1133
|
+
st54:
|
|
1070
1134
|
if ( ++p == pe )
|
|
1071
|
-
goto
|
|
1072
|
-
case
|
|
1135
|
+
goto _test_eof54;
|
|
1136
|
+
case 54:
|
|
1073
1137
|
switch( (*p) ) {
|
|
1074
|
-
case 45: goto
|
|
1075
|
-
case 95: goto
|
|
1138
|
+
case 45: goto st54;
|
|
1139
|
+
case 95: goto st54;
|
|
1076
1140
|
}
|
|
1077
1141
|
if ( (*p) < 65 ) {
|
|
1078
1142
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
1079
|
-
goto
|
|
1143
|
+
goto st54;
|
|
1080
1144
|
} else if ( (*p) > 90 ) {
|
|
1081
1145
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
1082
|
-
goto
|
|
1146
|
+
goto st54;
|
|
1083
1147
|
} else
|
|
1084
|
-
goto
|
|
1085
|
-
goto
|
|
1086
|
-
|
|
1148
|
+
goto st54;
|
|
1149
|
+
goto tr79;
|
|
1150
|
+
st55:
|
|
1087
1151
|
if ( ++p == pe )
|
|
1088
|
-
goto
|
|
1089
|
-
case
|
|
1152
|
+
goto _test_eof55;
|
|
1153
|
+
case 55:
|
|
1090
1154
|
if ( (*p) == 62 )
|
|
1091
|
-
goto
|
|
1092
|
-
goto
|
|
1093
|
-
|
|
1094
|
-
cs =
|
|
1095
|
-
#line
|
|
1155
|
+
goto tr81;
|
|
1156
|
+
goto tr80;
|
|
1157
|
+
tr83:
|
|
1158
|
+
( state->cs) = 56;
|
|
1159
|
+
#line 275 "ext/ragel/base_lexer.rl"
|
|
1096
1160
|
{te = p;p--;{
|
|
1097
1161
|
callback("on_element_name", data, encoding, ts, te);
|
|
1098
|
-
cs =
|
|
1162
|
+
( state->cs) = 58;
|
|
1099
1163
|
}}
|
|
1100
1164
|
goto _again;
|
|
1101
|
-
|
|
1102
|
-
#line
|
|
1165
|
+
tr84:
|
|
1166
|
+
#line 271 "ext/ragel/base_lexer.rl"
|
|
1103
1167
|
{te = p+1;{
|
|
1104
1168
|
callback("on_element_ns", data, encoding, ts, te - 1);
|
|
1105
1169
|
}}
|
|
1106
|
-
goto
|
|
1107
|
-
|
|
1170
|
+
goto st56;
|
|
1171
|
+
st56:
|
|
1108
1172
|
#line 1 "NONE"
|
|
1109
1173
|
{ts = 0;}
|
|
1110
1174
|
if ( ++p == pe )
|
|
1111
|
-
goto
|
|
1112
|
-
case
|
|
1175
|
+
goto _test_eof56;
|
|
1176
|
+
case 56:
|
|
1113
1177
|
#line 1 "NONE"
|
|
1114
1178
|
{ts = p;}
|
|
1115
|
-
#line
|
|
1179
|
+
#line 1180 "ext/c/lexer.c"
|
|
1116
1180
|
switch( (*p) ) {
|
|
1117
|
-
case 45: goto
|
|
1118
|
-
case 95: goto
|
|
1181
|
+
case 45: goto st57;
|
|
1182
|
+
case 95: goto st57;
|
|
1119
1183
|
}
|
|
1120
1184
|
if ( (*p) < 65 ) {
|
|
1121
1185
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
1122
|
-
goto
|
|
1186
|
+
goto st57;
|
|
1123
1187
|
} else if ( (*p) > 90 ) {
|
|
1124
1188
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
1125
|
-
goto
|
|
1189
|
+
goto st57;
|
|
1126
1190
|
} else
|
|
1127
|
-
goto
|
|
1191
|
+
goto st57;
|
|
1128
1192
|
goto st0;
|
|
1129
|
-
|
|
1193
|
+
st57:
|
|
1130
1194
|
if ( ++p == pe )
|
|
1131
|
-
goto
|
|
1132
|
-
case
|
|
1195
|
+
goto _test_eof57;
|
|
1196
|
+
case 57:
|
|
1133
1197
|
switch( (*p) ) {
|
|
1134
|
-
case 45: goto
|
|
1135
|
-
case 58: goto
|
|
1136
|
-
case 95: goto
|
|
1198
|
+
case 45: goto st57;
|
|
1199
|
+
case 58: goto tr84;
|
|
1200
|
+
case 95: goto st57;
|
|
1137
1201
|
}
|
|
1138
1202
|
if ( (*p) < 65 ) {
|
|
1139
1203
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
1140
|
-
goto
|
|
1204
|
+
goto st57;
|
|
1141
1205
|
} else if ( (*p) > 90 ) {
|
|
1142
1206
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
1143
|
-
goto
|
|
1207
|
+
goto st57;
|
|
1144
1208
|
} else
|
|
1145
|
-
goto
|
|
1146
|
-
goto
|
|
1147
|
-
|
|
1148
|
-
#line
|
|
1209
|
+
goto st57;
|
|
1210
|
+
goto tr83;
|
|
1211
|
+
tr31:
|
|
1212
|
+
#line 286 "ext/ragel/base_lexer.rl"
|
|
1149
1213
|
{te = p+1;{
|
|
1150
1214
|
callback_simple("advance_line");
|
|
1151
1215
|
}}
|
|
1152
|
-
goto
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
callback("on_string", data, encoding, ts + 1, te - 1);
|
|
1157
|
-
}}
|
|
1158
|
-
goto st62;
|
|
1159
|
-
tr43:
|
|
1160
|
-
cs = 62;
|
|
1161
|
-
#line 266 "ext/ragel/base_lexer.rl"
|
|
1216
|
+
goto st58;
|
|
1217
|
+
tr33:
|
|
1218
|
+
( state->cs) = 58;
|
|
1219
|
+
#line 310 "ext/ragel/base_lexer.rl"
|
|
1162
1220
|
{te = p+1;{
|
|
1163
1221
|
callback_simple("on_element_end");
|
|
1164
|
-
cs =
|
|
1222
|
+
( state->cs) = 29;
|
|
1165
1223
|
}}
|
|
1166
1224
|
goto _again;
|
|
1167
|
-
|
|
1168
|
-
#line
|
|
1225
|
+
tr85:
|
|
1226
|
+
#line 284 "ext/ragel/base_lexer.rl"
|
|
1169
1227
|
{te = p+1;}
|
|
1170
|
-
goto
|
|
1228
|
+
goto st58;
|
|
1229
|
+
tr87:
|
|
1230
|
+
#line 143 "ext/ragel/base_lexer.rl"
|
|
1231
|
+
{te = p+1;{
|
|
1232
|
+
callback_simple("on_string_dquote");
|
|
1233
|
+
|
|
1234
|
+
{( state->stack)[( state->top)++] = 58; goto st39;}
|
|
1235
|
+
}}
|
|
1236
|
+
goto st58;
|
|
1237
|
+
tr88:
|
|
1238
|
+
#line 137 "ext/ragel/base_lexer.rl"
|
|
1239
|
+
{te = p+1;{
|
|
1240
|
+
callback_simple("on_string_squote");
|
|
1241
|
+
|
|
1242
|
+
{( state->stack)[( state->top)++] = 58; goto st37;}
|
|
1243
|
+
}}
|
|
1244
|
+
goto st58;
|
|
1171
1245
|
tr91:
|
|
1172
|
-
cs =
|
|
1173
|
-
#line
|
|
1246
|
+
( state->cs) = 58;
|
|
1247
|
+
#line 304 "ext/ragel/base_lexer.rl"
|
|
1174
1248
|
{te = p+1;{
|
|
1175
1249
|
callback_simple("on_element_open_end");
|
|
1176
|
-
cs =
|
|
1250
|
+
( state->cs) = 29;
|
|
1177
1251
|
}}
|
|
1178
1252
|
goto _again;
|
|
1179
1253
|
tr92:
|
|
1180
|
-
#line
|
|
1254
|
+
#line 295 "ext/ragel/base_lexer.rl"
|
|
1181
1255
|
{te = p;p--;{
|
|
1182
1256
|
callback("on_attribute", data, encoding, ts, te);
|
|
1183
1257
|
}}
|
|
1184
|
-
goto
|
|
1258
|
+
goto st58;
|
|
1185
1259
|
tr93:
|
|
1186
|
-
#line
|
|
1260
|
+
#line 291 "ext/ragel/base_lexer.rl"
|
|
1187
1261
|
{te = p+1;{
|
|
1188
1262
|
callback("on_attribute_ns", data, encoding, ts, te - 1);
|
|
1189
1263
|
}}
|
|
1190
|
-
goto
|
|
1191
|
-
|
|
1264
|
+
goto st58;
|
|
1265
|
+
st58:
|
|
1192
1266
|
#line 1 "NONE"
|
|
1193
1267
|
{ts = 0;}
|
|
1194
1268
|
if ( ++p == pe )
|
|
1195
|
-
goto
|
|
1196
|
-
case
|
|
1269
|
+
goto _test_eof58;
|
|
1270
|
+
case 58:
|
|
1197
1271
|
#line 1 "NONE"
|
|
1198
1272
|
{ts = p;}
|
|
1199
|
-
#line
|
|
1273
|
+
#line 1274 "ext/c/lexer.c"
|
|
1200
1274
|
switch( (*p) ) {
|
|
1201
|
-
case 9: goto
|
|
1202
|
-
case 10: goto
|
|
1203
|
-
case 13: goto
|
|
1204
|
-
case 32: goto
|
|
1205
|
-
case 34: goto
|
|
1206
|
-
case 39: goto
|
|
1207
|
-
case 45: goto
|
|
1208
|
-
case 47: goto
|
|
1209
|
-
case 61: goto
|
|
1275
|
+
case 9: goto tr85;
|
|
1276
|
+
case 10: goto tr31;
|
|
1277
|
+
case 13: goto st27;
|
|
1278
|
+
case 32: goto tr85;
|
|
1279
|
+
case 34: goto tr87;
|
|
1280
|
+
case 39: goto tr88;
|
|
1281
|
+
case 45: goto st59;
|
|
1282
|
+
case 47: goto st28;
|
|
1283
|
+
case 61: goto tr85;
|
|
1210
1284
|
case 62: goto tr91;
|
|
1211
|
-
case 95: goto
|
|
1285
|
+
case 95: goto st59;
|
|
1212
1286
|
}
|
|
1213
1287
|
if ( (*p) < 65 ) {
|
|
1214
1288
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
1215
|
-
goto
|
|
1289
|
+
goto st59;
|
|
1216
1290
|
} else if ( (*p) > 90 ) {
|
|
1217
1291
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
1218
|
-
goto
|
|
1292
|
+
goto st59;
|
|
1219
1293
|
} else
|
|
1220
|
-
goto
|
|
1294
|
+
goto st59;
|
|
1221
1295
|
goto st0;
|
|
1222
|
-
|
|
1296
|
+
st27:
|
|
1223
1297
|
if ( ++p == pe )
|
|
1224
|
-
goto
|
|
1225
|
-
case
|
|
1298
|
+
goto _test_eof27;
|
|
1299
|
+
case 27:
|
|
1226
1300
|
if ( (*p) == 10 )
|
|
1227
|
-
goto
|
|
1301
|
+
goto tr31;
|
|
1228
1302
|
goto st0;
|
|
1229
|
-
|
|
1230
|
-
if ( ++p == pe )
|
|
1231
|
-
goto _test_eof32;
|
|
1232
|
-
case 32:
|
|
1233
|
-
if ( (*p) == 34 )
|
|
1234
|
-
goto tr41;
|
|
1235
|
-
goto st32;
|
|
1236
|
-
st33:
|
|
1237
|
-
if ( ++p == pe )
|
|
1238
|
-
goto _test_eof33;
|
|
1239
|
-
case 33:
|
|
1240
|
-
if ( (*p) == 39 )
|
|
1241
|
-
goto tr41;
|
|
1242
|
-
goto st33;
|
|
1243
|
-
st63:
|
|
1303
|
+
st59:
|
|
1244
1304
|
if ( ++p == pe )
|
|
1245
|
-
goto
|
|
1246
|
-
case
|
|
1305
|
+
goto _test_eof59;
|
|
1306
|
+
case 59:
|
|
1247
1307
|
switch( (*p) ) {
|
|
1248
|
-
case 45: goto
|
|
1308
|
+
case 45: goto st59;
|
|
1249
1309
|
case 58: goto tr93;
|
|
1250
|
-
case 95: goto
|
|
1310
|
+
case 95: goto st59;
|
|
1251
1311
|
}
|
|
1252
1312
|
if ( (*p) < 65 ) {
|
|
1253
1313
|
if ( 48 <= (*p) && (*p) <= 57 )
|
|
1254
|
-
goto
|
|
1314
|
+
goto st59;
|
|
1255
1315
|
} else if ( (*p) > 90 ) {
|
|
1256
1316
|
if ( 97 <= (*p) && (*p) <= 122 )
|
|
1257
|
-
goto
|
|
1317
|
+
goto st59;
|
|
1258
1318
|
} else
|
|
1259
|
-
goto
|
|
1319
|
+
goto st59;
|
|
1260
1320
|
goto tr92;
|
|
1261
|
-
|
|
1321
|
+
st28:
|
|
1262
1322
|
if ( ++p == pe )
|
|
1263
|
-
goto
|
|
1264
|
-
case
|
|
1323
|
+
goto _test_eof28;
|
|
1324
|
+
case 28:
|
|
1265
1325
|
if ( (*p) == 62 )
|
|
1266
|
-
goto
|
|
1326
|
+
goto tr33;
|
|
1267
1327
|
goto st0;
|
|
1268
1328
|
tr96:
|
|
1269
|
-
cs =
|
|
1270
|
-
#line
|
|
1329
|
+
( state->cs) = 60;
|
|
1330
|
+
#line 339 "ext/ragel/base_lexer.rl"
|
|
1271
1331
|
{te = p;p--;{
|
|
1272
1332
|
callback("on_text", data, encoding, ts, te);
|
|
1273
|
-
|
|
1333
|
+
|
|
1334
|
+
if ( lines > 0 )
|
|
1335
|
+
{
|
|
1336
|
+
advance_line(lines);
|
|
1337
|
+
|
|
1338
|
+
lines = 0;
|
|
1339
|
+
}
|
|
1340
|
+
|
|
1341
|
+
( state->cs) = 29;
|
|
1274
1342
|
}}
|
|
1275
1343
|
goto _again;
|
|
1276
1344
|
tr98:
|
|
1277
|
-
cs =
|
|
1278
|
-
#line
|
|
1345
|
+
( state->cs) = 60;
|
|
1346
|
+
#line 353 "ext/ragel/base_lexer.rl"
|
|
1279
1347
|
{te = p+1;{
|
|
1280
1348
|
callback("on_text", data, encoding, ts, mark);
|
|
1281
1349
|
|
|
1282
1350
|
p = mark - 1;
|
|
1283
1351
|
mark = 0;
|
|
1284
1352
|
|
|
1285
|
-
|
|
1353
|
+
if ( lines > 0 )
|
|
1354
|
+
{
|
|
1355
|
+
advance_line(lines);
|
|
1356
|
+
|
|
1357
|
+
lines = 0;
|
|
1358
|
+
}
|
|
1359
|
+
|
|
1360
|
+
( state->cs) = 29;
|
|
1286
1361
|
}}
|
|
1287
1362
|
goto _again;
|
|
1288
1363
|
tr99:
|
|
1289
|
-
cs =
|
|
1290
|
-
#line
|
|
1364
|
+
( state->cs) = 60;
|
|
1365
|
+
#line 339 "ext/ragel/base_lexer.rl"
|
|
1291
1366
|
{te = p+1;{
|
|
1292
1367
|
callback("on_text", data, encoding, ts, te);
|
|
1293
1368
|
|
|
1294
|
-
|
|
1369
|
+
if ( lines > 0 )
|
|
1370
|
+
{
|
|
1371
|
+
advance_line(lines);
|
|
1372
|
+
|
|
1373
|
+
lines = 0;
|
|
1374
|
+
}
|
|
1375
|
+
|
|
1376
|
+
( state->cs) = 29;
|
|
1295
1377
|
}}
|
|
1296
1378
|
goto _again;
|
|
1297
|
-
|
|
1379
|
+
st60:
|
|
1298
1380
|
#line 1 "NONE"
|
|
1299
1381
|
{ts = 0;}
|
|
1300
1382
|
if ( ++p == pe )
|
|
1301
|
-
goto
|
|
1302
|
-
case
|
|
1383
|
+
goto _test_eof60;
|
|
1384
|
+
case 60:
|
|
1303
1385
|
#line 1 "NONE"
|
|
1304
1386
|
{ts = p;}
|
|
1305
|
-
#line
|
|
1387
|
+
#line 1388 "ext/c/lexer.c"
|
|
1306
1388
|
if ( (*p) == 60 )
|
|
1307
1389
|
goto tr95;
|
|
1308
|
-
goto
|
|
1309
|
-
|
|
1390
|
+
goto tr94;
|
|
1391
|
+
tr94:
|
|
1392
|
+
#line 40 "ext/ragel/base_lexer.rl"
|
|
1393
|
+
{
|
|
1394
|
+
if ( (*p) == '\n' ) lines++;
|
|
1395
|
+
}
|
|
1396
|
+
goto st61;
|
|
1397
|
+
st61:
|
|
1310
1398
|
if ( ++p == pe )
|
|
1311
|
-
goto
|
|
1312
|
-
case
|
|
1399
|
+
goto _test_eof61;
|
|
1400
|
+
case 61:
|
|
1401
|
+
#line 1402 "ext/c/lexer.c"
|
|
1313
1402
|
if ( (*p) == 60 )
|
|
1314
1403
|
goto tr97;
|
|
1315
|
-
goto
|
|
1404
|
+
goto tr94;
|
|
1316
1405
|
tr97:
|
|
1317
|
-
#line
|
|
1406
|
+
#line 40 "ext/ragel/base_lexer.rl"
|
|
1407
|
+
{
|
|
1408
|
+
if ( (*p) == '\n' ) lines++;
|
|
1409
|
+
}
|
|
1410
|
+
#line 353 "ext/ragel/base_lexer.rl"
|
|
1318
1411
|
{ mark = p; }
|
|
1319
|
-
goto
|
|
1320
|
-
|
|
1412
|
+
goto st62;
|
|
1413
|
+
st62:
|
|
1321
1414
|
if ( ++p == pe )
|
|
1322
|
-
goto
|
|
1323
|
-
case
|
|
1324
|
-
#line
|
|
1415
|
+
goto _test_eof62;
|
|
1416
|
+
case 62:
|
|
1417
|
+
#line 1418 "ext/c/lexer.c"
|
|
1325
1418
|
switch( (*p) ) {
|
|
1326
1419
|
case 33: goto tr98;
|
|
1327
1420
|
case 45: goto tr98;
|
|
@@ -1337,16 +1430,20 @@ case 66:
|
|
|
1337
1430
|
goto tr98;
|
|
1338
1431
|
} else
|
|
1339
1432
|
goto tr98;
|
|
1340
|
-
goto
|
|
1433
|
+
goto tr94;
|
|
1341
1434
|
tr95:
|
|
1342
|
-
#line
|
|
1435
|
+
#line 40 "ext/ragel/base_lexer.rl"
|
|
1436
|
+
{
|
|
1437
|
+
if ( (*p) == '\n' ) lines++;
|
|
1438
|
+
}
|
|
1439
|
+
#line 353 "ext/ragel/base_lexer.rl"
|
|
1343
1440
|
{ mark = p; }
|
|
1344
|
-
goto
|
|
1345
|
-
|
|
1441
|
+
goto st63;
|
|
1442
|
+
st63:
|
|
1346
1443
|
if ( ++p == pe )
|
|
1347
|
-
goto
|
|
1348
|
-
case
|
|
1349
|
-
#line
|
|
1444
|
+
goto _test_eof63;
|
|
1445
|
+
case 63:
|
|
1446
|
+
#line 1447 "ext/c/lexer.c"
|
|
1350
1447
|
switch( (*p) ) {
|
|
1351
1448
|
case 33: goto tr99;
|
|
1352
1449
|
case 45: goto tr99;
|
|
@@ -1362,81 +1459,77 @@ case 67:
|
|
|
1362
1459
|
goto tr99;
|
|
1363
1460
|
} else
|
|
1364
1461
|
goto tr99;
|
|
1365
|
-
goto
|
|
1462
|
+
goto tr94;
|
|
1366
1463
|
}
|
|
1367
|
-
|
|
1368
|
-
|
|
1369
|
-
_test_eof1: cs = 1; goto _test_eof;
|
|
1370
|
-
_test_eof2: cs = 2; goto _test_eof;
|
|
1371
|
-
_test_eof3: cs = 3; goto _test_eof;
|
|
1372
|
-
_test_eof4: cs = 4; goto _test_eof;
|
|
1373
|
-
_test_eof5: cs = 5; goto _test_eof;
|
|
1374
|
-
_test_eof6: cs = 6; goto _test_eof;
|
|
1375
|
-
_test_eof7: cs = 7; goto _test_eof;
|
|
1376
|
-
_test_eof8: cs = 8; goto _test_eof;
|
|
1377
|
-
_test_eof9: cs = 9; goto _test_eof;
|
|
1378
|
-
_test_eof10: cs = 10; goto _test_eof;
|
|
1379
|
-
_test_eof11: cs = 11; goto _test_eof;
|
|
1380
|
-
_test_eof12: cs = 12; goto _test_eof;
|
|
1381
|
-
|
|
1382
|
-
_test_eof13: cs = 13; goto _test_eof;
|
|
1383
|
-
_test_eof14: cs = 14; goto _test_eof;
|
|
1384
|
-
_test_eof15: cs = 15; goto _test_eof;
|
|
1385
|
-
_test_eof16: cs = 16; goto _test_eof;
|
|
1386
|
-
_test_eof17: cs = 17; goto _test_eof;
|
|
1387
|
-
_test_eof18: cs = 18; goto _test_eof;
|
|
1388
|
-
_test_eof19: cs = 19; goto _test_eof;
|
|
1389
|
-
_test_eof20: cs = 20; goto _test_eof;
|
|
1390
|
-
_test_eof21: cs = 21; goto _test_eof;
|
|
1391
|
-
_test_eof22: cs = 22; goto _test_eof;
|
|
1392
|
-
_test_eof23: cs = 23; goto _test_eof;
|
|
1393
|
-
_test_eof24: cs = 24; goto _test_eof;
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
1412
|
-
|
|
1413
|
-
|
|
1414
|
-
|
|
1415
|
-
|
|
1416
|
-
|
|
1417
|
-
|
|
1418
|
-
|
|
1419
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
|
|
1426
|
-
|
|
1427
|
-
|
|
1428
|
-
|
|
1429
|
-
|
|
1430
|
-
_test_eof64: cs = 64; goto _test_eof;
|
|
1431
|
-
_test_eof65: cs = 65; goto _test_eof;
|
|
1432
|
-
_test_eof66: cs = 66; goto _test_eof;
|
|
1433
|
-
_test_eof67: cs = 67; goto _test_eof;
|
|
1464
|
+
_test_eof29: ( state->cs) = 29; goto _test_eof;
|
|
1465
|
+
_test_eof30: ( state->cs) = 30; goto _test_eof;
|
|
1466
|
+
_test_eof1: ( state->cs) = 1; goto _test_eof;
|
|
1467
|
+
_test_eof2: ( state->cs) = 2; goto _test_eof;
|
|
1468
|
+
_test_eof3: ( state->cs) = 3; goto _test_eof;
|
|
1469
|
+
_test_eof4: ( state->cs) = 4; goto _test_eof;
|
|
1470
|
+
_test_eof5: ( state->cs) = 5; goto _test_eof;
|
|
1471
|
+
_test_eof6: ( state->cs) = 6; goto _test_eof;
|
|
1472
|
+
_test_eof7: ( state->cs) = 7; goto _test_eof;
|
|
1473
|
+
_test_eof8: ( state->cs) = 8; goto _test_eof;
|
|
1474
|
+
_test_eof9: ( state->cs) = 9; goto _test_eof;
|
|
1475
|
+
_test_eof10: ( state->cs) = 10; goto _test_eof;
|
|
1476
|
+
_test_eof11: ( state->cs) = 11; goto _test_eof;
|
|
1477
|
+
_test_eof12: ( state->cs) = 12; goto _test_eof;
|
|
1478
|
+
_test_eof31: ( state->cs) = 31; goto _test_eof;
|
|
1479
|
+
_test_eof13: ( state->cs) = 13; goto _test_eof;
|
|
1480
|
+
_test_eof14: ( state->cs) = 14; goto _test_eof;
|
|
1481
|
+
_test_eof15: ( state->cs) = 15; goto _test_eof;
|
|
1482
|
+
_test_eof16: ( state->cs) = 16; goto _test_eof;
|
|
1483
|
+
_test_eof17: ( state->cs) = 17; goto _test_eof;
|
|
1484
|
+
_test_eof18: ( state->cs) = 18; goto _test_eof;
|
|
1485
|
+
_test_eof19: ( state->cs) = 19; goto _test_eof;
|
|
1486
|
+
_test_eof20: ( state->cs) = 20; goto _test_eof;
|
|
1487
|
+
_test_eof21: ( state->cs) = 21; goto _test_eof;
|
|
1488
|
+
_test_eof22: ( state->cs) = 22; goto _test_eof;
|
|
1489
|
+
_test_eof23: ( state->cs) = 23; goto _test_eof;
|
|
1490
|
+
_test_eof24: ( state->cs) = 24; goto _test_eof;
|
|
1491
|
+
_test_eof32: ( state->cs) = 32; goto _test_eof;
|
|
1492
|
+
_test_eof33: ( state->cs) = 33; goto _test_eof;
|
|
1493
|
+
_test_eof34: ( state->cs) = 34; goto _test_eof;
|
|
1494
|
+
_test_eof35: ( state->cs) = 35; goto _test_eof;
|
|
1495
|
+
_test_eof36: ( state->cs) = 36; goto _test_eof;
|
|
1496
|
+
_test_eof37: ( state->cs) = 37; goto _test_eof;
|
|
1497
|
+
_test_eof38: ( state->cs) = 38; goto _test_eof;
|
|
1498
|
+
_test_eof39: ( state->cs) = 39; goto _test_eof;
|
|
1499
|
+
_test_eof40: ( state->cs) = 40; goto _test_eof;
|
|
1500
|
+
_test_eof41: ( state->cs) = 41; goto _test_eof;
|
|
1501
|
+
_test_eof42: ( state->cs) = 42; goto _test_eof;
|
|
1502
|
+
_test_eof43: ( state->cs) = 43; goto _test_eof;
|
|
1503
|
+
_test_eof44: ( state->cs) = 44; goto _test_eof;
|
|
1504
|
+
_test_eof45: ( state->cs) = 45; goto _test_eof;
|
|
1505
|
+
_test_eof46: ( state->cs) = 46; goto _test_eof;
|
|
1506
|
+
_test_eof47: ( state->cs) = 47; goto _test_eof;
|
|
1507
|
+
_test_eof48: ( state->cs) = 48; goto _test_eof;
|
|
1508
|
+
_test_eof49: ( state->cs) = 49; goto _test_eof;
|
|
1509
|
+
_test_eof50: ( state->cs) = 50; goto _test_eof;
|
|
1510
|
+
_test_eof51: ( state->cs) = 51; goto _test_eof;
|
|
1511
|
+
_test_eof52: ( state->cs) = 52; goto _test_eof;
|
|
1512
|
+
_test_eof25: ( state->cs) = 25; goto _test_eof;
|
|
1513
|
+
_test_eof26: ( state->cs) = 26; goto _test_eof;
|
|
1514
|
+
_test_eof53: ( state->cs) = 53; goto _test_eof;
|
|
1515
|
+
_test_eof54: ( state->cs) = 54; goto _test_eof;
|
|
1516
|
+
_test_eof55: ( state->cs) = 55; goto _test_eof;
|
|
1517
|
+
_test_eof56: ( state->cs) = 56; goto _test_eof;
|
|
1518
|
+
_test_eof57: ( state->cs) = 57; goto _test_eof;
|
|
1519
|
+
_test_eof58: ( state->cs) = 58; goto _test_eof;
|
|
1520
|
+
_test_eof27: ( state->cs) = 27; goto _test_eof;
|
|
1521
|
+
_test_eof59: ( state->cs) = 59; goto _test_eof;
|
|
1522
|
+
_test_eof28: ( state->cs) = 28; goto _test_eof;
|
|
1523
|
+
_test_eof60: ( state->cs) = 60; goto _test_eof;
|
|
1524
|
+
_test_eof61: ( state->cs) = 61; goto _test_eof;
|
|
1525
|
+
_test_eof62: ( state->cs) = 62; goto _test_eof;
|
|
1526
|
+
_test_eof63: ( state->cs) = 63; goto _test_eof;
|
|
1434
1527
|
|
|
1435
1528
|
_test_eof: {}
|
|
1436
1529
|
if ( p == eof )
|
|
1437
1530
|
{
|
|
1438
|
-
switch ( cs ) {
|
|
1439
|
-
case
|
|
1531
|
+
switch ( ( state->cs) ) {
|
|
1532
|
+
case 30: goto tr36;
|
|
1440
1533
|
case 1: goto tr0;
|
|
1441
1534
|
case 2: goto tr0;
|
|
1442
1535
|
case 3: goto tr0;
|
|
@@ -1449,7 +1542,7 @@ case 67:
|
|
|
1449
1542
|
case 10: goto tr0;
|
|
1450
1543
|
case 11: goto tr0;
|
|
1451
1544
|
case 12: goto tr0;
|
|
1452
|
-
case
|
|
1545
|
+
case 31: goto tr40;
|
|
1453
1546
|
case 13: goto tr0;
|
|
1454
1547
|
case 14: goto tr0;
|
|
1455
1548
|
case 15: goto tr0;
|
|
@@ -1462,42 +1555,39 @@ case 67:
|
|
|
1462
1555
|
case 22: goto tr0;
|
|
1463
1556
|
case 23: goto tr0;
|
|
1464
1557
|
case 24: goto tr0;
|
|
1558
|
+
case 32: goto tr41;
|
|
1559
|
+
case 33: goto tr42;
|
|
1560
|
+
case 34: goto tr42;
|
|
1561
|
+
case 36: goto tr47;
|
|
1465
1562
|
case 38: goto tr51;
|
|
1466
|
-
case
|
|
1467
|
-
case
|
|
1468
|
-
case
|
|
1469
|
-
case 44: goto
|
|
1470
|
-
case 45: goto
|
|
1471
|
-
case 46: goto
|
|
1472
|
-
case 47: goto
|
|
1473
|
-
case 48: goto
|
|
1474
|
-
case 49: goto
|
|
1475
|
-
case 50: goto
|
|
1476
|
-
case 51: goto
|
|
1477
|
-
case 52: goto
|
|
1478
|
-
case
|
|
1479
|
-
case
|
|
1480
|
-
case
|
|
1481
|
-
case
|
|
1482
|
-
case
|
|
1483
|
-
case
|
|
1484
|
-
case
|
|
1485
|
-
case 59: goto tr81;
|
|
1486
|
-
case 61: goto tr85;
|
|
1487
|
-
case 63: goto tr92;
|
|
1488
|
-
case 65: goto tr96;
|
|
1489
|
-
case 66: goto tr96;
|
|
1490
|
-
case 67: goto tr96;
|
|
1563
|
+
case 40: goto tr54;
|
|
1564
|
+
case 42: goto tr63;
|
|
1565
|
+
case 43: goto tr64;
|
|
1566
|
+
case 44: goto tr64;
|
|
1567
|
+
case 45: goto tr64;
|
|
1568
|
+
case 46: goto tr64;
|
|
1569
|
+
case 47: goto tr64;
|
|
1570
|
+
case 48: goto tr64;
|
|
1571
|
+
case 49: goto tr64;
|
|
1572
|
+
case 50: goto tr64;
|
|
1573
|
+
case 51: goto tr64;
|
|
1574
|
+
case 52: goto tr64;
|
|
1575
|
+
case 54: goto tr79;
|
|
1576
|
+
case 55: goto tr80;
|
|
1577
|
+
case 57: goto tr83;
|
|
1578
|
+
case 59: goto tr92;
|
|
1579
|
+
case 61: goto tr96;
|
|
1580
|
+
case 62: goto tr96;
|
|
1581
|
+
case 63: goto tr96;
|
|
1491
1582
|
}
|
|
1492
1583
|
}
|
|
1493
1584
|
|
|
1494
1585
|
_out: {}
|
|
1495
1586
|
}
|
|
1496
1587
|
|
|
1497
|
-
#line
|
|
1588
|
+
#line 97 "ext/c/lexer.rl"
|
|
1498
1589
|
|
|
1499
|
-
|
|
1500
|
-
oga_ivar_set(self, "@cs", INT2NUM(cs));
|
|
1590
|
+
state->lines = lines;
|
|
1501
1591
|
|
|
1502
1592
|
return Qnil;
|
|
1503
1593
|
}
|
|
@@ -1507,14 +1597,39 @@ case 67:
|
|
|
1507
1597
|
*/
|
|
1508
1598
|
VALUE oga_xml_lexer_reset(VALUE self)
|
|
1509
1599
|
{
|
|
1510
|
-
|
|
1511
|
-
|
|
1600
|
+
OgaLexerState *state;
|
|
1601
|
+
|
|
1602
|
+
Data_Get_Struct(self, OgaLexerState, state);
|
|
1603
|
+
|
|
1604
|
+
state->act = 0;
|
|
1605
|
+
state->cs = c_lexer_start;
|
|
1606
|
+
state->lines = 0;
|
|
1607
|
+
state->top = 0;
|
|
1512
1608
|
|
|
1513
1609
|
return Qnil;
|
|
1514
1610
|
}
|
|
1515
1611
|
|
|
1612
|
+
/**
|
|
1613
|
+
* Frees the associated lexer state struct.
|
|
1614
|
+
*/
|
|
1615
|
+
void oga_xml_lexer_free(void *state)
|
|
1616
|
+
{
|
|
1617
|
+
free((OgaLexerState *) state);
|
|
1618
|
+
}
|
|
1619
|
+
|
|
1620
|
+
/**
|
|
1621
|
+
* Allocates and wraps the C lexer state struct. This state is used to keep
|
|
1622
|
+
* track of the current position, line numbers, etc.
|
|
1623
|
+
*/
|
|
1624
|
+
VALUE oga_xml_lexer_allocate(VALUE klass)
|
|
1625
|
+
{
|
|
1626
|
+
OgaLexerState *state = malloc(sizeof(OgaLexerState));
|
|
1516
1627
|
|
|
1517
|
-
|
|
1628
|
+
return Data_Wrap_Struct(klass, NULL, oga_xml_lexer_free, state);
|
|
1629
|
+
}
|
|
1630
|
+
|
|
1631
|
+
|
|
1632
|
+
#line 146 "ext/c/lexer.rl"
|
|
1518
1633
|
|
|
1519
1634
|
|
|
1520
1635
|
void Init_liboga_xml_lexer()
|
|
@@ -1525,4 +1640,6 @@ void Init_liboga_xml_lexer()
|
|
|
1525
1640
|
|
|
1526
1641
|
rb_define_method(cLexer, "advance_native", oga_xml_lexer_advance, 1);
|
|
1527
1642
|
rb_define_method(cLexer, "reset_native", oga_xml_lexer_reset, 0);
|
|
1643
|
+
|
|
1644
|
+
rb_define_alloc_func(cLexer, oga_xml_lexer_allocate);
|
|
1528
1645
|
}
|