Exchange the Mongrel parser with the Mongrel2 parser because of licensing issues
authorMichael Maier <maier@b2host.de>
Sun, 21 Nov 2010 20:09:20 +0000 (21 21:09 +0100)
committerMichael Maier <maier@b2host.de>
Sun, 21 Nov 2010 20:09:20 +0000 (21 21:09 +0100)
12 files changed:
config.m4
http11_common.h [new file with mode: 0644]
http11_parser.c [new file with mode: 0644]
http11_parser.h [new file with mode: 0644]
mistral.c
original_parser/http11_common.h [new file with mode: 0644]
original_parser/http11_parser.c [new file with mode: 0644]
original_parser/http11_parser.h [new file with mode: 0644]
original_parser/http11_parser.rl [moved from original_parser/parser.rl with 56% similarity]
original_parser/parser.h [deleted file]
parser.c [deleted file]
parser.h [deleted file]

index 6bad1a7..158d3be 100644 (file)
--- a/config.m4
+++ b/config.m4
@@ -30,5 +30,5 @@ dnl if test "$PHP_LIBEV" != "no"; then
 
        AC_DEFINE(HAVE_LIBEV,1,[Whether you have libev])
        
-       PHP_NEW_EXTENSION(mistral, mistral.c parser.c, $ext_shared)
+       PHP_NEW_EXTENSION(mistral, mistral.c http11_parser.c, $ext_shared)
 dnl fi
\ No newline at end of file
diff --git a/http11_common.h b/http11_common.h
new file mode 100644 (file)
index 0000000..6df7970
--- /dev/null
@@ -0,0 +1,9 @@
+#ifndef _http11_common_h
+#define _http11_common_h
+
+#include <sys/types.h>
+
+typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
+typedef void (*element_cb)(void *data, int type, const char *at, size_t length);
+
+#endif
diff --git a/http11_parser.c b/http11_parser.c
new file mode 100644 (file)
index 0000000..870dda4
--- /dev/null
@@ -0,0 +1,1300 @@
+
+#line 1 "http11_parser.rl"
+/**
+ *
+ * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ * 
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ *     * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names
+ *       of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "http11_parser.h"
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#define LEN(AT, FPC) (FPC - buffer - parser->AT)
+#define MARK(M,FPC) (parser->M = (FPC) - buffer)
+#define PTR_TO(F) (buffer + parser->F)
+
+/** Machine **/
+
+
+#line 165 "http11_parser.rl"
+
+
+/** Data **/
+
+#line 57 "http11_parser.c"
+static const int http_parser_start = 1;
+static const int http_parser_first_final = 60;
+static const int http_parser_error = 0;
+
+static const int http_parser_en_main = 1;
+
+
+#line 169 "http11_parser.rl"
+
+static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length)
+{
+  int len = (int)(end-begin);
+  if(len > max_length) {
+    return(0);
+  }
+  if(parser->on_element)
+    parser->on_element(parser->data, type, begin, len);
+  return(1);
+}
+
+
+
+int http_parser_init(http_parser *parser) {
+  int cs = 0;
+  
+#line 83 "http11_parser.c"
+       {
+       cs = http_parser_start;
+       }
+
+#line 186 "http11_parser.rl"
+  parser->cs = cs;
+  parser->body_start = 0;
+  parser->content_len = 0;
+  parser->mark = 0;
+  parser->nread = 0;
+  parser->field_len = 0;
+  parser->field_start = 0;
+
+  return(1);
+}
+
+/** exec **/
+size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  
+{
+  if(len == 0) return 0;
+
+  const char *p, *pe;
+  int cs = parser->cs;
+
+  assert(off <= len && "offset past end of buffer");
+
+  p = buffer+off;
+  pe = buffer+len;
+
+  assert(pe - p == (int)len - (int)off && "pointers aren't same distance");
+
+  
+#line 116 "http11_parser.c"
+       {
+       if ( p == pe )
+               goto _test_eof;
+       switch ( cs )
+       {
+case 1:
+       switch( (*p) ) {
+               case 36: goto tr0;
+               case 95: goto tr0;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto tr0;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto tr0;
+       } else
+               goto tr0;
+       goto st0;
+st0:
+cs = 0;
+       goto _out;
+tr0:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st2;
+st2:
+       if ( ++p == pe )
+               goto _test_eof2;
+case 2:
+#line 147 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st41;
+               case 95: goto st41;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st41;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st41;
+       } else
+               goto st41;
+       goto st0;
+tr2:
+#line 94 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_METHOD, PTR_TO(mark), p, 1024))
+      {p++; cs = 3; goto _out;}
+  }
+       goto st3;
+st3:
+       if ( ++p == pe )
+               goto _test_eof3;
+case 3:
+#line 173 "http11_parser.c"
+       switch( (*p) ) {
+               case 42: goto tr4;
+               case 47: goto tr5;
+               case 104: goto tr6;
+       }
+       goto st0;
+tr4:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st4;
+st4:
+       if ( ++p == pe )
+               goto _test_eof4;
+case 4:
+#line 188 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr7;
+               case 35: goto tr8;
+       }
+       goto st0;
+tr7:
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr33:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+#line 79 "http11_parser.rl"
+       {
+    if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr36:
+#line 79 "http11_parser.rl"
+       {
+    if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr40:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 5; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr51:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr55:
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+st5:
+       if ( ++p == pe )
+               goto _test_eof5;
+case 5:
+#line 259 "http11_parser.c"
+       if ( (*p) == 72 )
+               goto tr9;
+       goto st0;
+tr9:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st6;
+st6:
+       if ( ++p == pe )
+               goto _test_eof6;
+case 6:
+#line 271 "http11_parser.c"
+       if ( (*p) == 84 )
+               goto st7;
+       goto st0;
+st7:
+       if ( ++p == pe )
+               goto _test_eof7;
+case 7:
+       if ( (*p) == 84 )
+               goto st8;
+       goto st0;
+st8:
+       if ( ++p == pe )
+               goto _test_eof8;
+case 8:
+       if ( (*p) == 80 )
+               goto st9;
+       goto st0;
+st9:
+       if ( ++p == pe )
+               goto _test_eof9;
+case 9:
+       if ( (*p) == 47 )
+               goto st10;
+       goto st0;
+st10:
+       if ( ++p == pe )
+               goto _test_eof10;
+case 10:
+       if ( (*p) == 49 )
+               goto st11;
+       goto st0;
+st11:
+       if ( ++p == pe )
+               goto _test_eof11;
+case 11:
+       if ( (*p) == 46 )
+               goto st12;
+       goto st0;
+st12:
+       if ( ++p == pe )
+               goto _test_eof12;
+case 12:
+       if ( 48 <= (*p) && (*p) <= 49 )
+               goto st13;
+       goto st0;
+st13:
+       if ( ++p == pe )
+               goto _test_eof13;
+case 13:
+       switch( (*p) ) {
+               case 10: goto tr17;
+               case 13: goto tr18;
+       }
+       goto st0;
+tr17:
+#line 84 "http11_parser.rl"
+       {
+    if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10))
+      {p++; cs = 14; goto _out;}
+  }
+       goto st14;
+tr25:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st14;
+tr29:
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st14;
+st14:
+       if ( ++p == pe )
+               goto _test_eof14;
+case 14:
+#line 355 "http11_parser.c"
+       switch( (*p) ) {
+               case 10: goto tr19;
+               case 13: goto st15;
+               case 33: goto tr21;
+               case 124: goto tr21;
+               case 126: goto tr21;
+       }
+       if ( (*p) < 45 ) {
+               if ( (*p) > 39 ) {
+                       if ( 42 <= (*p) && (*p) <= 43 )
+                               goto tr21;
+               } else if ( (*p) >= 35 )
+                       goto tr21;
+       } else if ( (*p) > 46 ) {
+               if ( (*p) < 65 ) {
+                       if ( 48 <= (*p) && (*p) <= 57 )
+                               goto tr21;
+               } else if ( (*p) > 90 ) {
+                       if ( 94 <= (*p) && (*p) <= 122 )
+                               goto tr21;
+               } else
+                       goto tr21;
+       } else
+               goto tr21;
+       goto st0;
+tr19:
+#line 111 "http11_parser.rl"
+       {
+    parser->body_start = p - buffer + 1;    
+    {p++; cs = 60; goto _out;}
+  }
+       goto st60;
+st60:
+       if ( ++p == pe )
+               goto _test_eof60;
+case 60:
+#line 392 "http11_parser.c"
+       goto st0;
+st15:
+       if ( ++p == pe )
+               goto _test_eof15;
+case 15:
+       if ( (*p) == 10 )
+               goto tr19;
+       goto st0;
+tr21:
+#line 55 "http11_parser.rl"
+       { MARK(field_start, p); }
+       goto st16;
+st16:
+       if ( ++p == pe )
+               goto _test_eof16;
+case 16:
+#line 409 "http11_parser.c"
+       switch( (*p) ) {
+               case 33: goto st16;
+               case 58: goto tr23;
+               case 124: goto st16;
+               case 126: goto st16;
+       }
+       if ( (*p) < 45 ) {
+               if ( (*p) > 39 ) {
+                       if ( 42 <= (*p) && (*p) <= 43 )
+                               goto st16;
+               } else if ( (*p) >= 35 )
+                       goto st16;
+       } else if ( (*p) > 46 ) {
+               if ( (*p) < 65 ) {
+                       if ( 48 <= (*p) && (*p) <= 57 )
+                               goto st16;
+               } else if ( (*p) > 90 ) {
+                       if ( 94 <= (*p) && (*p) <= 122 )
+                               goto st16;
+               } else
+                       goto st16;
+       } else
+               goto st16;
+       goto st0;
+tr23:
+#line 56 "http11_parser.rl"
+       { 
+    parser->field_len = LEN(field_start, p);
+  }
+       goto st17;
+tr27:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+       goto st17;
+st17:
+       if ( ++p == pe )
+               goto _test_eof17;
+case 17:
+#line 448 "http11_parser.c"
+       switch( (*p) ) {
+               case 10: goto tr25;
+               case 13: goto tr26;
+               case 32: goto tr27;
+       }
+       goto tr24;
+tr24:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+       goto st18;
+st18:
+       if ( ++p == pe )
+               goto _test_eof18;
+case 18:
+#line 463 "http11_parser.c"
+       switch( (*p) ) {
+               case 10: goto tr29;
+               case 13: goto tr30;
+       }
+       goto st18;
+tr18:
+#line 84 "http11_parser.rl"
+       {
+    if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10))
+      {p++; cs = 19; goto _out;}
+  }
+       goto st19;
+tr26:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st19;
+tr30:
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st19;
+st19:
+       if ( ++p == pe )
+               goto _test_eof19;
+case 19:
+#line 498 "http11_parser.c"
+       if ( (*p) == 10 )
+               goto st14;
+       goto st0;
+tr8:
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+tr41:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 20; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+tr52:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 20; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+tr56:
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 20; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+st20:
+       if ( ++p == pe )
+               goto _test_eof20;
+case 20:
+#line 551 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr33;
+               case 37: goto tr34;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( (*p) > 31 ) {
+               if ( 34 <= (*p) && (*p) <= 35 )
+                       goto st0;
+       } else if ( (*p) >= 0 )
+               goto st0;
+       goto tr32;
+tr32:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st21;
+st21:
+       if ( ++p == pe )
+               goto _test_eof21;
+case 21:
+#line 573 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr36;
+               case 37: goto st22;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( (*p) > 31 ) {
+               if ( 34 <= (*p) && (*p) <= 35 )
+                       goto st0;
+       } else if ( (*p) >= 0 )
+               goto st0;
+       goto st21;
+tr34:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st22;
+st22:
+       if ( ++p == pe )
+               goto _test_eof22;
+case 22:
+#line 595 "http11_parser.c"
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st23;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st23;
+       } else
+               goto st23;
+       goto st0;
+st23:
+       if ( ++p == pe )
+               goto _test_eof23;
+case 23:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st21;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st21;
+       } else
+               goto st21;
+       goto st0;
+tr5:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st24;
+st24:
+       if ( ++p == pe )
+               goto _test_eof24;
+case 24:
+#line 626 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr40;
+               case 34: goto st0;
+               case 35: goto tr41;
+               case 37: goto st25;
+               case 59: goto tr43;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 63: goto tr44;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st24;
+st25:
+       if ( ++p == pe )
+               goto _test_eof25;
+case 25:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st26;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st26;
+       } else
+               goto st26;
+       goto st0;
+st26:
+       if ( ++p == pe )
+               goto _test_eof26;
+case 26:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st24;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st24;
+       } else
+               goto st24;
+       goto st0;
+tr43:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 27; goto _out;}
+  }
+       goto st27;
+st27:
+       if ( ++p == pe )
+               goto _test_eof27;
+case 27:
+#line 678 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr7;
+               case 34: goto st0;
+               case 35: goto tr8;
+               case 37: goto st28;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 63: goto st30;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st27;
+st28:
+       if ( ++p == pe )
+               goto _test_eof28;
+case 28:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st29;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st29;
+       } else
+               goto st29;
+       goto st0;
+st29:
+       if ( ++p == pe )
+               goto _test_eof29;
+case 29:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st27;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st27;
+       } else
+               goto st27;
+       goto st0;
+tr44:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 30; goto _out;}
+  }
+       goto st30;
+st30:
+       if ( ++p == pe )
+               goto _test_eof30;
+case 30:
+#line 729 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr51;
+               case 34: goto st0;
+               case 35: goto tr52;
+               case 37: goto tr53;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto tr50;
+tr50:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+       goto st31;
+st31:
+       if ( ++p == pe )
+               goto _test_eof31;
+case 31:
+#line 750 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr55;
+               case 34: goto st0;
+               case 35: goto tr56;
+               case 37: goto st32;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st31;
+tr53:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+       goto st32;
+st32:
+       if ( ++p == pe )
+               goto _test_eof32;
+case 32:
+#line 771 "http11_parser.c"
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st33;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st33;
+       } else
+               goto st33;
+       goto st0;
+st33:
+       if ( ++p == pe )
+               goto _test_eof33;
+case 33:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st31;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st31;
+       } else
+               goto st31;
+       goto st0;
+tr6:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st34;
+st34:
+       if ( ++p == pe )
+               goto _test_eof34;
+case 34:
+#line 802 "http11_parser.c"
+       if ( (*p) == 116 )
+               goto st35;
+       goto st0;
+st35:
+       if ( ++p == pe )
+               goto _test_eof35;
+case 35:
+       if ( (*p) == 116 )
+               goto st36;
+       goto st0;
+st36:
+       if ( ++p == pe )
+               goto _test_eof36;
+case 36:
+       if ( (*p) == 112 )
+               goto st37;
+       goto st0;
+st37:
+       if ( ++p == pe )
+               goto _test_eof37;
+case 37:
+       if ( (*p) == 58 )
+               goto st38;
+       goto st0;
+st38:
+       if ( ++p == pe )
+               goto _test_eof38;
+case 38:
+       switch( (*p) ) {
+               case 32: goto tr7;
+               case 34: goto st0;
+               case 35: goto tr8;
+               case 37: goto st39;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st38;
+st39:
+       if ( ++p == pe )
+               goto _test_eof39;
+case 39:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st40;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st40;
+       } else
+               goto st40;
+       goto st0;
+st40:
+       if ( ++p == pe )
+               goto _test_eof40;
+case 40:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st38;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st38;
+       } else
+               goto st38;
+       goto st0;
+st41:
+       if ( ++p == pe )
+               goto _test_eof41;
+case 41:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st42;
+               case 95: goto st42;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st42;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st42;
+       } else
+               goto st42;
+       goto st0;
+st42:
+       if ( ++p == pe )
+               goto _test_eof42;
+case 42:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st43;
+               case 95: goto st43;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st43;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st43;
+       } else
+               goto st43;
+       goto st0;
+st43:
+       if ( ++p == pe )
+               goto _test_eof43;
+case 43:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st44;
+               case 95: goto st44;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st44;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st44;
+       } else
+               goto st44;
+       goto st0;
+st44:
+       if ( ++p == pe )
+               goto _test_eof44;
+case 44:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st45;
+               case 95: goto st45;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st45;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st45;
+       } else
+               goto st45;
+       goto st0;
+st45:
+       if ( ++p == pe )
+               goto _test_eof45;
+case 45:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st46;
+               case 95: goto st46;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st46;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st46;
+       } else
+               goto st46;
+       goto st0;
+st46:
+       if ( ++p == pe )
+               goto _test_eof46;
+case 46:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st47;
+               case 95: goto st47;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st47;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st47;
+       } else
+               goto st47;
+       goto st0;
+st47:
+       if ( ++p == pe )
+               goto _test_eof47;
+case 47:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st48;
+               case 95: goto st48;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st48;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st48;
+       } else
+               goto st48;
+       goto st0;
+st48:
+       if ( ++p == pe )
+               goto _test_eof48;
+case 48:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st49;
+               case 95: goto st49;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st49;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st49;
+       } else
+               goto st49;
+       goto st0;
+st49:
+       if ( ++p == pe )
+               goto _test_eof49;
+case 49:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st50;
+               case 95: goto st50;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st50;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st50;
+       } else
+               goto st50;
+       goto st0;
+st50:
+       if ( ++p == pe )
+               goto _test_eof50;
+case 50:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st51;
+               case 95: goto st51;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st51;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st51;
+       } else
+               goto st51;
+       goto st0;
+st51:
+       if ( ++p == pe )
+               goto _test_eof51;
+case 51:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st52;
+               case 95: goto st52;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st52;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st52;
+       } else
+               goto st52;
+       goto st0;
+st52:
+       if ( ++p == pe )
+               goto _test_eof52;
+case 52:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st53;
+               case 95: goto st53;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st53;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st53;
+       } else
+               goto st53;
+       goto st0;
+st53:
+       if ( ++p == pe )
+               goto _test_eof53;
+case 53:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st54;
+               case 95: goto st54;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st54;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st54;
+       } else
+               goto st54;
+       goto st0;
+st54:
+       if ( ++p == pe )
+               goto _test_eof54;
+case 54:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st55;
+               case 95: goto st55;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st55;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st55;
+       } else
+               goto st55;
+       goto st0;
+st55:
+       if ( ++p == pe )
+               goto _test_eof55;
+case 55:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st56;
+               case 95: goto st56;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st56;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st56;
+       } else
+               goto st56;
+       goto st0;
+st56:
+       if ( ++p == pe )
+               goto _test_eof56;
+case 56:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st57;
+               case 95: goto st57;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st57;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st57;
+       } else
+               goto st57;
+       goto st0;
+st57:
+       if ( ++p == pe )
+               goto _test_eof57;
+case 57:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st58;
+               case 95: goto st58;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st58;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st58;
+       } else
+               goto st58;
+       goto st0;
+st58:
+       if ( ++p == pe )
+               goto _test_eof58;
+case 58:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st59;
+               case 95: goto st59;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st59;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st59;
+       } else
+               goto st59;
+       goto st0;
+st59:
+       if ( ++p == pe )
+               goto _test_eof59;
+case 59:
+       if ( (*p) == 32 )
+               goto tr2;
+       goto st0;
+       }
+       _test_eof2: cs = 2; goto _test_eof; 
+       _test_eof3: cs = 3; goto _test_eof; 
+       _test_eof4: cs = 4; goto _test_eof; 
+       _test_eof5: cs = 5; goto _test_eof; 
+       _test_eof6: cs = 6; goto _test_eof; 
+       _test_eof7: cs = 7; goto _test_eof; 
+       _test_eof8: cs = 8; goto _test_eof; 
+       _test_eof9: cs = 9; goto _test_eof; 
+       _test_eof10: cs = 10; goto _test_eof; 
+       _test_eof11: cs = 11; goto _test_eof; 
+       _test_eof12: cs = 12; goto _test_eof; 
+       _test_eof13: cs = 13; goto _test_eof; 
+       _test_eof14: cs = 14; goto _test_eof; 
+       _test_eof60: cs = 60; goto _test_eof; 
+       _test_eof15: cs = 15; goto _test_eof; 
+       _test_eof16: cs = 16; goto _test_eof; 
+       _test_eof17: cs = 17; goto _test_eof; 
+       _test_eof18: cs = 18; goto _test_eof; 
+       _test_eof19: cs = 19; goto _test_eof; 
+       _test_eof20: cs = 20; goto _test_eof; 
+       _test_eof21: cs = 21; goto _test_eof; 
+       _test_eof22: cs = 22; goto _test_eof; 
+       _test_eof23: cs = 23; goto _test_eof; 
+       _test_eof24: cs = 24; goto _test_eof; 
+       _test_eof25: cs = 25; goto _test_eof; 
+       _test_eof26: cs = 26; goto _test_eof; 
+       _test_eof27: cs = 27; goto _test_eof; 
+       _test_eof28: cs = 28; goto _test_eof; 
+       _test_eof29: cs = 29; goto _test_eof; 
+       _test_eof30: cs = 30; goto _test_eof; 
+       _test_eof31: cs = 31; goto _test_eof; 
+       _test_eof32: cs = 32; goto _test_eof; 
+       _test_eof33: cs = 33; goto _test_eof; 
+       _test_eof34: cs = 34; goto _test_eof; 
+       _test_eof35: cs = 35; goto _test_eof; 
+       _test_eof36: cs = 36; goto _test_eof; 
+       _test_eof37: cs = 37; goto _test_eof; 
+       _test_eof38: cs = 38; goto _test_eof; 
+       _test_eof39: cs = 39; goto _test_eof; 
+       _test_eof40: cs = 40; goto _test_eof; 
+       _test_eof41: cs = 41; goto _test_eof; 
+       _test_eof42: cs = 42; goto _test_eof; 
+       _test_eof43: cs = 43; goto _test_eof; 
+       _test_eof44: cs = 44; goto _test_eof; 
+       _test_eof45: cs = 45; goto _test_eof; 
+       _test_eof46: cs = 46; goto _test_eof; 
+       _test_eof47: cs = 47; goto _test_eof; 
+       _test_eof48: cs = 48; goto _test_eof; 
+       _test_eof49: cs = 49; goto _test_eof; 
+       _test_eof50: cs = 50; goto _test_eof; 
+       _test_eof51: cs = 51; goto _test_eof; 
+       _test_eof52: cs = 52; goto _test_eof; 
+       _test_eof53: cs = 53; goto _test_eof; 
+       _test_eof54: cs = 54; goto _test_eof; 
+       _test_eof55: cs = 55; goto _test_eof; 
+       _test_eof56: cs = 56; goto _test_eof; 
+       _test_eof57: cs = 57; goto _test_eof; 
+       _test_eof58: cs = 58; goto _test_eof; 
+       _test_eof59: cs = 59; goto _test_eof; 
+
+       _test_eof: {}
+       _out: {}
+       }
+
+#line 213 "http11_parser.rl"
+
+  assert(p <= pe && "Buffer overflow after parsing.");
+
+  if (!http_parser_has_error(parser)) {
+      parser->cs = cs;
+  }
+
+  parser->nread += p - (buffer + off);
+
+  assert(parser->nread <= len && "nread longer than length");
+  assert(parser->body_start <= len && "body starts after buffer end");
+  assert(parser->mark < len && "mark is after buffer end");
+  assert(parser->field_len <= len && "field has length longer than whole buffer");
+  assert(parser->field_start < len && "field starts after buffer end");
+
+  return(parser->nread);
+}
+
+int http_parser_finish(http_parser *parser)
+{
+  if (http_parser_has_error(parser) ) {
+    return -1;
+  } else if (http_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int http_parser_has_error(http_parser *parser) {
+  return parser->cs == http_parser_error;
+}
+
+int http_parser_is_finished(http_parser *parser) {
+  return parser->cs >= http_parser_first_final;
+}
diff --git a/http11_parser.h b/http11_parser.h
new file mode 100644 (file)
index 0000000..c7f0ae1
--- /dev/null
@@ -0,0 +1,41 @@
+
+#ifndef http11_parser_h
+#define http11_parser_h
+
+#include "http11_common.h"
+
+enum { CONTENT_LENGTH
+     , CONTENT_TYPE
+     , FRAGMENT
+     , HTTP_VERSION
+     , QUERY_STRING
+     , REQUEST_PATH
+     , REQUEST_METHOD
+     , REQUEST_URI
+     };
+
+typedef struct http_parser { 
+  int cs;
+  size_t body_start;
+  int content_len;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+  size_t query_start;
+
+  void *data;
+
+  field_cb http_field;
+  element_cb on_element;  
+} http_parser;
+
+int http_parser_init(http_parser *parser);
+int http_parser_finish(http_parser *parser);
+size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
+int http_parser_has_error(http_parser *parser);
+int http_parser_is_finished(http_parser *parser);
+
+#define http_parser_nread(parser) (parser)->nread 
+
+#endif
index caabff0..a73cf1a 100644 (file)
--- a/mistral.c
+++ b/mistral.c
@@ -22,7 +22,7 @@
 
 #include <ev.h>
 
-#include "parser.h"
+#include "http11_parser.h"
 #include "mistral.h"
 
 /*
@@ -42,7 +42,7 @@ struct client {
        struct ev_loop *loop;
        char *rbuff;
        int rlen;
-       int done;
+    int done;
 
        int close;
 };
@@ -62,7 +62,7 @@ http_parser parser;
 
 void http_field_cb(void *data, const char *field, size_t flen, const char *value, size_t vlen) {
        zval *server_vars = (zval *)data;
-       char *fld = malloc(5 + flen + 1);
+       char *fld = malloc(sizeof(char) * (5 + flen + 1));
        char *val = strndup(value, vlen);
        size_t i;
 
@@ -85,35 +85,35 @@ void http_on_element(void *data, int type, const char *at, size_t length) {
        zval *server_vars = (zval *)data;
 
        switch( type ) {
-               case MONGREL_CONTENT_LENGTH:
+               case CONTENT_LENGTH:
                        line = "CONTENT_LENGTH";
                        break;
 
-               case MONGREL_CONTENT_TYPE:
+               case CONTENT_TYPE:
                        line = "CONTENT_TYPE";
                        break;
 
-               case MONGREL_FRAGMENT:
+               case FRAGMENT:
                        line = "FRAGMENT";
                        break;
 
-               case MONGREL_HTTP_VERSION:
+               case HTTP_VERSION:
                        line = "HTTP_VERSION";
                        break;
 
-               case MONGREL_QUERY_STRING:
+               case QUERY_STRING:
                        line = "QUERY_STRING";
                        break;
 
-               case MONGREL_REQUEST_PATH:
+               case REQUEST_PATH:
                        line = "REQUEST_PATH";
                        break;
 
-               case MONGREL_REQUEST_METHOD:
+               case REQUEST_METHOD:
                        line = "REQUEST_METHOD";
                        break;
 
-               case MONGREL_REQUEST_URI:
+               case REQUEST_URI:
                        line = "REQUEST_URI";
                        break;
 
diff --git a/original_parser/http11_common.h b/original_parser/http11_common.h
new file mode 100644 (file)
index 0000000..6df7970
--- /dev/null
@@ -0,0 +1,9 @@
+#ifndef _http11_common_h
+#define _http11_common_h
+
+#include <sys/types.h>
+
+typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
+typedef void (*element_cb)(void *data, int type, const char *at, size_t length);
+
+#endif
diff --git a/original_parser/http11_parser.c b/original_parser/http11_parser.c
new file mode 100644 (file)
index 0000000..870dda4
--- /dev/null
@@ -0,0 +1,1300 @@
+
+#line 1 "http11_parser.rl"
+/**
+ *
+ * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ * 
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ *     * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names
+ *       of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "http11_parser.h"
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#define LEN(AT, FPC) (FPC - buffer - parser->AT)
+#define MARK(M,FPC) (parser->M = (FPC) - buffer)
+#define PTR_TO(F) (buffer + parser->F)
+
+/** Machine **/
+
+
+#line 165 "http11_parser.rl"
+
+
+/** Data **/
+
+#line 57 "http11_parser.c"
+static const int http_parser_start = 1;
+static const int http_parser_first_final = 60;
+static const int http_parser_error = 0;
+
+static const int http_parser_en_main = 1;
+
+
+#line 169 "http11_parser.rl"
+
+static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length)
+{
+  int len = (int)(end-begin);
+  if(len > max_length) {
+    return(0);
+  }
+  if(parser->on_element)
+    parser->on_element(parser->data, type, begin, len);
+  return(1);
+}
+
+
+
+int http_parser_init(http_parser *parser) {
+  int cs = 0;
+  
+#line 83 "http11_parser.c"
+       {
+       cs = http_parser_start;
+       }
+
+#line 186 "http11_parser.rl"
+  parser->cs = cs;
+  parser->body_start = 0;
+  parser->content_len = 0;
+  parser->mark = 0;
+  parser->nread = 0;
+  parser->field_len = 0;
+  parser->field_start = 0;
+
+  return(1);
+}
+
+/** exec **/
+size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  
+{
+  if(len == 0) return 0;
+
+  const char *p, *pe;
+  int cs = parser->cs;
+
+  assert(off <= len && "offset past end of buffer");
+
+  p = buffer+off;
+  pe = buffer+len;
+
+  assert(pe - p == (int)len - (int)off && "pointers aren't same distance");
+
+  
+#line 116 "http11_parser.c"
+       {
+       if ( p == pe )
+               goto _test_eof;
+       switch ( cs )
+       {
+case 1:
+       switch( (*p) ) {
+               case 36: goto tr0;
+               case 95: goto tr0;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto tr0;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto tr0;
+       } else
+               goto tr0;
+       goto st0;
+st0:
+cs = 0;
+       goto _out;
+tr0:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st2;
+st2:
+       if ( ++p == pe )
+               goto _test_eof2;
+case 2:
+#line 147 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st41;
+               case 95: goto st41;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st41;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st41;
+       } else
+               goto st41;
+       goto st0;
+tr2:
+#line 94 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_METHOD, PTR_TO(mark), p, 1024))
+      {p++; cs = 3; goto _out;}
+  }
+       goto st3;
+st3:
+       if ( ++p == pe )
+               goto _test_eof3;
+case 3:
+#line 173 "http11_parser.c"
+       switch( (*p) ) {
+               case 42: goto tr4;
+               case 47: goto tr5;
+               case 104: goto tr6;
+       }
+       goto st0;
+tr4:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st4;
+st4:
+       if ( ++p == pe )
+               goto _test_eof4;
+case 4:
+#line 188 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr7;
+               case 35: goto tr8;
+       }
+       goto st0;
+tr7:
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr33:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+#line 79 "http11_parser.rl"
+       {
+    if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr36:
+#line 79 "http11_parser.rl"
+       {
+    if(!apply_element(parser, FRAGMENT, PTR_TO(mark), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr40:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 5; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr51:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+tr55:
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 5; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 5; goto _out;}
+  }
+       goto st5;
+st5:
+       if ( ++p == pe )
+               goto _test_eof5;
+case 5:
+#line 259 "http11_parser.c"
+       if ( (*p) == 72 )
+               goto tr9;
+       goto st0;
+tr9:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st6;
+st6:
+       if ( ++p == pe )
+               goto _test_eof6;
+case 6:
+#line 271 "http11_parser.c"
+       if ( (*p) == 84 )
+               goto st7;
+       goto st0;
+st7:
+       if ( ++p == pe )
+               goto _test_eof7;
+case 7:
+       if ( (*p) == 84 )
+               goto st8;
+       goto st0;
+st8:
+       if ( ++p == pe )
+               goto _test_eof8;
+case 8:
+       if ( (*p) == 80 )
+               goto st9;
+       goto st0;
+st9:
+       if ( ++p == pe )
+               goto _test_eof9;
+case 9:
+       if ( (*p) == 47 )
+               goto st10;
+       goto st0;
+st10:
+       if ( ++p == pe )
+               goto _test_eof10;
+case 10:
+       if ( (*p) == 49 )
+               goto st11;
+       goto st0;
+st11:
+       if ( ++p == pe )
+               goto _test_eof11;
+case 11:
+       if ( (*p) == 46 )
+               goto st12;
+       goto st0;
+st12:
+       if ( ++p == pe )
+               goto _test_eof12;
+case 12:
+       if ( 48 <= (*p) && (*p) <= 49 )
+               goto st13;
+       goto st0;
+st13:
+       if ( ++p == pe )
+               goto _test_eof13;
+case 13:
+       switch( (*p) ) {
+               case 10: goto tr17;
+               case 13: goto tr18;
+       }
+       goto st0;
+tr17:
+#line 84 "http11_parser.rl"
+       {
+    if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10))
+      {p++; cs = 14; goto _out;}
+  }
+       goto st14;
+tr25:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st14;
+tr29:
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st14;
+st14:
+       if ( ++p == pe )
+               goto _test_eof14;
+case 14:
+#line 355 "http11_parser.c"
+       switch( (*p) ) {
+               case 10: goto tr19;
+               case 13: goto st15;
+               case 33: goto tr21;
+               case 124: goto tr21;
+               case 126: goto tr21;
+       }
+       if ( (*p) < 45 ) {
+               if ( (*p) > 39 ) {
+                       if ( 42 <= (*p) && (*p) <= 43 )
+                               goto tr21;
+               } else if ( (*p) >= 35 )
+                       goto tr21;
+       } else if ( (*p) > 46 ) {
+               if ( (*p) < 65 ) {
+                       if ( 48 <= (*p) && (*p) <= 57 )
+                               goto tr21;
+               } else if ( (*p) > 90 ) {
+                       if ( 94 <= (*p) && (*p) <= 122 )
+                               goto tr21;
+               } else
+                       goto tr21;
+       } else
+               goto tr21;
+       goto st0;
+tr19:
+#line 111 "http11_parser.rl"
+       {
+    parser->body_start = p - buffer + 1;    
+    {p++; cs = 60; goto _out;}
+  }
+       goto st60;
+st60:
+       if ( ++p == pe )
+               goto _test_eof60;
+case 60:
+#line 392 "http11_parser.c"
+       goto st0;
+st15:
+       if ( ++p == pe )
+               goto _test_eof15;
+case 15:
+       if ( (*p) == 10 )
+               goto tr19;
+       goto st0;
+tr21:
+#line 55 "http11_parser.rl"
+       { MARK(field_start, p); }
+       goto st16;
+st16:
+       if ( ++p == pe )
+               goto _test_eof16;
+case 16:
+#line 409 "http11_parser.c"
+       switch( (*p) ) {
+               case 33: goto st16;
+               case 58: goto tr23;
+               case 124: goto st16;
+               case 126: goto st16;
+       }
+       if ( (*p) < 45 ) {
+               if ( (*p) > 39 ) {
+                       if ( 42 <= (*p) && (*p) <= 43 )
+                               goto st16;
+               } else if ( (*p) >= 35 )
+                       goto st16;
+       } else if ( (*p) > 46 ) {
+               if ( (*p) < 65 ) {
+                       if ( 48 <= (*p) && (*p) <= 57 )
+                               goto st16;
+               } else if ( (*p) > 90 ) {
+                       if ( 94 <= (*p) && (*p) <= 122 )
+                               goto st16;
+               } else
+                       goto st16;
+       } else
+               goto st16;
+       goto st0;
+tr23:
+#line 56 "http11_parser.rl"
+       { 
+    parser->field_len = LEN(field_start, p);
+  }
+       goto st17;
+tr27:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+       goto st17;
+st17:
+       if ( ++p == pe )
+               goto _test_eof17;
+case 17:
+#line 448 "http11_parser.c"
+       switch( (*p) ) {
+               case 10: goto tr25;
+               case 13: goto tr26;
+               case 32: goto tr27;
+       }
+       goto tr24;
+tr24:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+       goto st18;
+st18:
+       if ( ++p == pe )
+               goto _test_eof18;
+case 18:
+#line 463 "http11_parser.c"
+       switch( (*p) ) {
+               case 10: goto tr29;
+               case 13: goto tr30;
+       }
+       goto st18;
+tr18:
+#line 84 "http11_parser.rl"
+       {
+    if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), p, 10))
+      {p++; cs = 19; goto _out;}
+  }
+       goto st19;
+tr26:
+#line 60 "http11_parser.rl"
+       { MARK(mark, p); }
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st19;
+tr30:
+#line 62 "http11_parser.rl"
+       {
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+       goto st19;
+st19:
+       if ( ++p == pe )
+               goto _test_eof19;
+case 19:
+#line 498 "http11_parser.c"
+       if ( (*p) == 10 )
+               goto st14;
+       goto st0;
+tr8:
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+tr41:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 20; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+tr52:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 20; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+tr56:
+#line 106 "http11_parser.rl"
+       {
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), p, 10*1024))
+      {p++; cs = 20; goto _out;}
+  }
+#line 99 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), p, 12*1024))
+      {p++; cs = 20; goto _out;}
+  }
+       goto st20;
+st20:
+       if ( ++p == pe )
+               goto _test_eof20;
+case 20:
+#line 551 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr33;
+               case 37: goto tr34;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( (*p) > 31 ) {
+               if ( 34 <= (*p) && (*p) <= 35 )
+                       goto st0;
+       } else if ( (*p) >= 0 )
+               goto st0;
+       goto tr32;
+tr32:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st21;
+st21:
+       if ( ++p == pe )
+               goto _test_eof21;
+case 21:
+#line 573 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr36;
+               case 37: goto st22;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( (*p) > 31 ) {
+               if ( 34 <= (*p) && (*p) <= 35 )
+                       goto st0;
+       } else if ( (*p) >= 0 )
+               goto st0;
+       goto st21;
+tr34:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st22;
+st22:
+       if ( ++p == pe )
+               goto _test_eof22;
+case 22:
+#line 595 "http11_parser.c"
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st23;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st23;
+       } else
+               goto st23;
+       goto st0;
+st23:
+       if ( ++p == pe )
+               goto _test_eof23;
+case 23:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st21;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st21;
+       } else
+               goto st21;
+       goto st0;
+tr5:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st24;
+st24:
+       if ( ++p == pe )
+               goto _test_eof24;
+case 24:
+#line 626 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr40;
+               case 34: goto st0;
+               case 35: goto tr41;
+               case 37: goto st25;
+               case 59: goto tr43;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 63: goto tr44;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st24;
+st25:
+       if ( ++p == pe )
+               goto _test_eof25;
+case 25:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st26;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st26;
+       } else
+               goto st26;
+       goto st0;
+st26:
+       if ( ++p == pe )
+               goto _test_eof26;
+case 26:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st24;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st24;
+       } else
+               goto st24;
+       goto st0;
+tr43:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 27; goto _out;}
+  }
+       goto st27;
+st27:
+       if ( ++p == pe )
+               goto _test_eof27;
+case 27:
+#line 678 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr7;
+               case 34: goto st0;
+               case 35: goto tr8;
+               case 37: goto st28;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 63: goto st30;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st27;
+st28:
+       if ( ++p == pe )
+               goto _test_eof28;
+case 28:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st29;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st29;
+       } else
+               goto st29;
+       goto st0;
+st29:
+       if ( ++p == pe )
+               goto _test_eof29;
+case 29:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st27;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st27;
+       } else
+               goto st27;
+       goto st0;
+tr44:
+#line 89 "http11_parser.rl"
+       {
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), p, 1024))
+      {p++; cs = 30; goto _out;}
+  }
+       goto st30;
+st30:
+       if ( ++p == pe )
+               goto _test_eof30;
+case 30:
+#line 729 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr51;
+               case 34: goto st0;
+               case 35: goto tr52;
+               case 37: goto tr53;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto tr50;
+tr50:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+       goto st31;
+st31:
+       if ( ++p == pe )
+               goto _test_eof31;
+case 31:
+#line 750 "http11_parser.c"
+       switch( (*p) ) {
+               case 32: goto tr55;
+               case 34: goto st0;
+               case 35: goto tr56;
+               case 37: goto st32;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st31;
+tr53:
+#line 104 "http11_parser.rl"
+       {MARK(query_start, p); }
+       goto st32;
+st32:
+       if ( ++p == pe )
+               goto _test_eof32;
+case 32:
+#line 771 "http11_parser.c"
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st33;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st33;
+       } else
+               goto st33;
+       goto st0;
+st33:
+       if ( ++p == pe )
+               goto _test_eof33;
+case 33:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st31;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st31;
+       } else
+               goto st31;
+       goto st0;
+tr6:
+#line 52 "http11_parser.rl"
+       {MARK(mark, p); }
+       goto st34;
+st34:
+       if ( ++p == pe )
+               goto _test_eof34;
+case 34:
+#line 802 "http11_parser.c"
+       if ( (*p) == 116 )
+               goto st35;
+       goto st0;
+st35:
+       if ( ++p == pe )
+               goto _test_eof35;
+case 35:
+       if ( (*p) == 116 )
+               goto st36;
+       goto st0;
+st36:
+       if ( ++p == pe )
+               goto _test_eof36;
+case 36:
+       if ( (*p) == 112 )
+               goto st37;
+       goto st0;
+st37:
+       if ( ++p == pe )
+               goto _test_eof37;
+case 37:
+       if ( (*p) == 58 )
+               goto st38;
+       goto st0;
+st38:
+       if ( ++p == pe )
+               goto _test_eof38;
+case 38:
+       switch( (*p) ) {
+               case 32: goto tr7;
+               case 34: goto st0;
+               case 35: goto tr8;
+               case 37: goto st39;
+               case 60: goto st0;
+               case 62: goto st0;
+               case 127: goto st0;
+       }
+       if ( 0 <= (*p) && (*p) <= 31 )
+               goto st0;
+       goto st38;
+st39:
+       if ( ++p == pe )
+               goto _test_eof39;
+case 39:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st40;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st40;
+       } else
+               goto st40;
+       goto st0;
+st40:
+       if ( ++p == pe )
+               goto _test_eof40;
+case 40:
+       if ( (*p) < 65 ) {
+               if ( 48 <= (*p) && (*p) <= 57 )
+                       goto st38;
+       } else if ( (*p) > 70 ) {
+               if ( 97 <= (*p) && (*p) <= 102 )
+                       goto st38;
+       } else
+               goto st38;
+       goto st0;
+st41:
+       if ( ++p == pe )
+               goto _test_eof41;
+case 41:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st42;
+               case 95: goto st42;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st42;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st42;
+       } else
+               goto st42;
+       goto st0;
+st42:
+       if ( ++p == pe )
+               goto _test_eof42;
+case 42:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st43;
+               case 95: goto st43;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st43;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st43;
+       } else
+               goto st43;
+       goto st0;
+st43:
+       if ( ++p == pe )
+               goto _test_eof43;
+case 43:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st44;
+               case 95: goto st44;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st44;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st44;
+       } else
+               goto st44;
+       goto st0;
+st44:
+       if ( ++p == pe )
+               goto _test_eof44;
+case 44:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st45;
+               case 95: goto st45;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st45;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st45;
+       } else
+               goto st45;
+       goto st0;
+st45:
+       if ( ++p == pe )
+               goto _test_eof45;
+case 45:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st46;
+               case 95: goto st46;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st46;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st46;
+       } else
+               goto st46;
+       goto st0;
+st46:
+       if ( ++p == pe )
+               goto _test_eof46;
+case 46:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st47;
+               case 95: goto st47;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st47;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st47;
+       } else
+               goto st47;
+       goto st0;
+st47:
+       if ( ++p == pe )
+               goto _test_eof47;
+case 47:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st48;
+               case 95: goto st48;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st48;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st48;
+       } else
+               goto st48;
+       goto st0;
+st48:
+       if ( ++p == pe )
+               goto _test_eof48;
+case 48:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st49;
+               case 95: goto st49;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st49;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st49;
+       } else
+               goto st49;
+       goto st0;
+st49:
+       if ( ++p == pe )
+               goto _test_eof49;
+case 49:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st50;
+               case 95: goto st50;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st50;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st50;
+       } else
+               goto st50;
+       goto st0;
+st50:
+       if ( ++p == pe )
+               goto _test_eof50;
+case 50:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st51;
+               case 95: goto st51;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st51;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st51;
+       } else
+               goto st51;
+       goto st0;
+st51:
+       if ( ++p == pe )
+               goto _test_eof51;
+case 51:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st52;
+               case 95: goto st52;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st52;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st52;
+       } else
+               goto st52;
+       goto st0;
+st52:
+       if ( ++p == pe )
+               goto _test_eof52;
+case 52:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st53;
+               case 95: goto st53;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st53;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st53;
+       } else
+               goto st53;
+       goto st0;
+st53:
+       if ( ++p == pe )
+               goto _test_eof53;
+case 53:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st54;
+               case 95: goto st54;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st54;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st54;
+       } else
+               goto st54;
+       goto st0;
+st54:
+       if ( ++p == pe )
+               goto _test_eof54;
+case 54:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st55;
+               case 95: goto st55;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st55;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st55;
+       } else
+               goto st55;
+       goto st0;
+st55:
+       if ( ++p == pe )
+               goto _test_eof55;
+case 55:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st56;
+               case 95: goto st56;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st56;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st56;
+       } else
+               goto st56;
+       goto st0;
+st56:
+       if ( ++p == pe )
+               goto _test_eof56;
+case 56:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st57;
+               case 95: goto st57;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st57;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st57;
+       } else
+               goto st57;
+       goto st0;
+st57:
+       if ( ++p == pe )
+               goto _test_eof57;
+case 57:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st58;
+               case 95: goto st58;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st58;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st58;
+       } else
+               goto st58;
+       goto st0;
+st58:
+       if ( ++p == pe )
+               goto _test_eof58;
+case 58:
+       switch( (*p) ) {
+               case 32: goto tr2;
+               case 36: goto st59;
+               case 95: goto st59;
+       }
+       if ( (*p) < 48 ) {
+               if ( 45 <= (*p) && (*p) <= 46 )
+                       goto st59;
+       } else if ( (*p) > 57 ) {
+               if ( 65 <= (*p) && (*p) <= 90 )
+                       goto st59;
+       } else
+               goto st59;
+       goto st0;
+st59:
+       if ( ++p == pe )
+               goto _test_eof59;
+case 59:
+       if ( (*p) == 32 )
+               goto tr2;
+       goto st0;
+       }
+       _test_eof2: cs = 2; goto _test_eof; 
+       _test_eof3: cs = 3; goto _test_eof; 
+       _test_eof4: cs = 4; goto _test_eof; 
+       _test_eof5: cs = 5; goto _test_eof; 
+       _test_eof6: cs = 6; goto _test_eof; 
+       _test_eof7: cs = 7; goto _test_eof; 
+       _test_eof8: cs = 8; goto _test_eof; 
+       _test_eof9: cs = 9; goto _test_eof; 
+       _test_eof10: cs = 10; goto _test_eof; 
+       _test_eof11: cs = 11; goto _test_eof; 
+       _test_eof12: cs = 12; goto _test_eof; 
+       _test_eof13: cs = 13; goto _test_eof; 
+       _test_eof14: cs = 14; goto _test_eof; 
+       _test_eof60: cs = 60; goto _test_eof; 
+       _test_eof15: cs = 15; goto _test_eof; 
+       _test_eof16: cs = 16; goto _test_eof; 
+       _test_eof17: cs = 17; goto _test_eof; 
+       _test_eof18: cs = 18; goto _test_eof; 
+       _test_eof19: cs = 19; goto _test_eof; 
+       _test_eof20: cs = 20; goto _test_eof; 
+       _test_eof21: cs = 21; goto _test_eof; 
+       _test_eof22: cs = 22; goto _test_eof; 
+       _test_eof23: cs = 23; goto _test_eof; 
+       _test_eof24: cs = 24; goto _test_eof; 
+       _test_eof25: cs = 25; goto _test_eof; 
+       _test_eof26: cs = 26; goto _test_eof; 
+       _test_eof27: cs = 27; goto _test_eof; 
+       _test_eof28: cs = 28; goto _test_eof; 
+       _test_eof29: cs = 29; goto _test_eof; 
+       _test_eof30: cs = 30; goto _test_eof; 
+       _test_eof31: cs = 31; goto _test_eof; 
+       _test_eof32: cs = 32; goto _test_eof; 
+       _test_eof33: cs = 33; goto _test_eof; 
+       _test_eof34: cs = 34; goto _test_eof; 
+       _test_eof35: cs = 35; goto _test_eof; 
+       _test_eof36: cs = 36; goto _test_eof; 
+       _test_eof37: cs = 37; goto _test_eof; 
+       _test_eof38: cs = 38; goto _test_eof; 
+       _test_eof39: cs = 39; goto _test_eof; 
+       _test_eof40: cs = 40; goto _test_eof; 
+       _test_eof41: cs = 41; goto _test_eof; 
+       _test_eof42: cs = 42; goto _test_eof; 
+       _test_eof43: cs = 43; goto _test_eof; 
+       _test_eof44: cs = 44; goto _test_eof; 
+       _test_eof45: cs = 45; goto _test_eof; 
+       _test_eof46: cs = 46; goto _test_eof; 
+       _test_eof47: cs = 47; goto _test_eof; 
+       _test_eof48: cs = 48; goto _test_eof; 
+       _test_eof49: cs = 49; goto _test_eof; 
+       _test_eof50: cs = 50; goto _test_eof; 
+       _test_eof51: cs = 51; goto _test_eof; 
+       _test_eof52: cs = 52; goto _test_eof; 
+       _test_eof53: cs = 53; goto _test_eof; 
+       _test_eof54: cs = 54; goto _test_eof; 
+       _test_eof55: cs = 55; goto _test_eof; 
+       _test_eof56: cs = 56; goto _test_eof; 
+       _test_eof57: cs = 57; goto _test_eof; 
+       _test_eof58: cs = 58; goto _test_eof; 
+       _test_eof59: cs = 59; goto _test_eof; 
+
+       _test_eof: {}
+       _out: {}
+       }
+
+#line 213 "http11_parser.rl"
+
+  assert(p <= pe && "Buffer overflow after parsing.");
+
+  if (!http_parser_has_error(parser)) {
+      parser->cs = cs;
+  }
+
+  parser->nread += p - (buffer + off);
+
+  assert(parser->nread <= len && "nread longer than length");
+  assert(parser->body_start <= len && "body starts after buffer end");
+  assert(parser->mark < len && "mark is after buffer end");
+  assert(parser->field_len <= len && "field has length longer than whole buffer");
+  assert(parser->field_start < len && "field starts after buffer end");
+
+  return(parser->nread);
+}
+
+int http_parser_finish(http_parser *parser)
+{
+  if (http_parser_has_error(parser) ) {
+    return -1;
+  } else if (http_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int http_parser_has_error(http_parser *parser) {
+  return parser->cs == http_parser_error;
+}
+
+int http_parser_is_finished(http_parser *parser) {
+  return parser->cs >= http_parser_first_final;
+}
diff --git a/original_parser/http11_parser.h b/original_parser/http11_parser.h
new file mode 100644 (file)
index 0000000..c7f0ae1
--- /dev/null
@@ -0,0 +1,41 @@
+
+#ifndef http11_parser_h
+#define http11_parser_h
+
+#include "http11_common.h"
+
+enum { CONTENT_LENGTH
+     , CONTENT_TYPE
+     , FRAGMENT
+     , HTTP_VERSION
+     , QUERY_STRING
+     , REQUEST_PATH
+     , REQUEST_METHOD
+     , REQUEST_URI
+     };
+
+typedef struct http_parser { 
+  int cs;
+  size_t body_start;
+  int content_len;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+  size_t query_start;
+
+  void *data;
+
+  field_cb http_field;
+  element_cb on_element;  
+} http_parser;
+
+int http_parser_init(http_parser *parser);
+int http_parser_finish(http_parser *parser);
+size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
+int http_parser_has_error(http_parser *parser);
+int http_parser_is_finished(http_parser *parser);
+
+#define http_parser_nread(parser) (parser)->nread 
+
+#endif
similarity index 56%
rename from original_parser/parser.rl
rename to original_parser/http11_parser.rl
index 5850e9f..301ec4e 100644 (file)
 /**
- * Copyright (c) 2005 Zed A. Shaw
- * You can redistribute it and/or modify it under the same terms as Ruby.
+ *
+ * Copyright (c) 2010, Zed A. Shaw and Mongrel2 Project Contributors.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ * 
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ * 
+ *     * Neither the name of the Mongrel2 Project, Zed A. Shaw, nor the names
+ *       of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written
+ *       permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#include "parser.h"
+
+#include "http11_parser.h"
 #include <stdio.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
 
-#define TRUE 1
-#define FALSE 0
 #define LEN(AT, FPC) (FPC - buffer - parser->AT)
 #define MARK(M,FPC) (parser->M = (FPC) - buffer)
 #define PTR_TO(F) (buffer + parser->F)
-/** machine **/
+
+/** Machine **/
+
 %%{
-  machine http_parser;
   
+  machine http_parser;
+
   action mark {MARK(mark, fpc); }
-  
+
+
   action start_field { MARK(field_start, fpc); }
   action write_field { 
     parser->field_len = LEN(field_start, fpc);
-    if(parser->field_len > 256) {
-      parser->overflow_error = TRUE;
-      fbreak;
-    }
   }
-  
+
   action start_value { MARK(mark, fpc); }
+
   action write_value {
-    if(LEN(mark, fpc) > 80 * 1024) { parser->overflow_error = TRUE; fbreak; }
     if(parser->http_field != NULL) {
       parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
     }
   }
-  
-  action content_length {
-    if(!apply_element(parser, MONGREL_CONTENT_LENGTH, PTR_TO(mark), fpc, 20))
-      fbreak;
-    set_content_length(parser, PTR_TO(mark), LEN(mark, fpc));
-  }
-  
+
   action content_type {
-    if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), fpc, 10*1024))
+    if(!apply_element(parser, CONTENT_TYPE, PTR_TO(mark), fpc, 10*1024))
       fbreak;
   }
-  
+
   action fragment {
-    if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), fpc, 10*1024))
+    if(!apply_element(parser, FRAGMENT, PTR_TO(mark), fpc, 10*1024))
       fbreak;
   }
-  
+
   action http_version {
-    if(!apply_element(parser, MONGREL_HTTP_VERSION, PTR_TO(mark), fpc, 10))
+    if(!apply_element(parser, HTTP_VERSION, PTR_TO(mark), fpc, 10))
       fbreak;
   }
-  
+
   action request_path {
-    if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), fpc, 1024))
+    if(!apply_element(parser, REQUEST_PATH, PTR_TO(mark), fpc, 1024))
       fbreak;
   }
-  
+
   action request_method {
-    if(!apply_element(parser, MONGREL_REQUEST_METHOD, PTR_TO(mark), fpc, 1024))
+    if(!apply_element(parser, REQUEST_METHOD, PTR_TO(mark), fpc, 1024))
       fbreak;
   }
-  
+
   action request_uri {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), fpc, 12*1024))
+    if(!apply_element(parser, REQUEST_URI, PTR_TO(mark), fpc, 12*1024))
       fbreak;
   }
-  
+
   action start_query {MARK(query_start, fpc); }
+
   action query_string {
-    if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), fpc, 10*1024))
+    if(!apply_element(parser, QUERY_STRING, PTR_TO(query_start), fpc, 10*1024))
       fbreak;
   }
-  
+
   action done {
-    parser->body_start = fpc - buffer + 1;
+    parser->body_start = fpc - buffer + 1;    
     fbreak;
   }
 
 #### HTTP PROTOCOL GRAMMAR
 # line endings
-  CRLF = "\r\n";
+  CRLF = ("\r\n" | "\n");
 
 # character types
   CTL = (cntrl | 127);
   token = (ascii -- (CTL | tspecials));
 
 # URI schemes and absolute paths
-  scheme = ( alpha | digit | "+" | "-" | "." )* ;
+  scheme = "http";
   absolute_uri = (scheme ":" (uchar | reserved )*);
 
   path = ( pchar+ ( "/" pchar* )* ) ;
   Fragment = ( uchar | reserved )* >mark %fragment;
   Method = ( upper | digit | safe ){1,20} >mark %request_method;
 
-  http_number = ( digit+ "." digit+ ) ;
+  http_number = ( "1." ("0" | "1") ) ;
   HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ;
   Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " HTTP_Version CRLF ) ;
 
   field_name = ( token -- ":" )+ >start_field %write_field;
 
   field_value = any* >start_value %write_value;
-  
-  known_headers = ( ("Content-Length:"i " "* (digit+ >mark %content_length))
-                  | ("Content-Type:"i " "* (any* >mark %content_type))
-                  ) :> CRLF;
-  unknown_header = (field_name ":" " "* field_value :> CRLF) -- known_headers;
-  
-  Request = Request_Line (known_headers | unknown_header)* ( CRLF @done );
 
-main := Request;
+  message_header = field_name ":" " "* field_value :> CRLF;
+
+  Request = Request_Line ( message_header )* ( CRLF );
+
+main := (Request ) @done;
 
 }%%
 
 /** Data **/
 %% write data;
 
-/* returns TRUE if applied, FALSE if there was an error */
 static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length)
 {
   int len = (int)(end-begin);
   if(len > max_length) {
-    parser->overflow_error = TRUE;
-    return FALSE;
+    return(0);
   }
   if(parser->on_element)
     parser->on_element(parser->data, type, begin, len);
-  return TRUE;
+  return(1);
 }
 
-static void set_content_length(http_parser *parser, const char *at, int length)
-{
-  /* atoi_length - why isn't this in the statndard library? i hate c */
-  assert(parser->content_length == 0);
-  int i, mult;
-  for(mult=1, i=length-1; i>=0; i--, mult*=10)
-    parser->content_length += (at[i] - '0') * mult;
-}
 
-void http_parser_init(http_parser *parser)  {
+
+int http_parser_init(http_parser *parser) {
   int cs = 0;
   %% write init;
   parser->cs = cs;
-  parser->overflow_error = FALSE;
   parser->body_start = 0;
-  parser->content_length = 0;
+  parser->content_len = 0;
   parser->mark = 0;
   parser->nread = 0;
   parser->field_len = 0;
   parser->field_start = 0;
-  parser->data = NULL;
-  parser->http_field = NULL;
-}
 
+  return(1);
+}
 
 /** exec **/
-size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
+size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  
+{
+  if(len == 0) return 0;
+
   const char *p, *pe;
   int cs = parser->cs;
-  
+
   assert(off <= len && "offset past end of buffer");
-  
+
   p = buffer+off;
   pe = buffer+len;
-  
-  /* Ragel 6 does not require this */
-  // assert(*pe == '\0' && "pointer does not end on NUL");
-  assert(pe - p == len - off && "pointers aren't same distance");
-  
+
+  assert(pe - p == (int)len - (int)off && "pointers aren't same distance");
+
   %% write exec;
-  
-  parser->cs = cs;
+
+  assert(p <= pe && "Buffer overflow after parsing.");
+
+  if (!http_parser_has_error(parser)) {
+      parser->cs = cs;
+  }
+
   parser->nread += p - (buffer + off);
-  
-  assert(p <= pe && "buffer overflow after parsing execute");
+
   assert(parser->nread <= len && "nread longer than length");
   assert(parser->body_start <= len && "body starts after buffer end");
   assert(parser->mark < len && "mark is after buffer end");
   assert(parser->field_len <= len && "field has length longer than whole buffer");
   assert(parser->field_start < len && "field starts after buffer end");
-  
-  if(parser->nread > 1024 * (80 + 32))
-    parser->overflow_error = TRUE;
-  
-  
-  /* Ragel 6 does not use write eof; no need for this
-  if(parser->body_start) {
-    // final \r\n combo encountered so stop right here 
-    parser->nread++;
-    %% write eof;
-  }
-  */
-  
+
   return(parser->nread);
 }
 
 int http_parser_finish(http_parser *parser)
 {
-  if (http_parser_has_error(parser))
+  if (http_parser_has_error(parser) ) {
     return -1;
-  else if (http_parser_is_finished(parser))
+  } else if (http_parser_is_finished(parser) ) {
     return 1;
-  else
+  } else {
     return 0;
+  }
 }
 
 int http_parser_has_error(http_parser *parser) {
-  return parser->cs == http_parser_error || parser->overflow_error;
+  return parser->cs == http_parser_error;
 }
 
 int http_parser_is_finished(http_parser *parser) {
diff --git a/original_parser/parser.h b/original_parser/parser.h
deleted file mode 100644 (file)
index d515281..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * Copyright (c) 2005 Zed A. Shaw
- * You can redistribute it and/or modify it under the same terms as Ruby.
- */
-
-#ifndef http11_parser_h
-#define http11_parser_h
-
-#include <sys/types.h>
-
-#if defined(_WIN32)
-#include <stddef.h>
-#endif
-
-enum { MONGREL_CONTENT_LENGTH
-     , MONGREL_CONTENT_TYPE
-     , MONGREL_FRAGMENT
-     , MONGREL_HTTP_VERSION
-     , MONGREL_QUERY_STRING
-     , MONGREL_REQUEST_PATH
-     , MONGREL_REQUEST_METHOD
-     , MONGREL_REQUEST_URI
-     };
-
-typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
-typedef void (*element_cb)(void *data, int type, const char *at, size_t length);
-
-typedef struct http_parser { 
-  int cs;
-  int overflow_error;
-  size_t body_start;
-  size_t content_length;
-  size_t nread;
-  size_t mark;
-  size_t field_start;
-  size_t field_len;
-  size_t query_start;
-
-  void *data;
-
-  field_cb http_field;
-  element_cb on_element;
-} http_parser;
-
-void http_parser_init(http_parser *parser);
-int http_parser_finish(http_parser *parser);
-size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
-int http_parser_has_error(http_parser *parser);
-int http_parser_is_finished(http_parser *parser);
-
-#define http_parser_nread(parser) (parser)->nread 
-
-#endif
diff --git a/parser.c b/parser.c
deleted file mode 100644 (file)
index d30253c..0000000
--- a/parser.c
+++ /dev/null
@@ -1,2860 +0,0 @@
-#line 1 "src/parser.rl"
-/**
- * Copyright (c) 2005 Zed A. Shaw
- * You can redistribute it and/or modify it under the same terms as Ruby.
- */
-#include "parser.h"
-#include <stdio.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <string.h>
-
-#define TRUE 1
-#define FALSE 0
-#define LEN(AT, FPC) (FPC - buffer - parser->AT)
-#define MARK(M,FPC) (parser->M = (FPC) - buffer)
-#define PTR_TO(F) (buffer + parser->F)
-/** machine **/
-#line 139 "src/parser.rl"
-
-
-/** Data **/
-
-#line 25 "src/parser.c"
-static const int http_parser_start = 1;
-static const int http_parser_first_final = 118;
-static const int http_parser_error = 0;
-
-static const int http_parser_en_main = 1;
-
-#line 143 "src/parser.rl"
-
-/* returns TRUE if applied, FALSE if there was an error */
-static int apply_element(http_parser *parser, int type, const char *begin, const char *end, int max_length)
-{
-  int len = (int)(end-begin);
-  if(len > max_length) {
-    parser->overflow_error = TRUE;
-    return FALSE;
-  }
-  if(parser->on_element)
-    parser->on_element(parser->data, type, begin, len);
-  return TRUE;
-}
-
-static void set_content_length(http_parser *parser, const char *at, int length)
-{
-  /* atoi_length - why isn't this in the statndard library? i hate c */
-  assert(parser->content_length == 0);
-  int i, mult;
-  for(mult=1, i=length-1; i>=0; i--, mult*=10)
-    parser->content_length += (at[i] - '0') * mult;
-}
-
-void http_parser_init(http_parser *parser)  {
-  int cs = 0;
-  
-#line 59 "src/parser.c"
-       {
-       cs = http_parser_start;
-       }
-#line 169 "src/parser.rl"
-  parser->cs = cs;
-  parser->overflow_error = FALSE;
-  parser->body_start = 0;
-  parser->content_length = 0;
-  parser->mark = 0;
-  parser->nread = 0;
-  parser->field_len = 0;
-  parser->field_start = 0;
-  parser->data = NULL;
-  parser->http_field = NULL;
-}
-
-
-/** exec **/
-size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
-  const char *p, *pe;
-  int cs = parser->cs;
-  
-  assert(off <= len && "offset past end of buffer");
-  
-  p = buffer+off;
-  pe = buffer+len;
-  
-  /* Ragel 6 does not require this */
-  // assert(*pe == '\0' && "pointer does not end on NUL");
-  assert(pe - p == len - off && "pointers aren't same distance");
-  
-  
-#line 92 "src/parser.c"
-       {
-       if ( p == pe )
-               goto _test_eof;
-       switch ( cs )
-       {
-case 1:
-       switch( (*p) ) {
-               case 36: goto tr0;
-               case 95: goto tr0;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto tr0;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto tr0;
-       } else
-               goto tr0;
-       goto st0;
-st0:
-cs = 0;
-       goto _out;
-tr0:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st2;
-st2:
-       if ( ++p == pe )
-               goto _test_eof2;
-case 2:
-#line 123 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st99;
-               case 95: goto st99;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st99;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st99;
-       } else
-               goto st99;
-       goto st0;
-tr2:
-#line 66 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_METHOD, PTR_TO(mark), p, 1024))
-      {p++; cs = 3; goto _out;}
-  }
-       goto st3;
-st3:
-       if ( ++p == pe )
-               goto _test_eof3;
-case 3:
-#line 149 "src/parser.c"
-       switch( (*p) ) {
-               case 42: goto tr4;
-               case 43: goto tr5;
-               case 47: goto tr6;
-               case 58: goto tr7;
-       }
-       if ( (*p) < 65 ) {
-               if ( 45 <= (*p) && (*p) <= 57 )
-                       goto tr5;
-       } else if ( (*p) > 90 ) {
-               if ( 97 <= (*p) && (*p) <= 122 )
-                       goto tr5;
-       } else
-               goto tr5;
-       goto st0;
-tr4:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st4;
-st4:
-       if ( ++p == pe )
-               goto _test_eof4;
-case 4:
-#line 173 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr8;
-               case 35: goto tr9;
-       }
-       goto st0;
-tr8:
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 5; goto _out;}
-  }
-       goto st5;
-tr103:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-#line 51 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), p, 10*1024))
-      {p++; cs = 5; goto _out;}
-  }
-       goto st5;
-tr106:
-#line 51 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_FRAGMENT, PTR_TO(mark), p, 10*1024))
-      {p++; cs = 5; goto _out;}
-  }
-       goto st5;
-tr114:
-#line 61 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
-      {p++; cs = 5; goto _out;}
-  }
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 5; goto _out;}
-  }
-       goto st5;
-tr125:
-#line 76 "src/parser.rl"
-       {MARK(query_start, p); }
-#line 77 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
-      {p++; cs = 5; goto _out;}
-  }
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 5; goto _out;}
-  }
-       goto st5;
-tr129:
-#line 77 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
-      {p++; cs = 5; goto _out;}
-  }
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 5; goto _out;}
-  }
-       goto st5;
-st5:
-       if ( ++p == pe )
-               goto _test_eof5;
-case 5:
-#line 244 "src/parser.c"
-       if ( (*p) == 72 )
-               goto tr10;
-       goto st0;
-tr10:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st6;
-st6:
-       if ( ++p == pe )
-               goto _test_eof6;
-case 6:
-#line 256 "src/parser.c"
-       if ( (*p) == 84 )
-               goto st7;
-       goto st0;
-st7:
-       if ( ++p == pe )
-               goto _test_eof7;
-case 7:
-       if ( (*p) == 84 )
-               goto st8;
-       goto st0;
-st8:
-       if ( ++p == pe )
-               goto _test_eof8;
-case 8:
-       if ( (*p) == 80 )
-               goto st9;
-       goto st0;
-st9:
-       if ( ++p == pe )
-               goto _test_eof9;
-case 9:
-       if ( (*p) == 47 )
-               goto st10;
-       goto st0;
-st10:
-       if ( ++p == pe )
-               goto _test_eof10;
-case 10:
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto st11;
-       goto st0;
-st11:
-       if ( ++p == pe )
-               goto _test_eof11;
-case 11:
-       if ( (*p) == 46 )
-               goto st12;
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto st11;
-       goto st0;
-st12:
-       if ( ++p == pe )
-               goto _test_eof12;
-case 12:
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto st13;
-       goto st0;
-st13:
-       if ( ++p == pe )
-               goto _test_eof13;
-case 13:
-       if ( (*p) == 13 )
-               goto tr18;
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto st13;
-       goto st0;
-tr18:
-#line 56 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_HTTP_VERSION, PTR_TO(mark), p, 10))
-      {p++; cs = 14; goto _out;}
-  }
-       goto st14;
-tr28:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-#line 33 "src/parser.rl"
-       {
-    if(LEN(mark, p) > 80 * 1024) { parser->overflow_error = TRUE; {p++; cs = 14; goto _out;} }
-    if(parser->http_field != NULL) {
-      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
-    }
-  }
-       goto st14;
-tr32:
-#line 33 "src/parser.rl"
-       {
-    if(LEN(mark, p) > 80 * 1024) { parser->overflow_error = TRUE; {p++; cs = 14; goto _out;} }
-    if(parser->http_field != NULL) {
-      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
-    }
-  }
-       goto st14;
-tr91:
-#line 40 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_CONTENT_LENGTH, PTR_TO(mark), p, 20))
-      {p++; cs = 14; goto _out;}
-    set_content_length(parser, PTR_TO(mark), LEN(mark, p));
-  }
-       goto st14;
-tr98:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-#line 46 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), p, 10*1024))
-      {p++; cs = 14; goto _out;}
-  }
-       goto st14;
-tr101:
-#line 46 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_CONTENT_TYPE, PTR_TO(mark), p, 10*1024))
-      {p++; cs = 14; goto _out;}
-  }
-       goto st14;
-st14:
-       if ( ++p == pe )
-               goto _test_eof14;
-case 14:
-#line 368 "src/parser.c"
-       if ( (*p) == 10 )
-               goto st15;
-       goto st0;
-st15:
-       if ( ++p == pe )
-               goto _test_eof15;
-case 15:
-       switch( (*p) ) {
-               case 13: goto st16;
-               case 33: goto tr21;
-               case 67: goto tr22;
-               case 99: goto tr22;
-               case 124: goto tr21;
-               case 126: goto tr21;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto tr21;
-               } else if ( (*p) >= 35 )
-                       goto tr21;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto tr21;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto tr21;
-               } else
-                       goto tr21;
-       } else
-               goto tr21;
-       goto st0;
-st16:
-       if ( ++p == pe )
-               goto _test_eof16;
-case 16:
-       if ( (*p) == 10 )
-               goto tr23;
-       goto st0;
-tr23:
-#line 82 "src/parser.rl"
-       {
-    parser->body_start = p - buffer + 1;
-    {p++; cs = 118; goto _out;}
-  }
-       goto st118;
-st118:
-       if ( ++p == pe )
-               goto _test_eof118;
-case 118:
-#line 420 "src/parser.c"
-       goto st0;
-tr21:
-#line 23 "src/parser.rl"
-       { MARK(field_start, p); }
-       goto st17;
-st17:
-       if ( ++p == pe )
-               goto _test_eof17;
-case 17:
-#line 430 "src/parser.c"
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-tr25:
-#line 24 "src/parser.rl"
-       { 
-    parser->field_len = LEN(field_start, p);
-    if(parser->field_len > 256) {
-      parser->overflow_error = TRUE;
-      {p++; cs = 18; goto _out;}
-    }
-  }
-       goto st18;
-tr29:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-       goto st18;
-st18:
-       if ( ++p == pe )
-               goto _test_eof18;
-case 18:
-#line 475 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr28;
-               case 32: goto tr29;
-               case 67: goto tr30;
-               case 99: goto tr30;
-       }
-       goto tr27;
-tr27:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-       goto st19;
-st19:
-       if ( ++p == pe )
-               goto _test_eof19;
-case 19:
-#line 491 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       goto st19;
-tr30:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-       goto st20;
-st20:
-       if ( ++p == pe )
-               goto _test_eof20;
-case 20:
-#line 506 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 79: goto st21;
-               case 99: goto st20;
-               case 111: goto st21;
-       }
-       goto st19;
-st21:
-       if ( ++p == pe )
-               goto _test_eof21;
-case 21:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 78: goto st22;
-               case 99: goto st20;
-               case 110: goto st22;
-       }
-       goto st19;
-st22:
-       if ( ++p == pe )
-               goto _test_eof22;
-case 22:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 84: goto st23;
-               case 99: goto st20;
-               case 116: goto st23;
-       }
-       goto st19;
-st23:
-       if ( ++p == pe )
-               goto _test_eof23;
-case 23:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 69: goto st24;
-               case 99: goto st20;
-               case 101: goto st24;
-       }
-       goto st19;
-st24:
-       if ( ++p == pe )
-               goto _test_eof24;
-case 24:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 78: goto st25;
-               case 99: goto st20;
-               case 110: goto st25;
-       }
-       goto st19;
-st25:
-       if ( ++p == pe )
-               goto _test_eof25;
-case 25:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 84: goto st26;
-               case 99: goto st20;
-               case 116: goto st26;
-       }
-       goto st19;
-st26:
-       if ( ++p == pe )
-               goto _test_eof26;
-case 26:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 45: goto st27;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       goto st19;
-st27:
-       if ( ++p == pe )
-               goto _test_eof27;
-case 27:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 76: goto st28;
-               case 84: goto st36;
-               case 99: goto st20;
-               case 108: goto st28;
-               case 116: goto st36;
-       }
-       goto st19;
-st28:
-       if ( ++p == pe )
-               goto _test_eof28;
-case 28:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 69: goto st29;
-               case 99: goto st20;
-               case 101: goto st29;
-       }
-       goto st19;
-st29:
-       if ( ++p == pe )
-               goto _test_eof29;
-case 29:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 78: goto st30;
-               case 99: goto st20;
-               case 110: goto st30;
-       }
-       goto st19;
-st30:
-       if ( ++p == pe )
-               goto _test_eof30;
-case 30:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 71: goto st31;
-               case 99: goto st20;
-               case 103: goto st31;
-       }
-       goto st19;
-st31:
-       if ( ++p == pe )
-               goto _test_eof31;
-case 31:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 84: goto st32;
-               case 99: goto st20;
-               case 116: goto st32;
-       }
-       goto st19;
-st32:
-       if ( ++p == pe )
-               goto _test_eof32;
-case 32:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 72: goto st33;
-               case 99: goto st20;
-               case 104: goto st33;
-       }
-       goto st19;
-st33:
-       if ( ++p == pe )
-               goto _test_eof33;
-case 33:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 58: goto st34;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       goto st19;
-st34:
-       if ( ++p == pe )
-               goto _test_eof34;
-case 34:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 32: goto st34;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto tr49;
-       goto st19;
-tr49:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st35;
-tr70:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st35;
-st35:
-       if ( ++p == pe )
-               goto _test_eof35;
-case 35:
-#line 698 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto st0;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto st35;
-       goto st19;
-st36:
-       if ( ++p == pe )
-               goto _test_eof36;
-case 36:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 89: goto st37;
-               case 99: goto st20;
-               case 121: goto st37;
-       }
-       goto st19;
-st37:
-       if ( ++p == pe )
-               goto _test_eof37;
-case 37:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 80: goto st38;
-               case 99: goto st20;
-               case 112: goto st38;
-       }
-       goto st19;
-st38:
-       if ( ++p == pe )
-               goto _test_eof38;
-case 38:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 67: goto st20;
-               case 69: goto st39;
-               case 99: goto st20;
-               case 101: goto st39;
-       }
-       goto st19;
-st39:
-       if ( ++p == pe )
-               goto _test_eof39;
-case 39:
-       switch( (*p) ) {
-               case 13: goto tr32;
-               case 58: goto st0;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       goto st19;
-st40:
-       if ( ++p == pe )
-               goto _test_eof40;
-case 40:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 79: goto st41;
-               case 99: goto st40;
-               case 111: goto st41;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st41:
-       if ( ++p == pe )
-               goto _test_eof41;
-case 41:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 78: goto st42;
-               case 99: goto st40;
-               case 110: goto st42;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st42:
-       if ( ++p == pe )
-               goto _test_eof42;
-case 42:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 84: goto st43;
-               case 99: goto st40;
-               case 116: goto st43;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st43:
-       if ( ++p == pe )
-               goto _test_eof43;
-case 43:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 69: goto st44;
-               case 99: goto st40;
-               case 101: goto st44;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st44:
-       if ( ++p == pe )
-               goto _test_eof44;
-case 44:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 78: goto st45;
-               case 99: goto st40;
-               case 110: goto st45;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st45:
-       if ( ++p == pe )
-               goto _test_eof45;
-case 45:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 84: goto st46;
-               case 99: goto st40;
-               case 116: goto st46;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st46:
-       if ( ++p == pe )
-               goto _test_eof46;
-case 46:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 45: goto st47;
-               case 46: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 48 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 57 ) {
-               if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else if ( (*p) >= 65 )
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st47:
-       if ( ++p == pe )
-               goto _test_eof47;
-case 47:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 76: goto st48;
-               case 84: goto st55;
-               case 99: goto st40;
-               case 108: goto st48;
-               case 116: goto st55;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st48:
-       if ( ++p == pe )
-               goto _test_eof48;
-case 48:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 69: goto st49;
-               case 99: goto st40;
-               case 101: goto st49;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st49:
-       if ( ++p == pe )
-               goto _test_eof49;
-case 49:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 78: goto st50;
-               case 99: goto st40;
-               case 110: goto st50;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st50:
-       if ( ++p == pe )
-               goto _test_eof50;
-case 50:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 71: goto st51;
-               case 99: goto st40;
-               case 103: goto st51;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st51:
-       if ( ++p == pe )
-               goto _test_eof51;
-case 51:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 84: goto st52;
-               case 99: goto st40;
-               case 116: goto st52;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st52:
-       if ( ++p == pe )
-               goto _test_eof52;
-case 52:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 72: goto st53;
-               case 99: goto st40;
-               case 104: goto st53;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st53:
-       if ( ++p == pe )
-               goto _test_eof53;
-case 53:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr68;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-tr68:
-#line 24 "src/parser.rl"
-       { 
-    parser->field_len = LEN(field_start, p);
-    if(parser->field_len > 256) {
-      parser->overflow_error = TRUE;
-      {p++; cs = 54; goto _out;}
-    }
-  }
-       goto st54;
-tr69:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-       goto st54;
-st54:
-       if ( ++p == pe )
-               goto _test_eof54;
-case 54:
-#line 1217 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr28;
-               case 32: goto tr69;
-               case 67: goto tr30;
-               case 99: goto tr30;
-       }
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto tr70;
-       goto tr27;
-st55:
-       if ( ++p == pe )
-               goto _test_eof55;
-case 55:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 89: goto st56;
-               case 99: goto st40;
-               case 121: goto st56;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st56:
-       if ( ++p == pe )
-               goto _test_eof56;
-case 56:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 80: goto st57;
-               case 99: goto st40;
-               case 112: goto st57;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st57:
-       if ( ++p == pe )
-               goto _test_eof57;
-case 57:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 69: goto st58;
-               case 99: goto st40;
-               case 101: goto st58;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st58:
-       if ( ++p == pe )
-               goto _test_eof58;
-case 58:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-tr22:
-#line 23 "src/parser.rl"
-       { MARK(field_start, p); }
-       goto st59;
-st59:
-       if ( ++p == pe )
-               goto _test_eof59;
-case 59:
-#line 1360 "src/parser.c"
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 79: goto st60;
-               case 99: goto st40;
-               case 111: goto st60;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st60:
-       if ( ++p == pe )
-               goto _test_eof60;
-case 60:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 78: goto st61;
-               case 99: goto st40;
-               case 110: goto st61;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st61:
-       if ( ++p == pe )
-               goto _test_eof61;
-case 61:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 84: goto st62;
-               case 99: goto st40;
-               case 116: goto st62;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st62:
-       if ( ++p == pe )
-               goto _test_eof62;
-case 62:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 69: goto st63;
-               case 99: goto st40;
-               case 101: goto st63;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st63:
-       if ( ++p == pe )
-               goto _test_eof63;
-case 63:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 78: goto st64;
-               case 99: goto st40;
-               case 110: goto st64;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st64:
-       if ( ++p == pe )
-               goto _test_eof64;
-case 64:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 84: goto st65;
-               case 99: goto st40;
-               case 116: goto st65;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st65:
-       if ( ++p == pe )
-               goto _test_eof65;
-case 65:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 45: goto st66;
-               case 46: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 48 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 57 ) {
-               if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else if ( (*p) >= 65 )
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st66:
-       if ( ++p == pe )
-               goto _test_eof66;
-case 66:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 76: goto st67;
-               case 84: goto st75;
-               case 99: goto st40;
-               case 108: goto st67;
-               case 116: goto st75;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st67:
-       if ( ++p == pe )
-               goto _test_eof67;
-case 67:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 69: goto st68;
-               case 99: goto st40;
-               case 101: goto st68;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st68:
-       if ( ++p == pe )
-               goto _test_eof68;
-case 68:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 78: goto st69;
-               case 99: goto st40;
-               case 110: goto st69;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st69:
-       if ( ++p == pe )
-               goto _test_eof69;
-case 69:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 71: goto st70;
-               case 99: goto st40;
-               case 103: goto st70;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st70:
-       if ( ++p == pe )
-               goto _test_eof70;
-case 70:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 84: goto st71;
-               case 99: goto st40;
-               case 116: goto st71;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st71:
-       if ( ++p == pe )
-               goto _test_eof71;
-case 71:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 72: goto st72;
-               case 99: goto st40;
-               case 104: goto st72;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st72:
-       if ( ++p == pe )
-               goto _test_eof72;
-case 72:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr88;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-tr88:
-#line 24 "src/parser.rl"
-       { 
-    parser->field_len = LEN(field_start, p);
-    if(parser->field_len > 256) {
-      parser->overflow_error = TRUE;
-      {p++; cs = 73; goto _out;}
-    }
-  }
-       goto st73;
-tr89:
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-       goto st73;
-st73:
-       if ( ++p == pe )
-               goto _test_eof73;
-case 73:
-#line 1820 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr28;
-               case 32: goto tr89;
-               case 67: goto tr30;
-               case 99: goto tr30;
-       }
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto tr90;
-       goto tr27;
-tr90:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-#line 32 "src/parser.rl"
-       { MARK(mark, p); }
-       goto st74;
-st74:
-       if ( ++p == pe )
-               goto _test_eof74;
-case 74:
-#line 1840 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr91;
-               case 67: goto st20;
-               case 99: goto st20;
-       }
-       if ( 48 <= (*p) && (*p) <= 57 )
-               goto st74;
-       goto st19;
-st75:
-       if ( ++p == pe )
-               goto _test_eof75;
-case 75:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 89: goto st76;
-               case 99: goto st40;
-               case 121: goto st76;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st76:
-       if ( ++p == pe )
-               goto _test_eof76;
-case 76:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 80: goto st77;
-               case 99: goto st40;
-               case 112: goto st77;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st77:
-       if ( ++p == pe )
-               goto _test_eof77;
-case 77:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto tr25;
-               case 67: goto st40;
-               case 69: goto st78;
-               case 99: goto st40;
-               case 101: goto st78;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-st78:
-       if ( ++p == pe )
-               goto _test_eof78;
-case 78:
-       switch( (*p) ) {
-               case 33: goto st17;
-               case 58: goto st79;
-               case 67: goto st40;
-               case 99: goto st40;
-               case 124: goto st17;
-               case 126: goto st17;
-       }
-       if ( (*p) < 45 ) {
-               if ( (*p) > 39 ) {
-                       if ( 42 <= (*p) && (*p) <= 43 )
-                               goto st17;
-               } else if ( (*p) >= 35 )
-                       goto st17;
-       } else if ( (*p) > 46 ) {
-               if ( (*p) < 65 ) {
-                       if ( 48 <= (*p) && (*p) <= 57 )
-                               goto st17;
-               } else if ( (*p) > 90 ) {
-                       if ( 94 <= (*p) && (*p) <= 122 )
-                               goto st17;
-               } else
-                       goto st17;
-       } else
-               goto st17;
-       goto st0;
-tr99:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st79;
-st79:
-       if ( ++p == pe )
-               goto _test_eof79;
-case 79:
-#line 1983 "src/parser.c"
-       switch( (*p) ) {
-               case 13: goto tr98;
-               case 32: goto tr99;
-       }
-       goto tr97;
-tr97:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st80;
-st80:
-       if ( ++p == pe )
-               goto _test_eof80;
-case 80:
-#line 1997 "src/parser.c"
-       if ( (*p) == 13 )
-               goto tr101;
-       goto st80;
-tr9:
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 81; goto _out;}
-  }
-       goto st81;
-tr115:
-#line 61 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
-      {p++; cs = 81; goto _out;}
-  }
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 81; goto _out;}
-  }
-       goto st81;
-tr126:
-#line 76 "src/parser.rl"
-       {MARK(query_start, p); }
-#line 77 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
-      {p++; cs = 81; goto _out;}
-  }
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 81; goto _out;}
-  }
-       goto st81;
-tr130:
-#line 77 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_QUERY_STRING, PTR_TO(query_start), p, 10*1024))
-      {p++; cs = 81; goto _out;}
-  }
-#line 71 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_URI, PTR_TO(mark), p, 12*1024))
-      {p++; cs = 81; goto _out;}
-  }
-       goto st81;
-st81:
-       if ( ++p == pe )
-               goto _test_eof81;
-case 81:
-#line 2050 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr103;
-               case 37: goto tr104;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 127: goto st0;
-       }
-       if ( (*p) > 31 ) {
-               if ( 34 <= (*p) && (*p) <= 35 )
-                       goto st0;
-       } else if ( (*p) >= 0 )
-               goto st0;
-       goto tr102;
-tr102:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st82;
-st82:
-       if ( ++p == pe )
-               goto _test_eof82;
-case 82:
-#line 2072 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr106;
-               case 37: goto st83;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 127: goto st0;
-       }
-       if ( (*p) > 31 ) {
-               if ( 34 <= (*p) && (*p) <= 35 )
-                       goto st0;
-       } else if ( (*p) >= 0 )
-               goto st0;
-       goto st82;
-tr104:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st83;
-st83:
-       if ( ++p == pe )
-               goto _test_eof83;
-case 83:
-#line 2094 "src/parser.c"
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st84;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st84;
-       } else
-               goto st84;
-       goto st0;
-st84:
-       if ( ++p == pe )
-               goto _test_eof84;
-case 84:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st82;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st82;
-       } else
-               goto st82;
-       goto st0;
-tr5:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st85;
-st85:
-       if ( ++p == pe )
-               goto _test_eof85;
-case 85:
-#line 2125 "src/parser.c"
-       switch( (*p) ) {
-               case 43: goto st85;
-               case 58: goto st86;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st85;
-       } else if ( (*p) > 57 ) {
-               if ( (*p) > 90 ) {
-                       if ( 97 <= (*p) && (*p) <= 122 )
-                               goto st85;
-               } else if ( (*p) >= 65 )
-                       goto st85;
-       } else
-               goto st85;
-       goto st0;
-tr7:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st86;
-st86:
-       if ( ++p == pe )
-               goto _test_eof86;
-case 86:
-#line 2150 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr8;
-               case 34: goto st0;
-               case 35: goto tr9;
-               case 37: goto st87;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 127: goto st0;
-       }
-       if ( 0 <= (*p) && (*p) <= 31 )
-               goto st0;
-       goto st86;
-st87:
-       if ( ++p == pe )
-               goto _test_eof87;
-case 87:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st88;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st88;
-       } else
-               goto st88;
-       goto st0;
-st88:
-       if ( ++p == pe )
-               goto _test_eof88;
-case 88:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st86;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st86;
-       } else
-               goto st86;
-       goto st0;
-tr6:
-#line 21 "src/parser.rl"
-       {MARK(mark, p); }
-       goto st89;
-st89:
-       if ( ++p == pe )
-               goto _test_eof89;
-case 89:
-#line 2197 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr114;
-               case 34: goto st0;
-               case 35: goto tr115;
-               case 37: goto st90;
-               case 59: goto tr117;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 63: goto tr118;
-               case 127: goto st0;
-       }
-       if ( 0 <= (*p) && (*p) <= 31 )
-               goto st0;
-       goto st89;
-st90:
-       if ( ++p == pe )
-               goto _test_eof90;
-case 90:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st91;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st91;
-       } else
-               goto st91;
-       goto st0;
-st91:
-       if ( ++p == pe )
-               goto _test_eof91;
-case 91:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st89;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st89;
-       } else
-               goto st89;
-       goto st0;
-tr117:
-#line 61 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
-      {p++; cs = 92; goto _out;}
-  }
-       goto st92;
-st92:
-       if ( ++p == pe )
-               goto _test_eof92;
-case 92:
-#line 2249 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr8;
-               case 34: goto st0;
-               case 35: goto tr9;
-               case 37: goto st93;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 63: goto st95;
-               case 127: goto st0;
-       }
-       if ( 0 <= (*p) && (*p) <= 31 )
-               goto st0;
-       goto st92;
-st93:
-       if ( ++p == pe )
-               goto _test_eof93;
-case 93:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st94;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st94;
-       } else
-               goto st94;
-       goto st0;
-st94:
-       if ( ++p == pe )
-               goto _test_eof94;
-case 94:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st92;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st92;
-       } else
-               goto st92;
-       goto st0;
-tr118:
-#line 61 "src/parser.rl"
-       {
-    if(!apply_element(parser, MONGREL_REQUEST_PATH, PTR_TO(mark), p, 1024))
-      {p++; cs = 95; goto _out;}
-  }
-       goto st95;
-st95:
-       if ( ++p == pe )
-               goto _test_eof95;
-case 95:
-#line 2300 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr125;
-               case 34: goto st0;
-               case 35: goto tr126;
-               case 37: goto tr127;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 127: goto st0;
-       }
-       if ( 0 <= (*p) && (*p) <= 31 )
-               goto st0;
-       goto tr124;
-tr124:
-#line 76 "src/parser.rl"
-       {MARK(query_start, p); }
-       goto st96;
-st96:
-       if ( ++p == pe )
-               goto _test_eof96;
-case 96:
-#line 2321 "src/parser.c"
-       switch( (*p) ) {
-               case 32: goto tr129;
-               case 34: goto st0;
-               case 35: goto tr130;
-               case 37: goto st97;
-               case 60: goto st0;
-               case 62: goto st0;
-               case 127: goto st0;
-       }
-       if ( 0 <= (*p) && (*p) <= 31 )
-               goto st0;
-       goto st96;
-tr127:
-#line 76 "src/parser.rl"
-       {MARK(query_start, p); }
-       goto st97;
-st97:
-       if ( ++p == pe )
-               goto _test_eof97;
-case 97:
-#line 2342 "src/parser.c"
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st98;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st98;
-       } else
-               goto st98;
-       goto st0;
-st98:
-       if ( ++p == pe )
-               goto _test_eof98;
-case 98:
-       if ( (*p) < 65 ) {
-               if ( 48 <= (*p) && (*p) <= 57 )
-                       goto st96;
-       } else if ( (*p) > 70 ) {
-               if ( 97 <= (*p) && (*p) <= 102 )
-                       goto st96;
-       } else
-               goto st96;
-       goto st0;
-st99:
-       if ( ++p == pe )
-               goto _test_eof99;
-case 99:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st100;
-               case 95: goto st100;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st100;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st100;
-       } else
-               goto st100;
-       goto st0;
-st100:
-       if ( ++p == pe )
-               goto _test_eof100;
-case 100:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st101;
-               case 95: goto st101;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st101;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st101;
-       } else
-               goto st101;
-       goto st0;
-st101:
-       if ( ++p == pe )
-               goto _test_eof101;
-case 101:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st102;
-               case 95: goto st102;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st102;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st102;
-       } else
-               goto st102;
-       goto st0;
-st102:
-       if ( ++p == pe )
-               goto _test_eof102;
-case 102:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st103;
-               case 95: goto st103;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st103;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st103;
-       } else
-               goto st103;
-       goto st0;
-st103:
-       if ( ++p == pe )
-               goto _test_eof103;
-case 103:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st104;
-               case 95: goto st104;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st104;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st104;
-       } else
-               goto st104;
-       goto st0;
-st104:
-       if ( ++p == pe )
-               goto _test_eof104;
-case 104:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st105;
-               case 95: goto st105;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st105;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st105;
-       } else
-               goto st105;
-       goto st0;
-st105:
-       if ( ++p == pe )
-               goto _test_eof105;
-case 105:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st106;
-               case 95: goto st106;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st106;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st106;
-       } else
-               goto st106;
-       goto st0;
-st106:
-       if ( ++p == pe )
-               goto _test_eof106;
-case 106:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st107;
-               case 95: goto st107;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st107;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st107;
-       } else
-               goto st107;
-       goto st0;
-st107:
-       if ( ++p == pe )
-               goto _test_eof107;
-case 107:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st108;
-               case 95: goto st108;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st108;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st108;
-       } else
-               goto st108;
-       goto st0;
-st108:
-       if ( ++p == pe )
-               goto _test_eof108;
-case 108:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st109;
-               case 95: goto st109;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st109;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st109;
-       } else
-               goto st109;
-       goto st0;
-st109:
-       if ( ++p == pe )
-               goto _test_eof109;
-case 109:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st110;
-               case 95: goto st110;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st110;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st110;
-       } else
-               goto st110;
-       goto st0;
-st110:
-       if ( ++p == pe )
-               goto _test_eof110;
-case 110:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st111;
-               case 95: goto st111;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st111;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st111;
-       } else
-               goto st111;
-       goto st0;
-st111:
-       if ( ++p == pe )
-               goto _test_eof111;
-case 111:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st112;
-               case 95: goto st112;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st112;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st112;
-       } else
-               goto st112;
-       goto st0;
-st112:
-       if ( ++p == pe )
-               goto _test_eof112;
-case 112:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st113;
-               case 95: goto st113;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st113;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st113;
-       } else
-               goto st113;
-       goto st0;
-st113:
-       if ( ++p == pe )
-               goto _test_eof113;
-case 113:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st114;
-               case 95: goto st114;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st114;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st114;
-       } else
-               goto st114;
-       goto st0;
-st114:
-       if ( ++p == pe )
-               goto _test_eof114;
-case 114:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st115;
-               case 95: goto st115;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st115;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st115;
-       } else
-               goto st115;
-       goto st0;
-st115:
-       if ( ++p == pe )
-               goto _test_eof115;
-case 115:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st116;
-               case 95: goto st116;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st116;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st116;
-       } else
-               goto st116;
-       goto st0;
-st116:
-       if ( ++p == pe )
-               goto _test_eof116;
-case 116:
-       switch( (*p) ) {
-               case 32: goto tr2;
-               case 36: goto st117;
-               case 95: goto st117;
-       }
-       if ( (*p) < 48 ) {
-               if ( 45 <= (*p) && (*p) <= 46 )
-                       goto st117;
-       } else if ( (*p) > 57 ) {
-               if ( 65 <= (*p) && (*p) <= 90 )
-                       goto st117;
-       } else
-               goto st117;
-       goto st0;
-st117:
-       if ( ++p == pe )
-               goto _test_eof117;
-case 117:
-       if ( (*p) == 32 )
-               goto tr2;
-       goto st0;
-       }
-       _test_eof2: cs = 2; goto _test_eof; 
-       _test_eof3: cs = 3; goto _test_eof; 
-       _test_eof4: cs = 4; goto _test_eof; 
-       _test_eof5: cs = 5; goto _test_eof; 
-       _test_eof6: cs = 6; goto _test_eof; 
-       _test_eof7: cs = 7; goto _test_eof; 
-       _test_eof8: cs = 8; goto _test_eof; 
-       _test_eof9: cs = 9; goto _test_eof; 
-       _test_eof10: cs = 10; goto _test_eof; 
-       _test_eof11: cs = 11; goto _test_eof; 
-       _test_eof12: cs = 12; goto _test_eof; 
-       _test_eof13: cs = 13; goto _test_eof; 
-       _test_eof14: cs = 14; goto _test_eof; 
-       _test_eof15: cs = 15; goto _test_eof; 
-       _test_eof16: cs = 16; goto _test_eof; 
-       _test_eof118: cs = 118; goto _test_eof; 
-       _test_eof17: cs = 17; goto _test_eof; 
-       _test_eof18: cs = 18; goto _test_eof; 
-       _test_eof19: cs = 19; goto _test_eof; 
-       _test_eof20: cs = 20; goto _test_eof; 
-       _test_eof21: cs = 21; goto _test_eof; 
-       _test_eof22: cs = 22; goto _test_eof; 
-       _test_eof23: cs = 23; goto _test_eof; 
-       _test_eof24: cs = 24; goto _test_eof; 
-       _test_eof25: cs = 25; goto _test_eof; 
-       _test_eof26: cs = 26; goto _test_eof; 
-       _test_eof27: cs = 27; goto _test_eof; 
-       _test_eof28: cs = 28; goto _test_eof; 
-       _test_eof29: cs = 29; goto _test_eof; 
-       _test_eof30: cs = 30; goto _test_eof; 
-       _test_eof31: cs = 31; goto _test_eof; 
-       _test_eof32: cs = 32; goto _test_eof; 
-       _test_eof33: cs = 33; goto _test_eof; 
-       _test_eof34: cs = 34; goto _test_eof; 
-       _test_eof35: cs = 35; goto _test_eof; 
-       _test_eof36: cs = 36; goto _test_eof; 
-       _test_eof37: cs = 37; goto _test_eof; 
-       _test_eof38: cs = 38; goto _test_eof; 
-       _test_eof39: cs = 39; goto _test_eof; 
-       _test_eof40: cs = 40; goto _test_eof; 
-       _test_eof41: cs = 41; goto _test_eof; 
-       _test_eof42: cs = 42; goto _test_eof; 
-       _test_eof43: cs = 43; goto _test_eof; 
-       _test_eof44: cs = 44; goto _test_eof; 
-       _test_eof45: cs = 45; goto _test_eof; 
-       _test_eof46: cs = 46; goto _test_eof; 
-       _test_eof47: cs = 47; goto _test_eof; 
-       _test_eof48: cs = 48; goto _test_eof; 
-       _test_eof49: cs = 49; goto _test_eof; 
-       _test_eof50: cs = 50; goto _test_eof; 
-       _test_eof51: cs = 51; goto _test_eof; 
-       _test_eof52: cs = 52; goto _test_eof; 
-       _test_eof53: cs = 53; goto _test_eof; 
-       _test_eof54: cs = 54; goto _test_eof; 
-       _test_eof55: cs = 55; goto _test_eof; 
-       _test_eof56: cs = 56; goto _test_eof; 
-       _test_eof57: cs = 57; goto _test_eof; 
-       _test_eof58: cs = 58; goto _test_eof; 
-       _test_eof59: cs = 59; goto _test_eof; 
-       _test_eof60: cs = 60; goto _test_eof; 
-       _test_eof61: cs = 61; goto _test_eof; 
-       _test_eof62: cs = 62; goto _test_eof; 
-       _test_eof63: cs = 63; goto _test_eof; 
-       _test_eof64: cs = 64; goto _test_eof; 
-       _test_eof65: cs = 65; goto _test_eof; 
-       _test_eof66: cs = 66; goto _test_eof; 
-       _test_eof67: cs = 67; goto _test_eof; 
-       _test_eof68: cs = 68; goto _test_eof; 
-       _test_eof69: cs = 69; goto _test_eof; 
-       _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_eof82: cs = 82; goto _test_eof; 
-       _test_eof83: cs = 83; goto _test_eof; 
-       _test_eof84: cs = 84; goto _test_eof; 
-       _test_eof85: cs = 85; goto _test_eof; 
-       _test_eof86: cs = 86; goto _test_eof; 
-       _test_eof87: cs = 87; goto _test_eof; 
-       _test_eof88: cs = 88; goto _test_eof; 
-       _test_eof89: cs = 89; goto _test_eof; 
-       _test_eof90: cs = 90; goto _test_eof; 
-       _test_eof91: cs = 91; goto _test_eof; 
-       _test_eof92: cs = 92; goto _test_eof; 
-       _test_eof93: cs = 93; goto _test_eof; 
-       _test_eof94: cs = 94; goto _test_eof; 
-       _test_eof95: cs = 95; goto _test_eof; 
-       _test_eof96: cs = 96; goto _test_eof; 
-       _test_eof97: cs = 97; goto _test_eof; 
-       _test_eof98: cs = 98; goto _test_eof; 
-       _test_eof99: cs = 99; goto _test_eof; 
-       _test_eof100: cs = 100; goto _test_eof; 
-       _test_eof101: cs = 101; goto _test_eof; 
-       _test_eof102: cs = 102; goto _test_eof; 
-       _test_eof103: cs = 103; goto _test_eof; 
-       _test_eof104: cs = 104; goto _test_eof; 
-       _test_eof105: cs = 105; goto _test_eof; 
-       _test_eof106: cs = 106; goto _test_eof; 
-       _test_eof107: cs = 107; goto _test_eof; 
-       _test_eof108: cs = 108; goto _test_eof; 
-       _test_eof109: cs = 109; goto _test_eof; 
-       _test_eof110: cs = 110; goto _test_eof; 
-       _test_eof111: cs = 111; goto _test_eof; 
-       _test_eof112: cs = 112; goto _test_eof; 
-       _test_eof113: cs = 113; goto _test_eof; 
-       _test_eof114: cs = 114; goto _test_eof; 
-       _test_eof115: cs = 115; goto _test_eof; 
-       _test_eof116: cs = 116; goto _test_eof; 
-       _test_eof117: cs = 117; goto _test_eof; 
-
-       _test_eof: {}
-       _out: {}
-       }
-#line 197 "src/parser.rl"
-  
-  parser->cs = cs;
-  parser->nread += p - (buffer + off);
-  
-  assert(p <= pe && "buffer overflow after parsing execute");
-  assert(parser->nread <= len && "nread longer than length");
-  assert(parser->body_start <= len && "body starts after buffer end");
-  assert(parser->mark < len && "mark is after buffer end");
-  assert(parser->field_len <= len && "field has length longer than whole buffer");
-  assert(parser->field_start < len && "field starts after buffer end");
-  
-  if(parser->nread > 1024 * (80 + 32))
-    parser->overflow_error = TRUE;
-  
-  
-  /* Ragel 6 does not use write eof; no need for this
-  if(parser->body_start) {
-    // final \r\n combo encountered so stop right here 
-    parser->nread++;
-    %% write eof;
-  }
-  */
-  
-  return(parser->nread);
-}
-
-int http_parser_finish(http_parser *parser)
-{
-  if (http_parser_has_error(parser))
-    return -1;
-  else if (http_parser_is_finished(parser))
-    return 1;
-  else
-    return 0;
-}
-
-int http_parser_has_error(http_parser *parser) {
-  return parser->cs == http_parser_error || parser->overflow_error;
-}
-
-int http_parser_is_finished(http_parser *parser) {
-  return parser->cs >= http_parser_first_final;
-}
diff --git a/parser.h b/parser.h
deleted file mode 100644 (file)
index d515281..0000000
--- a/parser.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/**
- * Copyright (c) 2005 Zed A. Shaw
- * You can redistribute it and/or modify it under the same terms as Ruby.
- */
-
-#ifndef http11_parser_h
-#define http11_parser_h
-
-#include <sys/types.h>
-
-#if defined(_WIN32)
-#include <stddef.h>
-#endif
-
-enum { MONGREL_CONTENT_LENGTH
-     , MONGREL_CONTENT_TYPE
-     , MONGREL_FRAGMENT
-     , MONGREL_HTTP_VERSION
-     , MONGREL_QUERY_STRING
-     , MONGREL_REQUEST_PATH
-     , MONGREL_REQUEST_METHOD
-     , MONGREL_REQUEST_URI
-     };
-
-typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
-typedef void (*element_cb)(void *data, int type, const char *at, size_t length);
-
-typedef struct http_parser { 
-  int cs;
-  int overflow_error;
-  size_t body_start;
-  size_t content_length;
-  size_t nread;
-  size_t mark;
-  size_t field_start;
-  size_t field_len;
-  size_t query_start;
-
-  void *data;
-
-  field_cb http_field;
-  element_cb on_element;
-} http_parser;
-
-void http_parser_init(http_parser *parser);
-int http_parser_finish(http_parser *parser);
-size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
-int http_parser_has_error(http_parser *parser);
-int http_parser_is_finished(http_parser *parser);
-
-#define http_parser_nread(parser) (parser)->nread 
-
-#endif