ebb 0.1.0 → 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.
Files changed (29) hide show
  1. data/README +4 -7
  2. data/benchmark/application.rb +12 -4
  3. data/benchmark/server_test.rb +10 -11
  4. data/bin/ebb_rails +0 -0
  5. data/libev/ev.c +235 -128
  6. data/libev/ev.h +84 -27
  7. data/libev/ev_epoll.c +30 -22
  8. data/libev/ev_kqueue.c +30 -22
  9. data/libev/ev_poll.c +30 -22
  10. data/libev/ev_port.c +30 -22
  11. data/libev/ev_select.c +34 -26
  12. data/libev/ev_vars.h +49 -0
  13. data/libev/ev_win32.c +31 -23
  14. data/libev/ev_wrap.h +12 -0
  15. data/ruby_lib/ebb.rb +94 -67
  16. data/ruby_lib/ebb/runner.rb +4 -5
  17. data/ruby_lib/ebb/runner/rails.rb +1 -4
  18. data/ruby_lib/rack/adapter/rails.rb +5 -0
  19. data/src/ebb.c +261 -387
  20. data/src/ebb.h +19 -29
  21. data/src/ebb_ruby.c +113 -108
  22. data/src/extconf.rb +0 -1
  23. data/src/parser.c +1755 -724
  24. data/src/parser.h +13 -10
  25. data/test/basic_test.rb +18 -1
  26. data/test/env_test.rb +6 -5
  27. data/test/helper.rb +53 -1
  28. metadata +3 -4
  29. data/benchmark/bench_results.rb +0 -58
data/src/ebb.h CHANGED
@@ -13,9 +13,9 @@
13
13
 
14
14
  typedef struct ebb_server ebb_server;
15
15
  typedef struct ebb_client ebb_client;
16
- #define EBB_VERSION "0.1.0"
16
+ #define EBB_VERSION "0.2.0"
17
17
  #define EBB_BUFFERSIZE (1024 * (80 + 33))
18
- #define EBB_MAX_CLIENTS 200
18
+ #define EBB_MAX_CLIENTS 1024
19
19
  #define EBB_TIMEOUT 30.0
20
20
  #define EBB_MAX_ENV 500
21
21
  #define EBB_TCP_COMMON \
@@ -28,31 +28,22 @@ void ebb_client_close(ebb_client*);
28
28
  /* user MUST call this function on each client passed by the request_cb */
29
29
  void ebb_client_release(ebb_client*);
30
30
  int ebb_client_read(ebb_client *client, char *buffer, int length);
31
- void ebb_client_write_status(ebb_client*, int status, const char *human_status);
31
+ void ebb_client_write_status(ebb_client*, int status, const char *reason_phrase);
32
32
  void ebb_client_write_header(ebb_client*, const char *field, const char *value);
33
- void ebb_client_write(ebb_client*, const char *data, int length);
34
- void ebb_client_begin_transmission( ebb_client *client);
33
+ void ebb_client_write_body(ebb_client*, const char *data, int length);
34
+ /* int ebb_client_should_keep_alive(ebb_client*); */
35
35
 
36
36
  struct ebb_env_item {
37
- enum { EBB_FIELD_VALUE_PAIR
38
- , EBB_REQUEST_METHOD
39
- , EBB_REQUEST_URI
40
- , EBB_FRAGMENT
41
- , EBB_REQUEST_PATH
42
- , EBB_QUERY_STRING
43
- , EBB_HTTP_VERSION
44
- , EBB_SERVER_PORT
45
- , EBB_CONTENT_LENGTH
46
- } type;
47
- const char *field;
48
- int field_length;
49
- const char *value;
50
- int value_length;
37
+ int type;
38
+ const char *field;
39
+ int field_length;
40
+ const char *value;
41
+ int value_length;
51
42
  };
52
43
 
53
44
  struct ebb_client {
54
45
  EBB_TCP_COMMON
55
-
46
+ char *ip;
56
47
  unsigned int in_use : 1;
57
48
 
58
49
  ebb_server *server;
@@ -60,23 +51,20 @@ struct ebb_client {
60
51
 
61
52
  char *request_buffer;
62
53
  ev_io read_watcher;
63
- size_t read, nread_from_body;
64
-
65
- char upload_file_filename[200];
66
- FILE *upload_file;
54
+ size_t read;
67
55
 
68
- int content_length;
56
+ char *body_head;
57
+ size_t body_head_len;
69
58
 
70
59
  ev_io write_watcher;
71
60
  GString *response_buffer;
72
61
  size_t written;
73
62
 
74
63
  ev_timer timeout_watcher;
75
-
64
+ unsigned int keep_alive : 1;
76
65
  unsigned int status_written : 1;
77
66
  unsigned int headers_written : 1;
78
67
  unsigned int body_written : 1;
79
- unsigned int began_transmission : 1;
80
68
 
81
69
  /* the ENV structure */
82
70
  int env_size;
@@ -94,9 +82,11 @@ void ebb_server_init( ebb_server *server
94
82
  , ebb_request_cb request_cb
95
83
  , void *request_cb_data
96
84
  );
85
+ int ebb_server_listen_on_fd(ebb_server*, const int sfd);
97
86
  int ebb_server_listen_on_port(ebb_server*, const int port);
98
- int ebb_server_listen_on_socket(ebb_server*, const char *socketpath);
87
+ int ebb_server_listen_on_unix_socket(ebb_server*, const char *socketpath);
99
88
  void ebb_server_unlisten(ebb_server*);
89
+ int ebb_server_clients_in_use_p(ebb_server*);
100
90
 
101
91
  struct ebb_server {
102
92
  EBB_TCP_COMMON
@@ -109,4 +99,4 @@ struct ebb_server {
109
99
  ebb_request_cb request_cb;
110
100
  };
111
101
 
112
- #endif
102
+ #endif
data/src/ebb_ruby.c CHANGED
@@ -11,18 +11,22 @@
11
11
  #include <ev.h>
12
12
 
13
13
  static VALUE cClient;
14
- static VALUE global_http_prefix;
15
- static VALUE global_request_method;
16
- static VALUE global_request_uri;
14
+ static VALUE waiting_clients;
15
+
17
16
  static VALUE global_fragment;
18
- static VALUE global_request_path;
17
+ static VALUE global_path_info;
19
18
  static VALUE global_query_string;
20
- static VALUE global_http_version;
21
19
  static VALUE global_request_body;
20
+ static VALUE global_request_method;
21
+ static VALUE global_request_path;
22
+ static VALUE global_request_uri;
22
23
  static VALUE global_server_port;
23
- static VALUE global_path_info;
24
24
  static VALUE global_content_length;
25
- static VALUE global_http_host;
25
+ static VALUE global_content_type;
26
+ static VALUE global_http_client_ip;
27
+ static VALUE global_http_prefix;
28
+ static VALUE global_http_version;
29
+
26
30
 
27
31
  /* You don't want to run more than one server per Ruby VM. Really
28
32
  * I'm making this explicit by not defining a Ebb::Server class but instead
@@ -53,22 +57,27 @@ static void detach_idle_watcher()
53
57
  ev_idle_stop(loop, &idle_watcher);
54
58
  }
55
59
 
56
- static int clients_in_use_p()
57
- {
58
- int i;
59
- for(i = 0; i < EBB_MAX_CLIENTS; i++)
60
- if(server->clients[i].in_use) return TRUE;
61
- return FALSE;
62
- }
63
60
 
64
61
  void request_cb(ebb_client *client, void *data)
65
62
  {
66
- VALUE waiting_clients = (VALUE)data;
67
63
  VALUE rb_client = Data_Wrap_Struct(cClient, 0, 0, client);
64
+
65
+ rb_iv_set(rb_client, "@fd", INT2FIX(client->fd));
66
+ rb_iv_set(rb_client, "@content_length", INT2FIX(client->parser.content_length));
67
+ if(client->body_head_len > 0)
68
+ rb_iv_set(rb_client, "@body_head", rb_str_new(client->body_head, client->body_head_len));
69
+
68
70
  rb_ary_push(waiting_clients, rb_client);
69
71
  attach_idle_watcher();
70
72
  }
71
73
 
74
+ VALUE server_listen_on_fd(VALUE _, VALUE sfd)
75
+ {
76
+ if(ebb_server_listen_on_fd(server, FIX2INT(sfd)) < 0)
77
+ rb_sys_fail("Problem listening on FD");
78
+ return Qnil;
79
+ }
80
+
72
81
  VALUE server_listen_on_port(VALUE _, VALUE port)
73
82
  {
74
83
  if(ebb_server_listen_on_port(server, FIX2INT(port)) < 0)
@@ -76,22 +85,49 @@ VALUE server_listen_on_port(VALUE _, VALUE port)
76
85
  return Qnil;
77
86
  }
78
87
 
88
+ VALUE server_listen_on_unix_socket(VALUE _, VALUE socketfile)
89
+ {
90
+ if(ebb_server_listen_on_unix_socket(server, StringValuePtr(socketfile)) < 0)
91
+ rb_sys_fail("Problem listening on unix socket");
92
+ return Qnil;
93
+ }
94
+
95
+
96
+ static struct timeval idle_timeout = { tv_sec: 0, tv_usec: 50000 };
97
+
79
98
  static void
80
99
  idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) {
81
- if(clients_in_use_p()) {
100
+ /* How to let other Ruby threads run while we're in this blocking C call */
101
+
102
+ /* TODO: For Ruby 1.9 I should use rb_thread_blocking_region() instead of
103
+ * this hacky idle_cb
104
+ */
105
+
106
+ if(ebb_server_clients_in_use_p(server)) {
107
+ /* If ruby has control of any clients - that means there are some requests
108
+ * still being processed inside of threads. We need to allow Ruby some
109
+ * time to work on these threads so we call rb_thread_schedule()
110
+ * I don't use rb_thread_select() here because it is very slow.
111
+ */
82
112
  rb_thread_schedule();
113
+
83
114
  } else if(!rb_thread_alone()) {
84
- /* if you have another long running thread running besides the ones used
85
- * for the webapp's requests you will run into performance problems in
86
- * ruby 1.8.x because rb_thread_select is slow.
87
- * (Don't worry - you're probably not doing this.)
115
+ /* If no clients are in use, but there are still other Ruby threads then
116
+ * some other thread is running in the Ruby VM which is not a request.
117
+ * This is a sub-optimal situation and we solve it by calling
118
+ * rb_thread_select() to wait for the server fd to wake up.
119
+ * One should try to avoid entering this state.
88
120
  */
89
- struct timeval select_timeout = { tv_sec: 0, tv_usec: 50000 };
90
121
  fd_set server_fd_set;
91
122
  FD_ZERO(&server_fd_set);
92
123
  FD_SET(server->fd, &server_fd_set);
93
- rb_thread_select(server->fd+1, &server_fd_set, 0, 0, &select_timeout);
124
+ rb_thread_select(server->fd+1, &server_fd_set, 0, 0, &idle_timeout);
94
125
  } else {
126
+ /* Otherwise there are no other threads. We can detach the idle_watcher
127
+ * and allow the server_process_connections() to block until the
128
+ * server fd wakes up. Because we don't use rb_thread_select() this
129
+ * is quite fast.
130
+ */
95
131
  detach_idle_watcher();
96
132
  }
97
133
  }
@@ -116,31 +152,37 @@ VALUE server_open(VALUE _)
116
152
  return server->open ? Qtrue : Qfalse;
117
153
  }
118
154
 
155
+ VALUE server_waiting_clients(VALUE _)
156
+ {
157
+ return waiting_clients;
158
+ }
159
+
119
160
  VALUE env_field(struct ebb_env_item *item)
120
161
  {
121
- VALUE f;
162
+ if(item->field) {
163
+ VALUE f = rb_str_new(NULL, RSTRING_LEN(global_http_prefix) + item->field_length);
164
+ memcpy( RSTRING_PTR(f)
165
+ , RSTRING_PTR(global_http_prefix)
166
+ , RSTRING_LEN(global_http_prefix)
167
+ );
168
+ int i;
169
+ for(i = 0; i < item->field_length; i++) {
170
+ char *ch = RSTRING_PTR(f) + RSTRING_LEN(global_http_prefix) + i;
171
+ *ch = item->field[i] == '-' ? '_' : ASCII_UPPER(item->field[i]);
172
+ }
173
+ return f;
174
+ }
122
175
  switch(item->type) {
123
- case EBB_FIELD_VALUE_PAIR:
124
- f = rb_str_new(NULL, RSTRING_LEN(global_http_prefix) + item->field_length);
125
- memcpy( RSTRING_PTR(f)
126
- , RSTRING_PTR(global_http_prefix)
127
- , RSTRING_LEN(global_http_prefix)
128
- );
129
- int i;
130
- for(i = 0; i < item->field_length; i++) {
131
- char *ch = RSTRING_PTR(f) + RSTRING_LEN(global_http_prefix) + i;
132
- *ch = item->field[i] == '-' ? '_' : ASCII_UPPER(item->field[i]);
133
- }
134
- return f;
135
- case EBB_REQUEST_METHOD: return global_request_method;
136
- case EBB_REQUEST_URI: return global_request_uri;
137
- case EBB_FRAGMENT: return global_fragment;
138
- case EBB_REQUEST_PATH: return global_request_path;
139
- case EBB_QUERY_STRING: return global_query_string;
140
- case EBB_HTTP_VERSION: return global_http_version;
141
- case EBB_SERVER_PORT: return global_server_port;
142
- case EBB_CONTENT_LENGTH: return global_content_length;
176
+ case MONGREL_CONTENT_LENGTH: return global_content_length;
177
+ case MONGREL_CONTENT_TYPE: return global_content_type;
178
+ case MONGREL_FRAGMENT: return global_fragment;
179
+ case MONGREL_HTTP_VERSION: return global_http_version;
180
+ case MONGREL_QUERY_STRING: return global_query_string;
181
+ case MONGREL_REQUEST_METHOD: return global_request_method;
182
+ case MONGREL_REQUEST_PATH: return global_request_path;
183
+ case MONGREL_REQUEST_URI: return global_request_uri;
143
184
  }
185
+ fprintf(stderr, "Unknown environ type: %d", item->type);
144
186
  assert(FALSE);
145
187
  return Qnil;
146
188
  }
@@ -158,50 +200,31 @@ VALUE env_value(struct ebb_env_item *item)
158
200
  VALUE client_env(VALUE _, VALUE rb_client)
159
201
  {
160
202
  ebb_client *client;
161
- VALUE field, value, hash = rb_hash_new();
203
+ VALUE field, value, env = rb_hash_new();
162
204
  int i;
163
205
 
164
206
  Data_Get_Struct(rb_client, ebb_client, client);
165
207
  for(i=0; i < client->env_size; i++) {
166
208
  field = env_field(&client->env[i]);
167
209
  value = env_value(&client->env[i]);
168
- rb_hash_aset(hash, field, value);
169
- //printf("(%s, %s)\n", StringValuePtr(field), StringValuePtr(value));
210
+ rb_hash_aset(env, field, value);
170
211
  }
171
- //printf("\n\n");
172
- rb_hash_aset(hash, global_path_info, rb_hash_aref(hash, global_request_path));
173
- return hash;
174
- }
175
-
176
-
177
- VALUE client_read_input(VALUE _, VALUE client, VALUE size)
178
- {
179
- ebb_client *_client;
180
- GString *_string;
181
- VALUE string;
182
- int _size = FIX2INT(size);
183
- Data_Get_Struct(client, ebb_client, _client);
184
212
 
185
- string = rb_str_buf_new( _size );
186
- int nread = ebb_client_read(_client, RSTRING_PTR(string), _size);
187
- #if RUBY_VERSION_CODE < 190
188
- RSTRING(string)->len = nread;
189
- #else
190
- rb_str_set_len(string, nread);
191
- #endif
213
+ if(client->server->port)
214
+ rb_hash_aset(env, global_server_port, rb_str_new2(client->server->port));
192
215
 
193
- if(nread < 0)
194
- rb_raise(rb_eRuntimeError,"There was a problem reading from input (bad tmp file?)");
195
- if(nread == 0)
196
- return Qnil;
197
- return string;
216
+ if(client->ip)
217
+ rb_hash_aset(env, global_http_client_ip, rb_str_new2(client->ip));
218
+
219
+ rb_hash_aset(env, global_path_info, rb_hash_aref(env, global_request_path));
220
+ return env;
198
221
  }
199
222
 
200
- VALUE client_write_status(VALUE _, VALUE client, VALUE status, VALUE human_status)
223
+ VALUE client_write_status(VALUE _, VALUE client, VALUE status, VALUE reason_phrase)
201
224
  {
202
225
  ebb_client *_client;
203
226
  Data_Get_Struct(client, ebb_client, _client);
204
- ebb_client_write_status(_client, FIX2INT(status), StringValuePtr(human_status));
227
+ ebb_client_write_status(_client, FIX2INT(status), StringValuePtr(reason_phrase));
205
228
  return Qnil;
206
229
  }
207
230
 
@@ -213,25 +236,15 @@ VALUE client_write_header(VALUE _, VALUE client, VALUE field, VALUE value)
213
236
  return Qnil;
214
237
  }
215
238
 
216
- VALUE client_write(VALUE _, VALUE client, VALUE string)
239
+ VALUE client_write_body(VALUE _, VALUE client, VALUE string)
217
240
  {
218
241
  ebb_client *_client;
219
242
  Data_Get_Struct(client, ebb_client, _client);
220
- ebb_client_write(_client, RSTRING_PTR(string), RSTRING_LEN(string));
243
+ ebb_client_write_body(_client, RSTRING_PTR(string), RSTRING_LEN(string));
221
244
  return Qnil;
222
245
  }
223
246
 
224
247
 
225
- VALUE client_begin_transmission(VALUE _, VALUE rb_client)
226
- {
227
- ebb_client *client;
228
- Data_Get_Struct(rb_client, ebb_client, client);
229
- client->status_written = TRUE;
230
- client->headers_written = TRUE;
231
- ebb_client_begin_transmission(client);
232
- return Qnil;
233
- }
234
-
235
248
  VALUE client_release(VALUE _, VALUE rb_client)
236
249
  {
237
250
  ebb_client *client;
@@ -240,49 +253,41 @@ VALUE client_release(VALUE _, VALUE rb_client)
240
253
  return Qnil;
241
254
  }
242
255
 
243
-
244
- VALUE client_set_body_written(VALUE _, VALUE rb_client, VALUE v)
245
- {
246
- ebb_client *client;
247
- Data_Get_Struct(rb_client, ebb_client, client);
248
- client->body_written = RTEST(v);
249
- return client->body_written ? Qtrue : Qfalse;
250
- }
251
-
252
256
  void Init_ebb_ext()
253
257
  {
254
258
  VALUE mEbb = rb_define_module("Ebb");
255
259
  VALUE mFFI = rb_define_module_under(mEbb, "FFI");
256
260
 
257
- rb_define_const(mEbb, "VERSION", rb_str_new2(EBB_VERSION));
261
+ rb_define_const(mFFI, "VERSION", rb_str_new2(EBB_VERSION));
258
262
 
259
263
  /** Defines global strings in the init method. */
260
264
  #define DEF_GLOBAL(N, val) global_##N = rb_obj_freeze(rb_str_new2(val)); rb_global_variable(&global_##N)
261
- DEF_GLOBAL(http_prefix, "HTTP_");
262
- DEF_GLOBAL(request_method, "REQUEST_METHOD");
263
- DEF_GLOBAL(request_uri, "REQUEST_URI");
265
+ DEF_GLOBAL(content_length, "CONTENT_LENGTH");
266
+ DEF_GLOBAL(content_type, "CONTENT_TYPE");
264
267
  DEF_GLOBAL(fragment, "FRAGMENT");
265
- DEF_GLOBAL(request_path, "REQUEST_PATH");
268
+ DEF_GLOBAL(path_info, "PATH_INFO");
266
269
  DEF_GLOBAL(query_string, "QUERY_STRING");
267
- DEF_GLOBAL(http_version, "HTTP_VERSION");
268
270
  DEF_GLOBAL(request_body, "REQUEST_BODY");
271
+ DEF_GLOBAL(request_method, "REQUEST_METHOD");
272
+ DEF_GLOBAL(request_path, "REQUEST_PATH");
273
+ DEF_GLOBAL(request_uri, "REQUEST_URI");
269
274
  DEF_GLOBAL(server_port, "SERVER_PORT");
270
- DEF_GLOBAL(path_info, "PATH_INFO");
271
- DEF_GLOBAL(content_length, "CONTENT_LENGTH");
272
- DEF_GLOBAL(http_host, "HTTP_HOST");
275
+ DEF_GLOBAL(http_client_ip, "HTTP_CLIENT_IP");
276
+ DEF_GLOBAL(http_prefix, "HTTP_");
277
+ DEF_GLOBAL(http_version, "HTTP_VERSION");
273
278
 
274
279
  rb_define_singleton_method(mFFI, "server_process_connections", server_process_connections, 0);
280
+ rb_define_singleton_method(mFFI, "server_listen_on_fd", server_listen_on_fd, 1);
275
281
  rb_define_singleton_method(mFFI, "server_listen_on_port", server_listen_on_port, 1);
282
+ rb_define_singleton_method(mFFI, "server_listen_on_unix_socket", server_listen_on_unix_socket, 1);
276
283
  rb_define_singleton_method(mFFI, "server_unlisten", server_unlisten, 0);
277
284
  rb_define_singleton_method(mFFI, "server_open?", server_open, 0);
285
+ rb_define_singleton_method(mFFI, "server_waiting_clients", server_waiting_clients, 0);
278
286
 
279
287
  cClient = rb_define_class_under(mEbb, "Client", rb_cObject);
280
- rb_define_singleton_method(mFFI, "client_read_input", client_read_input, 2);
281
288
  rb_define_singleton_method(mFFI, "client_write_status", client_write_status, 3);
282
289
  rb_define_singleton_method(mFFI, "client_write_header", client_write_header, 3);
283
- rb_define_singleton_method(mFFI, "client_write", client_write, 2);
284
- rb_define_singleton_method(mFFI, "client_begin_transmission", client_begin_transmission, 1);
285
- rb_define_singleton_method(mFFI, "client_set_body_written", client_set_body_written, 2);
290
+ rb_define_singleton_method(mFFI, "client_write_body", client_write_body, 2);
286
291
  rb_define_singleton_method(mFFI, "client_env", client_env, 1);
287
292
  rb_define_singleton_method(mFFI, "client_release", client_release, 1);
288
293
 
@@ -293,7 +298,7 @@ void Init_ebb_ext()
293
298
  attach_idle_watcher();
294
299
 
295
300
  server = ebb_server_alloc();
296
- VALUE waiting_clients = rb_ary_new();
301
+ waiting_clients = rb_ary_new();
297
302
  rb_iv_set(mFFI, "@waiting_clients", waiting_clients);
298
303
  ebb_server_init(server, loop, request_cb, (void*)waiting_clients);
299
304
  }
data/src/extconf.rb CHANGED
@@ -1,6 +1,5 @@
1
1
  require 'mkmf'
2
2
 
3
-
4
3
  unless pkg_config('glib-2.0')
5
4
  abort "Ebb requires glib-2.0 and pkg_config"
6
5
  end
data/src/parser.c CHANGED
@@ -15,47 +15,61 @@
15
15
  #define LEN(AT, FPC) (FPC - buffer - parser->AT)
16
16
  #define MARK(M,FPC) (parser->M = (FPC) - buffer)
17
17
  #define PTR_TO(F) (buffer + parser->F)
18
-
19
18
  /** machine **/
20
- #line 159 "src/parser.rl"
19
+ #line 139 "src/parser.rl"
21
20
 
22
21
 
23
22
  /** Data **/
24
23
 
25
- #line 26 "src/parser.c"
24
+ #line 25 "src/parser.c"
26
25
  static const int http_parser_start = 1;
27
- static const int http_parser_first_final = 73;
26
+ static const int http_parser_first_final = 118;
28
27
  static const int http_parser_error = 0;
29
28
 
30
29
  static const int http_parser_en_main = 1;
31
30
 
32
- #line 163 "src/parser.rl"
31
+ #line 143 "src/parser.rl"
32
+
33
+ /* returns TRUE if applied, FALSE if there was an error */
34
+ static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length)
35
+ {
36
+ int len = (int)(end-begin);
37
+ if(len > max_length) {
38
+ parser->overflow_error = TRUE;
39
+ return FALSE;
40
+ }
41
+ if(parser->on_element)
42
+ parser->on_element(parser->data, type, begin, len);
43
+ return TRUE;
44
+ }
45
+
46
+ static void set_content_length(http_parser *parser, const char *at, int length)
47
+ {
48
+ /* atoi_length - why isn't this in the statndard library? i hate c */
49
+ assert(parser->content_length == 0);
50
+ int i, mult;
51
+ for(mult=1, i=length-1; i>=0; i--, mult*=10)
52
+ parser->content_length += (at[i] - '0') * mult;
53
+ }
33
54
 
34
55
  void http_parser_init(http_parser *parser) {
35
56
  int cs = 0;
36
57
 
37
- #line 38 "src/parser.c"
58
+ #line 59 "src/parser.c"
38
59
  {
39
60
  cs = http_parser_start;
40
61
  }
41
- #line 167 "src/parser.rl"
62
+ #line 169 "src/parser.rl"
42
63
  parser->cs = cs;
43
64
  parser->overflow_error = FALSE;
44
65
  parser->body_start = 0;
45
- parser->content_len = 0;
66
+ parser->content_length = 0;
46
67
  parser->mark = 0;
47
68
  parser->nread = 0;
48
69
  parser->field_len = 0;
49
70
  parser->field_start = 0;
50
71
  parser->data = NULL;
51
72
  parser->http_field = NULL;
52
- parser->request_method = NULL;
53
- parser->request_uri = NULL;
54
- parser->fragment = NULL;
55
- parser->request_path = NULL;
56
- parser->query_string = NULL;
57
- parser->http_version = NULL;
58
- parser->content_length = NULL;
59
73
  }
60
74
 
61
75
 
@@ -74,7 +88,7 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len,
74
88
  assert(pe - p == len - off && "pointers aren't same distance");
75
89
 
76
90
 
77
- #line 78 "src/parser.c"
91
+ #line 92 "src/parser.c"
78
92
  {
79
93
  if ( p == pe )
80
94
  goto _test_eof;
@@ -98,40 +112,40 @@ st0:
98
112
  cs = 0;
99
113
  goto _out;
100
114
  tr0:
101
- #line 22 "src/parser.rl"
115
+ #line 21 "src/parser.rl"
102
116
  {MARK(mark, p); }
103
117
  goto st2;
104
118
  st2:
105
119
  if ( ++p == pe )
106
120
  goto _test_eof2;
107
121
  case 2:
108
- #line 109 "src/parser.c"
122
+ #line 123 "src/parser.c"
109
123
  switch( (*p) ) {
110
124
  case 32: goto tr2;
111
- case 36: goto st54;
112
- case 95: goto st54;
125
+ case 36: goto st99;
126
+ case 95: goto st99;
113
127
  }
114
128
  if ( (*p) < 48 ) {
115
129
  if ( 45 <= (*p) && (*p) <= 46 )
116
- goto st54;
130
+ goto st99;
117
131
  } else if ( (*p) > 57 ) {
118
132
  if ( 65 <= (*p) && (*p) <= 90 )
119
- goto st54;
133
+ goto st99;
120
134
  } else
121
- goto st54;
135
+ goto st99;
122
136
  goto st0;
123
137
  tr2:
124
- #line 50 "src/parser.rl"
125
- {
126
- if(parser->request_method != NULL)
127
- parser->request_method(parser->data, PTR_TO(mark), LEN(mark, p));
138
+ #line 66 "src/parser.rl"
139
+ {
140
+ if(!apply_element(parser, MONGREL_REQUEST_METHOD, PTR_TO(mark), p, 1024))
141
+ {p++; cs = 3; goto _out;}
128
142
  }
129
143
  goto st3;
130
144
  st3:
131
145
  if ( ++p == pe )
132
146
  goto _test_eof3;
133
147
  case 3:
134
- #line 135 "src/parser.c"
148
+ #line 149 "src/parser.c"
135
149
  switch( (*p) ) {
136
150
  case 42: goto tr4;
137
151
  case 43: goto tr5;
@@ -148,135 +162,97 @@ case 3:
148
162
  goto tr5;
149
163
  goto st0;
150
164
  tr4:
151
- #line 22 "src/parser.rl"
165
+ #line 21 "src/parser.rl"
152
166
  {MARK(mark, p); }
153
167
  goto st4;
154
168
  st4:
155
169
  if ( ++p == pe )
156
170
  goto _test_eof4;
157
171
  case 4:
158
- #line 159 "src/parser.c"
172
+ #line 173 "src/parser.c"
159
173
  switch( (*p) ) {
160
174
  case 32: goto tr8;
161
175
  case 35: goto tr9;
162
176
  }
163
177
  goto st0;
164
178
  tr8:
165
- #line 55 "src/parser.rl"
179
+ #line 71 "src/parser.rl"
166
180
  {
167
- if(LEN(mark, p) > 12 * 1024) {
168
- parser->overflow_error = TRUE;
181
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
169
182
  {p++; cs = 5; goto _out;}
170
- }
171
- if(parser->request_uri != NULL)
172
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
173
183
  }
174
184
  goto st5;
175
- tr50:
176
- #line 22 "src/parser.rl"
185
+ tr103:
186
+ #line 21 "src/parser.rl"
177
187
  {MARK(mark, p); }
178
- #line 88 "src/parser.rl"
188
+ #line 51 "src/parser.rl"
179
189
  {
180
- /* Don't know if this length is specified somewhere or not */
181
- if(LEN(mark, p) > 1024) {
182
- parser->overflow_error = TRUE;
190
+ if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), p, 10*1024))
183
191
  {p++; cs = 5; goto _out;}
184
- }
185
- if(parser->fragment != NULL)
186
- parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
187
192
  }
188
193
  goto st5;
189
- tr53:
190
- #line 88 "src/parser.rl"
194
+ tr106:
195
+ #line 51 "src/parser.rl"
191
196
  {
192
- /* Don't know if this length is specified somewhere or not */
193
- if(LEN(mark, p) > 1024) {
194
- parser->overflow_error = TRUE;
197
+ if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), p, 10*1024))
195
198
  {p++; cs = 5; goto _out;}
196
- }
197
- if(parser->fragment != NULL)
198
- parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
199
199
  }
200
200
  goto st5;
201
- tr61:
202
- #line 79 "src/parser.rl"
201
+ tr114:
202
+ #line 61 "src/parser.rl"
203
203
  {
204
- if(LEN(mark, p) > 1024) {
205
- parser->overflow_error = TRUE;
204
+ if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
206
205
  {p++; cs = 5; goto _out;}
207
- }
208
- if(parser->request_path != NULL)
209
- parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
210
206
  }
211
- #line 55 "src/parser.rl"
207
+ #line 71 "src/parser.rl"
212
208
  {
213
- if(LEN(mark, p) > 12 * 1024) {
214
- parser->overflow_error = TRUE;
209
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
215
210
  {p++; cs = 5; goto _out;}
216
- }
217
- if(parser->request_uri != NULL)
218
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
219
211
  }
220
212
  goto st5;
221
- tr72:
222
- #line 64 "src/parser.rl"
213
+ tr125:
214
+ #line 76 "src/parser.rl"
223
215
  {MARK(query_start, p); }
224
- #line 65 "src/parser.rl"
225
- {
226
- if(LEN(query_start, p) > 10 * 1024) {
227
- parser->overflow_error = TRUE;
216
+ #line 77 "src/parser.rl"
217
+ {
218
+ if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
228
219
  {p++; cs = 5; goto _out;}
229
- }
230
- if(parser->query_string != NULL)
231
- parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
232
220
  }
233
- #line 55 "src/parser.rl"
221
+ #line 71 "src/parser.rl"
234
222
  {
235
- if(LEN(mark, p) > 12 * 1024) {
236
- parser->overflow_error = TRUE;
223
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
237
224
  {p++; cs = 5; goto _out;}
238
- }
239
- if(parser->request_uri != NULL)
240
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
241
225
  }
242
226
  goto st5;
243
- tr76:
244
- #line 65 "src/parser.rl"
245
- {
246
- if(LEN(query_start, p) > 10 * 1024) {
247
- parser->overflow_error = TRUE;
227
+ tr129:
228
+ #line 77 "src/parser.rl"
229
+ {
230
+ if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
248
231
  {p++; cs = 5; goto _out;}
249
- }
250
- if(parser->query_string != NULL)
251
- parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
252
232
  }
253
- #line 55 "src/parser.rl"
233
+ #line 71 "src/parser.rl"
254
234
  {
255
- if(LEN(mark, p) > 12 * 1024) {
256
- parser->overflow_error = TRUE;
235
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
257
236
  {p++; cs = 5; goto _out;}
258
- }
259
- if(parser->request_uri != NULL)
260
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
261
237
  }
262
238
  goto st5;
263
239
  st5:
264
240
  if ( ++p == pe )
265
241
  goto _test_eof5;
266
242
  case 5:
267
- #line 268 "src/parser.c"
243
+ #line 244 "src/parser.c"
268
244
  if ( (*p) == 72 )
269
245
  goto tr10;
270
246
  goto st0;
271
247
  tr10:
272
- #line 22 "src/parser.rl"
248
+ #line 21 "src/parser.rl"
273
249
  {MARK(mark, p); }
274
250
  goto st6;
275
251
  st6:
276
252
  if ( ++p == pe )
277
253
  goto _test_eof6;
278
254
  case 6:
279
- #line 280 "src/parser.c"
255
+ #line 256 "src/parser.c"
280
256
  if ( (*p) == 84 )
281
257
  goto st7;
282
258
  goto st0;
@@ -334,61 +310,61 @@ case 13:
334
310
  goto st13;
335
311
  goto st0;
336
312
  tr18:
337
- #line 74 "src/parser.rl"
338
- {
339
- if(parser->http_version != NULL)
340
- parser->http_version(parser->data, PTR_TO(mark), LEN(mark, p));
313
+ #line 56 "src/parser.rl"
314
+ {
315
+ if(!apply_element(parser, MONGREL_HTTP_VERSION, PTR_TO(mark), p, 10))
316
+ {p++; cs = 14; goto _out;}
341
317
  }
342
318
  goto st14;
343
- tr27:
344
- #line 33 "src/parser.rl"
319
+ tr28:
320
+ #line 32 "src/parser.rl"
345
321
  { MARK(mark, p); }
346
- #line 34 "src/parser.rl"
322
+ #line 33 "src/parser.rl"
347
323
  {
348
- if(LEN(mark, p) > 80 * 1024) {
349
- parser->overflow_error = TRUE;
350
- {p++; cs = 14; goto _out;}
351
- }
324
+ if(LEN(mark, p) > 80 * 1024) { parser->overflow_error = TRUE; {p++; cs = 14; goto _out;} }
352
325
  if(parser->http_field != NULL) {
353
326
  parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
354
327
  }
355
328
  }
356
329
  goto st14;
357
- tr30:
358
- #line 34 "src/parser.rl"
330
+ tr32:
331
+ #line 33 "src/parser.rl"
359
332
  {
360
- if(LEN(mark, p) > 80 * 1024) {
361
- parser->overflow_error = TRUE;
362
- {p++; cs = 14; goto _out;}
363
- }
333
+ if(LEN(mark, p) > 80 * 1024) { parser->overflow_error = TRUE; {p++; cs = 14; goto _out;} }
364
334
  if(parser->http_field != NULL) {
365
335
  parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
366
336
  }
367
337
  }
368
338
  goto st14;
369
- tr47:
370
- #line 44 "src/parser.rl"
339
+ tr91:
340
+ #line 40 "src/parser.rl"
371
341
  {
372
- if(parser->content_length != NULL) {
373
- parser->content_length(parser->data, PTR_TO(mark), LEN(mark, p));
374
- }
342
+ if(!apply_element(parser, MONGREL_CONTENT_LENGTH, PTR_TO(mark), p, 20))
343
+ {p++; cs = 14; goto _out;}
344
+ set_content_length(parser, PTR_TO(mark), LEN(mark, p));
375
345
  }
376
- #line 34 "src/parser.rl"
346
+ goto st14;
347
+ tr98:
348
+ #line 21 "src/parser.rl"
349
+ {MARK(mark, p); }
350
+ #line 46 "src/parser.rl"
377
351
  {
378
- if(LEN(mark, p) > 80 * 1024) {
379
- parser->overflow_error = TRUE;
352
+ if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), p, 10*1024))
353
+ {p++; cs = 14; goto _out;}
354
+ }
355
+ goto st14;
356
+ tr101:
357
+ #line 46 "src/parser.rl"
358
+ {
359
+ if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), p, 10*1024))
380
360
  {p++; cs = 14; goto _out;}
381
- }
382
- if(parser->http_field != NULL) {
383
- parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
384
- }
385
361
  }
386
362
  goto st14;
387
363
  st14:
388
364
  if ( ++p == pe )
389
365
  goto _test_eof14;
390
366
  case 14:
391
- #line 392 "src/parser.c"
367
+ #line 368 "src/parser.c"
392
368
  if ( (*p) == 10 )
393
369
  goto st15;
394
370
  goto st0;
@@ -430,36 +406,32 @@ case 16:
430
406
  goto tr23;
431
407
  goto st0;
432
408
  tr23:
433
- #line 98 "src/parser.rl"
409
+ #line 82 "src/parser.rl"
434
410
  {
435
- if(parser->nread > 1024 * (80 + 32)) {
436
- parser->overflow_error = TRUE;
437
- {p++; cs = 73; goto _out;}
438
- }
439
- parser->body_start = p - buffer + 1;
440
- if(parser->header_done != NULL)
441
- parser->header_done(parser->data, p + 1, pe - p - 1);
442
- {p++; cs = 73; goto _out;}
411
+ parser->body_start = p - buffer + 1;
412
+ {p++; cs = 118; goto _out;}
443
413
  }
444
- goto st73;
445
- st73:
414
+ goto st118;
415
+ st118:
446
416
  if ( ++p == pe )
447
- goto _test_eof73;
448
- case 73:
449
- #line 450 "src/parser.c"
417
+ goto _test_eof118;
418
+ case 118:
419
+ #line 420 "src/parser.c"
450
420
  goto st0;
451
421
  tr21:
452
- #line 24 "src/parser.rl"
422
+ #line 23 "src/parser.rl"
453
423
  { MARK(field_start, p); }
454
424
  goto st17;
455
425
  st17:
456
426
  if ( ++p == pe )
457
427
  goto _test_eof17;
458
428
  case 17:
459
- #line 460 "src/parser.c"
429
+ #line 430 "src/parser.c"
460
430
  switch( (*p) ) {
461
431
  case 33: goto st17;
462
432
  case 58: goto tr25;
433
+ case 67: goto st40;
434
+ case 99: goto st40;
463
435
  case 124: goto st17;
464
436
  case 126: goto st17;
465
437
  }
@@ -482,7 +454,7 @@ case 17:
482
454
  goto st17;
483
455
  goto st0;
484
456
  tr25:
485
- #line 25 "src/parser.rl"
457
+ #line 24 "src/parser.rl"
486
458
  {
487
459
  parser->field_len = LEN(field_start, p);
488
460
  if(parser->field_len > 256) {
@@ -491,196 +463,1194 @@ tr25:
491
463
  }
492
464
  }
493
465
  goto st18;
494
- tr28:
495
- #line 33 "src/parser.rl"
466
+ tr29:
467
+ #line 32 "src/parser.rl"
496
468
  { MARK(mark, p); }
497
469
  goto st18;
498
470
  st18:
499
471
  if ( ++p == pe )
500
472
  goto _test_eof18;
501
473
  case 18:
502
- #line 503 "src/parser.c"
474
+ #line 475 "src/parser.c"
503
475
  switch( (*p) ) {
504
- case 13: goto tr27;
505
- case 32: goto tr28;
476
+ case 13: goto tr28;
477
+ case 32: goto tr29;
478
+ case 67: goto tr30;
479
+ case 99: goto tr30;
506
480
  }
507
- goto tr26;
508
- tr26:
509
- #line 33 "src/parser.rl"
481
+ goto tr27;
482
+ tr27:
483
+ #line 32 "src/parser.rl"
510
484
  { MARK(mark, p); }
511
485
  goto st19;
512
486
  st19:
513
487
  if ( ++p == pe )
514
488
  goto _test_eof19;
515
489
  case 19:
516
- #line 517 "src/parser.c"
517
- if ( (*p) == 13 )
518
- goto tr30;
490
+ #line 491 "src/parser.c"
491
+ switch( (*p) ) {
492
+ case 13: goto tr32;
493
+ case 67: goto st20;
494
+ case 99: goto st20;
495
+ }
519
496
  goto st19;
520
- tr22:
521
- #line 24 "src/parser.rl"
522
- { MARK(field_start, p); }
497
+ tr30:
498
+ #line 32 "src/parser.rl"
499
+ { MARK(mark, p); }
523
500
  goto st20;
524
501
  st20:
525
502
  if ( ++p == pe )
526
503
  goto _test_eof20;
527
504
  case 20:
528
- #line 529 "src/parser.c"
505
+ #line 506 "src/parser.c"
529
506
  switch( (*p) ) {
530
- case 33: goto st17;
531
- case 58: goto tr25;
507
+ case 13: goto tr32;
508
+ case 67: goto st20;
532
509
  case 79: goto st21;
510
+ case 99: goto st20;
533
511
  case 111: goto st21;
534
- case 124: goto st17;
535
- case 126: goto st17;
536
512
  }
537
- if ( (*p) < 45 ) {
538
- if ( (*p) > 39 ) {
539
- if ( 42 <= (*p) && (*p) <= 43 )
540
- goto st17;
541
- } else if ( (*p) >= 35 )
542
- goto st17;
543
- } else if ( (*p) > 46 ) {
544
- if ( (*p) < 65 ) {
545
- if ( 48 <= (*p) && (*p) <= 57 )
546
- goto st17;
547
- } else if ( (*p) > 90 ) {
548
- if ( 94 <= (*p) && (*p) <= 122 )
549
- goto st17;
550
- } else
551
- goto st17;
552
- } else
553
- goto st17;
554
- goto st0;
513
+ goto st19;
555
514
  st21:
556
515
  if ( ++p == pe )
557
516
  goto _test_eof21;
558
517
  case 21:
559
518
  switch( (*p) ) {
560
- case 33: goto st17;
561
- case 58: goto tr25;
519
+ case 13: goto tr32;
520
+ case 67: goto st20;
562
521
  case 78: goto st22;
522
+ case 99: goto st20;
563
523
  case 110: goto st22;
564
- case 124: goto st17;
565
- case 126: goto st17;
566
524
  }
567
- if ( (*p) < 45 ) {
568
- if ( (*p) > 39 ) {
569
- if ( 42 <= (*p) && (*p) <= 43 )
570
- goto st17;
571
- } else if ( (*p) >= 35 )
572
- goto st17;
573
- } else if ( (*p) > 46 ) {
574
- if ( (*p) < 65 ) {
575
- if ( 48 <= (*p) && (*p) <= 57 )
576
- goto st17;
577
- } else if ( (*p) > 90 ) {
578
- if ( 94 <= (*p) && (*p) <= 122 )
579
- goto st17;
580
- } else
581
- goto st17;
582
- } else
583
- goto st17;
584
- goto st0;
525
+ goto st19;
585
526
  st22:
586
527
  if ( ++p == pe )
587
528
  goto _test_eof22;
588
529
  case 22:
589
530
  switch( (*p) ) {
590
- case 33: goto st17;
591
- case 58: goto tr25;
531
+ case 13: goto tr32;
532
+ case 67: goto st20;
592
533
  case 84: goto st23;
534
+ case 99: goto st20;
593
535
  case 116: goto st23;
594
- case 124: goto st17;
595
- case 126: goto st17;
596
536
  }
597
- if ( (*p) < 45 ) {
598
- if ( (*p) > 39 ) {
599
- if ( 42 <= (*p) && (*p) <= 43 )
600
- goto st17;
601
- } else if ( (*p) >= 35 )
602
- goto st17;
603
- } else if ( (*p) > 46 ) {
604
- if ( (*p) < 65 ) {
605
- if ( 48 <= (*p) && (*p) <= 57 )
606
- goto st17;
607
- } else if ( (*p) > 90 ) {
608
- if ( 94 <= (*p) && (*p) <= 122 )
609
- goto st17;
610
- } else
611
- goto st17;
612
- } else
613
- goto st17;
614
- goto st0;
537
+ goto st19;
615
538
  st23:
616
539
  if ( ++p == pe )
617
540
  goto _test_eof23;
618
541
  case 23:
619
542
  switch( (*p) ) {
620
- case 33: goto st17;
621
- case 58: goto tr25;
543
+ case 13: goto tr32;
544
+ case 67: goto st20;
622
545
  case 69: goto st24;
546
+ case 99: goto st20;
623
547
  case 101: goto st24;
624
- case 124: goto st17;
625
- case 126: goto st17;
626
548
  }
627
- if ( (*p) < 45 ) {
628
- if ( (*p) > 39 ) {
629
- if ( 42 <= (*p) && (*p) <= 43 )
630
- goto st17;
631
- } else if ( (*p) >= 35 )
632
- goto st17;
633
- } else if ( (*p) > 46 ) {
634
- if ( (*p) < 65 ) {
635
- if ( 48 <= (*p) && (*p) <= 57 )
636
- goto st17;
637
- } else if ( (*p) > 90 ) {
638
- if ( 94 <= (*p) && (*p) <= 122 )
639
- goto st17;
640
- } else
641
- goto st17;
642
- } else
643
- goto st17;
644
- goto st0;
549
+ goto st19;
645
550
  st24:
646
551
  if ( ++p == pe )
647
552
  goto _test_eof24;
648
553
  case 24:
649
554
  switch( (*p) ) {
650
- case 33: goto st17;
651
- case 58: goto tr25;
555
+ case 13: goto tr32;
556
+ case 67: goto st20;
652
557
  case 78: goto st25;
558
+ case 99: goto st20;
653
559
  case 110: goto st25;
654
- case 124: goto st17;
655
- case 126: goto st17;
656
560
  }
657
- if ( (*p) < 45 ) {
658
- if ( (*p) > 39 ) {
659
- if ( 42 <= (*p) && (*p) <= 43 )
660
- goto st17;
661
- } else if ( (*p) >= 35 )
662
- goto st17;
663
- } else if ( (*p) > 46 ) {
664
- if ( (*p) < 65 ) {
665
- if ( 48 <= (*p) && (*p) <= 57 )
666
- goto st17;
667
- } else if ( (*p) > 90 ) {
668
- if ( 94 <= (*p) && (*p) <= 122 )
669
- goto st17;
670
- } else
671
- goto st17;
672
- } else
673
- goto st17;
674
- goto st0;
561
+ goto st19;
675
562
  st25:
676
563
  if ( ++p == pe )
677
- goto _test_eof25;
678
- case 25:
564
+ goto _test_eof25;
565
+ case 25:
566
+ switch( (*p) ) {
567
+ case 13: goto tr32;
568
+ case 67: goto st20;
569
+ case 84: goto st26;
570
+ case 99: goto st20;
571
+ case 116: goto st26;
572
+ }
573
+ goto st19;
574
+ st26:
575
+ if ( ++p == pe )
576
+ goto _test_eof26;
577
+ case 26:
578
+ switch( (*p) ) {
579
+ case 13: goto tr32;
580
+ case 45: goto st27;
581
+ case 67: goto st20;
582
+ case 99: goto st20;
583
+ }
584
+ goto st19;
585
+ st27:
586
+ if ( ++p == pe )
587
+ goto _test_eof27;
588
+ case 27:
589
+ switch( (*p) ) {
590
+ case 13: goto tr32;
591
+ case 67: goto st20;
592
+ case 76: goto st28;
593
+ case 84: goto st36;
594
+ case 99: goto st20;
595
+ case 108: goto st28;
596
+ case 116: goto st36;
597
+ }
598
+ goto st19;
599
+ st28:
600
+ if ( ++p == pe )
601
+ goto _test_eof28;
602
+ case 28:
603
+ switch( (*p) ) {
604
+ case 13: goto tr32;
605
+ case 67: goto st20;
606
+ case 69: goto st29;
607
+ case 99: goto st20;
608
+ case 101: goto st29;
609
+ }
610
+ goto st19;
611
+ st29:
612
+ if ( ++p == pe )
613
+ goto _test_eof29;
614
+ case 29:
615
+ switch( (*p) ) {
616
+ case 13: goto tr32;
617
+ case 67: goto st20;
618
+ case 78: goto st30;
619
+ case 99: goto st20;
620
+ case 110: goto st30;
621
+ }
622
+ goto st19;
623
+ st30:
624
+ if ( ++p == pe )
625
+ goto _test_eof30;
626
+ case 30:
627
+ switch( (*p) ) {
628
+ case 13: goto tr32;
629
+ case 67: goto st20;
630
+ case 71: goto st31;
631
+ case 99: goto st20;
632
+ case 103: goto st31;
633
+ }
634
+ goto st19;
635
+ st31:
636
+ if ( ++p == pe )
637
+ goto _test_eof31;
638
+ case 31:
639
+ switch( (*p) ) {
640
+ case 13: goto tr32;
641
+ case 67: goto st20;
642
+ case 84: goto st32;
643
+ case 99: goto st20;
644
+ case 116: goto st32;
645
+ }
646
+ goto st19;
647
+ st32:
648
+ if ( ++p == pe )
649
+ goto _test_eof32;
650
+ case 32:
651
+ switch( (*p) ) {
652
+ case 13: goto tr32;
653
+ case 67: goto st20;
654
+ case 72: goto st33;
655
+ case 99: goto st20;
656
+ case 104: goto st33;
657
+ }
658
+ goto st19;
659
+ st33:
660
+ if ( ++p == pe )
661
+ goto _test_eof33;
662
+ case 33:
663
+ switch( (*p) ) {
664
+ case 13: goto tr32;
665
+ case 58: goto st34;
666
+ case 67: goto st20;
667
+ case 99: goto st20;
668
+ }
669
+ goto st19;
670
+ st34:
671
+ if ( ++p == pe )
672
+ goto _test_eof34;
673
+ case 34:
674
+ switch( (*p) ) {
675
+ case 13: goto tr32;
676
+ case 32: goto st34;
677
+ case 67: goto st20;
678
+ case 99: goto st20;
679
+ }
680
+ if ( 48 <= (*p) && (*p) <= 57 )
681
+ goto tr49;
682
+ goto st19;
683
+ tr49:
684
+ #line 21 "src/parser.rl"
685
+ {MARK(mark, p); }
686
+ goto st35;
687
+ tr70:
688
+ #line 32 "src/parser.rl"
689
+ { MARK(mark, p); }
690
+ #line 21 "src/parser.rl"
691
+ {MARK(mark, p); }
692
+ goto st35;
693
+ st35:
694
+ if ( ++p == pe )
695
+ goto _test_eof35;
696
+ case 35:
697
+ #line 698 "src/parser.c"
698
+ switch( (*p) ) {
699
+ case 13: goto st0;
700
+ case 67: goto st20;
701
+ case 99: goto st20;
702
+ }
703
+ if ( 48 <= (*p) && (*p) <= 57 )
704
+ goto st35;
705
+ goto st19;
706
+ st36:
707
+ if ( ++p == pe )
708
+ goto _test_eof36;
709
+ case 36:
710
+ switch( (*p) ) {
711
+ case 13: goto tr32;
712
+ case 67: goto st20;
713
+ case 89: goto st37;
714
+ case 99: goto st20;
715
+ case 121: goto st37;
716
+ }
717
+ goto st19;
718
+ st37:
719
+ if ( ++p == pe )
720
+ goto _test_eof37;
721
+ case 37:
722
+ switch( (*p) ) {
723
+ case 13: goto tr32;
724
+ case 67: goto st20;
725
+ case 80: goto st38;
726
+ case 99: goto st20;
727
+ case 112: goto st38;
728
+ }
729
+ goto st19;
730
+ st38:
731
+ if ( ++p == pe )
732
+ goto _test_eof38;
733
+ case 38:
734
+ switch( (*p) ) {
735
+ case 13: goto tr32;
736
+ case 67: goto st20;
737
+ case 69: goto st39;
738
+ case 99: goto st20;
739
+ case 101: goto st39;
740
+ }
741
+ goto st19;
742
+ st39:
743
+ if ( ++p == pe )
744
+ goto _test_eof39;
745
+ case 39:
746
+ switch( (*p) ) {
747
+ case 13: goto tr32;
748
+ case 58: goto st0;
749
+ case 67: goto st20;
750
+ case 99: goto st20;
751
+ }
752
+ goto st19;
753
+ st40:
754
+ if ( ++p == pe )
755
+ goto _test_eof40;
756
+ case 40:
757
+ switch( (*p) ) {
758
+ case 33: goto st17;
759
+ case 58: goto tr25;
760
+ case 67: goto st40;
761
+ case 79: goto st41;
762
+ case 99: goto st40;
763
+ case 111: goto st41;
764
+ case 124: goto st17;
765
+ case 126: goto st17;
766
+ }
767
+ if ( (*p) < 45 ) {
768
+ if ( (*p) > 39 ) {
769
+ if ( 42 <= (*p) && (*p) <= 43 )
770
+ goto st17;
771
+ } else if ( (*p) >= 35 )
772
+ goto st17;
773
+ } else if ( (*p) > 46 ) {
774
+ if ( (*p) < 65 ) {
775
+ if ( 48 <= (*p) && (*p) <= 57 )
776
+ goto st17;
777
+ } else if ( (*p) > 90 ) {
778
+ if ( 94 <= (*p) && (*p) <= 122 )
779
+ goto st17;
780
+ } else
781
+ goto st17;
782
+ } else
783
+ goto st17;
784
+ goto st0;
785
+ st41:
786
+ if ( ++p == pe )
787
+ goto _test_eof41;
788
+ case 41:
789
+ switch( (*p) ) {
790
+ case 33: goto st17;
791
+ case 58: goto tr25;
792
+ case 67: goto st40;
793
+ case 78: goto st42;
794
+ case 99: goto st40;
795
+ case 110: goto st42;
796
+ case 124: goto st17;
797
+ case 126: goto st17;
798
+ }
799
+ if ( (*p) < 45 ) {
800
+ if ( (*p) > 39 ) {
801
+ if ( 42 <= (*p) && (*p) <= 43 )
802
+ goto st17;
803
+ } else if ( (*p) >= 35 )
804
+ goto st17;
805
+ } else if ( (*p) > 46 ) {
806
+ if ( (*p) < 65 ) {
807
+ if ( 48 <= (*p) && (*p) <= 57 )
808
+ goto st17;
809
+ } else if ( (*p) > 90 ) {
810
+ if ( 94 <= (*p) && (*p) <= 122 )
811
+ goto st17;
812
+ } else
813
+ goto st17;
814
+ } else
815
+ goto st17;
816
+ goto st0;
817
+ st42:
818
+ if ( ++p == pe )
819
+ goto _test_eof42;
820
+ case 42:
821
+ switch( (*p) ) {
822
+ case 33: goto st17;
823
+ case 58: goto tr25;
824
+ case 67: goto st40;
825
+ case 84: goto st43;
826
+ case 99: goto st40;
827
+ case 116: goto st43;
828
+ case 124: goto st17;
829
+ case 126: goto st17;
830
+ }
831
+ if ( (*p) < 45 ) {
832
+ if ( (*p) > 39 ) {
833
+ if ( 42 <= (*p) && (*p) <= 43 )
834
+ goto st17;
835
+ } else if ( (*p) >= 35 )
836
+ goto st17;
837
+ } else if ( (*p) > 46 ) {
838
+ if ( (*p) < 65 ) {
839
+ if ( 48 <= (*p) && (*p) <= 57 )
840
+ goto st17;
841
+ } else if ( (*p) > 90 ) {
842
+ if ( 94 <= (*p) && (*p) <= 122 )
843
+ goto st17;
844
+ } else
845
+ goto st17;
846
+ } else
847
+ goto st17;
848
+ goto st0;
849
+ st43:
850
+ if ( ++p == pe )
851
+ goto _test_eof43;
852
+ case 43:
853
+ switch( (*p) ) {
854
+ case 33: goto st17;
855
+ case 58: goto tr25;
856
+ case 67: goto st40;
857
+ case 69: goto st44;
858
+ case 99: goto st40;
859
+ case 101: goto st44;
860
+ case 124: goto st17;
861
+ case 126: goto st17;
862
+ }
863
+ if ( (*p) < 45 ) {
864
+ if ( (*p) > 39 ) {
865
+ if ( 42 <= (*p) && (*p) <= 43 )
866
+ goto st17;
867
+ } else if ( (*p) >= 35 )
868
+ goto st17;
869
+ } else if ( (*p) > 46 ) {
870
+ if ( (*p) < 65 ) {
871
+ if ( 48 <= (*p) && (*p) <= 57 )
872
+ goto st17;
873
+ } else if ( (*p) > 90 ) {
874
+ if ( 94 <= (*p) && (*p) <= 122 )
875
+ goto st17;
876
+ } else
877
+ goto st17;
878
+ } else
879
+ goto st17;
880
+ goto st0;
881
+ st44:
882
+ if ( ++p == pe )
883
+ goto _test_eof44;
884
+ case 44:
885
+ switch( (*p) ) {
886
+ case 33: goto st17;
887
+ case 58: goto tr25;
888
+ case 67: goto st40;
889
+ case 78: goto st45;
890
+ case 99: goto st40;
891
+ case 110: goto st45;
892
+ case 124: goto st17;
893
+ case 126: goto st17;
894
+ }
895
+ if ( (*p) < 45 ) {
896
+ if ( (*p) > 39 ) {
897
+ if ( 42 <= (*p) && (*p) <= 43 )
898
+ goto st17;
899
+ } else if ( (*p) >= 35 )
900
+ goto st17;
901
+ } else if ( (*p) > 46 ) {
902
+ if ( (*p) < 65 ) {
903
+ if ( 48 <= (*p) && (*p) <= 57 )
904
+ goto st17;
905
+ } else if ( (*p) > 90 ) {
906
+ if ( 94 <= (*p) && (*p) <= 122 )
907
+ goto st17;
908
+ } else
909
+ goto st17;
910
+ } else
911
+ goto st17;
912
+ goto st0;
913
+ st45:
914
+ if ( ++p == pe )
915
+ goto _test_eof45;
916
+ case 45:
917
+ switch( (*p) ) {
918
+ case 33: goto st17;
919
+ case 58: goto tr25;
920
+ case 67: goto st40;
921
+ case 84: goto st46;
922
+ case 99: goto st40;
923
+ case 116: goto st46;
924
+ case 124: goto st17;
925
+ case 126: goto st17;
926
+ }
927
+ if ( (*p) < 45 ) {
928
+ if ( (*p) > 39 ) {
929
+ if ( 42 <= (*p) && (*p) <= 43 )
930
+ goto st17;
931
+ } else if ( (*p) >= 35 )
932
+ goto st17;
933
+ } else if ( (*p) > 46 ) {
934
+ if ( (*p) < 65 ) {
935
+ if ( 48 <= (*p) && (*p) <= 57 )
936
+ goto st17;
937
+ } else if ( (*p) > 90 ) {
938
+ if ( 94 <= (*p) && (*p) <= 122 )
939
+ goto st17;
940
+ } else
941
+ goto st17;
942
+ } else
943
+ goto st17;
944
+ goto st0;
945
+ st46:
946
+ if ( ++p == pe )
947
+ goto _test_eof46;
948
+ case 46:
949
+ switch( (*p) ) {
950
+ case 33: goto st17;
951
+ case 45: goto st47;
952
+ case 46: goto st17;
953
+ case 58: goto tr25;
954
+ case 67: goto st40;
955
+ case 99: goto st40;
956
+ case 124: goto st17;
957
+ case 126: goto st17;
958
+ }
959
+ if ( (*p) < 48 ) {
960
+ if ( (*p) > 39 ) {
961
+ if ( 42 <= (*p) && (*p) <= 43 )
962
+ goto st17;
963
+ } else if ( (*p) >= 35 )
964
+ goto st17;
965
+ } else if ( (*p) > 57 ) {
966
+ if ( (*p) > 90 ) {
967
+ if ( 94 <= (*p) && (*p) <= 122 )
968
+ goto st17;
969
+ } else if ( (*p) >= 65 )
970
+ goto st17;
971
+ } else
972
+ goto st17;
973
+ goto st0;
974
+ st47:
975
+ if ( ++p == pe )
976
+ goto _test_eof47;
977
+ case 47:
978
+ switch( (*p) ) {
979
+ case 33: goto st17;
980
+ case 58: goto tr25;
981
+ case 67: goto st40;
982
+ case 76: goto st48;
983
+ case 84: goto st55;
984
+ case 99: goto st40;
985
+ case 108: goto st48;
986
+ case 116: goto st55;
987
+ case 124: goto st17;
988
+ case 126: goto st17;
989
+ }
990
+ if ( (*p) < 45 ) {
991
+ if ( (*p) > 39 ) {
992
+ if ( 42 <= (*p) && (*p) <= 43 )
993
+ goto st17;
994
+ } else if ( (*p) >= 35 )
995
+ goto st17;
996
+ } else if ( (*p) > 46 ) {
997
+ if ( (*p) < 65 ) {
998
+ if ( 48 <= (*p) && (*p) <= 57 )
999
+ goto st17;
1000
+ } else if ( (*p) > 90 ) {
1001
+ if ( 94 <= (*p) && (*p) <= 122 )
1002
+ goto st17;
1003
+ } else
1004
+ goto st17;
1005
+ } else
1006
+ goto st17;
1007
+ goto st0;
1008
+ st48:
1009
+ if ( ++p == pe )
1010
+ goto _test_eof48;
1011
+ case 48:
1012
+ switch( (*p) ) {
1013
+ case 33: goto st17;
1014
+ case 58: goto tr25;
1015
+ case 67: goto st40;
1016
+ case 69: goto st49;
1017
+ case 99: goto st40;
1018
+ case 101: goto st49;
1019
+ case 124: goto st17;
1020
+ case 126: goto st17;
1021
+ }
1022
+ if ( (*p) < 45 ) {
1023
+ if ( (*p) > 39 ) {
1024
+ if ( 42 <= (*p) && (*p) <= 43 )
1025
+ goto st17;
1026
+ } else if ( (*p) >= 35 )
1027
+ goto st17;
1028
+ } else if ( (*p) > 46 ) {
1029
+ if ( (*p) < 65 ) {
1030
+ if ( 48 <= (*p) && (*p) <= 57 )
1031
+ goto st17;
1032
+ } else if ( (*p) > 90 ) {
1033
+ if ( 94 <= (*p) && (*p) <= 122 )
1034
+ goto st17;
1035
+ } else
1036
+ goto st17;
1037
+ } else
1038
+ goto st17;
1039
+ goto st0;
1040
+ st49:
1041
+ if ( ++p == pe )
1042
+ goto _test_eof49;
1043
+ case 49:
1044
+ switch( (*p) ) {
1045
+ case 33: goto st17;
1046
+ case 58: goto tr25;
1047
+ case 67: goto st40;
1048
+ case 78: goto st50;
1049
+ case 99: goto st40;
1050
+ case 110: goto st50;
1051
+ case 124: goto st17;
1052
+ case 126: goto st17;
1053
+ }
1054
+ if ( (*p) < 45 ) {
1055
+ if ( (*p) > 39 ) {
1056
+ if ( 42 <= (*p) && (*p) <= 43 )
1057
+ goto st17;
1058
+ } else if ( (*p) >= 35 )
1059
+ goto st17;
1060
+ } else if ( (*p) > 46 ) {
1061
+ if ( (*p) < 65 ) {
1062
+ if ( 48 <= (*p) && (*p) <= 57 )
1063
+ goto st17;
1064
+ } else if ( (*p) > 90 ) {
1065
+ if ( 94 <= (*p) && (*p) <= 122 )
1066
+ goto st17;
1067
+ } else
1068
+ goto st17;
1069
+ } else
1070
+ goto st17;
1071
+ goto st0;
1072
+ st50:
1073
+ if ( ++p == pe )
1074
+ goto _test_eof50;
1075
+ case 50:
1076
+ switch( (*p) ) {
1077
+ case 33: goto st17;
1078
+ case 58: goto tr25;
1079
+ case 67: goto st40;
1080
+ case 71: goto st51;
1081
+ case 99: goto st40;
1082
+ case 103: goto st51;
1083
+ case 124: goto st17;
1084
+ case 126: goto st17;
1085
+ }
1086
+ if ( (*p) < 45 ) {
1087
+ if ( (*p) > 39 ) {
1088
+ if ( 42 <= (*p) && (*p) <= 43 )
1089
+ goto st17;
1090
+ } else if ( (*p) >= 35 )
1091
+ goto st17;
1092
+ } else if ( (*p) > 46 ) {
1093
+ if ( (*p) < 65 ) {
1094
+ if ( 48 <= (*p) && (*p) <= 57 )
1095
+ goto st17;
1096
+ } else if ( (*p) > 90 ) {
1097
+ if ( 94 <= (*p) && (*p) <= 122 )
1098
+ goto st17;
1099
+ } else
1100
+ goto st17;
1101
+ } else
1102
+ goto st17;
1103
+ goto st0;
1104
+ st51:
1105
+ if ( ++p == pe )
1106
+ goto _test_eof51;
1107
+ case 51:
1108
+ switch( (*p) ) {
1109
+ case 33: goto st17;
1110
+ case 58: goto tr25;
1111
+ case 67: goto st40;
1112
+ case 84: goto st52;
1113
+ case 99: goto st40;
1114
+ case 116: goto st52;
1115
+ case 124: goto st17;
1116
+ case 126: goto st17;
1117
+ }
1118
+ if ( (*p) < 45 ) {
1119
+ if ( (*p) > 39 ) {
1120
+ if ( 42 <= (*p) && (*p) <= 43 )
1121
+ goto st17;
1122
+ } else if ( (*p) >= 35 )
1123
+ goto st17;
1124
+ } else if ( (*p) > 46 ) {
1125
+ if ( (*p) < 65 ) {
1126
+ if ( 48 <= (*p) && (*p) <= 57 )
1127
+ goto st17;
1128
+ } else if ( (*p) > 90 ) {
1129
+ if ( 94 <= (*p) && (*p) <= 122 )
1130
+ goto st17;
1131
+ } else
1132
+ goto st17;
1133
+ } else
1134
+ goto st17;
1135
+ goto st0;
1136
+ st52:
1137
+ if ( ++p == pe )
1138
+ goto _test_eof52;
1139
+ case 52:
1140
+ switch( (*p) ) {
1141
+ case 33: goto st17;
1142
+ case 58: goto tr25;
1143
+ case 67: goto st40;
1144
+ case 72: goto st53;
1145
+ case 99: goto st40;
1146
+ case 104: goto st53;
1147
+ case 124: goto st17;
1148
+ case 126: goto st17;
1149
+ }
1150
+ if ( (*p) < 45 ) {
1151
+ if ( (*p) > 39 ) {
1152
+ if ( 42 <= (*p) && (*p) <= 43 )
1153
+ goto st17;
1154
+ } else if ( (*p) >= 35 )
1155
+ goto st17;
1156
+ } else if ( (*p) > 46 ) {
1157
+ if ( (*p) < 65 ) {
1158
+ if ( 48 <= (*p) && (*p) <= 57 )
1159
+ goto st17;
1160
+ } else if ( (*p) > 90 ) {
1161
+ if ( 94 <= (*p) && (*p) <= 122 )
1162
+ goto st17;
1163
+ } else
1164
+ goto st17;
1165
+ } else
1166
+ goto st17;
1167
+ goto st0;
1168
+ st53:
1169
+ if ( ++p == pe )
1170
+ goto _test_eof53;
1171
+ case 53:
1172
+ switch( (*p) ) {
1173
+ case 33: goto st17;
1174
+ case 58: goto tr68;
1175
+ case 67: goto st40;
1176
+ case 99: goto st40;
1177
+ case 124: goto st17;
1178
+ case 126: goto st17;
1179
+ }
1180
+ if ( (*p) < 45 ) {
1181
+ if ( (*p) > 39 ) {
1182
+ if ( 42 <= (*p) && (*p) <= 43 )
1183
+ goto st17;
1184
+ } else if ( (*p) >= 35 )
1185
+ goto st17;
1186
+ } else if ( (*p) > 46 ) {
1187
+ if ( (*p) < 65 ) {
1188
+ if ( 48 <= (*p) && (*p) <= 57 )
1189
+ goto st17;
1190
+ } else if ( (*p) > 90 ) {
1191
+ if ( 94 <= (*p) && (*p) <= 122 )
1192
+ goto st17;
1193
+ } else
1194
+ goto st17;
1195
+ } else
1196
+ goto st17;
1197
+ goto st0;
1198
+ tr68:
1199
+ #line 24 "src/parser.rl"
1200
+ {
1201
+ parser->field_len = LEN(field_start, p);
1202
+ if(parser->field_len > 256) {
1203
+ parser->overflow_error = TRUE;
1204
+ {p++; cs = 54; goto _out;}
1205
+ }
1206
+ }
1207
+ goto st54;
1208
+ tr69:
1209
+ #line 32 "src/parser.rl"
1210
+ { MARK(mark, p); }
1211
+ goto st54;
1212
+ st54:
1213
+ if ( ++p == pe )
1214
+ goto _test_eof54;
1215
+ case 54:
1216
+ #line 1217 "src/parser.c"
1217
+ switch( (*p) ) {
1218
+ case 13: goto tr28;
1219
+ case 32: goto tr69;
1220
+ case 67: goto tr30;
1221
+ case 99: goto tr30;
1222
+ }
1223
+ if ( 48 <= (*p) && (*p) <= 57 )
1224
+ goto tr70;
1225
+ goto tr27;
1226
+ st55:
1227
+ if ( ++p == pe )
1228
+ goto _test_eof55;
1229
+ case 55:
1230
+ switch( (*p) ) {
1231
+ case 33: goto st17;
1232
+ case 58: goto tr25;
1233
+ case 67: goto st40;
1234
+ case 89: goto st56;
1235
+ case 99: goto st40;
1236
+ case 121: goto st56;
1237
+ case 124: goto st17;
1238
+ case 126: goto st17;
1239
+ }
1240
+ if ( (*p) < 45 ) {
1241
+ if ( (*p) > 39 ) {
1242
+ if ( 42 <= (*p) && (*p) <= 43 )
1243
+ goto st17;
1244
+ } else if ( (*p) >= 35 )
1245
+ goto st17;
1246
+ } else if ( (*p) > 46 ) {
1247
+ if ( (*p) < 65 ) {
1248
+ if ( 48 <= (*p) && (*p) <= 57 )
1249
+ goto st17;
1250
+ } else if ( (*p) > 90 ) {
1251
+ if ( 94 <= (*p) && (*p) <= 122 )
1252
+ goto st17;
1253
+ } else
1254
+ goto st17;
1255
+ } else
1256
+ goto st17;
1257
+ goto st0;
1258
+ st56:
1259
+ if ( ++p == pe )
1260
+ goto _test_eof56;
1261
+ case 56:
1262
+ switch( (*p) ) {
1263
+ case 33: goto st17;
1264
+ case 58: goto tr25;
1265
+ case 67: goto st40;
1266
+ case 80: goto st57;
1267
+ case 99: goto st40;
1268
+ case 112: goto st57;
1269
+ case 124: goto st17;
1270
+ case 126: goto st17;
1271
+ }
1272
+ if ( (*p) < 45 ) {
1273
+ if ( (*p) > 39 ) {
1274
+ if ( 42 <= (*p) && (*p) <= 43 )
1275
+ goto st17;
1276
+ } else if ( (*p) >= 35 )
1277
+ goto st17;
1278
+ } else if ( (*p) > 46 ) {
1279
+ if ( (*p) < 65 ) {
1280
+ if ( 48 <= (*p) && (*p) <= 57 )
1281
+ goto st17;
1282
+ } else if ( (*p) > 90 ) {
1283
+ if ( 94 <= (*p) && (*p) <= 122 )
1284
+ goto st17;
1285
+ } else
1286
+ goto st17;
1287
+ } else
1288
+ goto st17;
1289
+ goto st0;
1290
+ st57:
1291
+ if ( ++p == pe )
1292
+ goto _test_eof57;
1293
+ case 57:
1294
+ switch( (*p) ) {
1295
+ case 33: goto st17;
1296
+ case 58: goto tr25;
1297
+ case 67: goto st40;
1298
+ case 69: goto st58;
1299
+ case 99: goto st40;
1300
+ case 101: goto st58;
1301
+ case 124: goto st17;
1302
+ case 126: goto st17;
1303
+ }
1304
+ if ( (*p) < 45 ) {
1305
+ if ( (*p) > 39 ) {
1306
+ if ( 42 <= (*p) && (*p) <= 43 )
1307
+ goto st17;
1308
+ } else if ( (*p) >= 35 )
1309
+ goto st17;
1310
+ } else if ( (*p) > 46 ) {
1311
+ if ( (*p) < 65 ) {
1312
+ if ( 48 <= (*p) && (*p) <= 57 )
1313
+ goto st17;
1314
+ } else if ( (*p) > 90 ) {
1315
+ if ( 94 <= (*p) && (*p) <= 122 )
1316
+ goto st17;
1317
+ } else
1318
+ goto st17;
1319
+ } else
1320
+ goto st17;
1321
+ goto st0;
1322
+ st58:
1323
+ if ( ++p == pe )
1324
+ goto _test_eof58;
1325
+ case 58:
1326
+ switch( (*p) ) {
1327
+ case 33: goto st17;
1328
+ case 67: goto st40;
1329
+ case 99: goto st40;
1330
+ case 124: goto st17;
1331
+ case 126: goto st17;
1332
+ }
1333
+ if ( (*p) < 45 ) {
1334
+ if ( (*p) > 39 ) {
1335
+ if ( 42 <= (*p) && (*p) <= 43 )
1336
+ goto st17;
1337
+ } else if ( (*p) >= 35 )
1338
+ goto st17;
1339
+ } else if ( (*p) > 46 ) {
1340
+ if ( (*p) < 65 ) {
1341
+ if ( 48 <= (*p) && (*p) <= 57 )
1342
+ goto st17;
1343
+ } else if ( (*p) > 90 ) {
1344
+ if ( 94 <= (*p) && (*p) <= 122 )
1345
+ goto st17;
1346
+ } else
1347
+ goto st17;
1348
+ } else
1349
+ goto st17;
1350
+ goto st0;
1351
+ tr22:
1352
+ #line 23 "src/parser.rl"
1353
+ { MARK(field_start, p); }
1354
+ goto st59;
1355
+ st59:
1356
+ if ( ++p == pe )
1357
+ goto _test_eof59;
1358
+ case 59:
1359
+ #line 1360 "src/parser.c"
1360
+ switch( (*p) ) {
1361
+ case 33: goto st17;
1362
+ case 58: goto tr25;
1363
+ case 67: goto st40;
1364
+ case 79: goto st60;
1365
+ case 99: goto st40;
1366
+ case 111: goto st60;
1367
+ case 124: goto st17;
1368
+ case 126: goto st17;
1369
+ }
1370
+ if ( (*p) < 45 ) {
1371
+ if ( (*p) > 39 ) {
1372
+ if ( 42 <= (*p) && (*p) <= 43 )
1373
+ goto st17;
1374
+ } else if ( (*p) >= 35 )
1375
+ goto st17;
1376
+ } else if ( (*p) > 46 ) {
1377
+ if ( (*p) < 65 ) {
1378
+ if ( 48 <= (*p) && (*p) <= 57 )
1379
+ goto st17;
1380
+ } else if ( (*p) > 90 ) {
1381
+ if ( 94 <= (*p) && (*p) <= 122 )
1382
+ goto st17;
1383
+ } else
1384
+ goto st17;
1385
+ } else
1386
+ goto st17;
1387
+ goto st0;
1388
+ st60:
1389
+ if ( ++p == pe )
1390
+ goto _test_eof60;
1391
+ case 60:
1392
+ switch( (*p) ) {
1393
+ case 33: goto st17;
1394
+ case 58: goto tr25;
1395
+ case 67: goto st40;
1396
+ case 78: goto st61;
1397
+ case 99: goto st40;
1398
+ case 110: goto st61;
1399
+ case 124: goto st17;
1400
+ case 126: goto st17;
1401
+ }
1402
+ if ( (*p) < 45 ) {
1403
+ if ( (*p) > 39 ) {
1404
+ if ( 42 <= (*p) && (*p) <= 43 )
1405
+ goto st17;
1406
+ } else if ( (*p) >= 35 )
1407
+ goto st17;
1408
+ } else if ( (*p) > 46 ) {
1409
+ if ( (*p) < 65 ) {
1410
+ if ( 48 <= (*p) && (*p) <= 57 )
1411
+ goto st17;
1412
+ } else if ( (*p) > 90 ) {
1413
+ if ( 94 <= (*p) && (*p) <= 122 )
1414
+ goto st17;
1415
+ } else
1416
+ goto st17;
1417
+ } else
1418
+ goto st17;
1419
+ goto st0;
1420
+ st61:
1421
+ if ( ++p == pe )
1422
+ goto _test_eof61;
1423
+ case 61:
1424
+ switch( (*p) ) {
1425
+ case 33: goto st17;
1426
+ case 58: goto tr25;
1427
+ case 67: goto st40;
1428
+ case 84: goto st62;
1429
+ case 99: goto st40;
1430
+ case 116: goto st62;
1431
+ case 124: goto st17;
1432
+ case 126: goto st17;
1433
+ }
1434
+ if ( (*p) < 45 ) {
1435
+ if ( (*p) > 39 ) {
1436
+ if ( 42 <= (*p) && (*p) <= 43 )
1437
+ goto st17;
1438
+ } else if ( (*p) >= 35 )
1439
+ goto st17;
1440
+ } else if ( (*p) > 46 ) {
1441
+ if ( (*p) < 65 ) {
1442
+ if ( 48 <= (*p) && (*p) <= 57 )
1443
+ goto st17;
1444
+ } else if ( (*p) > 90 ) {
1445
+ if ( 94 <= (*p) && (*p) <= 122 )
1446
+ goto st17;
1447
+ } else
1448
+ goto st17;
1449
+ } else
1450
+ goto st17;
1451
+ goto st0;
1452
+ st62:
1453
+ if ( ++p == pe )
1454
+ goto _test_eof62;
1455
+ case 62:
1456
+ switch( (*p) ) {
1457
+ case 33: goto st17;
1458
+ case 58: goto tr25;
1459
+ case 67: goto st40;
1460
+ case 69: goto st63;
1461
+ case 99: goto st40;
1462
+ case 101: goto st63;
1463
+ case 124: goto st17;
1464
+ case 126: goto st17;
1465
+ }
1466
+ if ( (*p) < 45 ) {
1467
+ if ( (*p) > 39 ) {
1468
+ if ( 42 <= (*p) && (*p) <= 43 )
1469
+ goto st17;
1470
+ } else if ( (*p) >= 35 )
1471
+ goto st17;
1472
+ } else if ( (*p) > 46 ) {
1473
+ if ( (*p) < 65 ) {
1474
+ if ( 48 <= (*p) && (*p) <= 57 )
1475
+ goto st17;
1476
+ } else if ( (*p) > 90 ) {
1477
+ if ( 94 <= (*p) && (*p) <= 122 )
1478
+ goto st17;
1479
+ } else
1480
+ goto st17;
1481
+ } else
1482
+ goto st17;
1483
+ goto st0;
1484
+ st63:
1485
+ if ( ++p == pe )
1486
+ goto _test_eof63;
1487
+ case 63:
1488
+ switch( (*p) ) {
1489
+ case 33: goto st17;
1490
+ case 58: goto tr25;
1491
+ case 67: goto st40;
1492
+ case 78: goto st64;
1493
+ case 99: goto st40;
1494
+ case 110: goto st64;
1495
+ case 124: goto st17;
1496
+ case 126: goto st17;
1497
+ }
1498
+ if ( (*p) < 45 ) {
1499
+ if ( (*p) > 39 ) {
1500
+ if ( 42 <= (*p) && (*p) <= 43 )
1501
+ goto st17;
1502
+ } else if ( (*p) >= 35 )
1503
+ goto st17;
1504
+ } else if ( (*p) > 46 ) {
1505
+ if ( (*p) < 65 ) {
1506
+ if ( 48 <= (*p) && (*p) <= 57 )
1507
+ goto st17;
1508
+ } else if ( (*p) > 90 ) {
1509
+ if ( 94 <= (*p) && (*p) <= 122 )
1510
+ goto st17;
1511
+ } else
1512
+ goto st17;
1513
+ } else
1514
+ goto st17;
1515
+ goto st0;
1516
+ st64:
1517
+ if ( ++p == pe )
1518
+ goto _test_eof64;
1519
+ case 64:
1520
+ switch( (*p) ) {
1521
+ case 33: goto st17;
1522
+ case 58: goto tr25;
1523
+ case 67: goto st40;
1524
+ case 84: goto st65;
1525
+ case 99: goto st40;
1526
+ case 116: goto st65;
1527
+ case 124: goto st17;
1528
+ case 126: goto st17;
1529
+ }
1530
+ if ( (*p) < 45 ) {
1531
+ if ( (*p) > 39 ) {
1532
+ if ( 42 <= (*p) && (*p) <= 43 )
1533
+ goto st17;
1534
+ } else if ( (*p) >= 35 )
1535
+ goto st17;
1536
+ } else if ( (*p) > 46 ) {
1537
+ if ( (*p) < 65 ) {
1538
+ if ( 48 <= (*p) && (*p) <= 57 )
1539
+ goto st17;
1540
+ } else if ( (*p) > 90 ) {
1541
+ if ( 94 <= (*p) && (*p) <= 122 )
1542
+ goto st17;
1543
+ } else
1544
+ goto st17;
1545
+ } else
1546
+ goto st17;
1547
+ goto st0;
1548
+ st65:
1549
+ if ( ++p == pe )
1550
+ goto _test_eof65;
1551
+ case 65:
1552
+ switch( (*p) ) {
1553
+ case 33: goto st17;
1554
+ case 45: goto st66;
1555
+ case 46: goto st17;
1556
+ case 58: goto tr25;
1557
+ case 67: goto st40;
1558
+ case 99: goto st40;
1559
+ case 124: goto st17;
1560
+ case 126: goto st17;
1561
+ }
1562
+ if ( (*p) < 48 ) {
1563
+ if ( (*p) > 39 ) {
1564
+ if ( 42 <= (*p) && (*p) <= 43 )
1565
+ goto st17;
1566
+ } else if ( (*p) >= 35 )
1567
+ goto st17;
1568
+ } else if ( (*p) > 57 ) {
1569
+ if ( (*p) > 90 ) {
1570
+ if ( 94 <= (*p) && (*p) <= 122 )
1571
+ goto st17;
1572
+ } else if ( (*p) >= 65 )
1573
+ goto st17;
1574
+ } else
1575
+ goto st17;
1576
+ goto st0;
1577
+ st66:
1578
+ if ( ++p == pe )
1579
+ goto _test_eof66;
1580
+ case 66:
1581
+ switch( (*p) ) {
1582
+ case 33: goto st17;
1583
+ case 58: goto tr25;
1584
+ case 67: goto st40;
1585
+ case 76: goto st67;
1586
+ case 84: goto st75;
1587
+ case 99: goto st40;
1588
+ case 108: goto st67;
1589
+ case 116: goto st75;
1590
+ case 124: goto st17;
1591
+ case 126: goto st17;
1592
+ }
1593
+ if ( (*p) < 45 ) {
1594
+ if ( (*p) > 39 ) {
1595
+ if ( 42 <= (*p) && (*p) <= 43 )
1596
+ goto st17;
1597
+ } else if ( (*p) >= 35 )
1598
+ goto st17;
1599
+ } else if ( (*p) > 46 ) {
1600
+ if ( (*p) < 65 ) {
1601
+ if ( 48 <= (*p) && (*p) <= 57 )
1602
+ goto st17;
1603
+ } else if ( (*p) > 90 ) {
1604
+ if ( 94 <= (*p) && (*p) <= 122 )
1605
+ goto st17;
1606
+ } else
1607
+ goto st17;
1608
+ } else
1609
+ goto st17;
1610
+ goto st0;
1611
+ st67:
1612
+ if ( ++p == pe )
1613
+ goto _test_eof67;
1614
+ case 67:
1615
+ switch( (*p) ) {
1616
+ case 33: goto st17;
1617
+ case 58: goto tr25;
1618
+ case 67: goto st40;
1619
+ case 69: goto st68;
1620
+ case 99: goto st40;
1621
+ case 101: goto st68;
1622
+ case 124: goto st17;
1623
+ case 126: goto st17;
1624
+ }
1625
+ if ( (*p) < 45 ) {
1626
+ if ( (*p) > 39 ) {
1627
+ if ( 42 <= (*p) && (*p) <= 43 )
1628
+ goto st17;
1629
+ } else if ( (*p) >= 35 )
1630
+ goto st17;
1631
+ } else if ( (*p) > 46 ) {
1632
+ if ( (*p) < 65 ) {
1633
+ if ( 48 <= (*p) && (*p) <= 57 )
1634
+ goto st17;
1635
+ } else if ( (*p) > 90 ) {
1636
+ if ( 94 <= (*p) && (*p) <= 122 )
1637
+ goto st17;
1638
+ } else
1639
+ goto st17;
1640
+ } else
1641
+ goto st17;
1642
+ goto st0;
1643
+ st68:
1644
+ if ( ++p == pe )
1645
+ goto _test_eof68;
1646
+ case 68:
679
1647
  switch( (*p) ) {
680
1648
  case 33: goto st17;
681
1649
  case 58: goto tr25;
682
- case 84: goto st26;
683
- case 116: goto st26;
1650
+ case 67: goto st40;
1651
+ case 78: goto st69;
1652
+ case 99: goto st40;
1653
+ case 110: goto st69;
684
1654
  case 124: goto st17;
685
1655
  case 126: goto st17;
686
1656
  }
@@ -702,42 +1672,49 @@ case 25:
702
1672
  } else
703
1673
  goto st17;
704
1674
  goto st0;
705
- st26:
1675
+ st69:
706
1676
  if ( ++p == pe )
707
- goto _test_eof26;
708
- case 26:
1677
+ goto _test_eof69;
1678
+ case 69:
709
1679
  switch( (*p) ) {
710
1680
  case 33: goto st17;
711
- case 45: goto st27;
712
- case 46: goto st17;
713
1681
  case 58: goto tr25;
1682
+ case 67: goto st40;
1683
+ case 71: goto st70;
1684
+ case 99: goto st40;
1685
+ case 103: goto st70;
714
1686
  case 124: goto st17;
715
1687
  case 126: goto st17;
716
1688
  }
717
- if ( (*p) < 48 ) {
1689
+ if ( (*p) < 45 ) {
718
1690
  if ( (*p) > 39 ) {
719
1691
  if ( 42 <= (*p) && (*p) <= 43 )
720
1692
  goto st17;
721
1693
  } else if ( (*p) >= 35 )
722
1694
  goto st17;
723
- } else if ( (*p) > 57 ) {
724
- if ( (*p) > 90 ) {
1695
+ } else if ( (*p) > 46 ) {
1696
+ if ( (*p) < 65 ) {
1697
+ if ( 48 <= (*p) && (*p) <= 57 )
1698
+ goto st17;
1699
+ } else if ( (*p) > 90 ) {
725
1700
  if ( 94 <= (*p) && (*p) <= 122 )
726
1701
  goto st17;
727
- } else if ( (*p) >= 65 )
1702
+ } else
728
1703
  goto st17;
729
1704
  } else
730
1705
  goto st17;
731
1706
  goto st0;
732
- st27:
1707
+ st70:
733
1708
  if ( ++p == pe )
734
- goto _test_eof27;
735
- case 27:
1709
+ goto _test_eof70;
1710
+ case 70:
736
1711
  switch( (*p) ) {
737
1712
  case 33: goto st17;
738
1713
  case 58: goto tr25;
739
- case 76: goto st28;
740
- case 108: goto st28;
1714
+ case 67: goto st40;
1715
+ case 84: goto st71;
1716
+ case 99: goto st40;
1717
+ case 116: goto st71;
741
1718
  case 124: goto st17;
742
1719
  case 126: goto st17;
743
1720
  }
@@ -759,15 +1736,17 @@ case 27:
759
1736
  } else
760
1737
  goto st17;
761
1738
  goto st0;
762
- st28:
1739
+ st71:
763
1740
  if ( ++p == pe )
764
- goto _test_eof28;
765
- case 28:
1741
+ goto _test_eof71;
1742
+ case 71:
766
1743
  switch( (*p) ) {
767
1744
  case 33: goto st17;
768
1745
  case 58: goto tr25;
769
- case 69: goto st29;
770
- case 101: goto st29;
1746
+ case 67: goto st40;
1747
+ case 72: goto st72;
1748
+ case 99: goto st40;
1749
+ case 104: goto st72;
771
1750
  case 124: goto st17;
772
1751
  case 126: goto st17;
773
1752
  }
@@ -789,15 +1768,15 @@ case 28:
789
1768
  } else
790
1769
  goto st17;
791
1770
  goto st0;
792
- st29:
1771
+ st72:
793
1772
  if ( ++p == pe )
794
- goto _test_eof29;
795
- case 29:
1773
+ goto _test_eof72;
1774
+ case 72:
796
1775
  switch( (*p) ) {
797
1776
  case 33: goto st17;
798
- case 58: goto tr25;
799
- case 78: goto st30;
800
- case 110: goto st30;
1777
+ case 58: goto tr88;
1778
+ case 67: goto st40;
1779
+ case 99: goto st40;
801
1780
  case 124: goto st17;
802
1781
  case 126: goto st17;
803
1782
  }
@@ -819,15 +1798,64 @@ case 29:
819
1798
  } else
820
1799
  goto st17;
821
1800
  goto st0;
822
- st30:
1801
+ tr88:
1802
+ #line 24 "src/parser.rl"
1803
+ {
1804
+ parser->field_len = LEN(field_start, p);
1805
+ if(parser->field_len > 256) {
1806
+ parser->overflow_error = TRUE;
1807
+ {p++; cs = 73; goto _out;}
1808
+ }
1809
+ }
1810
+ goto st73;
1811
+ tr89:
1812
+ #line 32 "src/parser.rl"
1813
+ { MARK(mark, p); }
1814
+ goto st73;
1815
+ st73:
823
1816
  if ( ++p == pe )
824
- goto _test_eof30;
825
- case 30:
1817
+ goto _test_eof73;
1818
+ case 73:
1819
+ #line 1820 "src/parser.c"
1820
+ switch( (*p) ) {
1821
+ case 13: goto tr28;
1822
+ case 32: goto tr89;
1823
+ case 67: goto tr30;
1824
+ case 99: goto tr30;
1825
+ }
1826
+ if ( 48 <= (*p) && (*p) <= 57 )
1827
+ goto tr90;
1828
+ goto tr27;
1829
+ tr90:
1830
+ #line 21 "src/parser.rl"
1831
+ {MARK(mark, p); }
1832
+ #line 32 "src/parser.rl"
1833
+ { MARK(mark, p); }
1834
+ goto st74;
1835
+ st74:
1836
+ if ( ++p == pe )
1837
+ goto _test_eof74;
1838
+ case 74:
1839
+ #line 1840 "src/parser.c"
1840
+ switch( (*p) ) {
1841
+ case 13: goto tr91;
1842
+ case 67: goto st20;
1843
+ case 99: goto st20;
1844
+ }
1845
+ if ( 48 <= (*p) && (*p) <= 57 )
1846
+ goto st74;
1847
+ goto st19;
1848
+ st75:
1849
+ if ( ++p == pe )
1850
+ goto _test_eof75;
1851
+ case 75:
826
1852
  switch( (*p) ) {
827
1853
  case 33: goto st17;
828
1854
  case 58: goto tr25;
829
- case 71: goto st31;
830
- case 103: goto st31;
1855
+ case 67: goto st40;
1856
+ case 89: goto st76;
1857
+ case 99: goto st40;
1858
+ case 121: goto st76;
831
1859
  case 124: goto st17;
832
1860
  case 126: goto st17;
833
1861
  }
@@ -849,15 +1877,17 @@ case 30:
849
1877
  } else
850
1878
  goto st17;
851
1879
  goto st0;
852
- st31:
1880
+ st76:
853
1881
  if ( ++p == pe )
854
- goto _test_eof31;
855
- case 31:
1882
+ goto _test_eof76;
1883
+ case 76:
856
1884
  switch( (*p) ) {
857
1885
  case 33: goto st17;
858
1886
  case 58: goto tr25;
859
- case 84: goto st32;
860
- case 116: goto st32;
1887
+ case 67: goto st40;
1888
+ case 80: goto st77;
1889
+ case 99: goto st40;
1890
+ case 112: goto st77;
861
1891
  case 124: goto st17;
862
1892
  case 126: goto st17;
863
1893
  }
@@ -879,15 +1909,17 @@ case 31:
879
1909
  } else
880
1910
  goto st17;
881
1911
  goto st0;
882
- st32:
1912
+ st77:
883
1913
  if ( ++p == pe )
884
- goto _test_eof32;
885
- case 32:
1914
+ goto _test_eof77;
1915
+ case 77:
886
1916
  switch( (*p) ) {
887
1917
  case 33: goto st17;
888
1918
  case 58: goto tr25;
889
- case 72: goto st33;
890
- case 104: goto st33;
1919
+ case 67: goto st40;
1920
+ case 69: goto st78;
1921
+ case 99: goto st40;
1922
+ case 101: goto st78;
891
1923
  case 124: goto st17;
892
1924
  case 126: goto st17;
893
1925
  }
@@ -909,13 +1941,15 @@ case 32:
909
1941
  } else
910
1942
  goto st17;
911
1943
  goto st0;
912
- st33:
1944
+ st78:
913
1945
  if ( ++p == pe )
914
- goto _test_eof33;
915
- case 33:
1946
+ goto _test_eof78;
1947
+ case 78:
916
1948
  switch( (*p) ) {
917
1949
  case 33: goto st17;
918
- case 58: goto tr44;
1950
+ case 58: goto st79;
1951
+ case 67: goto st40;
1952
+ case 99: goto st40;
919
1953
  case 124: goto st17;
920
1954
  case 126: goto st17;
921
1955
  }
@@ -937,129 +1971,85 @@ case 33:
937
1971
  } else
938
1972
  goto st17;
939
1973
  goto st0;
940
- tr44:
941
- #line 25 "src/parser.rl"
942
- {
943
- parser->field_len = LEN(field_start, p);
944
- if(parser->field_len > 256) {
945
- parser->overflow_error = TRUE;
946
- {p++; cs = 34; goto _out;}
947
- }
948
- }
949
- goto st34;
950
- tr45:
951
- #line 33 "src/parser.rl"
952
- { MARK(mark, p); }
953
- goto st34;
954
- st34:
1974
+ tr99:
1975
+ #line 21 "src/parser.rl"
1976
+ {MARK(mark, p); }
1977
+ goto st79;
1978
+ st79:
955
1979
  if ( ++p == pe )
956
- goto _test_eof34;
957
- case 34:
958
- #line 959 "src/parser.c"
1980
+ goto _test_eof79;
1981
+ case 79:
1982
+ #line 1983 "src/parser.c"
959
1983
  switch( (*p) ) {
960
- case 13: goto tr27;
961
- case 32: goto tr45;
1984
+ case 13: goto tr98;
1985
+ case 32: goto tr99;
962
1986
  }
963
- if ( 48 <= (*p) && (*p) <= 57 )
964
- goto tr46;
965
- goto tr26;
966
- tr46:
967
- #line 22 "src/parser.rl"
1987
+ goto tr97;
1988
+ tr97:
1989
+ #line 21 "src/parser.rl"
968
1990
  {MARK(mark, p); }
969
- #line 33 "src/parser.rl"
970
- { MARK(mark, p); }
971
- goto st35;
972
- st35:
1991
+ goto st80;
1992
+ st80:
973
1993
  if ( ++p == pe )
974
- goto _test_eof35;
975
- case 35:
976
- #line 977 "src/parser.c"
1994
+ goto _test_eof80;
1995
+ case 80:
1996
+ #line 1997 "src/parser.c"
977
1997
  if ( (*p) == 13 )
978
- goto tr47;
979
- if ( 48 <= (*p) && (*p) <= 57 )
980
- goto st35;
981
- goto st19;
1998
+ goto tr101;
1999
+ goto st80;
982
2000
  tr9:
983
- #line 55 "src/parser.rl"
2001
+ #line 71 "src/parser.rl"
984
2002
  {
985
- if(LEN(mark, p) > 12 * 1024) {
986
- parser->overflow_error = TRUE;
987
- {p++; cs = 36; goto _out;}
988
- }
989
- if(parser->request_uri != NULL)
990
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
2003
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
2004
+ {p++; cs = 81; goto _out;}
991
2005
  }
992
- goto st36;
993
- tr62:
994
- #line 79 "src/parser.rl"
2006
+ goto st81;
2007
+ tr115:
2008
+ #line 61 "src/parser.rl"
995
2009
  {
996
- if(LEN(mark, p) > 1024) {
997
- parser->overflow_error = TRUE;
998
- {p++; cs = 36; goto _out;}
999
- }
1000
- if(parser->request_path != NULL)
1001
- parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
2010
+ if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
2011
+ {p++; cs = 81; goto _out;}
1002
2012
  }
1003
- #line 55 "src/parser.rl"
2013
+ #line 71 "src/parser.rl"
1004
2014
  {
1005
- if(LEN(mark, p) > 12 * 1024) {
1006
- parser->overflow_error = TRUE;
1007
- {p++; cs = 36; goto _out;}
1008
- }
1009
- if(parser->request_uri != NULL)
1010
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
2015
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
2016
+ {p++; cs = 81; goto _out;}
1011
2017
  }
1012
- goto st36;
1013
- tr73:
1014
- #line 64 "src/parser.rl"
2018
+ goto st81;
2019
+ tr126:
2020
+ #line 76 "src/parser.rl"
1015
2021
  {MARK(query_start, p); }
1016
- #line 65 "src/parser.rl"
1017
- {
1018
- if(LEN(query_start, p) > 10 * 1024) {
1019
- parser->overflow_error = TRUE;
1020
- {p++; cs = 36; goto _out;}
1021
- }
1022
- if(parser->query_string != NULL)
1023
- parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
2022
+ #line 77 "src/parser.rl"
2023
+ {
2024
+ if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
2025
+ {p++; cs = 81; goto _out;}
1024
2026
  }
1025
- #line 55 "src/parser.rl"
2027
+ #line 71 "src/parser.rl"
1026
2028
  {
1027
- if(LEN(mark, p) > 12 * 1024) {
1028
- parser->overflow_error = TRUE;
1029
- {p++; cs = 36; goto _out;}
1030
- }
1031
- if(parser->request_uri != NULL)
1032
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
2029
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
2030
+ {p++; cs = 81; goto _out;}
1033
2031
  }
1034
- goto st36;
1035
- tr77:
1036
- #line 65 "src/parser.rl"
1037
- {
1038
- if(LEN(query_start, p) > 10 * 1024) {
1039
- parser->overflow_error = TRUE;
1040
- {p++; cs = 36; goto _out;}
1041
- }
1042
- if(parser->query_string != NULL)
1043
- parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
2032
+ goto st81;
2033
+ tr130:
2034
+ #line 77 "src/parser.rl"
2035
+ {
2036
+ if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
2037
+ {p++; cs = 81; goto _out;}
1044
2038
  }
1045
- #line 55 "src/parser.rl"
2039
+ #line 71 "src/parser.rl"
1046
2040
  {
1047
- if(LEN(mark, p) > 12 * 1024) {
1048
- parser->overflow_error = TRUE;
1049
- {p++; cs = 36; goto _out;}
1050
- }
1051
- if(parser->request_uri != NULL)
1052
- parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
2041
+ if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
2042
+ {p++; cs = 81; goto _out;}
1053
2043
  }
1054
- goto st36;
1055
- st36:
2044
+ goto st81;
2045
+ st81:
1056
2046
  if ( ++p == pe )
1057
- goto _test_eof36;
1058
- case 36:
1059
- #line 1060 "src/parser.c"
2047
+ goto _test_eof81;
2048
+ case 81:
2049
+ #line 2050 "src/parser.c"
1060
2050
  switch( (*p) ) {
1061
- case 32: goto tr50;
1062
- case 37: goto tr51;
2051
+ case 32: goto tr103;
2052
+ case 37: goto tr104;
1063
2053
  case 60: goto st0;
1064
2054
  case 62: goto st0;
1065
2055
  case 127: goto st0;
@@ -1069,19 +2059,19 @@ case 36:
1069
2059
  goto st0;
1070
2060
  } else if ( (*p) >= 0 )
1071
2061
  goto st0;
1072
- goto tr49;
1073
- tr49:
1074
- #line 22 "src/parser.rl"
2062
+ goto tr102;
2063
+ tr102:
2064
+ #line 21 "src/parser.rl"
1075
2065
  {MARK(mark, p); }
1076
- goto st37;
1077
- st37:
2066
+ goto st82;
2067
+ st82:
1078
2068
  if ( ++p == pe )
1079
- goto _test_eof37;
1080
- case 37:
1081
- #line 1082 "src/parser.c"
2069
+ goto _test_eof82;
2070
+ case 82:
2071
+ #line 2072 "src/parser.c"
1082
2072
  switch( (*p) ) {
1083
- case 32: goto tr53;
1084
- case 37: goto st38;
2073
+ case 32: goto tr106;
2074
+ case 37: goto st83;
1085
2075
  case 60: goto st0;
1086
2076
  case 62: goto st0;
1087
2077
  case 127: goto st0;
@@ -1091,622 +2081,614 @@ case 37:
1091
2081
  goto st0;
1092
2082
  } else if ( (*p) >= 0 )
1093
2083
  goto st0;
1094
- goto st37;
1095
- tr51:
1096
- #line 22 "src/parser.rl"
2084
+ goto st82;
2085
+ tr104:
2086
+ #line 21 "src/parser.rl"
1097
2087
  {MARK(mark, p); }
1098
- goto st38;
1099
- st38:
2088
+ goto st83;
2089
+ st83:
1100
2090
  if ( ++p == pe )
1101
- goto _test_eof38;
1102
- case 38:
1103
- #line 1104 "src/parser.c"
2091
+ goto _test_eof83;
2092
+ case 83:
2093
+ #line 2094 "src/parser.c"
1104
2094
  if ( (*p) < 65 ) {
1105
2095
  if ( 48 <= (*p) && (*p) <= 57 )
1106
- goto st39;
2096
+ goto st84;
1107
2097
  } else if ( (*p) > 70 ) {
1108
2098
  if ( 97 <= (*p) && (*p) <= 102 )
1109
- goto st39;
2099
+ goto st84;
1110
2100
  } else
1111
- goto st39;
2101
+ goto st84;
1112
2102
  goto st0;
1113
- st39:
2103
+ st84:
1114
2104
  if ( ++p == pe )
1115
- goto _test_eof39;
1116
- case 39:
2105
+ goto _test_eof84;
2106
+ case 84:
1117
2107
  if ( (*p) < 65 ) {
1118
2108
  if ( 48 <= (*p) && (*p) <= 57 )
1119
- goto st37;
2109
+ goto st82;
1120
2110
  } else if ( (*p) > 70 ) {
1121
2111
  if ( 97 <= (*p) && (*p) <= 102 )
1122
- goto st37;
2112
+ goto st82;
1123
2113
  } else
1124
- goto st37;
2114
+ goto st82;
1125
2115
  goto st0;
1126
2116
  tr5:
1127
- #line 22 "src/parser.rl"
2117
+ #line 21 "src/parser.rl"
1128
2118
  {MARK(mark, p); }
1129
- goto st40;
1130
- st40:
2119
+ goto st85;
2120
+ st85:
1131
2121
  if ( ++p == pe )
1132
- goto _test_eof40;
1133
- case 40:
1134
- #line 1135 "src/parser.c"
2122
+ goto _test_eof85;
2123
+ case 85:
2124
+ #line 2125 "src/parser.c"
1135
2125
  switch( (*p) ) {
1136
- case 43: goto st40;
1137
- case 58: goto st41;
2126
+ case 43: goto st85;
2127
+ case 58: goto st86;
1138
2128
  }
1139
2129
  if ( (*p) < 48 ) {
1140
2130
  if ( 45 <= (*p) && (*p) <= 46 )
1141
- goto st40;
2131
+ goto st85;
1142
2132
  } else if ( (*p) > 57 ) {
1143
2133
  if ( (*p) > 90 ) {
1144
2134
  if ( 97 <= (*p) && (*p) <= 122 )
1145
- goto st40;
2135
+ goto st85;
1146
2136
  } else if ( (*p) >= 65 )
1147
- goto st40;
2137
+ goto st85;
1148
2138
  } else
1149
- goto st40;
2139
+ goto st85;
1150
2140
  goto st0;
1151
2141
  tr7:
1152
- #line 22 "src/parser.rl"
2142
+ #line 21 "src/parser.rl"
1153
2143
  {MARK(mark, p); }
1154
- goto st41;
1155
- st41:
2144
+ goto st86;
2145
+ st86:
1156
2146
  if ( ++p == pe )
1157
- goto _test_eof41;
1158
- case 41:
1159
- #line 1160 "src/parser.c"
2147
+ goto _test_eof86;
2148
+ case 86:
2149
+ #line 2150 "src/parser.c"
1160
2150
  switch( (*p) ) {
1161
2151
  case 32: goto tr8;
1162
2152
  case 34: goto st0;
1163
2153
  case 35: goto tr9;
1164
- case 37: goto st42;
2154
+ case 37: goto st87;
1165
2155
  case 60: goto st0;
1166
2156
  case 62: goto st0;
1167
2157
  case 127: goto st0;
1168
2158
  }
1169
2159
  if ( 0 <= (*p) && (*p) <= 31 )
1170
2160
  goto st0;
1171
- goto st41;
1172
- st42:
2161
+ goto st86;
2162
+ st87:
1173
2163
  if ( ++p == pe )
1174
- goto _test_eof42;
1175
- case 42:
2164
+ goto _test_eof87;
2165
+ case 87:
1176
2166
  if ( (*p) < 65 ) {
1177
2167
  if ( 48 <= (*p) && (*p) <= 57 )
1178
- goto st43;
2168
+ goto st88;
1179
2169
  } else if ( (*p) > 70 ) {
1180
2170
  if ( 97 <= (*p) && (*p) <= 102 )
1181
- goto st43;
2171
+ goto st88;
1182
2172
  } else
1183
- goto st43;
2173
+ goto st88;
1184
2174
  goto st0;
1185
- st43:
2175
+ st88:
1186
2176
  if ( ++p == pe )
1187
- goto _test_eof43;
1188
- case 43:
2177
+ goto _test_eof88;
2178
+ case 88:
1189
2179
  if ( (*p) < 65 ) {
1190
2180
  if ( 48 <= (*p) && (*p) <= 57 )
1191
- goto st41;
2181
+ goto st86;
1192
2182
  } else if ( (*p) > 70 ) {
1193
2183
  if ( 97 <= (*p) && (*p) <= 102 )
1194
- goto st41;
2184
+ goto st86;
1195
2185
  } else
1196
- goto st41;
2186
+ goto st86;
1197
2187
  goto st0;
1198
2188
  tr6:
1199
- #line 22 "src/parser.rl"
2189
+ #line 21 "src/parser.rl"
1200
2190
  {MARK(mark, p); }
1201
- goto st44;
1202
- st44:
2191
+ goto st89;
2192
+ st89:
1203
2193
  if ( ++p == pe )
1204
- goto _test_eof44;
1205
- case 44:
1206
- #line 1207 "src/parser.c"
2194
+ goto _test_eof89;
2195
+ case 89:
2196
+ #line 2197 "src/parser.c"
1207
2197
  switch( (*p) ) {
1208
- case 32: goto tr61;
2198
+ case 32: goto tr114;
1209
2199
  case 34: goto st0;
1210
- case 35: goto tr62;
1211
- case 37: goto st45;
1212
- case 59: goto tr64;
2200
+ case 35: goto tr115;
2201
+ case 37: goto st90;
2202
+ case 59: goto tr117;
1213
2203
  case 60: goto st0;
1214
2204
  case 62: goto st0;
1215
- case 63: goto tr65;
2205
+ case 63: goto tr118;
1216
2206
  case 127: goto st0;
1217
2207
  }
1218
2208
  if ( 0 <= (*p) && (*p) <= 31 )
1219
2209
  goto st0;
1220
- goto st44;
1221
- st45:
2210
+ goto st89;
2211
+ st90:
1222
2212
  if ( ++p == pe )
1223
- goto _test_eof45;
1224
- case 45:
2213
+ goto _test_eof90;
2214
+ case 90:
1225
2215
  if ( (*p) < 65 ) {
1226
2216
  if ( 48 <= (*p) && (*p) <= 57 )
1227
- goto st46;
2217
+ goto st91;
1228
2218
  } else if ( (*p) > 70 ) {
1229
2219
  if ( 97 <= (*p) && (*p) <= 102 )
1230
- goto st46;
2220
+ goto st91;
1231
2221
  } else
1232
- goto st46;
2222
+ goto st91;
1233
2223
  goto st0;
1234
- st46:
2224
+ st91:
1235
2225
  if ( ++p == pe )
1236
- goto _test_eof46;
1237
- case 46:
2226
+ goto _test_eof91;
2227
+ case 91:
1238
2228
  if ( (*p) < 65 ) {
1239
2229
  if ( 48 <= (*p) && (*p) <= 57 )
1240
- goto st44;
2230
+ goto st89;
1241
2231
  } else if ( (*p) > 70 ) {
1242
2232
  if ( 97 <= (*p) && (*p) <= 102 )
1243
- goto st44;
2233
+ goto st89;
1244
2234
  } else
1245
- goto st44;
2235
+ goto st89;
1246
2236
  goto st0;
1247
- tr64:
1248
- #line 79 "src/parser.rl"
2237
+ tr117:
2238
+ #line 61 "src/parser.rl"
1249
2239
  {
1250
- if(LEN(mark, p) > 1024) {
1251
- parser->overflow_error = TRUE;
1252
- {p++; cs = 47; goto _out;}
1253
- }
1254
- if(parser->request_path != NULL)
1255
- parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
2240
+ if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
2241
+ {p++; cs = 92; goto _out;}
1256
2242
  }
1257
- goto st47;
1258
- st47:
2243
+ goto st92;
2244
+ st92:
1259
2245
  if ( ++p == pe )
1260
- goto _test_eof47;
1261
- case 47:
1262
- #line 1263 "src/parser.c"
2246
+ goto _test_eof92;
2247
+ case 92:
2248
+ #line 2249 "src/parser.c"
1263
2249
  switch( (*p) ) {
1264
2250
  case 32: goto tr8;
1265
2251
  case 34: goto st0;
1266
2252
  case 35: goto tr9;
1267
- case 37: goto st48;
2253
+ case 37: goto st93;
1268
2254
  case 60: goto st0;
1269
2255
  case 62: goto st0;
1270
- case 63: goto st50;
2256
+ case 63: goto st95;
1271
2257
  case 127: goto st0;
1272
2258
  }
1273
2259
  if ( 0 <= (*p) && (*p) <= 31 )
1274
2260
  goto st0;
1275
- goto st47;
1276
- st48:
2261
+ goto st92;
2262
+ st93:
1277
2263
  if ( ++p == pe )
1278
- goto _test_eof48;
1279
- case 48:
2264
+ goto _test_eof93;
2265
+ case 93:
1280
2266
  if ( (*p) < 65 ) {
1281
2267
  if ( 48 <= (*p) && (*p) <= 57 )
1282
- goto st49;
2268
+ goto st94;
1283
2269
  } else if ( (*p) > 70 ) {
1284
2270
  if ( 97 <= (*p) && (*p) <= 102 )
1285
- goto st49;
2271
+ goto st94;
1286
2272
  } else
1287
- goto st49;
2273
+ goto st94;
1288
2274
  goto st0;
1289
- st49:
2275
+ st94:
1290
2276
  if ( ++p == pe )
1291
- goto _test_eof49;
1292
- case 49:
2277
+ goto _test_eof94;
2278
+ case 94:
1293
2279
  if ( (*p) < 65 ) {
1294
2280
  if ( 48 <= (*p) && (*p) <= 57 )
1295
- goto st47;
2281
+ goto st92;
1296
2282
  } else if ( (*p) > 70 ) {
1297
2283
  if ( 97 <= (*p) && (*p) <= 102 )
1298
- goto st47;
2284
+ goto st92;
1299
2285
  } else
1300
- goto st47;
2286
+ goto st92;
1301
2287
  goto st0;
1302
- tr65:
1303
- #line 79 "src/parser.rl"
2288
+ tr118:
2289
+ #line 61 "src/parser.rl"
1304
2290
  {
1305
- if(LEN(mark, p) > 1024) {
1306
- parser->overflow_error = TRUE;
1307
- {p++; cs = 50; goto _out;}
1308
- }
1309
- if(parser->request_path != NULL)
1310
- parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
2291
+ if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
2292
+ {p++; cs = 95; goto _out;}
1311
2293
  }
1312
- goto st50;
1313
- st50:
2294
+ goto st95;
2295
+ st95:
1314
2296
  if ( ++p == pe )
1315
- goto _test_eof50;
1316
- case 50:
1317
- #line 1318 "src/parser.c"
2297
+ goto _test_eof95;
2298
+ case 95:
2299
+ #line 2300 "src/parser.c"
1318
2300
  switch( (*p) ) {
1319
- case 32: goto tr72;
2301
+ case 32: goto tr125;
1320
2302
  case 34: goto st0;
1321
- case 35: goto tr73;
1322
- case 37: goto tr74;
2303
+ case 35: goto tr126;
2304
+ case 37: goto tr127;
1323
2305
  case 60: goto st0;
1324
2306
  case 62: goto st0;
1325
2307
  case 127: goto st0;
1326
2308
  }
1327
2309
  if ( 0 <= (*p) && (*p) <= 31 )
1328
2310
  goto st0;
1329
- goto tr71;
1330
- tr71:
1331
- #line 64 "src/parser.rl"
2311
+ goto tr124;
2312
+ tr124:
2313
+ #line 76 "src/parser.rl"
1332
2314
  {MARK(query_start, p); }
1333
- goto st51;
1334
- st51:
2315
+ goto st96;
2316
+ st96:
1335
2317
  if ( ++p == pe )
1336
- goto _test_eof51;
1337
- case 51:
1338
- #line 1339 "src/parser.c"
2318
+ goto _test_eof96;
2319
+ case 96:
2320
+ #line 2321 "src/parser.c"
1339
2321
  switch( (*p) ) {
1340
- case 32: goto tr76;
2322
+ case 32: goto tr129;
1341
2323
  case 34: goto st0;
1342
- case 35: goto tr77;
1343
- case 37: goto st52;
2324
+ case 35: goto tr130;
2325
+ case 37: goto st97;
1344
2326
  case 60: goto st0;
1345
2327
  case 62: goto st0;
1346
2328
  case 127: goto st0;
1347
2329
  }
1348
2330
  if ( 0 <= (*p) && (*p) <= 31 )
1349
2331
  goto st0;
1350
- goto st51;
1351
- tr74:
1352
- #line 64 "src/parser.rl"
2332
+ goto st96;
2333
+ tr127:
2334
+ #line 76 "src/parser.rl"
1353
2335
  {MARK(query_start, p); }
1354
- goto st52;
1355
- st52:
2336
+ goto st97;
2337
+ st97:
1356
2338
  if ( ++p == pe )
1357
- goto _test_eof52;
1358
- case 52:
1359
- #line 1360 "src/parser.c"
2339
+ goto _test_eof97;
2340
+ case 97:
2341
+ #line 2342 "src/parser.c"
1360
2342
  if ( (*p) < 65 ) {
1361
2343
  if ( 48 <= (*p) && (*p) <= 57 )
1362
- goto st53;
2344
+ goto st98;
1363
2345
  } else if ( (*p) > 70 ) {
1364
2346
  if ( 97 <= (*p) && (*p) <= 102 )
1365
- goto st53;
2347
+ goto st98;
1366
2348
  } else
1367
- goto st53;
2349
+ goto st98;
1368
2350
  goto st0;
1369
- st53:
2351
+ st98:
1370
2352
  if ( ++p == pe )
1371
- goto _test_eof53;
1372
- case 53:
2353
+ goto _test_eof98;
2354
+ case 98:
1373
2355
  if ( (*p) < 65 ) {
1374
2356
  if ( 48 <= (*p) && (*p) <= 57 )
1375
- goto st51;
2357
+ goto st96;
1376
2358
  } else if ( (*p) > 70 ) {
1377
2359
  if ( 97 <= (*p) && (*p) <= 102 )
1378
- goto st51;
2360
+ goto st96;
1379
2361
  } else
1380
- goto st51;
2362
+ goto st96;
1381
2363
  goto st0;
1382
- st54:
2364
+ st99:
1383
2365
  if ( ++p == pe )
1384
- goto _test_eof54;
1385
- case 54:
2366
+ goto _test_eof99;
2367
+ case 99:
1386
2368
  switch( (*p) ) {
1387
2369
  case 32: goto tr2;
1388
- case 36: goto st55;
1389
- case 95: goto st55;
2370
+ case 36: goto st100;
2371
+ case 95: goto st100;
1390
2372
  }
1391
2373
  if ( (*p) < 48 ) {
1392
2374
  if ( 45 <= (*p) && (*p) <= 46 )
1393
- goto st55;
2375
+ goto st100;
1394
2376
  } else if ( (*p) > 57 ) {
1395
2377
  if ( 65 <= (*p) && (*p) <= 90 )
1396
- goto st55;
2378
+ goto st100;
1397
2379
  } else
1398
- goto st55;
2380
+ goto st100;
1399
2381
  goto st0;
1400
- st55:
2382
+ st100:
1401
2383
  if ( ++p == pe )
1402
- goto _test_eof55;
1403
- case 55:
2384
+ goto _test_eof100;
2385
+ case 100:
1404
2386
  switch( (*p) ) {
1405
2387
  case 32: goto tr2;
1406
- case 36: goto st56;
1407
- case 95: goto st56;
2388
+ case 36: goto st101;
2389
+ case 95: goto st101;
1408
2390
  }
1409
2391
  if ( (*p) < 48 ) {
1410
2392
  if ( 45 <= (*p) && (*p) <= 46 )
1411
- goto st56;
2393
+ goto st101;
1412
2394
  } else if ( (*p) > 57 ) {
1413
2395
  if ( 65 <= (*p) && (*p) <= 90 )
1414
- goto st56;
2396
+ goto st101;
1415
2397
  } else
1416
- goto st56;
2398
+ goto st101;
1417
2399
  goto st0;
1418
- st56:
2400
+ st101:
1419
2401
  if ( ++p == pe )
1420
- goto _test_eof56;
1421
- case 56:
2402
+ goto _test_eof101;
2403
+ case 101:
1422
2404
  switch( (*p) ) {
1423
2405
  case 32: goto tr2;
1424
- case 36: goto st57;
1425
- case 95: goto st57;
2406
+ case 36: goto st102;
2407
+ case 95: goto st102;
1426
2408
  }
1427
2409
  if ( (*p) < 48 ) {
1428
2410
  if ( 45 <= (*p) && (*p) <= 46 )
1429
- goto st57;
2411
+ goto st102;
1430
2412
  } else if ( (*p) > 57 ) {
1431
2413
  if ( 65 <= (*p) && (*p) <= 90 )
1432
- goto st57;
2414
+ goto st102;
1433
2415
  } else
1434
- goto st57;
2416
+ goto st102;
1435
2417
  goto st0;
1436
- st57:
2418
+ st102:
1437
2419
  if ( ++p == pe )
1438
- goto _test_eof57;
1439
- case 57:
2420
+ goto _test_eof102;
2421
+ case 102:
1440
2422
  switch( (*p) ) {
1441
2423
  case 32: goto tr2;
1442
- case 36: goto st58;
1443
- case 95: goto st58;
2424
+ case 36: goto st103;
2425
+ case 95: goto st103;
1444
2426
  }
1445
2427
  if ( (*p) < 48 ) {
1446
2428
  if ( 45 <= (*p) && (*p) <= 46 )
1447
- goto st58;
2429
+ goto st103;
1448
2430
  } else if ( (*p) > 57 ) {
1449
2431
  if ( 65 <= (*p) && (*p) <= 90 )
1450
- goto st58;
2432
+ goto st103;
1451
2433
  } else
1452
- goto st58;
2434
+ goto st103;
1453
2435
  goto st0;
1454
- st58:
2436
+ st103:
1455
2437
  if ( ++p == pe )
1456
- goto _test_eof58;
1457
- case 58:
2438
+ goto _test_eof103;
2439
+ case 103:
1458
2440
  switch( (*p) ) {
1459
2441
  case 32: goto tr2;
1460
- case 36: goto st59;
1461
- case 95: goto st59;
2442
+ case 36: goto st104;
2443
+ case 95: goto st104;
1462
2444
  }
1463
2445
  if ( (*p) < 48 ) {
1464
2446
  if ( 45 <= (*p) && (*p) <= 46 )
1465
- goto st59;
2447
+ goto st104;
1466
2448
  } else if ( (*p) > 57 ) {
1467
2449
  if ( 65 <= (*p) && (*p) <= 90 )
1468
- goto st59;
2450
+ goto st104;
1469
2451
  } else
1470
- goto st59;
2452
+ goto st104;
1471
2453
  goto st0;
1472
- st59:
2454
+ st104:
1473
2455
  if ( ++p == pe )
1474
- goto _test_eof59;
1475
- case 59:
2456
+ goto _test_eof104;
2457
+ case 104:
1476
2458
  switch( (*p) ) {
1477
2459
  case 32: goto tr2;
1478
- case 36: goto st60;
1479
- case 95: goto st60;
2460
+ case 36: goto st105;
2461
+ case 95: goto st105;
1480
2462
  }
1481
2463
  if ( (*p) < 48 ) {
1482
2464
  if ( 45 <= (*p) && (*p) <= 46 )
1483
- goto st60;
2465
+ goto st105;
1484
2466
  } else if ( (*p) > 57 ) {
1485
2467
  if ( 65 <= (*p) && (*p) <= 90 )
1486
- goto st60;
2468
+ goto st105;
1487
2469
  } else
1488
- goto st60;
2470
+ goto st105;
1489
2471
  goto st0;
1490
- st60:
2472
+ st105:
1491
2473
  if ( ++p == pe )
1492
- goto _test_eof60;
1493
- case 60:
2474
+ goto _test_eof105;
2475
+ case 105:
1494
2476
  switch( (*p) ) {
1495
2477
  case 32: goto tr2;
1496
- case 36: goto st61;
1497
- case 95: goto st61;
2478
+ case 36: goto st106;
2479
+ case 95: goto st106;
1498
2480
  }
1499
2481
  if ( (*p) < 48 ) {
1500
2482
  if ( 45 <= (*p) && (*p) <= 46 )
1501
- goto st61;
2483
+ goto st106;
1502
2484
  } else if ( (*p) > 57 ) {
1503
2485
  if ( 65 <= (*p) && (*p) <= 90 )
1504
- goto st61;
2486
+ goto st106;
1505
2487
  } else
1506
- goto st61;
2488
+ goto st106;
1507
2489
  goto st0;
1508
- st61:
2490
+ st106:
1509
2491
  if ( ++p == pe )
1510
- goto _test_eof61;
1511
- case 61:
2492
+ goto _test_eof106;
2493
+ case 106:
1512
2494
  switch( (*p) ) {
1513
2495
  case 32: goto tr2;
1514
- case 36: goto st62;
1515
- case 95: goto st62;
2496
+ case 36: goto st107;
2497
+ case 95: goto st107;
1516
2498
  }
1517
2499
  if ( (*p) < 48 ) {
1518
2500
  if ( 45 <= (*p) && (*p) <= 46 )
1519
- goto st62;
2501
+ goto st107;
1520
2502
  } else if ( (*p) > 57 ) {
1521
2503
  if ( 65 <= (*p) && (*p) <= 90 )
1522
- goto st62;
2504
+ goto st107;
1523
2505
  } else
1524
- goto st62;
2506
+ goto st107;
1525
2507
  goto st0;
1526
- st62:
2508
+ st107:
1527
2509
  if ( ++p == pe )
1528
- goto _test_eof62;
1529
- case 62:
2510
+ goto _test_eof107;
2511
+ case 107:
1530
2512
  switch( (*p) ) {
1531
2513
  case 32: goto tr2;
1532
- case 36: goto st63;
1533
- case 95: goto st63;
2514
+ case 36: goto st108;
2515
+ case 95: goto st108;
1534
2516
  }
1535
2517
  if ( (*p) < 48 ) {
1536
2518
  if ( 45 <= (*p) && (*p) <= 46 )
1537
- goto st63;
2519
+ goto st108;
1538
2520
  } else if ( (*p) > 57 ) {
1539
2521
  if ( 65 <= (*p) && (*p) <= 90 )
1540
- goto st63;
2522
+ goto st108;
1541
2523
  } else
1542
- goto st63;
2524
+ goto st108;
1543
2525
  goto st0;
1544
- st63:
2526
+ st108:
1545
2527
  if ( ++p == pe )
1546
- goto _test_eof63;
1547
- case 63:
2528
+ goto _test_eof108;
2529
+ case 108:
1548
2530
  switch( (*p) ) {
1549
2531
  case 32: goto tr2;
1550
- case 36: goto st64;
1551
- case 95: goto st64;
2532
+ case 36: goto st109;
2533
+ case 95: goto st109;
1552
2534
  }
1553
2535
  if ( (*p) < 48 ) {
1554
2536
  if ( 45 <= (*p) && (*p) <= 46 )
1555
- goto st64;
2537
+ goto st109;
1556
2538
  } else if ( (*p) > 57 ) {
1557
2539
  if ( 65 <= (*p) && (*p) <= 90 )
1558
- goto st64;
2540
+ goto st109;
1559
2541
  } else
1560
- goto st64;
2542
+ goto st109;
1561
2543
  goto st0;
1562
- st64:
2544
+ st109:
1563
2545
  if ( ++p == pe )
1564
- goto _test_eof64;
1565
- case 64:
2546
+ goto _test_eof109;
2547
+ case 109:
1566
2548
  switch( (*p) ) {
1567
2549
  case 32: goto tr2;
1568
- case 36: goto st65;
1569
- case 95: goto st65;
2550
+ case 36: goto st110;
2551
+ case 95: goto st110;
1570
2552
  }
1571
2553
  if ( (*p) < 48 ) {
1572
2554
  if ( 45 <= (*p) && (*p) <= 46 )
1573
- goto st65;
2555
+ goto st110;
1574
2556
  } else if ( (*p) > 57 ) {
1575
2557
  if ( 65 <= (*p) && (*p) <= 90 )
1576
- goto st65;
2558
+ goto st110;
1577
2559
  } else
1578
- goto st65;
2560
+ goto st110;
1579
2561
  goto st0;
1580
- st65:
2562
+ st110:
1581
2563
  if ( ++p == pe )
1582
- goto _test_eof65;
1583
- case 65:
2564
+ goto _test_eof110;
2565
+ case 110:
1584
2566
  switch( (*p) ) {
1585
2567
  case 32: goto tr2;
1586
- case 36: goto st66;
1587
- case 95: goto st66;
2568
+ case 36: goto st111;
2569
+ case 95: goto st111;
1588
2570
  }
1589
2571
  if ( (*p) < 48 ) {
1590
2572
  if ( 45 <= (*p) && (*p) <= 46 )
1591
- goto st66;
2573
+ goto st111;
1592
2574
  } else if ( (*p) > 57 ) {
1593
2575
  if ( 65 <= (*p) && (*p) <= 90 )
1594
- goto st66;
2576
+ goto st111;
1595
2577
  } else
1596
- goto st66;
2578
+ goto st111;
1597
2579
  goto st0;
1598
- st66:
2580
+ st111:
1599
2581
  if ( ++p == pe )
1600
- goto _test_eof66;
1601
- case 66:
2582
+ goto _test_eof111;
2583
+ case 111:
1602
2584
  switch( (*p) ) {
1603
2585
  case 32: goto tr2;
1604
- case 36: goto st67;
1605
- case 95: goto st67;
2586
+ case 36: goto st112;
2587
+ case 95: goto st112;
1606
2588
  }
1607
2589
  if ( (*p) < 48 ) {
1608
2590
  if ( 45 <= (*p) && (*p) <= 46 )
1609
- goto st67;
2591
+ goto st112;
1610
2592
  } else if ( (*p) > 57 ) {
1611
2593
  if ( 65 <= (*p) && (*p) <= 90 )
1612
- goto st67;
2594
+ goto st112;
1613
2595
  } else
1614
- goto st67;
2596
+ goto st112;
1615
2597
  goto st0;
1616
- st67:
2598
+ st112:
1617
2599
  if ( ++p == pe )
1618
- goto _test_eof67;
1619
- case 67:
2600
+ goto _test_eof112;
2601
+ case 112:
1620
2602
  switch( (*p) ) {
1621
2603
  case 32: goto tr2;
1622
- case 36: goto st68;
1623
- case 95: goto st68;
2604
+ case 36: goto st113;
2605
+ case 95: goto st113;
1624
2606
  }
1625
2607
  if ( (*p) < 48 ) {
1626
2608
  if ( 45 <= (*p) && (*p) <= 46 )
1627
- goto st68;
2609
+ goto st113;
1628
2610
  } else if ( (*p) > 57 ) {
1629
2611
  if ( 65 <= (*p) && (*p) <= 90 )
1630
- goto st68;
2612
+ goto st113;
1631
2613
  } else
1632
- goto st68;
2614
+ goto st113;
1633
2615
  goto st0;
1634
- st68:
2616
+ st113:
1635
2617
  if ( ++p == pe )
1636
- goto _test_eof68;
1637
- case 68:
2618
+ goto _test_eof113;
2619
+ case 113:
1638
2620
  switch( (*p) ) {
1639
2621
  case 32: goto tr2;
1640
- case 36: goto st69;
1641
- case 95: goto st69;
2622
+ case 36: goto st114;
2623
+ case 95: goto st114;
1642
2624
  }
1643
2625
  if ( (*p) < 48 ) {
1644
2626
  if ( 45 <= (*p) && (*p) <= 46 )
1645
- goto st69;
2627
+ goto st114;
1646
2628
  } else if ( (*p) > 57 ) {
1647
2629
  if ( 65 <= (*p) && (*p) <= 90 )
1648
- goto st69;
2630
+ goto st114;
1649
2631
  } else
1650
- goto st69;
2632
+ goto st114;
1651
2633
  goto st0;
1652
- st69:
2634
+ st114:
1653
2635
  if ( ++p == pe )
1654
- goto _test_eof69;
1655
- case 69:
2636
+ goto _test_eof114;
2637
+ case 114:
1656
2638
  switch( (*p) ) {
1657
2639
  case 32: goto tr2;
1658
- case 36: goto st70;
1659
- case 95: goto st70;
2640
+ case 36: goto st115;
2641
+ case 95: goto st115;
1660
2642
  }
1661
2643
  if ( (*p) < 48 ) {
1662
2644
  if ( 45 <= (*p) && (*p) <= 46 )
1663
- goto st70;
2645
+ goto st115;
1664
2646
  } else if ( (*p) > 57 ) {
1665
2647
  if ( 65 <= (*p) && (*p) <= 90 )
1666
- goto st70;
2648
+ goto st115;
1667
2649
  } else
1668
- goto st70;
2650
+ goto st115;
1669
2651
  goto st0;
1670
- st70:
2652
+ st115:
1671
2653
  if ( ++p == pe )
1672
- goto _test_eof70;
1673
- case 70:
2654
+ goto _test_eof115;
2655
+ case 115:
1674
2656
  switch( (*p) ) {
1675
2657
  case 32: goto tr2;
1676
- case 36: goto st71;
1677
- case 95: goto st71;
2658
+ case 36: goto st116;
2659
+ case 95: goto st116;
1678
2660
  }
1679
2661
  if ( (*p) < 48 ) {
1680
2662
  if ( 45 <= (*p) && (*p) <= 46 )
1681
- goto st71;
2663
+ goto st116;
1682
2664
  } else if ( (*p) > 57 ) {
1683
2665
  if ( 65 <= (*p) && (*p) <= 90 )
1684
- goto st71;
2666
+ goto st116;
1685
2667
  } else
1686
- goto st71;
2668
+ goto st116;
1687
2669
  goto st0;
1688
- st71:
2670
+ st116:
1689
2671
  if ( ++p == pe )
1690
- goto _test_eof71;
1691
- case 71:
2672
+ goto _test_eof116;
2673
+ case 116:
1692
2674
  switch( (*p) ) {
1693
2675
  case 32: goto tr2;
1694
- case 36: goto st72;
1695
- case 95: goto st72;
2676
+ case 36: goto st117;
2677
+ case 95: goto st117;
1696
2678
  }
1697
2679
  if ( (*p) < 48 ) {
1698
2680
  if ( 45 <= (*p) && (*p) <= 46 )
1699
- goto st72;
2681
+ goto st117;
1700
2682
  } else if ( (*p) > 57 ) {
1701
2683
  if ( 65 <= (*p) && (*p) <= 90 )
1702
- goto st72;
2684
+ goto st117;
1703
2685
  } else
1704
- goto st72;
2686
+ goto st117;
1705
2687
  goto st0;
1706
- st72:
2688
+ st117:
1707
2689
  if ( ++p == pe )
1708
- goto _test_eof72;
1709
- case 72:
2690
+ goto _test_eof117;
2691
+ case 117:
1710
2692
  if ( (*p) == 32 )
1711
2693
  goto tr2;
1712
2694
  goto st0;
@@ -1726,7 +2708,7 @@ case 72:
1726
2708
  _test_eof14: cs = 14; goto _test_eof;
1727
2709
  _test_eof15: cs = 15; goto _test_eof;
1728
2710
  _test_eof16: cs = 16; goto _test_eof;
1729
- _test_eof73: cs = 73; goto _test_eof;
2711
+ _test_eof118: cs = 118; goto _test_eof;
1730
2712
  _test_eof17: cs = 17; goto _test_eof;
1731
2713
  _test_eof18: cs = 18; goto _test_eof;
1732
2714
  _test_eof19: cs = 19; goto _test_eof;
@@ -1783,11 +2765,56 @@ case 72:
1783
2765
  _test_eof70: cs = 70; goto _test_eof;
1784
2766
  _test_eof71: cs = 71; goto _test_eof;
1785
2767
  _test_eof72: cs = 72; goto _test_eof;
2768
+ _test_eof73: cs = 73; goto _test_eof;
2769
+ _test_eof74: cs = 74; goto _test_eof;
2770
+ _test_eof75: cs = 75; goto _test_eof;
2771
+ _test_eof76: cs = 76; goto _test_eof;
2772
+ _test_eof77: cs = 77; goto _test_eof;
2773
+ _test_eof78: cs = 78; goto _test_eof;
2774
+ _test_eof79: cs = 79; goto _test_eof;
2775
+ _test_eof80: cs = 80; goto _test_eof;
2776
+ _test_eof81: cs = 81; goto _test_eof;
2777
+ _test_eof82: cs = 82; goto _test_eof;
2778
+ _test_eof83: cs = 83; goto _test_eof;
2779
+ _test_eof84: cs = 84; goto _test_eof;
2780
+ _test_eof85: cs = 85; goto _test_eof;
2781
+ _test_eof86: cs = 86; goto _test_eof;
2782
+ _test_eof87: cs = 87; goto _test_eof;
2783
+ _test_eof88: cs = 88; goto _test_eof;
2784
+ _test_eof89: cs = 89; goto _test_eof;
2785
+ _test_eof90: cs = 90; goto _test_eof;
2786
+ _test_eof91: cs = 91; goto _test_eof;
2787
+ _test_eof92: cs = 92; goto _test_eof;
2788
+ _test_eof93: cs = 93; goto _test_eof;
2789
+ _test_eof94: cs = 94; goto _test_eof;
2790
+ _test_eof95: cs = 95; goto _test_eof;
2791
+ _test_eof96: cs = 96; goto _test_eof;
2792
+ _test_eof97: cs = 97; goto _test_eof;
2793
+ _test_eof98: cs = 98; goto _test_eof;
2794
+ _test_eof99: cs = 99; goto _test_eof;
2795
+ _test_eof100: cs = 100; goto _test_eof;
2796
+ _test_eof101: cs = 101; goto _test_eof;
2797
+ _test_eof102: cs = 102; goto _test_eof;
2798
+ _test_eof103: cs = 103; goto _test_eof;
2799
+ _test_eof104: cs = 104; goto _test_eof;
2800
+ _test_eof105: cs = 105; goto _test_eof;
2801
+ _test_eof106: cs = 106; goto _test_eof;
2802
+ _test_eof107: cs = 107; goto _test_eof;
2803
+ _test_eof108: cs = 108; goto _test_eof;
2804
+ _test_eof109: cs = 109; goto _test_eof;
2805
+ _test_eof110: cs = 110; goto _test_eof;
2806
+ _test_eof111: cs = 111; goto _test_eof;
2807
+ _test_eof112: cs = 112; goto _test_eof;
2808
+ _test_eof113: cs = 113; goto _test_eof;
2809
+ _test_eof114: cs = 114; goto _test_eof;
2810
+ _test_eof115: cs = 115; goto _test_eof;
2811
+ _test_eof116: cs = 116; goto _test_eof;
2812
+ _test_eof117: cs = 117; goto _test_eof;
1786
2813
 
1787
2814
  _test_eof: {}
1788
2815
  _out: {}
1789
2816
  }
1790
- #line 202 "src/parser.rl"
2817
+ #line 197 "src/parser.rl"
1791
2818
 
1792
2819
  parser->cs = cs;
1793
2820
  parser->nread += p - (buffer + off);
@@ -1799,6 +2826,10 @@ case 72:
1799
2826
  assert(parser->field_len <= len && "field has length longer than whole buffer");
1800
2827
  assert(parser->field_start < len && "field starts after buffer end");
1801
2828
 
2829
+ if(parser->nread > 1024 * (80 + 32))
2830
+ parser->overflow_error = TRUE;
2831
+
2832
+
1802
2833
  /* Ragel 6 does not use write eof; no need for this
1803
2834
  if(parser->body_start) {
1804
2835
  // final \r\n combo encountered so stop right here
@@ -1826,4 +2857,4 @@ int http_parser_has_error(http_parser *parser) {
1826
2857
 
1827
2858
  int http_parser_is_finished(http_parser *parser) {
1828
2859
  return parser->cs >= http_parser_first_final;
1829
- }
2860
+ }