mongrel_esi 0.4.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.
- data/COPYING +53 -0
- data/LICENSE +471 -0
- data/README +186 -0
- data/Rakefile +141 -0
- data/bin/mongrel_esi +271 -0
- data/ext/esi/common.rl +41 -0
- data/ext/esi/esi_parser.c +387 -0
- data/ext/esi/extconf.rb +6 -0
- data/ext/esi/machine.rb +499 -0
- data/ext/esi/parser.c +1675 -0
- data/ext/esi/parser.h +113 -0
- data/ext/esi/parser.rb +49 -0
- data/ext/esi/parser.rl +398 -0
- data/ext/esi/ruby_esi.rl +135 -0
- data/ext/esi/run-test.rb +3 -0
- data/ext/esi/test/common.rl +41 -0
- data/ext/esi/test/parser.c +1676 -0
- data/ext/esi/test/parser.h +113 -0
- data/ext/esi/test/parser.rl +398 -0
- data/ext/esi/test/test.c +373 -0
- data/ext/esi/test1.rb +56 -0
- data/ext/esi/test2.rb +45 -0
- data/lib/esi/cache.rb +207 -0
- data/lib/esi/config.rb +154 -0
- data/lib/esi/dispatcher.rb +27 -0
- data/lib/esi/handler.rb +236 -0
- data/lib/esi/invalidator.rb +40 -0
- data/lib/esi/logger.rb +46 -0
- data/lib/esi/router.rb +84 -0
- data/lib/esi/tag/attempt.rb +6 -0
- data/lib/esi/tag/base.rb +85 -0
- data/lib/esi/tag/except.rb +24 -0
- data/lib/esi/tag/include.rb +190 -0
- data/lib/esi/tag/invalidate.rb +54 -0
- data/lib/esi/tag/try.rb +40 -0
- data/lib/multi_dirhandler.rb +70 -0
- data/setup.rb +1585 -0
- data/test/integration/basic_test.rb +39 -0
- data/test/integration/cache_test.rb +37 -0
- data/test/integration/docs/content/500.html +16 -0
- data/test/integration/docs/content/500_with_failover.html +16 -0
- data/test/integration/docs/content/500_with_failover_to_alt.html +8 -0
- data/test/integration/docs/content/ajax_test_page.html +15 -0
- data/test/integration/docs/content/cookie_variable.html +3 -0
- data/test/integration/docs/content/foo.html +15 -0
- data/test/integration/docs/content/include_in_include.html +15 -0
- data/test/integration/docs/content/malformed_transforms.html +16 -0
- data/test/integration/docs/content/malformed_transforms.html-correct +11 -0
- data/test/integration/docs/content/static-failover.html +20 -0
- data/test/integration/docs/content/test2.html +1 -0
- data/test/integration/docs/content/test3.html +17 -0
- data/test/integration/docs/esi_invalidate.html +6 -0
- data/test/integration/docs/esi_mixed_content.html +15 -0
- data/test/integration/docs/esi_test_content.html +27 -0
- data/test/integration/docs/index.html +688 -0
- data/test/integration/docs/test1.html +1 -0
- data/test/integration/docs/test3.html +9 -0
- data/test/integration/docs/test_failover.html +1 -0
- data/test/integration/handler_test.rb +270 -0
- data/test/integration/help.rb +234 -0
- data/test/net/get_test.rb +197 -0
- data/test/net/net_helper.rb +16 -0
- data/test/net/server_test.rb +249 -0
- data/test/unit/base_tag_test.rb +44 -0
- data/test/unit/esi-sample.html +56 -0
- data/test/unit/help.rb +77 -0
- data/test/unit/include_request_test.rb +69 -0
- data/test/unit/include_tag_test.rb +14 -0
- data/test/unit/parser_test.rb +478 -0
- data/test/unit/router_test.rb +34 -0
- data/test/unit/sample.html +21 -0
- data/tools/rakehelp.rb +119 -0
- metadata +182 -0
data/ext/esi/parser.c
ADDED
|
@@ -0,0 +1,1675 @@
|
|
|
1
|
+
#line 1 "parser.rl"
|
|
2
|
+
#include <stdio.h>
|
|
3
|
+
#include <stdlib.h>
|
|
4
|
+
#include <string.h>
|
|
5
|
+
#include <ctype.h>
|
|
6
|
+
#include "parser.h"
|
|
7
|
+
|
|
8
|
+
/* define default callbacks */
|
|
9
|
+
static void
|
|
10
|
+
esi_parser_default_start_cb( const void *data,
|
|
11
|
+
const char *name_start,
|
|
12
|
+
size_t name_length,
|
|
13
|
+
ESIAttribute *attributes,
|
|
14
|
+
void *user_data )
|
|
15
|
+
{
|
|
16
|
+
}
|
|
17
|
+
static void
|
|
18
|
+
esi_parser_default_end_cb( const void *data,
|
|
19
|
+
const char *name_start,
|
|
20
|
+
size_t name_length,
|
|
21
|
+
void *user_data )
|
|
22
|
+
{
|
|
23
|
+
}
|
|
24
|
+
static void
|
|
25
|
+
esi_parser_default_output_cp(const void *data,
|
|
26
|
+
size_t length,
|
|
27
|
+
void *user_data)
|
|
28
|
+
{
|
|
29
|
+
}
|
|
30
|
+
#ifdef DEBUG
|
|
31
|
+
static void debug_string( const char *msg, const char *str, size_t len )
|
|
32
|
+
{
|
|
33
|
+
char *pstr = esi_strndup( str, len );
|
|
34
|
+
printf( "%s :'%s'\n", msg, pstr );
|
|
35
|
+
free( pstr );
|
|
36
|
+
}
|
|
37
|
+
#endif
|
|
38
|
+
|
|
39
|
+
static void esi_parser_echo_char( ESIParser *parser, char ch )
|
|
40
|
+
{
|
|
41
|
+
parser->output_handler( (void*)&ch, 1, parser->user_data );
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
static void esi_parser_echo_buffer( ESIParser *parser )
|
|
45
|
+
{
|
|
46
|
+
// debug_string( "echobuffer", parser->echobuffer, parser->echobuffer_index+1 );
|
|
47
|
+
parser->output_handler( parser->echobuffer, parser->echobuffer_index+1, parser->user_data );
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
static void esi_parser_echobuffer_clear( ESIParser *parser )
|
|
51
|
+
{
|
|
52
|
+
parser->echobuffer_index = -1;
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
static void esi_parser_concat_to_echobuffer( ESIParser *parser, char ch )
|
|
56
|
+
{
|
|
57
|
+
parser->echobuffer_index++;
|
|
58
|
+
|
|
59
|
+
if( parser->echobuffer_allocated <= parser->echobuffer_index ){
|
|
60
|
+
// double the echobuffer size
|
|
61
|
+
parser->echobuffer_allocated *= 2;
|
|
62
|
+
parser->echobuffer = (char*)realloc( parser->echobuffer, parser->echobuffer_allocated );
|
|
63
|
+
}
|
|
64
|
+
parser->echobuffer[parser->echobuffer_index] = ch;
|
|
65
|
+
// debug_string( "echo buffer", parser->echobuffer, parser->echobuffer_index+1 );
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
static void ltrim_pointer( const char **ptr, const char *bounds, size_t *len )
|
|
69
|
+
{
|
|
70
|
+
// remove any spaces or = at the before the value
|
|
71
|
+
while( isspace( **ptr ) ||
|
|
72
|
+
**ptr == '=' ||
|
|
73
|
+
**ptr == '"' ||
|
|
74
|
+
**ptr == '<' ||
|
|
75
|
+
**ptr == '\'' &&
|
|
76
|
+
*len > 0 &&
|
|
77
|
+
(*ptr != bounds) ){
|
|
78
|
+
(*ptr)++;
|
|
79
|
+
(*len)--;
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
#line 198 "parser.rl"
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
#line 88 "parser.c"
|
|
88
|
+
static const int esi_start = 56;
|
|
89
|
+
static const int esi_first_final = 56;
|
|
90
|
+
static const int esi_error = -1;
|
|
91
|
+
|
|
92
|
+
static const int esi_en_main = 56;
|
|
93
|
+
|
|
94
|
+
#line 201 "parser.rl"
|
|
95
|
+
|
|
96
|
+
char *esi_strndup( const char *str, size_t len )
|
|
97
|
+
{
|
|
98
|
+
char *s = (char*)malloc(sizeof(char)*(len+1));
|
|
99
|
+
memcpy( s, str, len );
|
|
100
|
+
s[len] = '\0';
|
|
101
|
+
return s;
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
ESIAttribute *esi_attribute_new( const char *name, size_t name_length, const char *value, size_t value_length )
|
|
105
|
+
{
|
|
106
|
+
ESIAttribute *attr = (ESIAttribute*)malloc(sizeof(ESIAttribute));
|
|
107
|
+
attr->name = esi_strndup(name, name_length);
|
|
108
|
+
attr->value = esi_strndup(value, value_length);
|
|
109
|
+
attr->next = NULL;
|
|
110
|
+
return attr;
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
ESIAttribute *esi_attribute_copy( ESIAttribute *attribute )
|
|
114
|
+
{
|
|
115
|
+
ESIAttribute *head, *nattr;
|
|
116
|
+
if( !attribute ){ return NULL; }
|
|
117
|
+
|
|
118
|
+
// copy the first attribute
|
|
119
|
+
nattr = esi_attribute_new( attribute->name, strlen( attribute->name ),
|
|
120
|
+
attribute->value, strlen( attribute->value ) );
|
|
121
|
+
// save a pointer for return
|
|
122
|
+
head = nattr;
|
|
123
|
+
// copy next attributes
|
|
124
|
+
attribute = attribute->next;
|
|
125
|
+
while( attribute ) {
|
|
126
|
+
// set the next attribute
|
|
127
|
+
nattr->next = esi_attribute_new( attribute->name, strlen( attribute->name ),
|
|
128
|
+
attribute->value, strlen( attribute->value ) );
|
|
129
|
+
// next attribute
|
|
130
|
+
nattr = nattr->next;
|
|
131
|
+
attribute = attribute->next;
|
|
132
|
+
}
|
|
133
|
+
return head;
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
void esi_attribute_free( ESIAttribute *attribute )
|
|
137
|
+
{
|
|
138
|
+
ESIAttribute *ptr;
|
|
139
|
+
while( attribute ){
|
|
140
|
+
free( attribute->name );
|
|
141
|
+
free( attribute->value );
|
|
142
|
+
ptr = attribute->next;
|
|
143
|
+
free( attribute );
|
|
144
|
+
attribute = ptr;
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
ESIParser *esi_parser_new()
|
|
149
|
+
{
|
|
150
|
+
ESIParser *parser = (ESIParser*)malloc(sizeof(ESIParser));
|
|
151
|
+
parser->cs = esi_start;
|
|
152
|
+
parser->mark = NULL;
|
|
153
|
+
parser->overflow_data_size = 0;
|
|
154
|
+
parser->overflow_data = NULL;
|
|
155
|
+
|
|
156
|
+
/* allocate 1024 bytes for the echobuffer */
|
|
157
|
+
parser->echobuffer_allocated = 1024;
|
|
158
|
+
parser->echobuffer_index = -1;
|
|
159
|
+
parser->echobuffer = (char*)malloc(sizeof(char)*parser->echobuffer_allocated);
|
|
160
|
+
|
|
161
|
+
parser->attributes = NULL;
|
|
162
|
+
parser->last = NULL;
|
|
163
|
+
|
|
164
|
+
parser->start_tag_handler = esi_parser_default_start_cb;
|
|
165
|
+
parser->end_tag_handler = esi_parser_default_end_cb;
|
|
166
|
+
parser->output_handler = esi_parser_default_output_cp;
|
|
167
|
+
|
|
168
|
+
return parser;
|
|
169
|
+
}
|
|
170
|
+
void esi_parser_free( ESIParser *parser )
|
|
171
|
+
{
|
|
172
|
+
if( parser->overflow_data ){ free( parser->overflow_data ); }
|
|
173
|
+
|
|
174
|
+
free( parser->echobuffer );
|
|
175
|
+
esi_attribute_free( parser->attributes );
|
|
176
|
+
|
|
177
|
+
free( parser );
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
void esi_parser_output_handler( ESIParser *parser, output_cb output_handler )
|
|
181
|
+
{
|
|
182
|
+
parser->output_handler = output_handler;
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
int esi_parser_init( ESIParser *parser )
|
|
186
|
+
{
|
|
187
|
+
int cs;
|
|
188
|
+
|
|
189
|
+
#line 190 "parser.c"
|
|
190
|
+
{
|
|
191
|
+
cs = esi_start;
|
|
192
|
+
}
|
|
193
|
+
#line 295 "parser.rl"
|
|
194
|
+
parser->prev_state = parser->cs = cs;
|
|
195
|
+
return 0;
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
static int compute_offset( const char *mark, const char *data )
|
|
199
|
+
{
|
|
200
|
+
if( mark ){
|
|
201
|
+
return mark - data;
|
|
202
|
+
}
|
|
203
|
+
return -1;
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
|
|
207
|
+
{
|
|
208
|
+
int cs = parser->cs;
|
|
209
|
+
const char *p = data;
|
|
210
|
+
const char *pe = data + length;
|
|
211
|
+
|
|
212
|
+
if( length == 0 ){ return cs; }
|
|
213
|
+
|
|
214
|
+
if( parser->overflow_data && parser->overflow_data_size > 0 ){
|
|
215
|
+
|
|
216
|
+
// recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
|
|
217
|
+
int mark_offset = compute_offset( parser->mark, parser->overflow_data );
|
|
218
|
+
int tag_text_offset = compute_offset( parser->tag_text, parser->overflow_data );
|
|
219
|
+
int attr_key_offset = compute_offset( parser->attr_key, parser->overflow_data );
|
|
220
|
+
int attr_value_offset = compute_offset( parser->attr_value, parser->overflow_data );
|
|
221
|
+
|
|
222
|
+
// debug_string("grow overflow buffer", parser->overflow_data, parser->overflow_data_size );
|
|
223
|
+
|
|
224
|
+
parser->overflow_data = (char*)realloc( parser->overflow_data, sizeof(char)*(parser->overflow_data_size+length) );
|
|
225
|
+
memcpy( parser->overflow_data+parser->overflow_data_size, data, length );
|
|
226
|
+
|
|
227
|
+
p = parser->overflow_data + parser->overflow_data_size;
|
|
228
|
+
|
|
229
|
+
// in our new memory space mark will now be
|
|
230
|
+
parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
|
|
231
|
+
parser->tag_text = ( tag_text_offset >= 0 ) ? parser->overflow_data + tag_text_offset : NULL;
|
|
232
|
+
parser->attr_key = ( attr_key_offset >= 0 ) ? parser->overflow_data + attr_key_offset : NULL;
|
|
233
|
+
parser->attr_value = ( attr_value_offset >= 0 ) ? parser->overflow_data + attr_value_offset : NULL;
|
|
234
|
+
|
|
235
|
+
data = parser->overflow_data;
|
|
236
|
+
parser->overflow_data_size = length = length + parser->overflow_data_size;
|
|
237
|
+
pe = data + length;
|
|
238
|
+
|
|
239
|
+
// debug_string( "overflow", parser->overflow_data, parser->overflow_data_size );
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
if( !parser->mark ){
|
|
243
|
+
parser->mark = p;
|
|
244
|
+
}
|
|
245
|
+
|
|
246
|
+
// printf( "cs: %d, ", cs );
|
|
247
|
+
// debug_string( "data", data, length );
|
|
248
|
+
|
|
249
|
+
|
|
250
|
+
#line 251 "parser.c"
|
|
251
|
+
{
|
|
252
|
+
if ( p == pe )
|
|
253
|
+
goto _out;
|
|
254
|
+
_resume:
|
|
255
|
+
switch ( cs ) {
|
|
256
|
+
case 56:
|
|
257
|
+
if ( (*p) == 60 )
|
|
258
|
+
goto tr1;
|
|
259
|
+
goto tr0;
|
|
260
|
+
case 0:
|
|
261
|
+
if ( (*p) == 60 )
|
|
262
|
+
goto tr1;
|
|
263
|
+
goto tr0;
|
|
264
|
+
case 1:
|
|
265
|
+
switch( (*p) ) {
|
|
266
|
+
case 47: goto tr2;
|
|
267
|
+
case 60: goto tr1;
|
|
268
|
+
case 101: goto tr3;
|
|
269
|
+
}
|
|
270
|
+
goto tr0;
|
|
271
|
+
case 2:
|
|
272
|
+
switch( (*p) ) {
|
|
273
|
+
case 60: goto tr1;
|
|
274
|
+
case 101: goto tr4;
|
|
275
|
+
}
|
|
276
|
+
goto tr0;
|
|
277
|
+
case 3:
|
|
278
|
+
switch( (*p) ) {
|
|
279
|
+
case 60: goto tr1;
|
|
280
|
+
case 115: goto tr5;
|
|
281
|
+
}
|
|
282
|
+
goto tr0;
|
|
283
|
+
case 4:
|
|
284
|
+
switch( (*p) ) {
|
|
285
|
+
case 60: goto tr1;
|
|
286
|
+
case 105: goto tr6;
|
|
287
|
+
}
|
|
288
|
+
goto tr0;
|
|
289
|
+
case 5:
|
|
290
|
+
switch( (*p) ) {
|
|
291
|
+
case 58: goto tr7;
|
|
292
|
+
case 60: goto tr1;
|
|
293
|
+
}
|
|
294
|
+
goto tr0;
|
|
295
|
+
case 6:
|
|
296
|
+
if ( (*p) == 60 )
|
|
297
|
+
goto tr1;
|
|
298
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
299
|
+
goto tr8;
|
|
300
|
+
goto tr0;
|
|
301
|
+
case 7:
|
|
302
|
+
switch( (*p) ) {
|
|
303
|
+
case 60: goto tr1;
|
|
304
|
+
case 62: goto tr9;
|
|
305
|
+
}
|
|
306
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
307
|
+
goto tr8;
|
|
308
|
+
goto tr0;
|
|
309
|
+
case 8:
|
|
310
|
+
switch( (*p) ) {
|
|
311
|
+
case 60: goto tr1;
|
|
312
|
+
case 115: goto tr10;
|
|
313
|
+
}
|
|
314
|
+
goto tr0;
|
|
315
|
+
case 9:
|
|
316
|
+
switch( (*p) ) {
|
|
317
|
+
case 60: goto tr1;
|
|
318
|
+
case 105: goto tr11;
|
|
319
|
+
}
|
|
320
|
+
goto tr0;
|
|
321
|
+
case 10:
|
|
322
|
+
switch( (*p) ) {
|
|
323
|
+
case 58: goto tr12;
|
|
324
|
+
case 60: goto tr1;
|
|
325
|
+
}
|
|
326
|
+
goto tr0;
|
|
327
|
+
case 11:
|
|
328
|
+
if ( (*p) == 60 )
|
|
329
|
+
goto tr1;
|
|
330
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
331
|
+
goto tr13;
|
|
332
|
+
goto tr0;
|
|
333
|
+
case 12:
|
|
334
|
+
switch( (*p) ) {
|
|
335
|
+
case 32: goto tr14;
|
|
336
|
+
case 47: goto tr15;
|
|
337
|
+
case 60: goto tr1;
|
|
338
|
+
case 62: goto tr16;
|
|
339
|
+
}
|
|
340
|
+
if ( (*p) > 13 ) {
|
|
341
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
342
|
+
goto tr13;
|
|
343
|
+
} else if ( (*p) >= 9 )
|
|
344
|
+
goto tr14;
|
|
345
|
+
goto tr0;
|
|
346
|
+
case 13:
|
|
347
|
+
switch( (*p) ) {
|
|
348
|
+
case 32: goto tr17;
|
|
349
|
+
case 45: goto tr18;
|
|
350
|
+
case 47: goto tr19;
|
|
351
|
+
case 60: goto tr1;
|
|
352
|
+
case 62: goto tr20;
|
|
353
|
+
case 95: goto tr18;
|
|
354
|
+
}
|
|
355
|
+
if ( (*p) < 65 ) {
|
|
356
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
357
|
+
goto tr17;
|
|
358
|
+
} else if ( (*p) > 90 ) {
|
|
359
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
360
|
+
goto tr18;
|
|
361
|
+
} else
|
|
362
|
+
goto tr18;
|
|
363
|
+
goto tr0;
|
|
364
|
+
case 14:
|
|
365
|
+
switch( (*p) ) {
|
|
366
|
+
case 32: goto tr17;
|
|
367
|
+
case 45: goto tr18;
|
|
368
|
+
case 47: goto tr19;
|
|
369
|
+
case 60: goto tr1;
|
|
370
|
+
case 95: goto tr18;
|
|
371
|
+
}
|
|
372
|
+
if ( (*p) < 65 ) {
|
|
373
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
374
|
+
goto tr17;
|
|
375
|
+
} else if ( (*p) > 90 ) {
|
|
376
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
377
|
+
goto tr18;
|
|
378
|
+
} else
|
|
379
|
+
goto tr18;
|
|
380
|
+
goto tr0;
|
|
381
|
+
case 15:
|
|
382
|
+
switch( (*p) ) {
|
|
383
|
+
case 45: goto tr18;
|
|
384
|
+
case 60: goto tr1;
|
|
385
|
+
case 61: goto tr21;
|
|
386
|
+
case 95: goto tr18;
|
|
387
|
+
}
|
|
388
|
+
if ( (*p) < 65 ) {
|
|
389
|
+
if ( 48 <= (*p) && (*p) <= 57 )
|
|
390
|
+
goto tr18;
|
|
391
|
+
} else if ( (*p) > 90 ) {
|
|
392
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
393
|
+
goto tr18;
|
|
394
|
+
} else
|
|
395
|
+
goto tr18;
|
|
396
|
+
goto tr0;
|
|
397
|
+
case 16:
|
|
398
|
+
switch( (*p) ) {
|
|
399
|
+
case 32: goto tr22;
|
|
400
|
+
case 34: goto tr23;
|
|
401
|
+
case 39: goto tr23;
|
|
402
|
+
case 60: goto tr1;
|
|
403
|
+
}
|
|
404
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
405
|
+
goto tr22;
|
|
406
|
+
goto tr0;
|
|
407
|
+
case 17:
|
|
408
|
+
switch( (*p) ) {
|
|
409
|
+
case 33: goto tr24;
|
|
410
|
+
case 60: goto tr25;
|
|
411
|
+
case 95: goto tr24;
|
|
412
|
+
case 125: goto tr24;
|
|
413
|
+
}
|
|
414
|
+
if ( (*p) < 40 ) {
|
|
415
|
+
if ( 35 <= (*p) && (*p) <= 38 )
|
|
416
|
+
goto tr24;
|
|
417
|
+
} else if ( (*p) > 90 ) {
|
|
418
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
419
|
+
goto tr24;
|
|
420
|
+
} else
|
|
421
|
+
goto tr24;
|
|
422
|
+
goto tr0;
|
|
423
|
+
case 18:
|
|
424
|
+
switch( (*p) ) {
|
|
425
|
+
case 34: goto tr26;
|
|
426
|
+
case 39: goto tr26;
|
|
427
|
+
case 60: goto tr25;
|
|
428
|
+
case 95: goto tr24;
|
|
429
|
+
case 125: goto tr24;
|
|
430
|
+
}
|
|
431
|
+
if ( (*p) > 90 ) {
|
|
432
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
433
|
+
goto tr24;
|
|
434
|
+
} else if ( (*p) >= 33 )
|
|
435
|
+
goto tr24;
|
|
436
|
+
goto tr0;
|
|
437
|
+
case 19:
|
|
438
|
+
switch( (*p) ) {
|
|
439
|
+
case 32: goto tr27;
|
|
440
|
+
case 45: goto tr18;
|
|
441
|
+
case 47: goto tr28;
|
|
442
|
+
case 60: goto tr1;
|
|
443
|
+
case 62: goto tr20;
|
|
444
|
+
case 95: goto tr18;
|
|
445
|
+
}
|
|
446
|
+
if ( (*p) < 65 ) {
|
|
447
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
448
|
+
goto tr27;
|
|
449
|
+
} else if ( (*p) > 90 ) {
|
|
450
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
451
|
+
goto tr18;
|
|
452
|
+
} else
|
|
453
|
+
goto tr18;
|
|
454
|
+
goto tr0;
|
|
455
|
+
case 20:
|
|
456
|
+
switch( (*p) ) {
|
|
457
|
+
case 32: goto tr27;
|
|
458
|
+
case 45: goto tr18;
|
|
459
|
+
case 47: goto tr28;
|
|
460
|
+
case 60: goto tr1;
|
|
461
|
+
case 95: goto tr18;
|
|
462
|
+
}
|
|
463
|
+
if ( (*p) < 65 ) {
|
|
464
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
465
|
+
goto tr27;
|
|
466
|
+
} else if ( (*p) > 90 ) {
|
|
467
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
468
|
+
goto tr18;
|
|
469
|
+
} else
|
|
470
|
+
goto tr18;
|
|
471
|
+
goto tr0;
|
|
472
|
+
case 21:
|
|
473
|
+
switch( (*p) ) {
|
|
474
|
+
case 60: goto tr1;
|
|
475
|
+
case 62: goto tr29;
|
|
476
|
+
}
|
|
477
|
+
goto tr0;
|
|
478
|
+
case 57:
|
|
479
|
+
if ( (*p) == 60 )
|
|
480
|
+
goto tr71;
|
|
481
|
+
goto tr70;
|
|
482
|
+
case 22:
|
|
483
|
+
switch( (*p) ) {
|
|
484
|
+
case 34: goto tr26;
|
|
485
|
+
case 39: goto tr26;
|
|
486
|
+
case 47: goto tr30;
|
|
487
|
+
case 60: goto tr25;
|
|
488
|
+
case 95: goto tr24;
|
|
489
|
+
case 101: goto tr31;
|
|
490
|
+
case 125: goto tr24;
|
|
491
|
+
}
|
|
492
|
+
if ( (*p) > 90 ) {
|
|
493
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
494
|
+
goto tr24;
|
|
495
|
+
} else if ( (*p) >= 33 )
|
|
496
|
+
goto tr24;
|
|
497
|
+
goto tr0;
|
|
498
|
+
case 23:
|
|
499
|
+
switch( (*p) ) {
|
|
500
|
+
case 34: goto tr26;
|
|
501
|
+
case 39: goto tr26;
|
|
502
|
+
case 60: goto tr25;
|
|
503
|
+
case 95: goto tr24;
|
|
504
|
+
case 101: goto tr32;
|
|
505
|
+
case 125: goto tr24;
|
|
506
|
+
}
|
|
507
|
+
if ( (*p) > 90 ) {
|
|
508
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
509
|
+
goto tr24;
|
|
510
|
+
} else if ( (*p) >= 33 )
|
|
511
|
+
goto tr24;
|
|
512
|
+
goto tr0;
|
|
513
|
+
case 24:
|
|
514
|
+
switch( (*p) ) {
|
|
515
|
+
case 34: goto tr26;
|
|
516
|
+
case 39: goto tr26;
|
|
517
|
+
case 60: goto tr25;
|
|
518
|
+
case 95: goto tr24;
|
|
519
|
+
case 115: goto tr33;
|
|
520
|
+
case 125: goto tr24;
|
|
521
|
+
}
|
|
522
|
+
if ( (*p) > 90 ) {
|
|
523
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
524
|
+
goto tr24;
|
|
525
|
+
} else if ( (*p) >= 33 )
|
|
526
|
+
goto tr24;
|
|
527
|
+
goto tr0;
|
|
528
|
+
case 25:
|
|
529
|
+
switch( (*p) ) {
|
|
530
|
+
case 34: goto tr26;
|
|
531
|
+
case 39: goto tr26;
|
|
532
|
+
case 60: goto tr25;
|
|
533
|
+
case 95: goto tr24;
|
|
534
|
+
case 105: goto tr34;
|
|
535
|
+
case 125: goto tr24;
|
|
536
|
+
}
|
|
537
|
+
if ( (*p) > 90 ) {
|
|
538
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
539
|
+
goto tr24;
|
|
540
|
+
} else if ( (*p) >= 33 )
|
|
541
|
+
goto tr24;
|
|
542
|
+
goto tr0;
|
|
543
|
+
case 26:
|
|
544
|
+
switch( (*p) ) {
|
|
545
|
+
case 34: goto tr26;
|
|
546
|
+
case 39: goto tr26;
|
|
547
|
+
case 58: goto tr35;
|
|
548
|
+
case 60: goto tr25;
|
|
549
|
+
case 95: goto tr24;
|
|
550
|
+
case 125: goto tr24;
|
|
551
|
+
}
|
|
552
|
+
if ( (*p) > 90 ) {
|
|
553
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
554
|
+
goto tr24;
|
|
555
|
+
} else if ( (*p) >= 33 )
|
|
556
|
+
goto tr24;
|
|
557
|
+
goto tr0;
|
|
558
|
+
case 27:
|
|
559
|
+
switch( (*p) ) {
|
|
560
|
+
case 34: goto tr26;
|
|
561
|
+
case 39: goto tr26;
|
|
562
|
+
case 60: goto tr25;
|
|
563
|
+
case 95: goto tr24;
|
|
564
|
+
case 123: goto tr24;
|
|
565
|
+
case 125: goto tr24;
|
|
566
|
+
}
|
|
567
|
+
if ( (*p) > 90 ) {
|
|
568
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
569
|
+
goto tr36;
|
|
570
|
+
} else if ( (*p) >= 33 )
|
|
571
|
+
goto tr24;
|
|
572
|
+
goto tr0;
|
|
573
|
+
case 28:
|
|
574
|
+
switch( (*p) ) {
|
|
575
|
+
case 34: goto tr26;
|
|
576
|
+
case 39: goto tr26;
|
|
577
|
+
case 60: goto tr25;
|
|
578
|
+
case 62: goto tr37;
|
|
579
|
+
case 95: goto tr24;
|
|
580
|
+
case 123: goto tr24;
|
|
581
|
+
case 125: goto tr24;
|
|
582
|
+
}
|
|
583
|
+
if ( (*p) > 90 ) {
|
|
584
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
585
|
+
goto tr36;
|
|
586
|
+
} else if ( (*p) >= 33 )
|
|
587
|
+
goto tr24;
|
|
588
|
+
goto tr0;
|
|
589
|
+
case 29:
|
|
590
|
+
switch( (*p) ) {
|
|
591
|
+
case 34: goto tr26;
|
|
592
|
+
case 39: goto tr26;
|
|
593
|
+
case 60: goto tr25;
|
|
594
|
+
case 95: goto tr24;
|
|
595
|
+
case 115: goto tr38;
|
|
596
|
+
case 125: goto tr24;
|
|
597
|
+
}
|
|
598
|
+
if ( (*p) > 90 ) {
|
|
599
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
600
|
+
goto tr24;
|
|
601
|
+
} else if ( (*p) >= 33 )
|
|
602
|
+
goto tr24;
|
|
603
|
+
goto tr0;
|
|
604
|
+
case 30:
|
|
605
|
+
switch( (*p) ) {
|
|
606
|
+
case 34: goto tr26;
|
|
607
|
+
case 39: goto tr26;
|
|
608
|
+
case 60: goto tr25;
|
|
609
|
+
case 95: goto tr24;
|
|
610
|
+
case 105: goto tr39;
|
|
611
|
+
case 125: goto tr24;
|
|
612
|
+
}
|
|
613
|
+
if ( (*p) > 90 ) {
|
|
614
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
615
|
+
goto tr24;
|
|
616
|
+
} else if ( (*p) >= 33 )
|
|
617
|
+
goto tr24;
|
|
618
|
+
goto tr0;
|
|
619
|
+
case 31:
|
|
620
|
+
switch( (*p) ) {
|
|
621
|
+
case 34: goto tr26;
|
|
622
|
+
case 39: goto tr26;
|
|
623
|
+
case 58: goto tr40;
|
|
624
|
+
case 60: goto tr25;
|
|
625
|
+
case 95: goto tr24;
|
|
626
|
+
case 125: goto tr24;
|
|
627
|
+
}
|
|
628
|
+
if ( (*p) > 90 ) {
|
|
629
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
630
|
+
goto tr24;
|
|
631
|
+
} else if ( (*p) >= 33 )
|
|
632
|
+
goto tr24;
|
|
633
|
+
goto tr0;
|
|
634
|
+
case 32:
|
|
635
|
+
switch( (*p) ) {
|
|
636
|
+
case 34: goto tr26;
|
|
637
|
+
case 39: goto tr26;
|
|
638
|
+
case 60: goto tr25;
|
|
639
|
+
case 95: goto tr24;
|
|
640
|
+
case 123: goto tr24;
|
|
641
|
+
case 125: goto tr24;
|
|
642
|
+
}
|
|
643
|
+
if ( (*p) > 90 ) {
|
|
644
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
645
|
+
goto tr41;
|
|
646
|
+
} else if ( (*p) >= 33 )
|
|
647
|
+
goto tr24;
|
|
648
|
+
goto tr0;
|
|
649
|
+
case 33:
|
|
650
|
+
switch( (*p) ) {
|
|
651
|
+
case 32: goto tr14;
|
|
652
|
+
case 34: goto tr26;
|
|
653
|
+
case 39: goto tr26;
|
|
654
|
+
case 47: goto tr42;
|
|
655
|
+
case 60: goto tr25;
|
|
656
|
+
case 62: goto tr43;
|
|
657
|
+
case 95: goto tr24;
|
|
658
|
+
case 123: goto tr24;
|
|
659
|
+
case 125: goto tr24;
|
|
660
|
+
}
|
|
661
|
+
if ( (*p) < 33 ) {
|
|
662
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
663
|
+
goto tr14;
|
|
664
|
+
} else if ( (*p) > 90 ) {
|
|
665
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
666
|
+
goto tr41;
|
|
667
|
+
} else
|
|
668
|
+
goto tr24;
|
|
669
|
+
goto tr0;
|
|
670
|
+
case 34:
|
|
671
|
+
switch( (*p) ) {
|
|
672
|
+
case 34: goto tr26;
|
|
673
|
+
case 39: goto tr26;
|
|
674
|
+
case 60: goto tr25;
|
|
675
|
+
case 62: goto tr44;
|
|
676
|
+
case 95: goto tr24;
|
|
677
|
+
case 125: goto tr24;
|
|
678
|
+
}
|
|
679
|
+
if ( (*p) > 90 ) {
|
|
680
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
681
|
+
goto tr24;
|
|
682
|
+
} else if ( (*p) >= 33 )
|
|
683
|
+
goto tr24;
|
|
684
|
+
goto tr0;
|
|
685
|
+
case 58:
|
|
686
|
+
switch( (*p) ) {
|
|
687
|
+
case 34: goto tr74;
|
|
688
|
+
case 39: goto tr74;
|
|
689
|
+
case 60: goto tr75;
|
|
690
|
+
case 95: goto tr73;
|
|
691
|
+
case 125: goto tr73;
|
|
692
|
+
}
|
|
693
|
+
if ( (*p) > 90 ) {
|
|
694
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
695
|
+
goto tr73;
|
|
696
|
+
} else if ( (*p) >= 33 )
|
|
697
|
+
goto tr73;
|
|
698
|
+
goto tr72;
|
|
699
|
+
case 35:
|
|
700
|
+
switch( (*p) ) {
|
|
701
|
+
case 34: goto tr46;
|
|
702
|
+
case 39: goto tr46;
|
|
703
|
+
case 60: goto tr47;
|
|
704
|
+
case 95: goto tr45;
|
|
705
|
+
case 125: goto tr45;
|
|
706
|
+
}
|
|
707
|
+
if ( (*p) > 90 ) {
|
|
708
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
709
|
+
goto tr45;
|
|
710
|
+
} else if ( (*p) >= 33 )
|
|
711
|
+
goto tr45;
|
|
712
|
+
goto tr0;
|
|
713
|
+
case 36:
|
|
714
|
+
switch( (*p) ) {
|
|
715
|
+
case 32: goto tr48;
|
|
716
|
+
case 45: goto tr49;
|
|
717
|
+
case 47: goto tr28;
|
|
718
|
+
case 60: goto tr1;
|
|
719
|
+
case 62: goto tr20;
|
|
720
|
+
case 95: goto tr49;
|
|
721
|
+
}
|
|
722
|
+
if ( (*p) < 65 ) {
|
|
723
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
724
|
+
goto tr48;
|
|
725
|
+
} else if ( (*p) > 90 ) {
|
|
726
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
727
|
+
goto tr49;
|
|
728
|
+
} else
|
|
729
|
+
goto tr49;
|
|
730
|
+
goto tr0;
|
|
731
|
+
case 37:
|
|
732
|
+
switch( (*p) ) {
|
|
733
|
+
case 32: goto tr48;
|
|
734
|
+
case 45: goto tr49;
|
|
735
|
+
case 47: goto tr28;
|
|
736
|
+
case 60: goto tr1;
|
|
737
|
+
case 95: goto tr49;
|
|
738
|
+
}
|
|
739
|
+
if ( (*p) < 65 ) {
|
|
740
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
741
|
+
goto tr48;
|
|
742
|
+
} else if ( (*p) > 90 ) {
|
|
743
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
744
|
+
goto tr49;
|
|
745
|
+
} else
|
|
746
|
+
goto tr49;
|
|
747
|
+
goto tr0;
|
|
748
|
+
case 38:
|
|
749
|
+
switch( (*p) ) {
|
|
750
|
+
case 45: goto tr49;
|
|
751
|
+
case 60: goto tr1;
|
|
752
|
+
case 61: goto tr50;
|
|
753
|
+
case 95: goto tr49;
|
|
754
|
+
}
|
|
755
|
+
if ( (*p) < 65 ) {
|
|
756
|
+
if ( 48 <= (*p) && (*p) <= 57 )
|
|
757
|
+
goto tr49;
|
|
758
|
+
} else if ( (*p) > 90 ) {
|
|
759
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
760
|
+
goto tr49;
|
|
761
|
+
} else
|
|
762
|
+
goto tr49;
|
|
763
|
+
goto tr0;
|
|
764
|
+
case 39:
|
|
765
|
+
switch( (*p) ) {
|
|
766
|
+
case 32: goto tr51;
|
|
767
|
+
case 34: goto tr52;
|
|
768
|
+
case 39: goto tr52;
|
|
769
|
+
case 60: goto tr1;
|
|
770
|
+
}
|
|
771
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
772
|
+
goto tr51;
|
|
773
|
+
goto tr0;
|
|
774
|
+
case 40:
|
|
775
|
+
switch( (*p) ) {
|
|
776
|
+
case 33: goto tr45;
|
|
777
|
+
case 60: goto tr47;
|
|
778
|
+
case 95: goto tr45;
|
|
779
|
+
case 125: goto tr45;
|
|
780
|
+
}
|
|
781
|
+
if ( (*p) < 40 ) {
|
|
782
|
+
if ( 35 <= (*p) && (*p) <= 38 )
|
|
783
|
+
goto tr45;
|
|
784
|
+
} else if ( (*p) > 90 ) {
|
|
785
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
786
|
+
goto tr45;
|
|
787
|
+
} else
|
|
788
|
+
goto tr45;
|
|
789
|
+
goto tr0;
|
|
790
|
+
case 41:
|
|
791
|
+
switch( (*p) ) {
|
|
792
|
+
case 34: goto tr46;
|
|
793
|
+
case 39: goto tr46;
|
|
794
|
+
case 47: goto tr53;
|
|
795
|
+
case 60: goto tr47;
|
|
796
|
+
case 95: goto tr45;
|
|
797
|
+
case 101: goto tr54;
|
|
798
|
+
case 125: goto tr45;
|
|
799
|
+
}
|
|
800
|
+
if ( (*p) > 90 ) {
|
|
801
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
802
|
+
goto tr45;
|
|
803
|
+
} else if ( (*p) >= 33 )
|
|
804
|
+
goto tr45;
|
|
805
|
+
goto tr0;
|
|
806
|
+
case 42:
|
|
807
|
+
switch( (*p) ) {
|
|
808
|
+
case 34: goto tr46;
|
|
809
|
+
case 39: goto tr46;
|
|
810
|
+
case 60: goto tr47;
|
|
811
|
+
case 95: goto tr45;
|
|
812
|
+
case 101: goto tr55;
|
|
813
|
+
case 125: goto tr45;
|
|
814
|
+
}
|
|
815
|
+
if ( (*p) > 90 ) {
|
|
816
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
817
|
+
goto tr45;
|
|
818
|
+
} else if ( (*p) >= 33 )
|
|
819
|
+
goto tr45;
|
|
820
|
+
goto tr0;
|
|
821
|
+
case 43:
|
|
822
|
+
switch( (*p) ) {
|
|
823
|
+
case 34: goto tr46;
|
|
824
|
+
case 39: goto tr46;
|
|
825
|
+
case 60: goto tr47;
|
|
826
|
+
case 95: goto tr45;
|
|
827
|
+
case 115: goto tr56;
|
|
828
|
+
case 125: goto tr45;
|
|
829
|
+
}
|
|
830
|
+
if ( (*p) > 90 ) {
|
|
831
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
832
|
+
goto tr45;
|
|
833
|
+
} else if ( (*p) >= 33 )
|
|
834
|
+
goto tr45;
|
|
835
|
+
goto tr0;
|
|
836
|
+
case 44:
|
|
837
|
+
switch( (*p) ) {
|
|
838
|
+
case 34: goto tr46;
|
|
839
|
+
case 39: goto tr46;
|
|
840
|
+
case 60: goto tr47;
|
|
841
|
+
case 95: goto tr45;
|
|
842
|
+
case 105: goto tr57;
|
|
843
|
+
case 125: goto tr45;
|
|
844
|
+
}
|
|
845
|
+
if ( (*p) > 90 ) {
|
|
846
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
847
|
+
goto tr45;
|
|
848
|
+
} else if ( (*p) >= 33 )
|
|
849
|
+
goto tr45;
|
|
850
|
+
goto tr0;
|
|
851
|
+
case 45:
|
|
852
|
+
switch( (*p) ) {
|
|
853
|
+
case 34: goto tr46;
|
|
854
|
+
case 39: goto tr46;
|
|
855
|
+
case 58: goto tr58;
|
|
856
|
+
case 60: goto tr47;
|
|
857
|
+
case 95: goto tr45;
|
|
858
|
+
case 125: goto tr45;
|
|
859
|
+
}
|
|
860
|
+
if ( (*p) > 90 ) {
|
|
861
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
862
|
+
goto tr45;
|
|
863
|
+
} else if ( (*p) >= 33 )
|
|
864
|
+
goto tr45;
|
|
865
|
+
goto tr0;
|
|
866
|
+
case 46:
|
|
867
|
+
switch( (*p) ) {
|
|
868
|
+
case 34: goto tr46;
|
|
869
|
+
case 39: goto tr46;
|
|
870
|
+
case 60: goto tr47;
|
|
871
|
+
case 95: goto tr45;
|
|
872
|
+
case 123: goto tr45;
|
|
873
|
+
case 125: goto tr45;
|
|
874
|
+
}
|
|
875
|
+
if ( (*p) > 90 ) {
|
|
876
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
877
|
+
goto tr59;
|
|
878
|
+
} else if ( (*p) >= 33 )
|
|
879
|
+
goto tr45;
|
|
880
|
+
goto tr0;
|
|
881
|
+
case 47:
|
|
882
|
+
switch( (*p) ) {
|
|
883
|
+
case 34: goto tr46;
|
|
884
|
+
case 39: goto tr46;
|
|
885
|
+
case 60: goto tr47;
|
|
886
|
+
case 62: goto tr60;
|
|
887
|
+
case 95: goto tr45;
|
|
888
|
+
case 123: goto tr45;
|
|
889
|
+
case 125: goto tr45;
|
|
890
|
+
}
|
|
891
|
+
if ( (*p) > 90 ) {
|
|
892
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
893
|
+
goto tr59;
|
|
894
|
+
} else if ( (*p) >= 33 )
|
|
895
|
+
goto tr45;
|
|
896
|
+
goto tr0;
|
|
897
|
+
case 48:
|
|
898
|
+
switch( (*p) ) {
|
|
899
|
+
case 34: goto tr46;
|
|
900
|
+
case 39: goto tr46;
|
|
901
|
+
case 60: goto tr47;
|
|
902
|
+
case 95: goto tr45;
|
|
903
|
+
case 115: goto tr61;
|
|
904
|
+
case 125: goto tr45;
|
|
905
|
+
}
|
|
906
|
+
if ( (*p) > 90 ) {
|
|
907
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
908
|
+
goto tr45;
|
|
909
|
+
} else if ( (*p) >= 33 )
|
|
910
|
+
goto tr45;
|
|
911
|
+
goto tr0;
|
|
912
|
+
case 49:
|
|
913
|
+
switch( (*p) ) {
|
|
914
|
+
case 34: goto tr46;
|
|
915
|
+
case 39: goto tr46;
|
|
916
|
+
case 60: goto tr47;
|
|
917
|
+
case 95: goto tr45;
|
|
918
|
+
case 105: goto tr62;
|
|
919
|
+
case 125: goto tr45;
|
|
920
|
+
}
|
|
921
|
+
if ( (*p) > 90 ) {
|
|
922
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
923
|
+
goto tr45;
|
|
924
|
+
} else if ( (*p) >= 33 )
|
|
925
|
+
goto tr45;
|
|
926
|
+
goto tr0;
|
|
927
|
+
case 50:
|
|
928
|
+
switch( (*p) ) {
|
|
929
|
+
case 34: goto tr46;
|
|
930
|
+
case 39: goto tr46;
|
|
931
|
+
case 58: goto tr63;
|
|
932
|
+
case 60: goto tr47;
|
|
933
|
+
case 95: goto tr45;
|
|
934
|
+
case 125: goto tr45;
|
|
935
|
+
}
|
|
936
|
+
if ( (*p) > 90 ) {
|
|
937
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
938
|
+
goto tr45;
|
|
939
|
+
} else if ( (*p) >= 33 )
|
|
940
|
+
goto tr45;
|
|
941
|
+
goto tr0;
|
|
942
|
+
case 51:
|
|
943
|
+
switch( (*p) ) {
|
|
944
|
+
case 34: goto tr46;
|
|
945
|
+
case 39: goto tr46;
|
|
946
|
+
case 60: goto tr47;
|
|
947
|
+
case 95: goto tr45;
|
|
948
|
+
case 123: goto tr45;
|
|
949
|
+
case 125: goto tr45;
|
|
950
|
+
}
|
|
951
|
+
if ( (*p) > 90 ) {
|
|
952
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
953
|
+
goto tr64;
|
|
954
|
+
} else if ( (*p) >= 33 )
|
|
955
|
+
goto tr45;
|
|
956
|
+
goto tr0;
|
|
957
|
+
case 52:
|
|
958
|
+
switch( (*p) ) {
|
|
959
|
+
case 32: goto tr14;
|
|
960
|
+
case 34: goto tr46;
|
|
961
|
+
case 39: goto tr46;
|
|
962
|
+
case 47: goto tr65;
|
|
963
|
+
case 60: goto tr47;
|
|
964
|
+
case 62: goto tr66;
|
|
965
|
+
case 95: goto tr45;
|
|
966
|
+
case 123: goto tr45;
|
|
967
|
+
case 125: goto tr45;
|
|
968
|
+
}
|
|
969
|
+
if ( (*p) < 33 ) {
|
|
970
|
+
if ( 9 <= (*p) && (*p) <= 13 )
|
|
971
|
+
goto tr14;
|
|
972
|
+
} else if ( (*p) > 90 ) {
|
|
973
|
+
if ( 97 <= (*p) && (*p) <= 122 )
|
|
974
|
+
goto tr64;
|
|
975
|
+
} else
|
|
976
|
+
goto tr45;
|
|
977
|
+
goto tr0;
|
|
978
|
+
case 53:
|
|
979
|
+
switch( (*p) ) {
|
|
980
|
+
case 34: goto tr46;
|
|
981
|
+
case 39: goto tr46;
|
|
982
|
+
case 60: goto tr47;
|
|
983
|
+
case 62: goto tr67;
|
|
984
|
+
case 95: goto tr45;
|
|
985
|
+
case 125: goto tr45;
|
|
986
|
+
}
|
|
987
|
+
if ( (*p) > 90 ) {
|
|
988
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
989
|
+
goto tr45;
|
|
990
|
+
} else if ( (*p) >= 33 )
|
|
991
|
+
goto tr45;
|
|
992
|
+
goto tr0;
|
|
993
|
+
case 59:
|
|
994
|
+
switch( (*p) ) {
|
|
995
|
+
case 34: goto tr74;
|
|
996
|
+
case 39: goto tr74;
|
|
997
|
+
case 60: goto tr75;
|
|
998
|
+
case 95: goto tr73;
|
|
999
|
+
case 125: goto tr73;
|
|
1000
|
+
}
|
|
1001
|
+
if ( (*p) > 90 ) {
|
|
1002
|
+
if ( 97 <= (*p) && (*p) <= 123 )
|
|
1003
|
+
goto tr73;
|
|
1004
|
+
} else if ( (*p) >= 33 )
|
|
1005
|
+
goto tr73;
|
|
1006
|
+
goto tr72;
|
|
1007
|
+
case 54:
|
|
1008
|
+
switch( (*p) ) {
|
|
1009
|
+
case 60: goto tr1;
|
|
1010
|
+
case 62: goto tr68;
|
|
1011
|
+
}
|
|
1012
|
+
goto tr0;
|
|
1013
|
+
case 60:
|
|
1014
|
+
if ( (*p) == 60 )
|
|
1015
|
+
goto tr76;
|
|
1016
|
+
goto tr72;
|
|
1017
|
+
case 55:
|
|
1018
|
+
switch( (*p) ) {
|
|
1019
|
+
case 60: goto tr1;
|
|
1020
|
+
case 62: goto tr69;
|
|
1021
|
+
}
|
|
1022
|
+
goto tr0;
|
|
1023
|
+
}
|
|
1024
|
+
|
|
1025
|
+
tr0: cs = 0; goto f0;
|
|
1026
|
+
tr9: cs = 0; goto f2;
|
|
1027
|
+
tr16: cs = 0; goto f4;
|
|
1028
|
+
tr70: cs = 0; goto f9;
|
|
1029
|
+
tr72: cs = 0; goto f11;
|
|
1030
|
+
tr1: cs = 1; goto f1;
|
|
1031
|
+
tr71: cs = 1; goto f10;
|
|
1032
|
+
tr76: cs = 1; goto f13;
|
|
1033
|
+
tr2: cs = 2; goto f0;
|
|
1034
|
+
tr4: cs = 3; goto f0;
|
|
1035
|
+
tr5: cs = 4; goto f0;
|
|
1036
|
+
tr6: cs = 5; goto f0;
|
|
1037
|
+
tr7: cs = 6; goto f0;
|
|
1038
|
+
tr8: cs = 7; goto f0;
|
|
1039
|
+
tr3: cs = 8; goto f0;
|
|
1040
|
+
tr10: cs = 9; goto f0;
|
|
1041
|
+
tr11: cs = 10; goto f0;
|
|
1042
|
+
tr12: cs = 11; goto f0;
|
|
1043
|
+
tr13: cs = 12; goto f0;
|
|
1044
|
+
tr14: cs = 13; goto f3;
|
|
1045
|
+
tr17: cs = 14; goto f0;
|
|
1046
|
+
tr18: cs = 15; goto f0;
|
|
1047
|
+
tr22: cs = 16; goto f0;
|
|
1048
|
+
tr21: cs = 16; goto f6;
|
|
1049
|
+
tr23: cs = 17; goto f0;
|
|
1050
|
+
tr24: cs = 18; goto f0;
|
|
1051
|
+
tr37: cs = 18; goto f2;
|
|
1052
|
+
tr43: cs = 18; goto f4;
|
|
1053
|
+
tr26: cs = 19; goto f7;
|
|
1054
|
+
tr27: cs = 20; goto f0;
|
|
1055
|
+
tr28: cs = 21; goto f0;
|
|
1056
|
+
tr25: cs = 22; goto f1;
|
|
1057
|
+
tr30: cs = 23; goto f0;
|
|
1058
|
+
tr32: cs = 24; goto f0;
|
|
1059
|
+
tr33: cs = 25; goto f0;
|
|
1060
|
+
tr34: cs = 26; goto f0;
|
|
1061
|
+
tr35: cs = 27; goto f0;
|
|
1062
|
+
tr36: cs = 28; goto f0;
|
|
1063
|
+
tr31: cs = 29; goto f0;
|
|
1064
|
+
tr38: cs = 30; goto f0;
|
|
1065
|
+
tr39: cs = 31; goto f0;
|
|
1066
|
+
tr40: cs = 32; goto f0;
|
|
1067
|
+
tr41: cs = 33; goto f0;
|
|
1068
|
+
tr42: cs = 34; goto f3;
|
|
1069
|
+
tr45: cs = 35; goto f0;
|
|
1070
|
+
tr60: cs = 35; goto f2;
|
|
1071
|
+
tr66: cs = 35; goto f4;
|
|
1072
|
+
tr73: cs = 35; goto f11;
|
|
1073
|
+
tr46: cs = 36; goto f7;
|
|
1074
|
+
tr74: cs = 36; goto f12;
|
|
1075
|
+
tr48: cs = 37; goto f0;
|
|
1076
|
+
tr49: cs = 38; goto f0;
|
|
1077
|
+
tr51: cs = 39; goto f0;
|
|
1078
|
+
tr50: cs = 39; goto f6;
|
|
1079
|
+
tr52: cs = 40; goto f0;
|
|
1080
|
+
tr47: cs = 41; goto f1;
|
|
1081
|
+
tr75: cs = 41; goto f13;
|
|
1082
|
+
tr53: cs = 42; goto f0;
|
|
1083
|
+
tr55: cs = 43; goto f0;
|
|
1084
|
+
tr56: cs = 44; goto f0;
|
|
1085
|
+
tr57: cs = 45; goto f0;
|
|
1086
|
+
tr58: cs = 46; goto f0;
|
|
1087
|
+
tr59: cs = 47; goto f0;
|
|
1088
|
+
tr54: cs = 48; goto f0;
|
|
1089
|
+
tr61: cs = 49; goto f0;
|
|
1090
|
+
tr62: cs = 50; goto f0;
|
|
1091
|
+
tr63: cs = 51; goto f0;
|
|
1092
|
+
tr64: cs = 52; goto f0;
|
|
1093
|
+
tr65: cs = 53; goto f3;
|
|
1094
|
+
tr19: cs = 54; goto f3;
|
|
1095
|
+
tr15: cs = 55; goto f3;
|
|
1096
|
+
tr20: cs = 57; goto f5;
|
|
1097
|
+
tr29: cs = 57; goto f8;
|
|
1098
|
+
tr44: cs = 58; goto f0;
|
|
1099
|
+
tr67: cs = 59; goto f0;
|
|
1100
|
+
tr69: cs = 60; goto f0;
|
|
1101
|
+
tr68: cs = 60; goto f8;
|
|
1102
|
+
|
|
1103
|
+
f0:
|
|
1104
|
+
#line 175 "parser.rl"
|
|
1105
|
+
{
|
|
1106
|
+
switch( cs ){
|
|
1107
|
+
case 0:
|
|
1108
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1109
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1110
|
+
// stream echobuffer
|
|
1111
|
+
esi_parser_echo_buffer( parser );
|
|
1112
|
+
}
|
|
1113
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1114
|
+
// stream the current character
|
|
1115
|
+
esi_parser_echo_char( parser, *p );
|
|
1116
|
+
}
|
|
1117
|
+
// clear the echobuffer
|
|
1118
|
+
esi_parser_echobuffer_clear( parser );
|
|
1119
|
+
break;
|
|
1120
|
+
default:
|
|
1121
|
+
// append characters to echobuffer
|
|
1122
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1123
|
+
}
|
|
1124
|
+
parser->prev_state = cs;
|
|
1125
|
+
}
|
|
1126
|
+
goto _again;
|
|
1127
|
+
f1:
|
|
1128
|
+
#line 175 "parser.rl"
|
|
1129
|
+
{
|
|
1130
|
+
switch( cs ){
|
|
1131
|
+
case 0:
|
|
1132
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1133
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1134
|
+
// stream echobuffer
|
|
1135
|
+
esi_parser_echo_buffer( parser );
|
|
1136
|
+
}
|
|
1137
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1138
|
+
// stream the current character
|
|
1139
|
+
esi_parser_echo_char( parser, *p );
|
|
1140
|
+
}
|
|
1141
|
+
// clear the echobuffer
|
|
1142
|
+
esi_parser_echobuffer_clear( parser );
|
|
1143
|
+
break;
|
|
1144
|
+
default:
|
|
1145
|
+
// append characters to echobuffer
|
|
1146
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1147
|
+
}
|
|
1148
|
+
parser->prev_state = cs;
|
|
1149
|
+
}
|
|
1150
|
+
#line 85 "parser.rl"
|
|
1151
|
+
{
|
|
1152
|
+
parser->mark = p;
|
|
1153
|
+
//debug_string( "begin", p, 1 );
|
|
1154
|
+
}
|
|
1155
|
+
goto _again;
|
|
1156
|
+
f9:
|
|
1157
|
+
#line 175 "parser.rl"
|
|
1158
|
+
{
|
|
1159
|
+
switch( cs ){
|
|
1160
|
+
case 0:
|
|
1161
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1162
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1163
|
+
// stream echobuffer
|
|
1164
|
+
esi_parser_echo_buffer( parser );
|
|
1165
|
+
}
|
|
1166
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1167
|
+
// stream the current character
|
|
1168
|
+
esi_parser_echo_char( parser, *p );
|
|
1169
|
+
}
|
|
1170
|
+
// clear the echobuffer
|
|
1171
|
+
esi_parser_echobuffer_clear( parser );
|
|
1172
|
+
break;
|
|
1173
|
+
default:
|
|
1174
|
+
// append characters to echobuffer
|
|
1175
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1176
|
+
}
|
|
1177
|
+
parser->prev_state = cs;
|
|
1178
|
+
}
|
|
1179
|
+
#line 89 "parser.rl"
|
|
1180
|
+
{
|
|
1181
|
+
// printf( "finish\n" );
|
|
1182
|
+
}
|
|
1183
|
+
goto _again;
|
|
1184
|
+
f3:
|
|
1185
|
+
#line 175 "parser.rl"
|
|
1186
|
+
{
|
|
1187
|
+
switch( cs ){
|
|
1188
|
+
case 0:
|
|
1189
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1190
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1191
|
+
// stream echobuffer
|
|
1192
|
+
esi_parser_echo_buffer( parser );
|
|
1193
|
+
}
|
|
1194
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1195
|
+
// stream the current character
|
|
1196
|
+
esi_parser_echo_char( parser, *p );
|
|
1197
|
+
}
|
|
1198
|
+
// clear the echobuffer
|
|
1199
|
+
esi_parser_echobuffer_clear( parser );
|
|
1200
|
+
break;
|
|
1201
|
+
default:
|
|
1202
|
+
// append characters to echobuffer
|
|
1203
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1204
|
+
}
|
|
1205
|
+
parser->prev_state = cs;
|
|
1206
|
+
}
|
|
1207
|
+
#line 94 "parser.rl"
|
|
1208
|
+
{
|
|
1209
|
+
parser->tag_text = parser->mark+1;
|
|
1210
|
+
parser->tag_text_length = p - (parser->mark+1);
|
|
1211
|
+
// debug_string( "have esi start", parser->tag_text, parser->tag_text_length );
|
|
1212
|
+
parser->mark = p;
|
|
1213
|
+
//debug_string( "see_start_tag", p, 1 );
|
|
1214
|
+
}
|
|
1215
|
+
goto _again;
|
|
1216
|
+
f8:
|
|
1217
|
+
#line 175 "parser.rl"
|
|
1218
|
+
{
|
|
1219
|
+
switch( cs ){
|
|
1220
|
+
case 0:
|
|
1221
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1222
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1223
|
+
// stream echobuffer
|
|
1224
|
+
esi_parser_echo_buffer( parser );
|
|
1225
|
+
}
|
|
1226
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1227
|
+
// stream the current character
|
|
1228
|
+
esi_parser_echo_char( parser, *p );
|
|
1229
|
+
}
|
|
1230
|
+
// clear the echobuffer
|
|
1231
|
+
esi_parser_echobuffer_clear( parser );
|
|
1232
|
+
break;
|
|
1233
|
+
default:
|
|
1234
|
+
// append characters to echobuffer
|
|
1235
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1236
|
+
}
|
|
1237
|
+
parser->prev_state = cs;
|
|
1238
|
+
}
|
|
1239
|
+
#line 102 "parser.rl"
|
|
1240
|
+
{
|
|
1241
|
+
//debug_string( "see_end_tag: before parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1242
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1243
|
+
//debug_string( "see_end_tag: after parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1244
|
+
parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
|
|
1245
|
+
//debug_string( "see_end_tag: after start parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1246
|
+
parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
|
|
1247
|
+
//debug_string( "see_end_tag: after end parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1248
|
+
parser->tag_text = NULL;
|
|
1249
|
+
parser->tag_text_length = 0;
|
|
1250
|
+
parser->mark = p;
|
|
1251
|
+
//debug_string( "see_end_tag", p, 1 );
|
|
1252
|
+
}
|
|
1253
|
+
goto _again;
|
|
1254
|
+
f5:
|
|
1255
|
+
#line 175 "parser.rl"
|
|
1256
|
+
{
|
|
1257
|
+
switch( cs ){
|
|
1258
|
+
case 0:
|
|
1259
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1260
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1261
|
+
// stream echobuffer
|
|
1262
|
+
esi_parser_echo_buffer( parser );
|
|
1263
|
+
}
|
|
1264
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1265
|
+
// stream the current character
|
|
1266
|
+
esi_parser_echo_char( parser, *p );
|
|
1267
|
+
}
|
|
1268
|
+
// clear the echobuffer
|
|
1269
|
+
esi_parser_echobuffer_clear( parser );
|
|
1270
|
+
break;
|
|
1271
|
+
default:
|
|
1272
|
+
// append characters to echobuffer
|
|
1273
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1274
|
+
}
|
|
1275
|
+
parser->prev_state = cs;
|
|
1276
|
+
}
|
|
1277
|
+
#line 116 "parser.rl"
|
|
1278
|
+
{
|
|
1279
|
+
// debug_string( "parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1280
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1281
|
+
parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
|
|
1282
|
+
parser->tag_text = NULL;
|
|
1283
|
+
parser->tag_text_length = 0;
|
|
1284
|
+
}
|
|
1285
|
+
goto _again;
|
|
1286
|
+
f6:
|
|
1287
|
+
#line 175 "parser.rl"
|
|
1288
|
+
{
|
|
1289
|
+
switch( cs ){
|
|
1290
|
+
case 0:
|
|
1291
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1292
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1293
|
+
// stream echobuffer
|
|
1294
|
+
esi_parser_echo_buffer( parser );
|
|
1295
|
+
}
|
|
1296
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1297
|
+
// stream the current character
|
|
1298
|
+
esi_parser_echo_char( parser, *p );
|
|
1299
|
+
}
|
|
1300
|
+
// clear the echobuffer
|
|
1301
|
+
esi_parser_echobuffer_clear( parser );
|
|
1302
|
+
break;
|
|
1303
|
+
default:
|
|
1304
|
+
// append characters to echobuffer
|
|
1305
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1306
|
+
}
|
|
1307
|
+
parser->prev_state = cs;
|
|
1308
|
+
}
|
|
1309
|
+
#line 124 "parser.rl"
|
|
1310
|
+
{
|
|
1311
|
+
parser->attr_key = parser->mark;
|
|
1312
|
+
parser->attr_key_length = p - parser->mark;
|
|
1313
|
+
parser->mark = p;
|
|
1314
|
+
ltrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
|
|
1315
|
+
// debug_string( "\tattribute key", parser->attr_key, parser->attr_key_length );
|
|
1316
|
+
//debug_string( "see_attribute_key", p, 1 );
|
|
1317
|
+
}
|
|
1318
|
+
goto _again;
|
|
1319
|
+
f7:
|
|
1320
|
+
#line 175 "parser.rl"
|
|
1321
|
+
{
|
|
1322
|
+
switch( cs ){
|
|
1323
|
+
case 0:
|
|
1324
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1325
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1326
|
+
// stream echobuffer
|
|
1327
|
+
esi_parser_echo_buffer( parser );
|
|
1328
|
+
}
|
|
1329
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1330
|
+
// stream the current character
|
|
1331
|
+
esi_parser_echo_char( parser, *p );
|
|
1332
|
+
}
|
|
1333
|
+
// clear the echobuffer
|
|
1334
|
+
esi_parser_echobuffer_clear( parser );
|
|
1335
|
+
break;
|
|
1336
|
+
default:
|
|
1337
|
+
// append characters to echobuffer
|
|
1338
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1339
|
+
}
|
|
1340
|
+
parser->prev_state = cs;
|
|
1341
|
+
}
|
|
1342
|
+
#line 133 "parser.rl"
|
|
1343
|
+
{
|
|
1344
|
+
ESIAttribute *attr;
|
|
1345
|
+
parser->attr_value = parser->mark;
|
|
1346
|
+
parser->attr_value_length = p - parser->mark;
|
|
1347
|
+
parser->mark = p;
|
|
1348
|
+
|
|
1349
|
+
ltrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
|
|
1350
|
+
|
|
1351
|
+
// allocate a new attribute
|
|
1352
|
+
attr = esi_attribute_new( parser->attr_key, parser->attr_key_length,
|
|
1353
|
+
parser->attr_value, parser->attr_value_length );
|
|
1354
|
+
if( parser->attributes ){
|
|
1355
|
+
parser->last->next = attr;
|
|
1356
|
+
parser->last = attr;
|
|
1357
|
+
}
|
|
1358
|
+
else{
|
|
1359
|
+
parser->last = parser->attributes = attr;
|
|
1360
|
+
}
|
|
1361
|
+
// debug_string( "\tattribute value", parser->attr_value, parser->attr_value_length );
|
|
1362
|
+
//debug_string( "see_attribute_value", p, 1 );
|
|
1363
|
+
}
|
|
1364
|
+
goto _again;
|
|
1365
|
+
f4:
|
|
1366
|
+
#line 175 "parser.rl"
|
|
1367
|
+
{
|
|
1368
|
+
switch( cs ){
|
|
1369
|
+
case 0:
|
|
1370
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1371
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1372
|
+
// stream echobuffer
|
|
1373
|
+
esi_parser_echo_buffer( parser );
|
|
1374
|
+
}
|
|
1375
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1376
|
+
// stream the current character
|
|
1377
|
+
esi_parser_echo_char( parser, *p );
|
|
1378
|
+
}
|
|
1379
|
+
// clear the echobuffer
|
|
1380
|
+
esi_parser_echobuffer_clear( parser );
|
|
1381
|
+
break;
|
|
1382
|
+
default:
|
|
1383
|
+
// append characters to echobuffer
|
|
1384
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1385
|
+
}
|
|
1386
|
+
parser->prev_state = cs;
|
|
1387
|
+
}
|
|
1388
|
+
#line 155 "parser.rl"
|
|
1389
|
+
{
|
|
1390
|
+
parser->tag_text = parser->mark;
|
|
1391
|
+
parser->tag_text_length = p - parser->mark;
|
|
1392
|
+
parser->mark = p;
|
|
1393
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1394
|
+
parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, NULL, parser->user_data );
|
|
1395
|
+
//debug_string( "block_start_tag", p, 1 );
|
|
1396
|
+
}
|
|
1397
|
+
goto _again;
|
|
1398
|
+
f2:
|
|
1399
|
+
#line 175 "parser.rl"
|
|
1400
|
+
{
|
|
1401
|
+
switch( cs ){
|
|
1402
|
+
case 0:
|
|
1403
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1404
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1405
|
+
// stream echobuffer
|
|
1406
|
+
esi_parser_echo_buffer( parser );
|
|
1407
|
+
}
|
|
1408
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1409
|
+
// stream the current character
|
|
1410
|
+
esi_parser_echo_char( parser, *p );
|
|
1411
|
+
}
|
|
1412
|
+
// clear the echobuffer
|
|
1413
|
+
esi_parser_echobuffer_clear( parser );
|
|
1414
|
+
break;
|
|
1415
|
+
default:
|
|
1416
|
+
// append characters to echobuffer
|
|
1417
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1418
|
+
}
|
|
1419
|
+
parser->prev_state = cs;
|
|
1420
|
+
}
|
|
1421
|
+
#line 164 "parser.rl"
|
|
1422
|
+
{
|
|
1423
|
+
parser->tag_text = parser->mark+2;
|
|
1424
|
+
parser->tag_text_length = p - (parser->mark+2);
|
|
1425
|
+
//printf( "mark: [%s], p: [%s], length: %d\n", parser->mark, p, parser->tag_text_length );
|
|
1426
|
+
parser->mark = p;
|
|
1427
|
+
//debug_string( "block_end_tag: before parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1428
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1429
|
+
//debug_string( "block_end_tag: after parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1430
|
+
parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
|
|
1431
|
+
}
|
|
1432
|
+
goto _again;
|
|
1433
|
+
f10:
|
|
1434
|
+
#line 175 "parser.rl"
|
|
1435
|
+
{
|
|
1436
|
+
switch( cs ){
|
|
1437
|
+
case 0:
|
|
1438
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1439
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1440
|
+
// stream echobuffer
|
|
1441
|
+
esi_parser_echo_buffer( parser );
|
|
1442
|
+
}
|
|
1443
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1444
|
+
// stream the current character
|
|
1445
|
+
esi_parser_echo_char( parser, *p );
|
|
1446
|
+
}
|
|
1447
|
+
// clear the echobuffer
|
|
1448
|
+
esi_parser_echobuffer_clear( parser );
|
|
1449
|
+
break;
|
|
1450
|
+
default:
|
|
1451
|
+
// append characters to echobuffer
|
|
1452
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1453
|
+
}
|
|
1454
|
+
parser->prev_state = cs;
|
|
1455
|
+
}
|
|
1456
|
+
#line 85 "parser.rl"
|
|
1457
|
+
{
|
|
1458
|
+
parser->mark = p;
|
|
1459
|
+
//debug_string( "begin", p, 1 );
|
|
1460
|
+
}
|
|
1461
|
+
#line 89 "parser.rl"
|
|
1462
|
+
{
|
|
1463
|
+
// printf( "finish\n" );
|
|
1464
|
+
}
|
|
1465
|
+
goto _again;
|
|
1466
|
+
f11:
|
|
1467
|
+
#line 175 "parser.rl"
|
|
1468
|
+
{
|
|
1469
|
+
switch( cs ){
|
|
1470
|
+
case 0:
|
|
1471
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1472
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1473
|
+
// stream echobuffer
|
|
1474
|
+
esi_parser_echo_buffer( parser );
|
|
1475
|
+
}
|
|
1476
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1477
|
+
// stream the current character
|
|
1478
|
+
esi_parser_echo_char( parser, *p );
|
|
1479
|
+
}
|
|
1480
|
+
// clear the echobuffer
|
|
1481
|
+
esi_parser_echobuffer_clear( parser );
|
|
1482
|
+
break;
|
|
1483
|
+
default:
|
|
1484
|
+
// append characters to echobuffer
|
|
1485
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1486
|
+
}
|
|
1487
|
+
parser->prev_state = cs;
|
|
1488
|
+
}
|
|
1489
|
+
#line 102 "parser.rl"
|
|
1490
|
+
{
|
|
1491
|
+
//debug_string( "see_end_tag: before parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1492
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1493
|
+
//debug_string( "see_end_tag: after parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1494
|
+
parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
|
|
1495
|
+
//debug_string( "see_end_tag: after start parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1496
|
+
parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
|
|
1497
|
+
//debug_string( "see_end_tag: after end parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1498
|
+
parser->tag_text = NULL;
|
|
1499
|
+
parser->tag_text_length = 0;
|
|
1500
|
+
parser->mark = p;
|
|
1501
|
+
//debug_string( "see_end_tag", p, 1 );
|
|
1502
|
+
}
|
|
1503
|
+
#line 89 "parser.rl"
|
|
1504
|
+
{
|
|
1505
|
+
// printf( "finish\n" );
|
|
1506
|
+
}
|
|
1507
|
+
goto _again;
|
|
1508
|
+
f13:
|
|
1509
|
+
#line 175 "parser.rl"
|
|
1510
|
+
{
|
|
1511
|
+
switch( cs ){
|
|
1512
|
+
case 0:
|
|
1513
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1514
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1515
|
+
// stream echobuffer
|
|
1516
|
+
esi_parser_echo_buffer( parser );
|
|
1517
|
+
}
|
|
1518
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1519
|
+
// stream the current character
|
|
1520
|
+
esi_parser_echo_char( parser, *p );
|
|
1521
|
+
}
|
|
1522
|
+
// clear the echobuffer
|
|
1523
|
+
esi_parser_echobuffer_clear( parser );
|
|
1524
|
+
break;
|
|
1525
|
+
default:
|
|
1526
|
+
// append characters to echobuffer
|
|
1527
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1528
|
+
}
|
|
1529
|
+
parser->prev_state = cs;
|
|
1530
|
+
}
|
|
1531
|
+
#line 85 "parser.rl"
|
|
1532
|
+
{
|
|
1533
|
+
parser->mark = p;
|
|
1534
|
+
//debug_string( "begin", p, 1 );
|
|
1535
|
+
}
|
|
1536
|
+
#line 102 "parser.rl"
|
|
1537
|
+
{
|
|
1538
|
+
//debug_string( "see_end_tag: before parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1539
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1540
|
+
//debug_string( "see_end_tag: after parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1541
|
+
parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
|
|
1542
|
+
//debug_string( "see_end_tag: after start parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1543
|
+
parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
|
|
1544
|
+
//debug_string( "see_end_tag: after end parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1545
|
+
parser->tag_text = NULL;
|
|
1546
|
+
parser->tag_text_length = 0;
|
|
1547
|
+
parser->mark = p;
|
|
1548
|
+
//debug_string( "see_end_tag", p, 1 );
|
|
1549
|
+
}
|
|
1550
|
+
#line 89 "parser.rl"
|
|
1551
|
+
{
|
|
1552
|
+
// printf( "finish\n" );
|
|
1553
|
+
}
|
|
1554
|
+
goto _again;
|
|
1555
|
+
f12:
|
|
1556
|
+
#line 175 "parser.rl"
|
|
1557
|
+
{
|
|
1558
|
+
switch( cs ){
|
|
1559
|
+
case 0:
|
|
1560
|
+
if( parser->prev_state != 12 && parser->prev_state != 7 ){
|
|
1561
|
+
if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
|
|
1562
|
+
// stream echobuffer
|
|
1563
|
+
esi_parser_echo_buffer( parser );
|
|
1564
|
+
}
|
|
1565
|
+
// printf( "[%d: %c]", cs, *p );
|
|
1566
|
+
// stream the current character
|
|
1567
|
+
esi_parser_echo_char( parser, *p );
|
|
1568
|
+
}
|
|
1569
|
+
// clear the echobuffer
|
|
1570
|
+
esi_parser_echobuffer_clear( parser );
|
|
1571
|
+
break;
|
|
1572
|
+
default:
|
|
1573
|
+
// append characters to echobuffer
|
|
1574
|
+
esi_parser_concat_to_echobuffer( parser, *p );
|
|
1575
|
+
}
|
|
1576
|
+
parser->prev_state = cs;
|
|
1577
|
+
}
|
|
1578
|
+
#line 102 "parser.rl"
|
|
1579
|
+
{
|
|
1580
|
+
//debug_string( "see_end_tag: before parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1581
|
+
ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
|
|
1582
|
+
//debug_string( "see_end_tag: after parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1583
|
+
parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
|
|
1584
|
+
//debug_string( "see_end_tag: after start parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1585
|
+
parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
|
|
1586
|
+
//debug_string( "see_end_tag: after end parsed esi tag", parser->tag_text, parser->tag_text_length );
|
|
1587
|
+
parser->tag_text = NULL;
|
|
1588
|
+
parser->tag_text_length = 0;
|
|
1589
|
+
parser->mark = p;
|
|
1590
|
+
//debug_string( "see_end_tag", p, 1 );
|
|
1591
|
+
}
|
|
1592
|
+
#line 133 "parser.rl"
|
|
1593
|
+
{
|
|
1594
|
+
ESIAttribute *attr;
|
|
1595
|
+
parser->attr_value = parser->mark;
|
|
1596
|
+
parser->attr_value_length = p - parser->mark;
|
|
1597
|
+
parser->mark = p;
|
|
1598
|
+
|
|
1599
|
+
ltrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
|
|
1600
|
+
|
|
1601
|
+
// allocate a new attribute
|
|
1602
|
+
attr = esi_attribute_new( parser->attr_key, parser->attr_key_length,
|
|
1603
|
+
parser->attr_value, parser->attr_value_length );
|
|
1604
|
+
if( parser->attributes ){
|
|
1605
|
+
parser->last->next = attr;
|
|
1606
|
+
parser->last = attr;
|
|
1607
|
+
}
|
|
1608
|
+
else{
|
|
1609
|
+
parser->last = parser->attributes = attr;
|
|
1610
|
+
}
|
|
1611
|
+
// debug_string( "\tattribute value", parser->attr_value, parser->attr_value_length );
|
|
1612
|
+
//debug_string( "see_attribute_value", p, 1 );
|
|
1613
|
+
}
|
|
1614
|
+
#line 89 "parser.rl"
|
|
1615
|
+
{
|
|
1616
|
+
// printf( "finish\n" );
|
|
1617
|
+
}
|
|
1618
|
+
goto _again;
|
|
1619
|
+
|
|
1620
|
+
_again:
|
|
1621
|
+
if ( ++p != pe )
|
|
1622
|
+
goto _resume;
|
|
1623
|
+
_out: {}
|
|
1624
|
+
}
|
|
1625
|
+
#line 351 "parser.rl"
|
|
1626
|
+
|
|
1627
|
+
parser->cs = cs;
|
|
1628
|
+
|
|
1629
|
+
if( cs != esi_start && cs != 0 ){
|
|
1630
|
+
|
|
1631
|
+
if( !parser->overflow_data ){
|
|
1632
|
+
// recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
|
|
1633
|
+
int mark_offset = compute_offset( parser->mark, data );
|
|
1634
|
+
int tag_text_offset = compute_offset( parser->tag_text, data );
|
|
1635
|
+
int attr_key_offset = compute_offset( parser->attr_key, data );
|
|
1636
|
+
int attr_value_offset = compute_offset( parser->attr_value, data );
|
|
1637
|
+
//debug_string( "mark before move", parser->mark, 1 );
|
|
1638
|
+
|
|
1639
|
+
parser->overflow_data = (char*)malloc( sizeof( char ) * length );
|
|
1640
|
+
memcpy( parser->overflow_data, data, length );
|
|
1641
|
+
parser->overflow_data_size = length;
|
|
1642
|
+
|
|
1643
|
+
// in our new memory space mark will now be
|
|
1644
|
+
parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
|
|
1645
|
+
parser->tag_text = ( tag_text_offset >= 0 ) ? parser->overflow_data + tag_text_offset : NULL;
|
|
1646
|
+
parser->attr_key = ( attr_key_offset >= 0 ) ? parser->overflow_data + attr_key_offset : NULL;
|
|
1647
|
+
parser->attr_value = ( attr_value_offset >= 0 ) ? parser->overflow_data + attr_value_offset : NULL;
|
|
1648
|
+
//if( parser->mark ){ debug_string( "mark after move", parser->mark, 1 ); } else { printf( "mark is now empty\n" ); }
|
|
1649
|
+
}
|
|
1650
|
+
|
|
1651
|
+
}else if( parser->overflow_data ){
|
|
1652
|
+
free( parser->overflow_data );
|
|
1653
|
+
parser->overflow_data = NULL;
|
|
1654
|
+
parser->overflow_data_size = 0;
|
|
1655
|
+
}
|
|
1656
|
+
|
|
1657
|
+
return cs;
|
|
1658
|
+
}
|
|
1659
|
+
int esi_parser_finish( ESIParser *parser )
|
|
1660
|
+
{
|
|
1661
|
+
|
|
1662
|
+
#line 1663 "parser.c"
|
|
1663
|
+
#line 387 "parser.rl"
|
|
1664
|
+
return 0;
|
|
1665
|
+
}
|
|
1666
|
+
|
|
1667
|
+
void esi_parser_start_tag_handler( ESIParser *parser, start_tag_cb callback )
|
|
1668
|
+
{
|
|
1669
|
+
parser->start_tag_handler = callback;
|
|
1670
|
+
}
|
|
1671
|
+
|
|
1672
|
+
void esi_parser_end_tag_handler( ESIParser *parser, end_tag_cb callback )
|
|
1673
|
+
{
|
|
1674
|
+
parser->end_tag_handler = callback;
|
|
1675
|
+
}
|