cool.io 1.2.0-x86-mswin32-60

data/ext/cool.io/watcher.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifndef WATCHER_H
+#define WATCHER_H
+
+#define Watcher_Attach(watcher_type, detach_func, watcher, loop) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  if(!rb_obj_is_kind_of(loop, cCoolio_Loop)) \
+    rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop"); \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  Data_Get_Struct(loop, struct Coolio_Loop, loop_data); \
+  \
+  if(watcher_data->loop != Qnil) \
+    detach_func(watcher); \
+  \
+  watcher_data->loop = loop; \
+  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  rb_call_super(1, &loop)
+
+#define Watcher_Detach(watcher_type, watcher) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  \
+  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  rb_call_super(0, 0)
+
+#define Watcher_Enable(watcher_type, watcher) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  rb_call_super(0, 0); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  \
+  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
+
+#define Watcher_Disable(watcher_type, watcher) \
+  struct Coolio_Watcher *watcher_data; \
+  struct Coolio_Loop *loop_data; \
+  \
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  \
+  if(watcher_data->loop == Qnil) \
+    rb_raise(rb_eRuntimeError, "not attached to a loop"); \
+  \
+  rb_call_super(0, 0); \
+  \
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  \
+  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
+
+#endif

data/ext/http11_client/.gitignore

@@ -0,0 +1,5 @@
+Makefile
+mkmf.log
+*.o
+*.so
+*.bundle

data/ext/http11_client/LICENSE

@@ -0,0 +1,31 @@
+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.
+

data/ext/http11_client/ext_help.h

@@ -0,0 +1,14 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+#define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
+#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE() 
+#endif
+
+#endif

data/ext/http11_client/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config("http11_client")
+have_library("c", "main")
+
+create_makefile("http11_client")

data/ext/http11_client/http11_client.c

@@ -0,0 +1,300 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#include "ruby.h"
+#include "ext_help.h"
+#include <assert.h>
+#include <string.h>
+#include "http11_parser.h"
+#include <ctype.h>
+
+static VALUE mCoolio;
+static VALUE cHttpClientParser;
+static VALUE eHttpClientParserError;
+
+#define  id_reason rb_intern("@http_reason")
+#define  id_status rb_intern("@http_status")
+#define  id_version rb_intern("@http_version")
+#define  id_body rb_intern("@http_body")
+#define  id_chunk_size rb_intern("@http_chunk_size")
+#define  id_last_chunk rb_intern("@last_chunk")
+
+void client_http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
+{
+  char *ch, *end;
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+  VALUE f = Qnil;
+
+  v = rb_str_new(value, vlen);
+  f = rb_str_new(field, flen);
+
+  /* Yes Children, rb_str_upcase_bang isn't even available as an intern.h function.
+   * how incredibly handy to not have that.  Nope, I have to do it by hand.*/
+  for(ch = RSTRING_PTR(f), end = ch + RSTRING_LEN(f); ch < end; ch++) {
+    if(*ch == '-') {
+      *ch = '_';
+    } else {
+      *ch = toupper(*ch);
+    }
+  }
+
+  rb_hash_aset(req, f, v);
+}
+
+void client_reason_phrase(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_reason, v);
+}
+
+void client_status_code(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_status, v);
+}
+
+void client_http_version(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_version, v);
+}
+
+/** Finalizes the request header to have a bunch of stuff that's
+  needed. */
+void client_header_done(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  v = rb_str_new(at, length);
+  rb_ivar_set(req, id_body, v);
+}
+
+void client_chunk_size(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+
+  if(length <= 0) {
+    rb_raise(eHttpClientParserError, "Chunked Encoding gave <= 0 chunk size.");
+  }
+
+  v = rb_str_new(at, length);
+
+  rb_ivar_set(req, id_chunk_size, v);
+}
+
+void client_last_chunk(void *data, const char *at, size_t length) {
+  VALUE req = (VALUE)data;
+  rb_ivar_set(req, id_last_chunk,Qtrue);
+}
+
+
+void HttpClientParser_free(void *data) {
+  TRACE();
+
+  if(data) {
+    free(data);
+  }
+}
+
+
+VALUE HttpClientParser_alloc(VALUE klass)
+{
+  VALUE obj;
+  httpclient_parser *hp = ALLOC_N(httpclient_parser, 1);
+  TRACE();
+  hp->http_field = client_http_field;
+  hp->status_code = client_status_code;
+  hp->reason_phrase = client_reason_phrase;
+  hp->http_version = client_http_version;
+  hp->header_done = client_header_done;
+  hp->chunk_size = client_chunk_size;
+  hp->last_chunk = client_last_chunk;
+  httpclient_parser_init(hp);
+
+  obj = Data_Wrap_Struct(klass, NULL, HttpClientParser_free, hp);
+
+  return obj;
+}
+
+
+/**
+ * call-seq:
+ *    parser.new -> parser
+ *
+ * Creates a new parser.
+ */
+VALUE HttpClientParser_init(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+  httpclient_parser_init(http);
+
+  return self;
+}
+
+
+/**
+ * call-seq:
+ *    parser.reset -> nil
+ *
+ * Resets the parser to it's initial state so that you can reuse it
+ * rather than making new ones.
+ */
+VALUE HttpClientParser_reset(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+  httpclient_parser_init(http);
+
+  return Qnil;
+}
+
+
+/**
+ * call-seq:
+ *    parser.finish -> true/false
+ *
+ * Finishes a parser early which could put in a "good" or bad state.
+ * You should call reset after finish it or bad things will happen.
+ */
+VALUE HttpClientParser_finish(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+  httpclient_parser_finish(http);
+
+  return httpclient_parser_is_finished(http) ? Qtrue : Qfalse;
+}
+
+
+/**
+ * call-seq:
+ *    parser.execute(req_hash, data, start) -> Integer
+ *
+ * Takes a Hash and a String of data, parses the String of data filling in the Hash
+ * returning an Integer to indicate how much of the data has been read.  No matter
+ * what the return value, you should call HttpClientParser#finished? and HttpClientParser#error?
+ * to figure out if it's done parsing or there was an error.
+ * 
+ * This function now throws an exception when there is a parsing error.  This makes 
+ * the logic for working with the parser much easier.  You can still test for an 
+ * error, but now you need to wrap the parser with an exception handling block.
+ *
+ * The third argument allows for parsing a partial request and then continuing
+ * the parsing from that position.  It needs all of the original data as well 
+ * so you have to append to the data buffer as you read.
+ */
+VALUE HttpClientParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+{
+  httpclient_parser *http = NULL;
+  int from = 0;
+  char *dptr = NULL;
+  long dlen = 0;
+
+  REQUIRE_TYPE(req_hash, T_HASH);
+  REQUIRE_TYPE(data, T_STRING);
+  REQUIRE_TYPE(start, T_FIXNUM);
+
+  DATA_GET(self, httpclient_parser, http);
+
+  from = FIX2INT(start);
+  dptr = RSTRING_PTR(data);
+  dlen = RSTRING_LEN(data);
+
+  if(from >= dlen) {
+    rb_raise(eHttpClientParserError, "Requested start is after data buffer end.");
+  } else {
+    http->data = (void *)req_hash;
+    httpclient_parser_execute(http, dptr, dlen, from);
+
+    if(httpclient_parser_has_error(http)) {
+      rb_raise(eHttpClientParserError, "Invalid HTTP format, parsing fails.");
+    } else {
+      return INT2FIX(httpclient_parser_nread(http));
+    }
+  }
+}
+
+
+
+/**
+ * call-seq:
+ *    parser.error? -> true/false
+ *
+ * Tells you whether the parser is in an error state.
+ */
+VALUE HttpClientParser_has_error(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+
+  return httpclient_parser_has_error(http) ? Qtrue : Qfalse;
+}
+
+
+/**
+ * call-seq:
+ *    parser.finished? -> true/false
+ *
+ * Tells you whether the parser is finished or not and in a good state.
+ */
+VALUE HttpClientParser_is_finished(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+
+  return httpclient_parser_is_finished(http) ? Qtrue : Qfalse;
+}
+
+
+/**
+ * call-seq:
+ *    parser.nread -> Integer
+ *
+ * Returns the amount of data processed so far during this processing cycle.  It is
+ * set to 0 on initialize or reset calls and is incremented each time execute is called.
+ */
+VALUE HttpClientParser_nread(VALUE self)
+{
+  httpclient_parser *http = NULL;
+  DATA_GET(self, httpclient_parser, http);
+
+  return INT2FIX(http->nread);
+}
+
+
+
+void Init_http11_client()
+{
+
+  mCoolio = rb_define_module("Coolio");
+
+  eHttpClientParserError = rb_define_class_under(mCoolio, "HttpClientParserError", rb_eIOError);
+
+  cHttpClientParser = rb_define_class_under(mCoolio, "HttpClientParser", rb_cObject);
+  rb_define_alloc_func(cHttpClientParser, HttpClientParser_alloc);
+  rb_define_method(cHttpClientParser, "initialize", HttpClientParser_init,0);
+  rb_define_method(cHttpClientParser, "reset", HttpClientParser_reset,0);
+  rb_define_method(cHttpClientParser, "finish", HttpClientParser_finish,0);
+  rb_define_method(cHttpClientParser, "execute", HttpClientParser_execute,3);
+  rb_define_method(cHttpClientParser, "error?", HttpClientParser_has_error,0);
+  rb_define_method(cHttpClientParser, "finished?", HttpClientParser_is_finished,0);
+  rb_define_method(cHttpClientParser, "nread", HttpClientParser_nread,0);
+}

data/ext/http11_client/http11_parser.c

@@ -0,0 +1,403 @@
+#line 1 "http11_parser.rl"
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#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)
+#define L(M) fprintf(stderr, "" # M "\n");
+
+
+/** machine **/
+#line 95 "http11_parser.rl"
+
+
+/** Data **/
+
+#line 27 "http11_parser.c"
+static const char _httpclient_parser_actions[] = {
+	0, 1, 0, 1, 1, 1, 2, 1, 
+	3, 1, 4, 1, 5, 1, 7, 1, 
+	8, 1, 10, 2, 2, 3, 2, 6, 
+	0, 2, 6, 5, 2, 9, 10, 2, 
+	10, 9, 3, 2, 3, 4
+};
+
+static const short _httpclient_parser_key_offsets[] = {
+	0, 10, 10, 11, 22, 26, 27, 28, 
+	39, 54, 75, 90, 110, 125, 146, 161, 
+	181, 196, 214, 229, 246, 247, 248, 249, 
+	250, 252, 255, 257, 260, 262, 264, 266, 
+	268, 269, 270, 286, 302, 304, 305, 306
+};
+
+static const char _httpclient_parser_trans_keys[] = {
+	13, 48, 59, 72, 49, 57, 65, 70, 
+	97, 102, 10, 13, 32, 59, 9, 12, 
+	48, 57, 65, 70, 97, 102, 13, 32, 
+	9, 12, 10, 10, 13, 32, 59, 9, 
+	12, 48, 57, 65, 70, 97, 102, 33, 
+	124, 126, 35, 39, 42, 43, 45, 46, 
+	48, 57, 65, 90, 94, 122, 13, 32, 
+	33, 59, 61, 124, 126, 9, 12, 35, 
+	39, 42, 43, 45, 46, 48, 57, 65, 
+	90, 94, 122, 33, 124, 126, 35, 39, 
+	42, 43, 45, 46, 48, 57, 65, 90, 
+	94, 122, 13, 32, 33, 59, 124, 126, 
+	9, 12, 35, 39, 42, 43, 45, 46, 
+	48, 57, 65, 90, 94, 122, 33, 124, 
+	126, 35, 39, 42, 43, 45, 46, 48, 
+	57, 65, 90, 94, 122, 13, 32, 33, 
+	59, 61, 124, 126, 9, 12, 35, 39, 
+	42, 43, 45, 46, 48, 57, 65, 90, 
+	94, 122, 33, 124, 126, 35, 39, 42, 
+	43, 45, 46, 48, 57, 65, 90, 94, 
+	122, 13, 32, 33, 59, 124, 126, 9, 
+	12, 35, 39, 42, 43, 45, 46, 48, 
+	57, 65, 90, 94, 122, 33, 124, 126, 
+	35, 39, 42, 43, 45, 46, 48, 57, 
+	65, 90, 94, 122, 13, 33, 59, 61, 
+	124, 126, 35, 39, 42, 43, 45, 46, 
+	48, 57, 65, 90, 94, 122, 33, 124, 
+	126, 35, 39, 42, 43, 45, 46, 48, 
+	57, 65, 90, 94, 122, 13, 33, 59, 
+	124, 126, 35, 39, 42, 43, 45, 46, 
+	48, 57, 65, 90, 94, 122, 84, 84, 
+	80, 47, 48, 57, 46, 48, 57, 48, 
+	57, 32, 48, 57, 48, 57, 48, 57, 
+	48, 57, 13, 32, 13, 10, 13, 33, 
+	124, 126, 35, 39, 42, 43, 45, 46, 
+	48, 57, 65, 90, 94, 122, 33, 58, 
+	124, 126, 35, 39, 42, 43, 45, 46, 
+	48, 57, 65, 90, 94, 122, 13, 32, 
+	13, 13, 0
+};
+
+static const char _httpclient_parser_single_lengths[] = {
+	4, 0, 1, 3, 2, 1, 1, 3, 
+	3, 7, 3, 6, 3, 7, 3, 6, 
+	3, 6, 3, 5, 1, 1, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 2, 
+	1, 1, 4, 4, 2, 1, 1, 0
+};
+
+static const char _httpclient_parser_range_lengths[] = {
+	3, 0, 0, 4, 1, 0, 0, 4, 
+	6, 7, 6, 7, 6, 7, 6, 7, 
+	6, 6, 6, 6, 0, 0, 0, 0, 
+	1, 1, 1, 1, 1, 1, 1, 0, 
+	0, 0, 6, 6, 0, 0, 0, 0
+};
+
+static const unsigned char _httpclient_parser_index_offsets[] = {
+	0, 8, 8, 10, 18, 22, 24, 26, 
+	34, 44, 59, 69, 83, 93, 108, 118, 
+	132, 142, 155, 165, 177, 179, 181, 183, 
+	185, 187, 190, 192, 195, 197, 199, 201, 
+	204, 206, 208, 219, 230, 233, 235, 237
+};
+
+static const char _httpclient_parser_indicies[] = {
+	14, 15, 17, 18, 16, 16, 16, 0, 
+	30, 0, 63, 37, 64, 37, 39, 39, 
+	39, 0, 19, 32, 32, 0, 29, 0, 
+	31, 0, 38, 37, 40, 37, 39, 39, 
+	39, 0, 58, 58, 58, 58, 58, 58, 
+	58, 58, 58, 0, 42, 41, 43, 44, 
+	45, 43, 43, 41, 43, 43, 43, 43, 
+	43, 43, 0, 59, 59, 59, 59, 59, 
+	59, 59, 59, 59, 0, 34, 33, 35, 
+	36, 35, 35, 33, 35, 35, 35, 35, 
+	35, 35, 0, 70, 70, 70, 70, 70, 
+	70, 70, 70, 70, 0, 65, 41, 66, 
+	67, 68, 66, 66, 41, 66, 66, 66, 
+	66, 66, 66, 0, 69, 69, 69, 69, 
+	69, 69, 69, 69, 69, 0, 60, 33, 
+	61, 62, 61, 61, 33, 61, 61, 61, 
+	61, 61, 61, 0, 10, 10, 10, 10, 
+	10, 10, 10, 10, 10, 0, 24, 25, 
+	26, 27, 25, 25, 25, 25, 25, 25, 
+	25, 25, 0, 11, 11, 11, 11, 11, 
+	11, 11, 11, 11, 0, 21, 22, 23, 
+	22, 22, 22, 22, 22, 22, 22, 22, 
+	0, 1, 0, 56, 0, 2, 0, 5, 
+	0, 7, 0, 6, 7, 0, 13, 0, 
+	12, 13, 0, 4, 0, 3, 0, 57, 
+	0, 54, 55, 53, 49, 48, 28, 0, 
+	19, 20, 20, 20, 20, 20, 20, 20, 
+	20, 20, 0, 8, 9, 8, 8, 8, 
+	8, 8, 8, 8, 8, 0, 47, 52, 
+	51, 47, 46, 49, 50, 0, 0
+};
+
+static const char _httpclient_parser_trans_targs_wi[] = {
+	1, 21, 23, 30, 29, 24, 26, 25, 
+	35, 36, 17, 19, 28, 27, 2, 3, 
+	7, 16, 20, 5, 35, 2, 19, 16, 
+	2, 17, 16, 18, 34, 39, 39, 39, 
+	4, 4, 5, 11, 8, 4, 5, 7, 
+	8, 4, 5, 9, 8, 10, 37, 33, 
+	32, 33, 32, 37, 36, 32, 33, 38, 
+	22, 31, 9, 11, 6, 15, 12, 6, 
+	12, 6, 13, 12, 14, 15, 13
+};
+
+static const char _httpclient_parser_trans_actions_wi[] = {
+	0, 0, 0, 0, 1, 0, 0, 0, 
+	0, 5, 3, 7, 13, 0, 0, 1, 
+	1, 0, 1, 0, 3, 9, 0, 9, 
+	34, 0, 34, 19, 0, 17, 28, 31, 
+	0, 9, 9, 0, 9, 15, 15, 0, 
+	15, 34, 34, 0, 34, 19, 0, 9, 
+	0, 11, 1, 7, 7, 22, 25, 22, 
+	0, 0, 3, 7, 9, 0, 9, 15, 
+	15, 34, 0, 34, 19, 7, 3
+};
+
+static const int httpclient_parser_start = 0;
+
+static const int httpclient_parser_first_final = 39;
+
+static const int httpclient_parser_error = 1;
+
+#line 99 "http11_parser.rl"
+
+int httpclient_parser_init(httpclient_parser *parser)  {
+  int cs = 0;
+  
+#line 178 "http11_parser.c"
+	{
+	cs = httpclient_parser_start;
+	}
+#line 103 "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 httpclient_parser_execute(httpclient_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;
+
+  assert(*pe == '\0' && "pointer does not end on NUL");
+  assert(pe - p == len - off && "pointers aren't same distance");
+
+
+  
+#line 210 "http11_parser.c"
+	{
+	int _klen;
+	unsigned int _trans;
+	const char *_acts;
+	unsigned int _nacts;
+	const char *_keys;
+
+	if ( p == pe )
+		goto _out;
+_resume:
+	if ( cs == 1 )
+		goto _out;
+	_keys = _httpclient_parser_trans_keys + _httpclient_parser_key_offsets[cs];
+	_trans = _httpclient_parser_index_offsets[cs];
+
+	_klen = _httpclient_parser_single_lengths[cs];
+	if ( _klen > 0 ) {
+		const char *_lower = _keys;
+		const char *_mid;
+		const char *_upper = _keys + _klen - 1;
+		while (1) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + ((_upper-_lower) >> 1);
+			if ( (*p) < *_mid )
+				_upper = _mid - 1;
+			else if ( (*p) > *_mid )
+				_lower = _mid + 1;
+			else {
+				_trans += (_mid - _keys);
+				goto _match;
+			}
+		}
+		_keys += _klen;
+		_trans += _klen;
+	}
+
+	_klen = _httpclient_parser_range_lengths[cs];
+	if ( _klen > 0 ) {
+		const char *_lower = _keys;
+		const char *_mid;
+		const char *_upper = _keys + (_klen<<1) - 2;
+		while (1) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + (((_upper-_lower) >> 1) & ~1);
+			if ( (*p) < _mid[0] )
+				_upper = _mid - 2;
+			else if ( (*p) > _mid[1] )
+				_lower = _mid + 2;
+			else {
+				_trans += ((_mid - _keys)>>1);
+				goto _match;
+			}
+		}
+		_trans += _klen;
+	}
+
+_match:
+	_trans = _httpclient_parser_indicies[_trans];
+	cs = _httpclient_parser_trans_targs_wi[_trans];
+
+	if ( _httpclient_parser_trans_actions_wi[_trans] == 0 )
+		goto _again;
+
+	_acts = _httpclient_parser_actions + _httpclient_parser_trans_actions_wi[_trans];
+	_nacts = (unsigned int) *_acts++;
+	while ( _nacts-- > 0 )
+	{
+		switch ( *_acts++ )
+		{
+	case 0:
+#line 23 "http11_parser.rl"
+	{MARK(mark, p); }
+	break;
+	case 1:
+#line 25 "http11_parser.rl"
+	{ MARK(field_start, p); }
+	break;
+	case 2:
+#line 27 "http11_parser.rl"
+	{ 
+    parser->field_len = LEN(field_start, p);
+  }
+	break;
+	case 3:
+#line 31 "http11_parser.rl"
+	{ MARK(mark, p); }
+	break;
+	case 4:
+#line 33 "http11_parser.rl"
+	{ 
+    parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+  }
+	break;
+	case 5:
+#line 37 "http11_parser.rl"
+	{ 
+    parser->reason_phrase(parser->data, PTR_TO(mark), LEN(mark, p));
+  }
+	break;
+	case 6:
+#line 41 "http11_parser.rl"
+	{ 
+    parser->status_code(parser->data, PTR_TO(mark), LEN(mark, p));
+  }
+	break;
+	case 7:
+#line 45 "http11_parser.rl"
+	{	
+    parser->http_version(parser->data, PTR_TO(mark), LEN(mark, p));
+  }
+	break;
+	case 8:
+#line 49 "http11_parser.rl"
+	{
+    parser->chunk_size(parser->data, PTR_TO(mark), LEN(mark, p));
+  }
+	break;
+	case 9:
+#line 53 "http11_parser.rl"
+	{
+    parser->last_chunk(parser->data, NULL, 0);
+  }
+	break;
+	case 10:
+#line 57 "http11_parser.rl"
+	{ 
+    parser->body_start = p - buffer + 1; 
+    if(parser->header_done != NULL)
+      parser->header_done(parser->data, p + 1, pe - p - 1);
+    goto _out;
+  }
+	break;
+#line 347 "http11_parser.c"
+		}
+	}
+
+_again:
+	if ( ++p != pe )
+		goto _resume;
+	_out: {}
+	}
+#line 130 "http11_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->body_start) {
+    /* final \r\n combo encountered so stop right here */
+    
+#line 371 "http11_parser.c"
+#line 144 "http11_parser.rl"
+    parser->nread++;
+  }
+
+  return(parser->nread);
+}
+
+int httpclient_parser_finish(httpclient_parser *parser)
+{
+  int cs = parser->cs;
+
+  
+#line 384 "http11_parser.c"
+#line 155 "http11_parser.rl"
+
+  parser->cs = cs;
+
+  if (httpclient_parser_has_error(parser) ) {
+    return -1;
+  } else if (httpclient_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int httpclient_parser_has_error(httpclient_parser *parser) {
+  return parser->cs == httpclient_parser_error;
+}
+
+int httpclient_parser_is_finished(httpclient_parser *parser) {
+  return parser->cs == httpclient_parser_first_final;
+}