ebb 0.0.4 → 0.1.0

data/src/ebb.h

@@ -4,20 +4,16 @@
  */
 #ifndef ebb_h
 #define ebb_h
-
+#define EV_STANDALONE 1
+#include <ev.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <glib.h>
-
-#define EV_STANDALONE 1
-#include <ev.h>
-
 #include "parser.h"
 
-
 typedef struct ebb_server ebb_server;
 typedef struct ebb_client ebb_client;
-
+#define EBB_VERSION "0.1.0"
 #define EBB_BUFFERSIZE (1024 * (80 + 33))
 #define EBB_MAX_CLIENTS 200
 #define EBB_TIMEOUT 30.0
@@ -29,12 +25,13 @@ typedef struct ebb_client ebb_client;
 
 /*** Ebb Client ***/
 void ebb_client_close(ebb_client*);
+/* user MUST call this function on each client passed by the request_cb */
+void ebb_client_release(ebb_client*);
 int ebb_client_read(ebb_client *client, char *buffer, int length);
 void ebb_client_write_status(ebb_client*, int status, const char *human_status);
 void ebb_client_write_header(ebb_client*, const char *field, const char *value);
 void ebb_client_write(ebb_client*, const char *data, int length);
-void ebb_client_finished( ebb_client *client);
-
+void ebb_client_begin_transmission( ebb_client *client);
 
 struct ebb_env_item {
   enum { EBB_FIELD_VALUE_PAIR
@@ -44,7 +41,6 @@ struct ebb_env_item {
        , EBB_REQUEST_PATH
        , EBB_QUERY_STRING
        , EBB_HTTP_VERSION
-       , EBB_SERVER_NAME
        , EBB_SERVER_PORT
        , EBB_CONTENT_LENGTH
        } type;
@@ -57,10 +53,12 @@ struct ebb_env_item {
 struct ebb_client {
   EBB_TCP_COMMON
   
+  unsigned int in_use : 1;
+  
   ebb_server *server;
   http_parser parser;
   
-  char request_buffer[EBB_BUFFERSIZE];
+  char *request_buffer;
   ev_io read_watcher;
   size_t read, nread_from_body;
   
@@ -75,9 +73,10 @@ struct ebb_client {
   
   ev_timer timeout_watcher;
   
-  int status_sent;
-  int headers_sent;
-  int body_sent;
+  unsigned int status_written : 1;
+  unsigned int headers_written : 1;
+  unsigned int body_written : 1;
+  unsigned int began_transmission : 1;
   
   /* the ENV structure */
   int env_size;
@@ -110,4 +109,4 @@ struct ebb_server {
   ebb_request_cb request_cb;
 };
 
-#endif
+#endif

data/src/ebb_ruby.c

@@ -3,12 +3,13 @@
  * License. See README file for details.
  */
 #include <ruby.h>
+#include <rubyio.h>
+#include <rubysig.h>
 #include <assert.h>
 #include <fcntl.h>
 #include <ebb.h>
 #include <ev.h>
 
-static VALUE cServer;
 static VALUE cClient;
 static VALUE global_http_prefix;
 static VALUE global_request_method;
@@ -18,99 +19,102 @@ static VALUE global_request_path;
 static VALUE global_query_string;
 static VALUE global_http_version;
 static VALUE global_request_body;
-static VALUE global_server_name;
 static VALUE global_server_port;
 static VALUE global_path_info;
 static VALUE global_content_length;
 static VALUE global_http_host;
 
+/* You don't want to run more than one server per Ruby VM. Really
+ * I'm making this explicit by not defining a Ebb::Server class but instead
+ * initializing a single server and single event loop on module load.
+ */
+static ebb_server *server;
+struct ev_loop *loop;
+struct ev_idle idle_watcher;
+
 /* Variables with a leading underscore are C-level variables */
 
 #define ASCII_UPPER(ch) ('a' <= ch && ch <= 'z' ? ch - 'a' + 'A' : ch)
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(s) (RSTRING(s)->ptr)
+# define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
 
-VALUE client_new(ebb_client *_client)
+static void attach_idle_watcher()
 {
-  VALUE client = Data_Wrap_Struct(cClient, 0, 0, _client);
-  return client;
+  if(!ev_is_active(&idle_watcher)) {
+    ev_idle_start (loop, &idle_watcher);
+  }
 }
 
 
-void request_cb(ebb_client *_client, void *data)
+static void detach_idle_watcher()
 {
-  VALUE server = (VALUE)data;
-  VALUE waiting_clients;
-  VALUE client = client_new(_client);
-  
-  waiting_clients = rb_iv_get(server, "@waiting_clients");
-  rb_ary_push(waiting_clients, client);
+  ev_idle_stop(loop, &idle_watcher);
 }
 
-
-VALUE server_alloc(VALUE self)
+static int clients_in_use_p()
 {
-  struct ev_loop *loop = ev_default_loop (0);
-  ebb_server *_server = ebb_server_alloc();
-  VALUE server = Qnil;
-  server = Data_Wrap_Struct(cServer, 0, ebb_server_free, _server);
-  ebb_server_init(_server, loop, request_cb, (void*)server);
-  return server; 
+  int i;
+  for(i = 0; i < EBB_MAX_CLIENTS; i++)
+    if(server->clients[i].in_use) return TRUE;
+  return FALSE;
 }
 
-
-VALUE server_listen_on_port(VALUE x, VALUE server, VALUE port)
+void request_cb(ebb_client *client, void *data)
 {
-  ebb_server *_server;
-  Data_Get_Struct(server, ebb_server, _server);
-  int r = ebb_server_listen_on_port(_server, FIX2INT(port));
-  return r < 0 ? Qfalse : Qtrue;
+  VALUE waiting_clients = (VALUE)data;
+  VALUE rb_client = Data_Wrap_Struct(cClient, 0, 0, client);
+  rb_ary_push(waiting_clients, rb_client);
+  attach_idle_watcher();
 }
 
-
-VALUE server_listen_on_socket(VALUE x, VALUE server, VALUE socketpath)
+VALUE server_listen_on_port(VALUE _, VALUE port)
 {
-  ebb_server *_server;
-  Data_Get_Struct(server, ebb_server, _server);
-  int r = ebb_server_listen_on_socket(_server, StringValuePtr(socketpath));
-  return r < 0 ? Qfalse : Qtrue;
+  if(ebb_server_listen_on_port(server, FIX2INT(port)) < 0)
+    rb_sys_fail("Problem listening on port");
+  return Qnil;
 }
 
-
 static void
-oneshot_timeout (struct ev_loop *loop, struct ev_timer *w, int revents) {;}
-
+idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) {
+  if(clients_in_use_p()) {
+    rb_thread_schedule();
+  } else if(!rb_thread_alone()) {
+    /* if you have another long running thread running besides the ones used
+     * for the webapp's requests you will run into performance problems in 
+     * ruby 1.8.x because rb_thread_select is slow. 
+     * (Don't worry - you're probably not doing this.)
+     */
+    struct timeval select_timeout = { tv_sec: 0, tv_usec: 50000 };
+    fd_set server_fd_set;
+    FD_ZERO(&server_fd_set);
+    FD_SET(server->fd, &server_fd_set);
+    rb_thread_select(server->fd+1, &server_fd_set, 0, 0, &select_timeout);
+  } else {
+    detach_idle_watcher();
+  }
+}
 
-VALUE server_process_connections(VALUE x, VALUE server)
+VALUE server_process_connections(VALUE _)
 {
-  ebb_server *_server;
-  VALUE host, port;
-  
-  Data_Get_Struct(server, ebb_server, _server);
-  
-  ev_timer timeout;
-  ev_timer_init (&timeout, oneshot_timeout, 0.5, 0.);
-  ev_timer_start (_server->loop, &timeout);
-   
-  ev_loop(_server->loop, EVLOOP_ONESHOT);
-  /* XXX: Need way to know when the loop is finished...
-   * should return true or false */
-   
-  ev_timer_stop(_server->loop, &timeout);
-  
-  if(_server->open)
-    return Qtrue;
-  else
-    return Qfalse;
+  TRAP_BEG;
+  ev_loop(loop, EVLOOP_ONESHOT);
+  TRAP_END;
+  return Qnil;
 }
 
 
-VALUE server_unlisten(VALUE x, VALUE server)
+VALUE server_unlisten(VALUE _)
 {
-  ebb_server *_server;
-  Data_Get_Struct(server, ebb_server, _server);
-  ebb_server_unlisten(_server);
+  ebb_server_unlisten(server);
   return Qnil;
 }
 
+VALUE server_open(VALUE _)
+{
+  return server->open ? Qtrue : Qfalse;
+}
 
 VALUE env_field(struct ebb_env_item *item)
 {
@@ -134,7 +138,6 @@ VALUE env_field(struct ebb_env_item *item)
     case EBB_REQUEST_PATH:    return global_request_path;
     case EBB_QUERY_STRING:    return global_query_string;
     case EBB_HTTP_VERSION:    return global_http_version;
-    case EBB_SERVER_NAME:     return global_server_name;
     case EBB_SERVER_PORT:     return global_server_port;
     case EBB_CONTENT_LENGTH:  return global_content_length;
   }
@@ -152,24 +155,26 @@ VALUE env_value(struct ebb_env_item *item)
 }
 
 
-VALUE client_env(VALUE x, VALUE client)
+VALUE client_env(VALUE _, VALUE rb_client)
 {
-  ebb_client *_client;
-  VALUE hash = rb_hash_new();
-  int i;  
-  Data_Get_Struct(client, ebb_client, _client);
+  ebb_client *client;
+  VALUE field, value, hash = rb_hash_new();
+  int i;
   
-  for(i=0; i < _client->env_size; i++) {
-    rb_hash_aset(hash, env_field(&_client->env[i])
-                     , env_value(&_client->env[i])
-                     );
+  Data_Get_Struct(rb_client, ebb_client, client);
+  for(i=0; i < client->env_size; i++) {
+    field = env_field(&client->env[i]);
+    value = env_value(&client->env[i]);
+    rb_hash_aset(hash, field, value);
+    //printf("(%s, %s)\n", StringValuePtr(field), StringValuePtr(value));
   }
+  //printf("\n\n");
   rb_hash_aset(hash, global_path_info, rb_hash_aref(hash, global_request_path));
   return hash;
 }
 
 
-VALUE client_read_input(VALUE x, VALUE client, VALUE size)
+VALUE client_read_input(VALUE _, VALUE client, VALUE size)
 {
   ebb_client *_client;
   GString *_string;
@@ -192,7 +197,7 @@ VALUE client_read_input(VALUE x, VALUE client, VALUE size)
   return string;
 }
 
-VALUE client_write_status(VALUE x, VALUE client, VALUE status, VALUE human_status)
+VALUE client_write_status(VALUE _, VALUE client, VALUE status, VALUE human_status)
 {
   ebb_client *_client;
   Data_Get_Struct(client, ebb_client, _client);
@@ -200,7 +205,7 @@ VALUE client_write_status(VALUE x, VALUE client, VALUE status, VALUE human_statu
   return Qnil;
 }
 
-VALUE client_write_header(VALUE x, VALUE client, VALUE field, VALUE value)
+VALUE client_write_header(VALUE _, VALUE client, VALUE field, VALUE value)
 {
   ebb_client *_client;
   Data_Get_Struct(client, ebb_client, _client);
@@ -208,7 +213,7 @@ VALUE client_write_header(VALUE x, VALUE client, VALUE field, VALUE value)
   return Qnil;
 }
 
-VALUE client_write(VALUE x, VALUE client, VALUE string)
+VALUE client_write(VALUE _, VALUE client, VALUE string)
 {
   ebb_client *_client;
   Data_Get_Struct(client, ebb_client, _client);
@@ -217,20 +222,40 @@ VALUE client_write(VALUE x, VALUE client, VALUE string)
 }
 
 
-VALUE client_finished(VALUE x, VALUE client)
+VALUE client_begin_transmission(VALUE _, VALUE rb_client)
 {
-  ebb_client *_client;
-  Data_Get_Struct(client, ebb_client, _client);
-  ebb_client_finished(_client);
+  ebb_client *client;
+  Data_Get_Struct(rb_client, ebb_client, client);
+  client->status_written = TRUE;
+  client->headers_written = TRUE;
+  ebb_client_begin_transmission(client);
   return Qnil;
 }
 
+VALUE client_release(VALUE _, VALUE rb_client)
+{
+  ebb_client *client;
+  Data_Get_Struct(rb_client, ebb_client, client);
+  ebb_client_release(client);
+  return Qnil;
+}
+
+
+VALUE client_set_body_written(VALUE _, VALUE rb_client, VALUE v)
+{
+  ebb_client *client;
+  Data_Get_Struct(rb_client, ebb_client, client);
+  client->body_written = RTEST(v);
+  return client->body_written ? Qtrue : Qfalse;
+}
 
 void Init_ebb_ext()
 {
   VALUE mEbb = rb_define_module("Ebb");
   VALUE mFFI = rb_define_module_under(mEbb, "FFI");
   
+  rb_define_const(mEbb, "VERSION", rb_str_new2(EBB_VERSION));
+  
   /** Defines global strings in the init method. */
 #define DEF_GLOBAL(N, val) global_##N = rb_obj_freeze(rb_str_new2(val)); rb_global_variable(&global_##N)
   DEF_GLOBAL(http_prefix, "HTTP_");
@@ -241,24 +266,34 @@ void Init_ebb_ext()
   DEF_GLOBAL(query_string, "QUERY_STRING");
   DEF_GLOBAL(http_version, "HTTP_VERSION");
   DEF_GLOBAL(request_body, "REQUEST_BODY");
-  DEF_GLOBAL(server_name, "SERVER_NAME");
   DEF_GLOBAL(server_port, "SERVER_PORT");
   DEF_GLOBAL(path_info, "PATH_INFO");
   DEF_GLOBAL(content_length, "CONTENT_LENGTH");
   DEF_GLOBAL(http_host, "HTTP_HOST");
   
-  cServer = rb_define_class_under(mEbb, "Server", rb_cObject);
-  rb_define_alloc_func(cServer, server_alloc);
-  rb_define_singleton_method(mFFI, "server_process_connections", server_process_connections, 1);
-  rb_define_singleton_method(mFFI, "server_listen_on_port", server_listen_on_port, 2);
-  rb_define_singleton_method(mFFI, "server_listen_on_socket", server_listen_on_socket, 2);
-  rb_define_singleton_method(mFFI, "server_unlisten", server_unlisten, 1);
+  rb_define_singleton_method(mFFI, "server_process_connections", server_process_connections, 0);
+  rb_define_singleton_method(mFFI, "server_listen_on_port", server_listen_on_port, 1);
+  rb_define_singleton_method(mFFI, "server_unlisten", server_unlisten, 0);
+  rb_define_singleton_method(mFFI, "server_open?", server_open, 0);
   
   cClient = rb_define_class_under(mEbb, "Client", rb_cObject);
   rb_define_singleton_method(mFFI, "client_read_input", client_read_input, 2);
   rb_define_singleton_method(mFFI, "client_write_status", client_write_status, 3);
   rb_define_singleton_method(mFFI, "client_write_header", client_write_header, 3);
   rb_define_singleton_method(mFFI, "client_write", client_write, 2);
-  rb_define_singleton_method(mFFI, "client_finished", client_finished, 1);
+  rb_define_singleton_method(mFFI, "client_begin_transmission", client_begin_transmission, 1);
+  rb_define_singleton_method(mFFI, "client_set_body_written", client_set_body_written, 2);
   rb_define_singleton_method(mFFI, "client_env", client_env, 1);
+  rb_define_singleton_method(mFFI, "client_release", client_release, 1);
+  
+  /* initialize ebb_server */
+  loop = ev_default_loop (0);
+  
+  ev_idle_init (&idle_watcher, idle_cb);
+  attach_idle_watcher();
+  
+  server = ebb_server_alloc();
+  VALUE waiting_clients = rb_ary_new();
+  rb_iv_set(mFFI, "@waiting_clients", waiting_clients);
+  ebb_server_init(server, loop, request_cb, (void*)waiting_clients);
 }

data/src/parser.c

@@ -24,7 +24,7 @@
 
 #line 26 "src/parser.c"
 static const int http_parser_start = 1;
-static const int http_parser_first_final = 82;
+static const int http_parser_first_final = 73;
 static const int http_parser_error = 0;
 
 static const int http_parser_en_main = 1;
@@ -108,17 +108,17 @@ case 2:
 #line 109 "src/parser.c"
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st63;
-		case 95: goto st63;
+		case 36: goto st54;
+		case 95: goto st54;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st63;
+			goto st54;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st63;
+			goto st54;
 	} else
-		goto st63;
+		goto st54;
 	goto st0;
 tr2:
 #line 50 "src/parser.rl"
@@ -172,7 +172,7 @@ tr8:
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr58:
+tr50:
 #line 22 "src/parser.rl"
 	{MARK(mark, p); }
 #line 88 "src/parser.rl"
@@ -186,7 +186,7 @@ tr58:
       parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr61:
+tr53:
 #line 88 "src/parser.rl"
 	{
     /* Don't know if this length is specified somewhere or not */
@@ -198,7 +198,7 @@ tr61:
       parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr69:
+tr61:
 #line 79 "src/parser.rl"
 	{
     if(LEN(mark, p) > 1024) {
@@ -218,7 +218,7 @@ tr69:
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr80:
+tr72:
 #line 64 "src/parser.rl"
 	{MARK(query_start, p); }
 #line 65 "src/parser.rl"
@@ -240,7 +240,7 @@ tr80:
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr84:
+tr76:
 #line 65 "src/parser.rl"
 	{ 
     if(LEN(query_start, p) > 10 * 1024) {
@@ -434,18 +434,18 @@ tr23:
 	{
     if(parser->nread > 1024 * (80 + 32)) {
       parser->overflow_error = TRUE;
-      {p++; cs = 82; goto _out;}
+      {p++; cs = 73; goto _out;}
     }
     parser->body_start = p - buffer + 1; 
     if(parser->header_done != NULL)
       parser->header_done(parser->data, p + 1, pe - p - 1);
-    {p++; cs = 82; goto _out;}
+    {p++; cs = 73; goto _out;}
   }
-	goto st82;
-st82:
+	goto st73;
+st73:
 	if ( ++p == pe )
-		goto _test_eof82;
-case 82:
+		goto _test_eof73;
+case 73:
 #line 450 "src/parser.c"
 	goto st0;
 tr21:
@@ -977,104 +977,25 @@ case 35:
 	if ( (*p) == 13 )
 		goto tr47;
 	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st36;
-	goto st19;
-st36:
-	if ( ++p == pe )
-		goto _test_eof36;
-case 36:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st37;
-	goto st19;
-st37:
-	if ( ++p == pe )
-		goto _test_eof37;
-case 37:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st38;
-	goto st19;
-st38:
-	if ( ++p == pe )
-		goto _test_eof38;
-case 38:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st39;
-	goto st19;
-st39:
-	if ( ++p == pe )
-		goto _test_eof39;
-case 39:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st40;
-	goto st19;
-st40:
-	if ( ++p == pe )
-		goto _test_eof40;
-case 40:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st41;
-	goto st19;
-st41:
-	if ( ++p == pe )
-		goto _test_eof41;
-case 41:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st42;
-	goto st19;
-st42:
-	if ( ++p == pe )
-		goto _test_eof42;
-case 42:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st43;
-	goto st19;
-st43:
-	if ( ++p == pe )
-		goto _test_eof43;
-case 43:
-	if ( (*p) == 13 )
-		goto tr47;
-	if ( 48 <= (*p) && (*p) <= 57 )
-		goto st44;
-	goto st19;
-st44:
-	if ( ++p == pe )
-		goto _test_eof44;
-case 44:
-	if ( (*p) == 13 )
-		goto tr47;
+		goto st35;
 	goto st19;
 tr9:
 #line 55 "src/parser.rl"
 	{
     if(LEN(mark, p) > 12 * 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
-	goto st45;
-tr70:
+	goto st36;
+tr62:
 #line 79 "src/parser.rl"
 	{
     if(LEN(mark, p) > 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
@@ -1083,20 +1004,20 @@ tr70:
 	{
     if(LEN(mark, p) > 12 * 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
-	goto st45;
-tr81:
+	goto st36;
+tr73:
 #line 64 "src/parser.rl"
 	{MARK(query_start, p); }
 #line 65 "src/parser.rl"
 	{ 
     if(LEN(query_start, p) > 10 * 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->query_string != NULL)
       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
@@ -1105,18 +1026,18 @@ tr81:
 	{
     if(LEN(mark, p) > 12 * 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
-	goto st45;
-tr85:
+	goto st36;
+tr77:
 #line 65 "src/parser.rl"
 	{ 
     if(LEN(query_start, p) > 10 * 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->query_string != NULL)
       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
@@ -1125,20 +1046,20 @@ tr85:
 	{
     if(LEN(mark, p) > 12 * 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 45; goto _out;}
+      {p++; cs = 36; goto _out;}
     }
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
-	goto st45;
-st45:
+	goto st36;
+st36:
 	if ( ++p == pe )
-		goto _test_eof45;
-case 45:
-#line 1139 "src/parser.c"
+		goto _test_eof36;
+case 36:
+#line 1060 "src/parser.c"
 	switch( (*p) ) {
-		case 32: goto tr58;
-		case 37: goto tr59;
+		case 32: goto tr50;
+		case 37: goto tr51;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
@@ -1148,19 +1069,19 @@ case 45:
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
-	goto tr57;
-tr57:
+	goto tr49;
+tr49:
 #line 22 "src/parser.rl"
 	{MARK(mark, p); }
-	goto st46;
-st46:
+	goto st37;
+st37:
 	if ( ++p == pe )
-		goto _test_eof46;
-case 46:
-#line 1161 "src/parser.c"
+		goto _test_eof37;
+case 37:
+#line 1082 "src/parser.c"
 	switch( (*p) ) {
-		case 32: goto tr61;
-		case 37: goto st47;
+		case 32: goto tr53;
+		case 37: goto st38;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
@@ -1170,622 +1091,622 @@ case 46:
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
-	goto st46;
-tr59:
+	goto st37;
+tr51:
 #line 22 "src/parser.rl"
 	{MARK(mark, p); }
-	goto st47;
-st47:
+	goto st38;
+st38:
 	if ( ++p == pe )
-		goto _test_eof47;
-case 47:
-#line 1183 "src/parser.c"
+		goto _test_eof38;
+case 38:
+#line 1104 "src/parser.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st48;
+			goto st39;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st48;
+			goto st39;
 	} else
-		goto st48;
+		goto st39;
 	goto st0;
-st48:
+st39:
 	if ( ++p == pe )
-		goto _test_eof48;
-case 48:
+		goto _test_eof39;
+case 39:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st46;
+			goto st37;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st46;
+			goto st37;
 	} else
-		goto st46;
+		goto st37;
 	goto st0;
 tr5:
 #line 22 "src/parser.rl"
 	{MARK(mark, p); }
-	goto st49;
-st49:
+	goto st40;
+st40:
 	if ( ++p == pe )
-		goto _test_eof49;
-case 49:
-#line 1214 "src/parser.c"
+		goto _test_eof40;
+case 40:
+#line 1135 "src/parser.c"
 	switch( (*p) ) {
-		case 43: goto st49;
-		case 58: goto st50;
+		case 43: goto st40;
+		case 58: goto st41;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st49;
+			goto st40;
 	} else if ( (*p) > 57 ) {
 		if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto st49;
+				goto st40;
 		} else if ( (*p) >= 65 )
-			goto st49;
+			goto st40;
 	} else
-		goto st49;
+		goto st40;
 	goto st0;
 tr7:
 #line 22 "src/parser.rl"
 	{MARK(mark, p); }
-	goto st50;
-st50:
+	goto st41;
+st41:
 	if ( ++p == pe )
-		goto _test_eof50;
-case 50:
-#line 1239 "src/parser.c"
+		goto _test_eof41;
+case 41:
+#line 1160 "src/parser.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 34: goto st0;
 		case 35: goto tr9;
-		case 37: goto st51;
+		case 37: goto st42;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto st50;
-st51:
+	goto st41;
+st42:
 	if ( ++p == pe )
-		goto _test_eof51;
-case 51:
+		goto _test_eof42;
+case 42:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st52;
+			goto st43;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st52;
+			goto st43;
 	} else
-		goto st52;
+		goto st43;
 	goto st0;
-st52:
+st43:
 	if ( ++p == pe )
-		goto _test_eof52;
-case 52:
+		goto _test_eof43;
+case 43:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st50;
+			goto st41;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st50;
+			goto st41;
 	} else
-		goto st50;
+		goto st41;
 	goto st0;
 tr6:
 #line 22 "src/parser.rl"
 	{MARK(mark, p); }
-	goto st53;
-st53:
+	goto st44;
+st44:
 	if ( ++p == pe )
-		goto _test_eof53;
-case 53:
-#line 1286 "src/parser.c"
+		goto _test_eof44;
+case 44:
+#line 1207 "src/parser.c"
 	switch( (*p) ) {
-		case 32: goto tr69;
+		case 32: goto tr61;
 		case 34: goto st0;
-		case 35: goto tr70;
-		case 37: goto st54;
-		case 59: goto tr72;
+		case 35: goto tr62;
+		case 37: goto st45;
+		case 59: goto tr64;
 		case 60: goto st0;
 		case 62: goto st0;
-		case 63: goto tr73;
+		case 63: goto tr65;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto st53;
-st54:
+	goto st44;
+st45:
 	if ( ++p == pe )
-		goto _test_eof54;
-case 54:
+		goto _test_eof45;
+case 45:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st55;
+			goto st46;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st55;
+			goto st46;
 	} else
-		goto st55;
+		goto st46;
 	goto st0;
-st55:
+st46:
 	if ( ++p == pe )
-		goto _test_eof55;
-case 55:
+		goto _test_eof46;
+case 46:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st53;
+			goto st44;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st53;
+			goto st44;
 	} else
-		goto st53;
+		goto st44;
 	goto st0;
-tr72:
+tr64:
 #line 79 "src/parser.rl"
 	{
     if(LEN(mark, p) > 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 56; goto _out;}
+      {p++; cs = 47; goto _out;}
     }
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
   }
-	goto st56;
-st56:
+	goto st47;
+st47:
 	if ( ++p == pe )
-		goto _test_eof56;
-case 56:
-#line 1342 "src/parser.c"
+		goto _test_eof47;
+case 47:
+#line 1263 "src/parser.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 34: goto st0;
 		case 35: goto tr9;
-		case 37: goto st57;
+		case 37: goto st48;
 		case 60: goto st0;
 		case 62: goto st0;
-		case 63: goto st59;
+		case 63: goto st50;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto st56;
-st57:
+	goto st47;
+st48:
 	if ( ++p == pe )
-		goto _test_eof57;
-case 57:
+		goto _test_eof48;
+case 48:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st58;
+			goto st49;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st58;
+			goto st49;
 	} else
-		goto st58;
+		goto st49;
 	goto st0;
-st58:
+st49:
 	if ( ++p == pe )
-		goto _test_eof58;
-case 58:
+		goto _test_eof49;
+case 49:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st56;
+			goto st47;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st56;
+			goto st47;
 	} else
-		goto st56;
+		goto st47;
 	goto st0;
-tr73:
+tr65:
 #line 79 "src/parser.rl"
 	{
     if(LEN(mark, p) > 1024) {
       parser->overflow_error = TRUE;
-      {p++; cs = 59; goto _out;}
+      {p++; cs = 50; goto _out;}
     }
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
   }
-	goto st59;
-st59:
+	goto st50;
+st50:
 	if ( ++p == pe )
-		goto _test_eof59;
-case 59:
-#line 1397 "src/parser.c"
+		goto _test_eof50;
+case 50:
+#line 1318 "src/parser.c"
 	switch( (*p) ) {
-		case 32: goto tr80;
+		case 32: goto tr72;
 		case 34: goto st0;
-		case 35: goto tr81;
-		case 37: goto tr82;
+		case 35: goto tr73;
+		case 37: goto tr74;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr79;
-tr79:
+	goto tr71;
+tr71:
 #line 64 "src/parser.rl"
 	{MARK(query_start, p); }
-	goto st60;
-st60:
+	goto st51;
+st51:
 	if ( ++p == pe )
-		goto _test_eof60;
-case 60:
-#line 1418 "src/parser.c"
+		goto _test_eof51;
+case 51:
+#line 1339 "src/parser.c"
 	switch( (*p) ) {
-		case 32: goto tr84;
+		case 32: goto tr76;
 		case 34: goto st0;
-		case 35: goto tr85;
-		case 37: goto st61;
+		case 35: goto tr77;
+		case 37: goto st52;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto st60;
-tr82:
+	goto st51;
+tr74:
 #line 64 "src/parser.rl"
 	{MARK(query_start, p); }
-	goto st61;
-st61:
+	goto st52;
+st52:
 	if ( ++p == pe )
-		goto _test_eof61;
-case 61:
-#line 1439 "src/parser.c"
+		goto _test_eof52;
+case 52:
+#line 1360 "src/parser.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st62;
+			goto st53;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st62;
+			goto st53;
 	} else
-		goto st62;
+		goto st53;
 	goto st0;
-st62:
+st53:
 	if ( ++p == pe )
-		goto _test_eof62;
-case 62:
+		goto _test_eof53;
+case 53:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto st60;
+			goto st51;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto st60;
+			goto st51;
 	} else
-		goto st60;
+		goto st51;
 	goto st0;
-st63:
+st54:
 	if ( ++p == pe )
-		goto _test_eof63;
-case 63:
+		goto _test_eof54;
+case 54:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st64;
-		case 95: goto st64;
+		case 36: goto st55;
+		case 95: goto st55;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st64;
+			goto st55;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st64;
+			goto st55;
 	} else
-		goto st64;
+		goto st55;
 	goto st0;
-st64:
+st55:
 	if ( ++p == pe )
-		goto _test_eof64;
-case 64:
+		goto _test_eof55;
+case 55:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st65;
-		case 95: goto st65;
+		case 36: goto st56;
+		case 95: goto st56;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st65;
+			goto st56;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st65;
+			goto st56;
 	} else
-		goto st65;
+		goto st56;
 	goto st0;
-st65:
+st56:
 	if ( ++p == pe )
-		goto _test_eof65;
-case 65:
+		goto _test_eof56;
+case 56:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st66;
-		case 95: goto st66;
+		case 36: goto st57;
+		case 95: goto st57;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st66;
+			goto st57;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st66;
+			goto st57;
 	} else
-		goto st66;
+		goto st57;
 	goto st0;
-st66:
+st57:
 	if ( ++p == pe )
-		goto _test_eof66;
-case 66:
+		goto _test_eof57;
+case 57:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st67;
-		case 95: goto st67;
+		case 36: goto st58;
+		case 95: goto st58;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st67;
+			goto st58;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st67;
+			goto st58;
 	} else
-		goto st67;
+		goto st58;
 	goto st0;
-st67:
+st58:
 	if ( ++p == pe )
-		goto _test_eof67;
-case 67:
+		goto _test_eof58;
+case 58:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st68;
-		case 95: goto st68;
+		case 36: goto st59;
+		case 95: goto st59;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st68;
+			goto st59;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st68;
+			goto st59;
 	} else
-		goto st68;
+		goto st59;
 	goto st0;
-st68:
+st59:
 	if ( ++p == pe )
-		goto _test_eof68;
-case 68:
+		goto _test_eof59;
+case 59:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st69;
-		case 95: goto st69;
+		case 36: goto st60;
+		case 95: goto st60;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st69;
+			goto st60;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st69;
+			goto st60;
 	} else
-		goto st69;
+		goto st60;
 	goto st0;
-st69:
+st60:
 	if ( ++p == pe )
-		goto _test_eof69;
-case 69:
+		goto _test_eof60;
+case 60:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st70;
-		case 95: goto st70;
+		case 36: goto st61;
+		case 95: goto st61;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st70;
+			goto st61;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st70;
+			goto st61;
 	} else
-		goto st70;
+		goto st61;
 	goto st0;
-st70:
+st61:
 	if ( ++p == pe )
-		goto _test_eof70;
-case 70:
+		goto _test_eof61;
+case 61:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st71;
-		case 95: goto st71;
+		case 36: goto st62;
+		case 95: goto st62;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st71;
+			goto st62;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st71;
+			goto st62;
 	} else
-		goto st71;
+		goto st62;
 	goto st0;
-st71:
+st62:
 	if ( ++p == pe )
-		goto _test_eof71;
-case 71:
+		goto _test_eof62;
+case 62:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st72;
-		case 95: goto st72;
+		case 36: goto st63;
+		case 95: goto st63;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st72;
+			goto st63;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st72;
+			goto st63;
 	} else
-		goto st72;
+		goto st63;
 	goto st0;
-st72:
+st63:
 	if ( ++p == pe )
-		goto _test_eof72;
-case 72:
+		goto _test_eof63;
+case 63:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st73;
-		case 95: goto st73;
+		case 36: goto st64;
+		case 95: goto st64;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st73;
+			goto st64;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st73;
+			goto st64;
 	} else
-		goto st73;
+		goto st64;
 	goto st0;
-st73:
+st64:
 	if ( ++p == pe )
-		goto _test_eof73;
-case 73:
+		goto _test_eof64;
+case 64:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st74;
-		case 95: goto st74;
+		case 36: goto st65;
+		case 95: goto st65;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st74;
+			goto st65;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st74;
+			goto st65;
 	} else
-		goto st74;
+		goto st65;
 	goto st0;
-st74:
+st65:
 	if ( ++p == pe )
-		goto _test_eof74;
-case 74:
+		goto _test_eof65;
+case 65:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st75;
-		case 95: goto st75;
+		case 36: goto st66;
+		case 95: goto st66;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st75;
+			goto st66;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st75;
+			goto st66;
 	} else
-		goto st75;
+		goto st66;
 	goto st0;
-st75:
+st66:
 	if ( ++p == pe )
-		goto _test_eof75;
-case 75:
+		goto _test_eof66;
+case 66:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st76;
-		case 95: goto st76;
+		case 36: goto st67;
+		case 95: goto st67;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st76;
+			goto st67;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st76;
+			goto st67;
 	} else
-		goto st76;
+		goto st67;
 	goto st0;
-st76:
+st67:
 	if ( ++p == pe )
-		goto _test_eof76;
-case 76:
+		goto _test_eof67;
+case 67:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st77;
-		case 95: goto st77;
+		case 36: goto st68;
+		case 95: goto st68;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st77;
+			goto st68;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st77;
+			goto st68;
 	} else
-		goto st77;
+		goto st68;
 	goto st0;
-st77:
+st68:
 	if ( ++p == pe )
-		goto _test_eof77;
-case 77:
+		goto _test_eof68;
+case 68:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st78;
-		case 95: goto st78;
+		case 36: goto st69;
+		case 95: goto st69;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st78;
+			goto st69;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st78;
+			goto st69;
 	} else
-		goto st78;
+		goto st69;
 	goto st0;
-st78:
+st69:
 	if ( ++p == pe )
-		goto _test_eof78;
-case 78:
+		goto _test_eof69;
+case 69:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st79;
-		case 95: goto st79;
+		case 36: goto st70;
+		case 95: goto st70;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st79;
+			goto st70;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st79;
+			goto st70;
 	} else
-		goto st79;
+		goto st70;
 	goto st0;
-st79:
+st70:
 	if ( ++p == pe )
-		goto _test_eof79;
-case 79:
+		goto _test_eof70;
+case 70:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st80;
-		case 95: goto st80;
+		case 36: goto st71;
+		case 95: goto st71;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st80;
+			goto st71;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st80;
+			goto st71;
 	} else
-		goto st80;
+		goto st71;
 	goto st0;
-st80:
+st71:
 	if ( ++p == pe )
-		goto _test_eof80;
-case 80:
+		goto _test_eof71;
+case 71:
 	switch( (*p) ) {
 		case 32: goto tr2;
-		case 36: goto st81;
-		case 95: goto st81;
+		case 36: goto st72;
+		case 95: goto st72;
 	}
 	if ( (*p) < 48 ) {
 		if ( 45 <= (*p) && (*p) <= 46 )
-			goto st81;
+			goto st72;
 	} else if ( (*p) > 57 ) {
 		if ( 65 <= (*p) && (*p) <= 90 )
-			goto st81;
+			goto st72;
 	} else
-		goto st81;
+		goto st72;
 	goto st0;
-st81:
+st72:
 	if ( ++p == pe )
-		goto _test_eof81;
-case 81:
+		goto _test_eof72;
+case 72:
 	if ( (*p) == 32 )
 		goto tr2;
 	goto st0;
@@ -1805,7 +1726,7 @@ case 81:
 	_test_eof14: cs = 14; goto _test_eof; 
 	_test_eof15: cs = 15; goto _test_eof; 
 	_test_eof16: cs = 16; goto _test_eof; 
-	_test_eof82: cs = 82; goto _test_eof; 
+	_test_eof73: cs = 73; goto _test_eof; 
 	_test_eof17: cs = 17; goto _test_eof; 
 	_test_eof18: cs = 18; goto _test_eof; 
 	_test_eof19: cs = 19; goto _test_eof; 
@@ -1862,15 +1783,6 @@ case 81:
 	_test_eof70: cs = 70; goto _test_eof; 
 	_test_eof71: cs = 71; goto _test_eof; 
 	_test_eof72: cs = 72; goto _test_eof; 
-	_test_eof73: cs = 73; goto _test_eof; 
-	_test_eof74: cs = 74; goto _test_eof; 
-	_test_eof75: cs = 75; goto _test_eof; 
-	_test_eof76: cs = 76; goto _test_eof; 
-	_test_eof77: cs = 77; goto _test_eof; 
-	_test_eof78: cs = 78; goto _test_eof; 
-	_test_eof79: cs = 79; goto _test_eof; 
-	_test_eof80: cs = 80; goto _test_eof; 
-	_test_eof81: cs = 81; goto _test_eof; 
 
 	_test_eof: {}
 	_out: {}