mongrel_esi 0.5.0 → 0.5.1

data/ext/esi/parser.rl

@@ -15,6 +15,8 @@ static void debug_string( const char *msg, const char *str, size_t len )
   printf( "%s :'%s'\n", msg, pstr );
   free( pstr );
 }
+#else
+#define debug_string(m,s,l)
 #endif
 
 /* define default callbacks */
@@ -93,7 +95,7 @@ static void esi_parser_concat_to_echobuffer( ESIParser *parser, char ch )
 {
   parser->echobuffer_index++;
 
-  if( parser->echobuffer_allocated <= parser->echobuffer_index ){
+  if( parser->echobuffer_allocated <= parser->echobuffer_index ) {
     /* double the echobuffer size 
      * we're getting some crazy input if this case ever happens
      */
@@ -114,7 +116,7 @@ static void ltrim_pointer( const char **ptr, const char *bounds, size_t *len )
          **ptr == '=' ||
          **ptr == '"' ||
          **ptr == '<' ||
-         **ptr == '\'' ) && (*len > 0) && (*ptr != bounds) ){
+         **ptr == '\'' ) && (*len > 0) && (*ptr != bounds) ) {
     (*ptr)++;
     (*len)--;
   }
@@ -229,11 +231,11 @@ static void rtrim_pointer( const char **ptr, const char *bounds, size_t *len )
                               parser->attr_value, parser->attr_value_length );
 
     /* add the new attribute to the list of attributes */
-    if( parser->attributes ){
+    if( parser->attributes ) {
       parser->last->next = attr;
       parser->last = attr;
     }
-    else{
+    else {
       parser->last = parser->attributes = attr;
     }
   }
@@ -277,7 +279,7 @@ static void rtrim_pointer( const char **ptr, const char *bounds, size_t *len )
   # process each character in the input stream for output
   action echo {
     //printf( "[%c:%d],", *p, cs );
-    switch( cs ){
+    switch( cs ) {
     case 0: /* non matching state */
       if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
         if( parser->echobuffer && parser->echobuffer_index != -1 ){
@@ -363,11 +365,14 @@ ESIParser *esi_parser_new()
   ESIParser *parser = (ESIParser*)malloc(sizeof(ESIParser));
   parser->cs = esi_start;
   parser->mark = NULL;
+  parser->tag_text = NULL;
+  parser->attr_key = NULL;
+  parser->attr_value = NULL;
   parser->overflow_data_size = 0;
   parser->overflow_data = NULL;
 
-  /* allocate 1024 bytes for the echobuffer */
-  parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE; /* NOTE: change this value, to reduce memory consumtion or allocations */
+  /* allocate ESI_OUTPUT_BUFFER_SIZE bytes for the echobuffer */
+  parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
   parser->echobuffer_index = -1;
   parser->echobuffer = (char*)malloc(sizeof(char)*parser->echobuffer_allocated);
 
@@ -408,12 +413,58 @@ int esi_parser_init( ESIParser *parser )
 
 static int compute_offset( const char *mark, const char *data )
 {
-  if( mark ){
+  if( mark ) {
     return mark - data;
   }
   return -1;
 }
 
+/*
+ * scans the data buffer for a start sequence /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/
+ * returns index of if start sequence found else returns -1
+ */
+static int
+esi_parser_scan_for_start( ESIParser *parser, const char *data, size_t length )
+{
+  size_t i, f = -2, s = -2;
+  char ch;
+
+  for( i = 0; i < length; ++i ) {
+    ch = data[i];
+    switch( ch ) {
+    case '<':
+      f = s = i;
+      break;
+    case '/':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case 'e':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case 's':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case 'i':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case ':':
+      if( s == (i-1) && f != -2 ) { s = i; return f; }
+      break;
+    default:
+      f = s = -2;
+      break;
+    }
+  }
+
+  // if s and f are still valid at end of input return f
+  if( f != -2 && s != -2 ) {
+    return f;
+  }
+  else {
+    return -1;
+  }
+}
+
 /* accept an arbitrary length string buffer
  * when this methods exits it determines if an end state was reached
  * if no end state was reached it saves the full input into an internal buffer
@@ -426,11 +477,23 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
   const char *p = data;
   const char *eof = NULL; // ragel 6.x compat
   const char *pe = data + length;
+  int pindex;
 
   if( length == 0 ){ return cs; }
 
+  /* scan data for any '<esi:' start sequences, /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/ */
+  if( cs == esi_start ) { 
+    pindex = esi_parser_scan_for_start( parser, data, length );
+    if( pindex == -1 ) {
+      for( pindex = 0; pindex < length; ++pindex ) {
+        esi_parser_echo_char( parser, data[pindex] );
+      }
+      return cs;
+    }
+  }
+
   /* there's an existing overflow buffer data append the new data to the existing data */
-  if( parser->overflow_data && parser->overflow_data_size > 0 ){
+  if( parser->overflow_data && parser->overflow_data_size > 0 ) {
 
     // recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
     int mark_offset = compute_offset( parser->mark, parser->overflow_data );
@@ -456,7 +519,7 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
 
   }
 
-  if( !parser->mark ){
+  if( !parser->mark ) {
     parser->mark = p;
   }
 
@@ -466,7 +529,7 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
 
   parser->cs = cs;
 
-  if( cs != esi_start && cs != 0 ){
+  if( cs != esi_start && cs != 0 ) {
 
     /* reached the end and we're not at a termination point save the buffer as overflow */
     if( !parser->overflow_data ){
@@ -477,10 +540,16 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
       int attr_value_offset = compute_offset( parser->attr_value, data );
       //debug_string( "mark before move", parser->mark, 1 );
 
-      parser->overflow_data = (char*)malloc( sizeof( char ) * length );
+      if( ESI_OUTPUT_BUFFER_SIZE > length ) {
+        parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
+      }
+      else {
+        parser->echobuffer_allocated = length;
+      }
+      parser->overflow_data = (char*)malloc( sizeof( char ) * parser->echobuffer_allocated );
       memcpy( parser->overflow_data, data, length );
       parser->overflow_data_size = length;
-//      printf( "allocate overflow data: %ld\n", parser->overflow_data_size );
+      //printf( "allocate overflow data: %ld\n", parser->echobuffer_allocated );
 
       // in our new memory space mark will now be
       parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
@@ -490,7 +559,7 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
       //if( parser->mark ){ debug_string( "mark after  move", parser->mark, 1 ); } else { printf( "mark is now empty\n" ); }
     }
 
-  }else if( parser->overflow_data ){
+  }else if( parser->overflow_data ) {
     /* dump the overflow buffer execution ended at a final state */
     free( parser->overflow_data );
     parser->overflow_data = NULL;

data/ext/esi/test/parser.c

@@ -1,10 +1,25 @@
 #line 1 "parser.rl"
+/** 
+ * Copyright (c) 2008 Todd A. Fisher
+ * see LICENSE
+ */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
+#include <ctype.h>
 #include "parser.h"
 
+#ifdef DEBUG
+static void debug_string( const char *msg, const char *str, size_t len )
+{
+  char *pstr = esi_strndup( str, len );
+  printf( "%s :'%s'\n", msg, pstr );
+  free( pstr );
+}
+#else
+#define debug_string(m,s,l)
+#endif
+
 /* define default callbacks */
 static void 
 esi_parser_default_start_cb( const void *data,
@@ -28,258 +43,129 @@ esi_parser_default_output_cp(const void *data,
 {
 }
 
-#if defined(DEBUG)
-static void debug_string( const char *msg, const char *str, size_t len )
+/* 
+ * flush output buffer
+ */
+static void esi_parser_flush_output( ESIParser *parser )
 {
-  char *pstr = esi_strndup( str, len );
-  printf( "%s :'%s'\n", msg, pstr );
-  free( pstr );
+  if( parser->output_buffer_size > 0 ) {
+    //debug_string( "esi_parser_flush_output:", parser->output_buffer, parser->output_buffer_size );
+    parser->output_handler( (void*)parser->output_buffer, parser->output_buffer_size, parser->user_data );
+    parser->output_buffer_size = 0;
+  }
 }
-#endif
-
+/* send the character to the output handler marking it 
+ * as ready for consumption, e.g. not an esi tag
+ */
 static void esi_parser_echo_char( ESIParser *parser, char ch )
 {
-  parser->output_handler( (void*)&ch, 1, parser->user_data );
+  parser->output_buffer[parser->output_buffer_size++] = ch;
+  if( parser->output_buffer_size == ESI_OUTPUT_BUFFER_SIZE ) {
+    // flush the buffer to the consumer
+    esi_parser_flush_output( parser );
+  }
 }
-
+/* send any buffered characters to the output handler. 
+ * This happens when we enter a case such as <em>  where the
+ * first two characters < and e  match the <esi:  expression
+ */
 static void esi_parser_echo_buffer( ESIParser *parser )
 {
-//  debug_string( "echobuffer", parser->echobuffer, parser->echobuffer_index+1 );
-  parser->output_handler( parser->echobuffer, parser->echobuffer_index+1, parser->user_data );
+  size_t i = 0, len = parser->echobuffer_index + 1;;
+  //debug_string( "echobuffer", parser->echobuffer, parser->echobuffer_index+1 );
+  //parser->output_handler( parser->echobuffer, parser->echobuffer_index+1, parser->user_data );
+  for( ; i < len; ++i ) {
+    esi_parser_echo_char( parser, parser->echobuffer[i] );
+  }
 }
-
+/*
+ * clear the buffer, no buffered characters should be emitted .
+ * e.g. we matched an esi tag completely and all buffered characters can be tossed out
+ */
 static void esi_parser_echobuffer_clear( ESIParser *parser )
 {
   parser->echobuffer_index = -1;
 }
 
+/*
+ * add a character to the echobuffer. 
+ * this happens when we can't determine if the character is allowed to be sent to the client device
+ * e.g. matching <e  it's not yet determined if these characters are safe to send or not
+ */
 static void esi_parser_concat_to_echobuffer( ESIParser *parser, char ch )
 {
   parser->echobuffer_index++;
 
-  if( parser->echobuffer_allocated <= parser->echobuffer_index ){
-    // double the echobuffer size
+  if( parser->echobuffer_allocated <= parser->echobuffer_index ) {
+    /* double the echobuffer size 
+     * we're getting some crazy input if this case ever happens
+     */
     parser->echobuffer_allocated *= 2;
     parser->echobuffer = (char*)realloc( parser->echobuffer, parser->echobuffer_allocated );
   }
   parser->echobuffer[parser->echobuffer_index] = ch;
 //  debug_string( "echo buffer", parser->echobuffer, parser->echobuffer_index+1 );
 }
+/*
+ * the mark boundary is not always going to be exactly on the attribute or tag name boundary
+ * this trims characters from the left to right, advancing *ptr and reducing *len
+ */
+static void ltrim_pointer( const char **ptr, const char *bounds, size_t *len )
+{
+  // remove any spaces or = at the before the value
+  while( (isspace( **ptr ) ||
+         **ptr == '=' ||
+         **ptr == '"' ||
+         **ptr == '<' ||
+         **ptr == '\'' ) && (*len > 0) && (*ptr != bounds) ) {
+    (*ptr)++;
+    (*len)--;
+  }
+}
+/*
+ * similar to ltrim_pointer, this walks from bounds to *ptr, reducing *len 
+ */
+static void rtrim_pointer( const char **ptr, const char *bounds, size_t *len )
+{
+  bounds = (*ptr+(*len-1));
+  // remove any spaces or = at the before the value
+  while( (isspace( *bounds ) ||
+         *bounds == '=' ||
+         *bounds == '"' ||
+         *bounds == '>' ||
+         *bounds == '\'') && (*len > 0) && (*ptr != bounds) ){
+    bounds--;
+    (*len)--;
+  }
+}
 
-#line 164 "parser.rl"
-
-
-
-#line 74 "parser.c"
-static const char _esi_actions[] = {
-	0, 1, 9, 2, 9, 0, 2, 9, 
-	1, 2, 9, 2, 2, 9, 3, 2, 
-	9, 4, 2, 9, 5, 2, 9, 6, 
-	2, 9, 7, 2, 9, 8, 3, 9, 
-	0, 1, 3, 9, 3, 1, 4, 9, 
-	0, 3, 1, 4, 9, 3, 6, 1
-	
-};
-
-static const short _esi_key_offsets[] = {
-	0, 1, 4, 6, 8, 10, 12, 15, 
-	19, 21, 23, 25, 28, 36, 48, 59, 
-	69, 75, 85, 94, 106, 117, 119, 130, 
-	140, 150, 160, 170, 180, 191, 201, 211, 
-	221, 231, 246, 256, 265, 277, 288, 298, 
-	304, 314, 325, 335, 345, 355, 365, 375, 
-	386, 396, 406, 416, 426, 441, 451, 453, 
-	455, 456, 457, 466, 475
-};
-
-static const char _esi_trans_keys[] = {
-	60, 47, 60, 101, 60, 101, 60, 115, 
-	60, 105, 58, 60, 60, 97, 122, 60, 
-	62, 97, 122, 60, 115, 60, 105, 58, 
-	60, 60, 97, 122, 32, 47, 60, 62, 
-	9, 13, 97, 122, 32, 45, 47, 60, 
-	62, 95, 9, 13, 65, 90, 97, 122, 
-	32, 45, 47, 60, 95, 9, 13, 65, 
-	90, 97, 122, 45, 60, 61, 95, 48, 
-	57, 65, 90, 97, 122, 32, 34, 39, 
-	60, 9, 13, 33, 60, 95, 125, 35, 
-	38, 40, 90, 97, 123, 34, 39, 60, 
-	95, 125, 33, 90, 97, 123, 32, 45, 
-	47, 60, 62, 95, 9, 13, 65, 90, 
-	97, 122, 32, 45, 47, 60, 95, 9, 
-	13, 65, 90, 97, 122, 60, 62, 34, 
-	39, 47, 60, 95, 101, 125, 33, 90, 
-	97, 123, 34, 39, 60, 95, 101, 125, 
-	33, 90, 97, 123, 34, 39, 60, 95, 
-	115, 125, 33, 90, 97, 123, 34, 39, 
-	60, 95, 105, 125, 33, 90, 97, 123, 
-	34, 39, 58, 60, 95, 125, 33, 90, 
-	97, 123, 34, 39, 60, 95, 123, 125, 
-	33, 90, 97, 122, 34, 39, 60, 62, 
-	95, 123, 125, 33, 90, 97, 122, 34, 
-	39, 60, 95, 115, 125, 33, 90, 97, 
-	123, 34, 39, 60, 95, 105, 125, 33, 
-	90, 97, 123, 34, 39, 58, 60, 95, 
-	125, 33, 90, 97, 123, 34, 39, 60, 
-	95, 123, 125, 33, 90, 97, 122, 32, 
-	34, 39, 47, 60, 62, 95, 123, 125, 
-	9, 13, 33, 90, 97, 122, 34, 39, 
-	60, 62, 95, 125, 33, 90, 97, 123, 
-	34, 39, 60, 95, 125, 33, 90, 97, 
-	123, 32, 45, 47, 60, 62, 95, 9, 
-	13, 65, 90, 97, 122, 32, 45, 47, 
-	60, 95, 9, 13, 65, 90, 97, 122, 
-	45, 60, 61, 95, 48, 57, 65, 90, 
-	97, 122, 32, 34, 39, 60, 9, 13, 
-	33, 60, 95, 125, 35, 38, 40, 90, 
-	97, 123, 34, 39, 47, 60, 95, 101, 
-	125, 33, 90, 97, 123, 34, 39, 60, 
-	95, 101, 125, 33, 90, 97, 123, 34, 
-	39, 60, 95, 115, 125, 33, 90, 97, 
-	123, 34, 39, 60, 95, 105, 125, 33, 
-	90, 97, 123, 34, 39, 58, 60, 95, 
-	125, 33, 90, 97, 123, 34, 39, 60, 
-	95, 123, 125, 33, 90, 97, 122, 34, 
-	39, 60, 62, 95, 123, 125, 33, 90, 
-	97, 122, 34, 39, 60, 95, 115, 125, 
-	33, 90, 97, 123, 34, 39, 60, 95, 
-	105, 125, 33, 90, 97, 123, 34, 39, 
-	58, 60, 95, 125, 33, 90, 97, 123, 
-	34, 39, 60, 95, 123, 125, 33, 90, 
-	97, 122, 32, 34, 39, 47, 60, 62, 
-	95, 123, 125, 9, 13, 33, 90, 97, 
-	122, 34, 39, 60, 62, 95, 125, 33, 
-	90, 97, 123, 60, 62, 60, 62, 60, 
-	60, 34, 39, 60, 95, 125, 33, 90, 
-	97, 123, 34, 39, 60, 95, 125, 33, 
-	90, 97, 123, 60, 0
-};
-
-static const char _esi_single_lengths[] = {
-	1, 3, 2, 2, 2, 2, 1, 2, 
-	2, 2, 2, 1, 4, 6, 5, 4, 
-	4, 4, 5, 6, 5, 2, 7, 6, 
-	6, 6, 6, 6, 7, 6, 6, 6, 
-	6, 9, 6, 5, 6, 5, 4, 4, 
-	4, 7, 6, 6, 6, 6, 6, 7, 
-	6, 6, 6, 6, 9, 6, 2, 2, 
-	1, 1, 5, 5, 1
-};
-
-static const char _esi_range_lengths[] = {
-	0, 0, 0, 0, 0, 0, 1, 1, 
-	0, 0, 0, 1, 2, 3, 3, 3, 
-	1, 3, 2, 3, 3, 0, 2, 2, 
-	2, 2, 2, 2, 2, 2, 2, 2, 
-	2, 3, 2, 2, 3, 3, 3, 1, 
-	3, 2, 2, 2, 2, 2, 2, 2, 
-	2, 2, 2, 2, 3, 2, 0, 0, 
-	0, 0, 2, 2, 0
-};
-
-static const short _esi_index_offsets[] = {
-	0, 2, 6, 9, 12, 15, 18, 21, 
-	25, 28, 31, 34, 37, 44, 54, 63, 
-	71, 77, 85, 93, 103, 112, 115, 125, 
-	134, 143, 152, 161, 170, 180, 189, 198, 
-	207, 216, 229, 238, 246, 256, 265, 273, 
-	279, 287, 297, 306, 315, 324, 333, 342, 
-	352, 361, 370, 379, 388, 401, 410, 413, 
-	416, 418, 420, 428, 436
-};
+#line 306 "parser.rl"
 
-static const char _esi_indicies[] = {
-	1, 0, 2, 1, 3, 0, 1, 4, 
-	0, 1, 5, 0, 1, 6, 0, 7, 
-	1, 0, 1, 8, 0, 1, 9, 8, 
-	0, 1, 10, 0, 1, 11, 0, 12, 
-	1, 0, 1, 13, 0, 14, 15, 1, 
-	16, 14, 13, 0, 17, 18, 19, 1, 
-	20, 18, 17, 18, 18, 0, 17, 18, 
-	19, 1, 18, 17, 18, 18, 0, 18, 
-	1, 21, 18, 18, 18, 18, 0, 22, 
-	23, 23, 1, 22, 0, 24, 25, 24, 
-	24, 24, 24, 24, 0, 26, 26, 25, 
-	24, 24, 24, 24, 0, 27, 18, 28, 
-	1, 20, 18, 27, 18, 18, 0, 27, 
-	18, 28, 1, 18, 27, 18, 18, 0, 
-	1, 29, 0, 26, 26, 30, 25, 24, 
-	31, 24, 24, 24, 0, 26, 26, 25, 
-	24, 32, 24, 24, 24, 0, 26, 26, 
-	25, 24, 33, 24, 24, 24, 0, 26, 
-	26, 25, 24, 34, 24, 24, 24, 0, 
-	26, 26, 35, 25, 24, 24, 24, 24, 
-	0, 26, 26, 25, 24, 24, 24, 24, 
-	36, 0, 26, 26, 25, 37, 24, 24, 
-	24, 24, 36, 0, 26, 26, 25, 24, 
-	38, 24, 24, 24, 0, 26, 26, 25, 
-	24, 39, 24, 24, 24, 0, 26, 26, 
-	40, 25, 24, 24, 24, 24, 0, 26, 
-	26, 25, 24, 24, 24, 24, 41, 0, 
-	14, 26, 26, 42, 25, 43, 24, 24, 
-	24, 14, 24, 41, 0, 26, 26, 25, 
-	44, 24, 24, 24, 24, 0, 46, 46, 
-	47, 45, 45, 45, 45, 0, 48, 49, 
-	28, 1, 20, 49, 48, 49, 49, 0, 
-	48, 49, 28, 1, 49, 48, 49, 49, 
-	0, 49, 1, 50, 49, 49, 49, 49, 
-	0, 51, 52, 52, 1, 51, 0, 45, 
-	47, 45, 45, 45, 45, 45, 0, 46, 
-	46, 53, 47, 45, 54, 45, 45, 45, 
-	0, 46, 46, 47, 45, 55, 45, 45, 
-	45, 0, 46, 46, 47, 45, 56, 45, 
-	45, 45, 0, 46, 46, 47, 45, 57, 
-	45, 45, 45, 0, 46, 46, 58, 47, 
-	45, 45, 45, 45, 0, 46, 46, 47, 
-	45, 45, 45, 45, 59, 0, 46, 46, 
-	47, 60, 45, 45, 45, 45, 59, 0, 
-	46, 46, 47, 45, 61, 45, 45, 45, 
-	0, 46, 46, 47, 45, 62, 45, 45, 
-	45, 0, 46, 46, 63, 47, 45, 45, 
-	45, 45, 0, 46, 46, 47, 45, 45, 
-	45, 45, 64, 0, 14, 46, 46, 65, 
-	47, 66, 45, 45, 45, 14, 45, 64, 
-	0, 46, 46, 47, 67, 45, 45, 45, 
-	45, 0, 1, 68, 0, 1, 69, 0, 
-	1, 0, 71, 70, 74, 74, 75, 73, 
-	73, 73, 73, 72, 74, 74, 75, 73, 
-	73, 73, 73, 72, 76, 72, 0
-};
 
-static const char _esi_trans_targs_wi[] = {
-	0, 1, 2, 8, 3, 4, 5, 6, 
-	7, 0, 9, 10, 11, 12, 13, 55, 
-	0, 14, 15, 54, 57, 16, 16, 17, 
-	18, 22, 19, 20, 21, 57, 23, 29, 
-	24, 25, 26, 27, 28, 18, 30, 31, 
-	32, 33, 34, 18, 58, 35, 36, 41, 
-	37, 38, 39, 39, 40, 42, 48, 43, 
-	44, 45, 46, 47, 35, 49, 50, 51, 
-	52, 53, 35, 59, 60, 60, 0, 1, 
-	0, 35, 36, 41, 1
-};
 
-static const char _esi_trans_actions_wi[] = {
-	1, 3, 1, 1, 1, 1, 1, 1, 
-	1, 27, 1, 1, 1, 1, 9, 9, 
-	24, 1, 1, 9, 15, 18, 1, 1, 
-	1, 3, 21, 1, 1, 12, 1, 1, 
-	1, 1, 1, 1, 1, 27, 1, 1, 
-	1, 1, 9, 24, 1, 1, 21, 3, 
-	1, 1, 18, 1, 1, 1, 1, 1, 
-	1, 1, 1, 1, 27, 1, 1, 1, 
-	1, 9, 24, 1, 12, 1, 6, 30, 
-	34, 34, 43, 38, 38
+#line 147 "parser.c"
+static const char _esi_eof_actions[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 10, 10, 10, 10
 };
 
-static const int esi_start = 56;
-static const int esi_first_final = 56;
+static const int esi_start = 75;
+static const int esi_first_final = 75;
 static const int esi_error = -1;
 
-static const int esi_en_main = 56;
+static const int esi_en_main = 75;
 
-#line 167 "parser.rl"
+#line 309 "parser.rl"
 
+/* dup the string up to len */
 char *esi_strndup( const char *str, size_t len )
 {
   char *s = (char*)malloc(sizeof(char)*(len+1));
@@ -297,6 +183,29 @@ ESIAttribute *esi_attribute_new( const char *name, size_t name_length, const cha
   return attr;
 }
 
+ESIAttribute *esi_attribute_copy( ESIAttribute *attribute )
+{
+  ESIAttribute *head, *nattr;
+  if( !attribute ){ return NULL; }
+
+  // copy the first attribute
+  nattr = esi_attribute_new( attribute->name, strlen( attribute->name ),
+                             attribute->value, strlen( attribute->value ) );
+  // save a pointer for return
+  head = nattr;
+  // copy next attributes
+  attribute = attribute->next;
+  while( attribute ) {
+    // set the next attribute
+    nattr->next = esi_attribute_new( attribute->name, strlen( attribute->name ),
+                                     attribute->value, strlen( attribute->value ) );
+    // next attribute
+    nattr = nattr->next;
+    attribute = attribute->next;
+  }
+  return head;
+}
+
 void esi_attribute_free( ESIAttribute *attribute )
 {
   ESIAttribute *ptr;
@@ -314,11 +223,14 @@ ESIParser *esi_parser_new()
   ESIParser *parser = (ESIParser*)malloc(sizeof(ESIParser));
   parser->cs = esi_start;
   parser->mark = NULL;
+  parser->tag_text = NULL;
+  parser->attr_key = NULL;
+  parser->attr_value = NULL;
   parser->overflow_data_size = 0;
   parser->overflow_data = NULL;
 
-  /* allocate 1024 bytes for the echobuffer */
-  parser->echobuffer_allocated = 1024;
+  /* allocate ESI_OUTPUT_BUFFER_SIZE bytes for the echobuffer */
+  parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
   parser->echobuffer_index = -1;
   parser->echobuffer = (char*)malloc(sizeof(char)*parser->echobuffer_allocated);
 
@@ -329,6 +241,9 @@ ESIParser *esi_parser_new()
   parser->end_tag_handler = esi_parser_default_end_cb;
   parser->output_handler = esi_parser_default_output_cp;
 
+  parser->output_buffer_size = 0;
+  memset( parser->output_buffer, 0, ESI_OUTPUT_BUFFER_SIZE );
+
   return parser;
 }
 void esi_parser_free( ESIParser *parser )
@@ -350,32 +265,98 @@ int esi_parser_init( ESIParser *parser )
 {
   int cs;
   
-#line 354 "parser.c"
+#line 269 "parser.c"
 	{
 	cs = esi_start;
 	}
-#line 238 "parser.rl"
+#line 410 "parser.rl"
   parser->prev_state = parser->cs = cs;
   return 0;
 }
 
 static int compute_offset( const char *mark, const char *data )
 {
-  if( mark ){
+  if( mark ) {
     return mark - data;
   }
   return -1;
 }
 
+/*
+ * scans the data buffer for a start sequence /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/
+ * returns index of if start sequence found else returns -1
+ */
+static int
+esi_parser_scan_for_start( ESIParser *parser, const char *data, size_t length )
+{
+  size_t i, f = -2, s = -2;
+  char ch;
+
+  for( i = 0; i < length; ++i ) {
+    ch = data[i];
+    switch( ch ) {
+    case '<':
+      f = s = i;
+      break;
+    case '/':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case 'e':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case 's':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case 'i':
+      if( s == (i-1) && f != -2 ) { s = i; }
+      break;
+    case ':':
+      if( s == (i-1) && f != -2 ) { s = i; return f; }
+      break;
+    default:
+      f = s = -2;
+      break;
+    }
+  }
+
+  // if s and f are still valid at end of input return f
+  if( f != -2 && s != -2 ) {
+    return f;
+  }
+  else {
+    return -1;
+  }
+}
+
+/* accept an arbitrary length string buffer
+ * when this methods exits it determines if an end state was reached
+ * if no end state was reached it saves the full input into an internal buffer
+ * when invoked next, it reuses that internable buffer copying all pointers into the 
+ * newly allocated buffer. if it exits in a terminal state, e.g. 0 then it will dump these buffers
+ */
 int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
 {
   int cs = parser->cs;
   const char *p = data;
+  const char *eof = NULL; // ragel 6.x compat
   const char *pe = data + length;
+  int pindex;
 
   if( length == 0 ){ return cs; }
 
-  if( parser->overflow_data && parser->overflow_data_size > 0 ){
+  /* scan data for any '<esi:' start sequences, /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/ */
+  if( cs == esi_start ) { 
+    pindex = esi_parser_scan_for_start( parser, data, length );
+    if( pindex == -1 ) {
+      for( pindex = 0; pindex < length; ++pindex ) {
+        esi_parser_echo_char( parser, data[pindex] );
+      }
+      return cs;
+    }
+  }
+
+  /* there's an existing overflow buffer data append the new data to the existing data */
+  if( parser->overflow_data && parser->overflow_data_size > 0 ) {
 
     // recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
     int mark_offset = compute_offset( parser->mark, parser->overflow_data );
@@ -383,252 +364,1493 @@ int esi_parser_execute( ESIParser *parser, const char *data, size_t length )
     int attr_key_offset = compute_offset( parser->attr_key, parser->overflow_data );
     int attr_value_offset = compute_offset( parser->attr_value, parser->overflow_data );
 
-//    debug_string("grow overflow buffer", parser->overflow_data, parser->overflow_data_size );
-
     parser->overflow_data = (char*)realloc( parser->overflow_data, sizeof(char)*(parser->overflow_data_size+length) );
     memcpy( parser->overflow_data+parser->overflow_data_size, data, length );
 
     p = parser->overflow_data + parser->overflow_data_size;
-    
+ 
     // in our new memory space mark will now be
-    parser->mark = ( mark_offset > 0 ) ? parser->overflow_data + mark_offset : NULL;
-    parser->tag_text = ( tag_text_offset > 0 ) ? parser->overflow_data + tag_text_offset : NULL;
-    parser->attr_key = ( attr_key_offset > 0 ) ? parser->overflow_data + attr_key_offset : NULL;
-    parser->attr_value = ( attr_value_offset > 0 ) ? parser->overflow_data + attr_value_offset : NULL;
+    parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
+    parser->tag_text = ( tag_text_offset >= 0 ) ? parser->overflow_data + tag_text_offset : NULL;
+    parser->attr_key = ( attr_key_offset >= 0 ) ? parser->overflow_data + attr_key_offset : NULL;
+    parser->attr_value = ( attr_value_offset >= 0 ) ? parser->overflow_data + attr_value_offset : NULL;
  
     data = parser->overflow_data;
     parser->overflow_data_size = length = length + parser->overflow_data_size;
+//    printf( "grow overflow data: %ld\n", parser->overflow_data_size );
     pe = data + length;
 
-//    debug_string( "overflow", parser->overflow_data, parser->overflow_data_size );
   }
 
-  if( !parser->mark ){
+  if( !parser->mark ) {
     parser->mark = p;
   }
 
 //  printf( "cs: %d, ", cs );
-//  debug_string( "data", data, length );
 
   
-#line 415 "parser.c"
+#line 393 "parser.c"
 	{
-	int _klen;
-	unsigned int _trans;
-	const char *_acts;
-	unsigned int _nacts;
-	const char *_keys;
-
 	if ( p == pe )
-		goto _out;
+		goto _test_eof;
 _resume:
-	_keys = _esi_trans_keys + _esi_key_offsets[cs];
-	_trans = _esi_index_offsets[cs];
-
-	_klen = _esi_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 = _esi_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 = _esi_indicies[_trans];
-	cs = _esi_trans_targs_wi[_trans];
-
-	if ( _esi_trans_actions_wi[_trans] == 0 )
-		goto _again;
-
-	_acts = _esi_actions + _esi_trans_actions_wi[_trans];
-	_nacts = (unsigned int) *_acts++;
-	while ( _nacts-- > 0 )
+	switch ( cs ) {
+case 75:
+	if ( (*p) == 60 )
+		goto tr1;
+	goto tr0;
+case 0:
+	if ( (*p) == 60 )
+		goto tr1;
+	goto tr0;
+case 1:
+	switch( (*p) ) {
+		case 47: goto tr2;
+		case 60: goto tr1;
+		case 101: goto tr3;
+	}
+	goto tr0;
+case 2:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 101: goto tr4;
+	}
+	goto tr0;
+case 3:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 115: goto tr5;
+	}
+	goto tr0;
+case 4:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 105: goto tr6;
+	}
+	goto tr0;
+case 5:
+	switch( (*p) ) {
+		case 58: goto tr7;
+		case 60: goto tr1;
+	}
+	goto tr0;
+case 6:
+	if ( (*p) == 60 )
+		goto tr1;
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr8;
+	goto tr0;
+case 7:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 62: goto tr9;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr8;
+	goto tr0;
+case 8:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 115: goto tr10;
+	}
+	goto tr0;
+case 9:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 105: goto tr11;
+	}
+	goto tr0;
+case 10:
+	switch( (*p) ) {
+		case 58: goto tr12;
+		case 60: goto tr1;
+	}
+	goto tr0;
+case 11:
+	if ( (*p) == 60 )
+		goto tr1;
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr13;
+	goto tr0;
+case 12:
+	switch( (*p) ) {
+		case 32: goto tr14;
+		case 60: goto tr1;
+		case 62: goto tr15;
+	}
+	if ( (*p) > 13 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr13;
+	} else if ( (*p) >= 9 )
+		goto tr14;
+	goto tr0;
+case 13:
+	switch( (*p) ) {
+		case 32: goto tr16;
+		case 45: goto tr17;
+		case 47: goto tr18;
+		case 60: goto tr1;
+		case 62: goto tr19;
+		case 95: goto tr17;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr16;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr17;
+	} else
+		goto tr17;
+	goto tr0;
+case 14:
+	switch( (*p) ) {
+		case 32: goto tr16;
+		case 45: goto tr17;
+		case 47: goto tr18;
+		case 60: goto tr1;
+		case 95: goto tr17;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr16;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr17;
+	} else
+		goto tr17;
+	goto tr0;
+case 15:
+	switch( (*p) ) {
+		case 45: goto tr17;
+		case 60: goto tr1;
+		case 61: goto tr20;
+		case 95: goto tr17;
+	}
+	if ( (*p) < 65 ) {
+		if ( 48 <= (*p) && (*p) <= 57 )
+			goto tr17;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr17;
+	} else
+		goto tr17;
+	goto tr0;
+case 16:
+	switch( (*p) ) {
+		case 32: goto tr21;
+		case 34: goto tr22;
+		case 39: goto tr23;
+		case 60: goto tr1;
+	}
+	if ( 9 <= (*p) && (*p) <= 13 )
+		goto tr21;
+	goto tr0;
+case 17:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	goto tr22;
+case 18:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 47: goto tr27;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 101: goto tr28;
+	}
+	goto tr22;
+case 19:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 101: goto tr29;
+	}
+	goto tr22;
+case 20:
+	switch( (*p) ) {
+		case 34: goto tr30;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	goto tr22;
+case 21:
+	switch( (*p) ) {
+		case 32: goto tr31;
+		case 34: goto tr24;
+		case 45: goto tr32;
+		case 47: goto tr33;
+		case 60: goto tr25;
+		case 62: goto tr34;
+		case 92: goto tr26;
+		case 95: goto tr32;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr31;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr32;
+	} else
+		goto tr32;
+	goto tr22;
+case 22:
+	switch( (*p) ) {
+		case 32: goto tr31;
+		case 34: goto tr24;
+		case 45: goto tr32;
+		case 47: goto tr33;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 95: goto tr32;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr31;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr32;
+	} else
+		goto tr32;
+	goto tr22;
+case 23:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 45: goto tr32;
+		case 60: goto tr25;
+		case 61: goto tr35;
+		case 92: goto tr26;
+		case 95: goto tr32;
+	}
+	if ( (*p) < 65 ) {
+		if ( 48 <= (*p) && (*p) <= 57 )
+			goto tr32;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr32;
+	} else
+		goto tr32;
+	goto tr22;
+case 24:
+	switch( (*p) ) {
+		case 32: goto tr36;
+		case 34: goto tr30;
+		case 39: goto tr37;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	if ( 9 <= (*p) && (*p) <= 13 )
+		goto tr36;
+	goto tr22;
+case 25:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	goto tr37;
+case 26:
+	switch( (*p) ) {
+		case 32: goto tr41;
+		case 39: goto tr24;
+		case 45: goto tr42;
+		case 47: goto tr43;
+		case 60: goto tr44;
+		case 62: goto tr45;
+		case 92: goto tr46;
+		case 95: goto tr42;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr41;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr42;
+	} else
+		goto tr42;
+	goto tr23;
+case 27:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	goto tr23;
+case 28:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 47: goto tr47;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 101: goto tr48;
+	}
+	goto tr23;
+case 29:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 101: goto tr49;
+	}
+	goto tr23;
+case 30:
+	switch( (*p) ) {
+		case 39: goto tr38;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	goto tr23;
+case 31:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 115: goto tr50;
+	}
+	goto tr23;
+case 32:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 105: goto tr51;
+	}
+	goto tr23;
+case 33:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 58: goto tr52;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	goto tr23;
+case 34:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr53;
+	goto tr23;
+case 35:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 62: goto tr54;
+		case 92: goto tr46;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr53;
+	goto tr23;
+case 36:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 115: goto tr55;
+	}
+	goto tr23;
+case 37:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 105: goto tr56;
+	}
+	goto tr23;
+case 38:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 58: goto tr57;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	goto tr23;
+case 39:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr58;
+	goto tr23;
+case 40:
+	switch( (*p) ) {
+		case 32: goto tr59;
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 62: goto tr60;
+		case 92: goto tr46;
+	}
+	if ( (*p) > 13 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr58;
+	} else if ( (*p) >= 9 )
+		goto tr59;
+	goto tr23;
+case 76:
+	switch( (*p) ) {
+		case 39: goto tr100;
+		case 60: goto tr101;
+		case 92: goto tr102;
+	}
+	goto tr99;
+case 41:
+	switch( (*p) ) {
+		case 32: goto tr41;
+		case 39: goto tr24;
+		case 45: goto tr42;
+		case 47: goto tr43;
+		case 60: goto tr44;
+		case 92: goto tr46;
+		case 95: goto tr42;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr41;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr42;
+	} else
+		goto tr42;
+	goto tr23;
+case 42:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 45: goto tr42;
+		case 60: goto tr44;
+		case 61: goto tr61;
+		case 92: goto tr46;
+		case 95: goto tr42;
+	}
+	if ( (*p) < 65 ) {
+		if ( 48 <= (*p) && (*p) <= 57 )
+			goto tr42;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr42;
+	} else
+		goto tr42;
+	goto tr23;
+case 43:
+	switch( (*p) ) {
+		case 32: goto tr62;
+		case 34: goto tr37;
+		case 39: goto tr38;
+		case 60: goto tr44;
+		case 92: goto tr46;
+	}
+	if ( 9 <= (*p) && (*p) <= 13 )
+		goto tr62;
+	goto tr23;
+case 44:
+	switch( (*p) ) {
+		case 39: goto tr24;
+		case 60: goto tr44;
+		case 62: goto tr63;
+		case 92: goto tr46;
+	}
+	goto tr23;
+case 45:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 47: goto tr64;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 101: goto tr65;
+	}
+	goto tr37;
+case 46:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 101: goto tr66;
+	}
+	goto tr37;
+case 47:
+	switch( (*p) ) {
+		case 34: goto tr67;
+		case 39: goto tr67;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	goto tr37;
+case 48:
+	switch( (*p) ) {
+		case 32: goto tr68;
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 45: goto tr69;
+		case 47: goto tr70;
+		case 60: goto tr39;
+		case 62: goto tr71;
+		case 92: goto tr40;
+		case 95: goto tr69;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr68;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr69;
+	} else
+		goto tr69;
+	goto tr37;
+case 49:
+	switch( (*p) ) {
+		case 32: goto tr68;
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 45: goto tr69;
+		case 47: goto tr70;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 95: goto tr69;
+	}
+	if ( (*p) < 65 ) {
+		if ( 9 <= (*p) && (*p) <= 13 )
+			goto tr68;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr69;
+	} else
+		goto tr69;
+	goto tr37;
+case 50:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 45: goto tr69;
+		case 60: goto tr39;
+		case 61: goto tr72;
+		case 92: goto tr40;
+		case 95: goto tr69;
+	}
+	if ( (*p) < 65 ) {
+		if ( 48 <= (*p) && (*p) <= 57 )
+			goto tr69;
+	} else if ( (*p) > 90 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr69;
+	} else
+		goto tr69;
+	goto tr37;
+case 51:
+	switch( (*p) ) {
+		case 32: goto tr73;
+		case 34: goto tr67;
+		case 39: goto tr67;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	if ( 9 <= (*p) && (*p) <= 13 )
+		goto tr73;
+	goto tr37;
+case 52:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 62: goto tr74;
+		case 92: goto tr40;
+	}
+	goto tr37;
+case 77:
+	switch( (*p) ) {
+		case 34: goto tr104;
+		case 39: goto tr105;
+		case 60: goto tr106;
+		case 92: goto tr107;
+	}
+	goto tr103;
+case 53:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 115: goto tr75;
+	}
+	goto tr37;
+case 54:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 105: goto tr76;
+	}
+	goto tr37;
+case 55:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 58: goto tr77;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	goto tr37;
+case 56:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr78;
+	goto tr37;
+case 57:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 62: goto tr79;
+		case 92: goto tr40;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr78;
+	goto tr37;
+case 58:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 115: goto tr80;
+	}
+	goto tr37;
+case 59:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+		case 105: goto tr81;
+	}
+	goto tr37;
+case 60:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 58: goto tr82;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	goto tr37;
+case 61:
+	switch( (*p) ) {
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 92: goto tr40;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr83;
+	goto tr37;
+case 62:
+	switch( (*p) ) {
+		case 32: goto tr84;
+		case 34: goto tr38;
+		case 39: goto tr30;
+		case 60: goto tr39;
+		case 62: goto tr85;
+		case 92: goto tr40;
+	}
+	if ( (*p) > 13 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr83;
+	} else if ( (*p) >= 9 )
+		goto tr84;
+	goto tr37;
+case 63:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 62: goto tr86;
+		case 92: goto tr26;
+	}
+	goto tr22;
+case 78:
+	switch( (*p) ) {
+		case 34: goto tr100;
+		case 60: goto tr109;
+		case 92: goto tr110;
+	}
+	goto tr108;
+case 64:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 115: goto tr87;
+	}
+	goto tr22;
+case 65:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 105: goto tr88;
+	}
+	goto tr22;
+case 66:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 58: goto tr89;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	goto tr22;
+case 67:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr90;
+	goto tr22;
+case 68:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 62: goto tr91;
+		case 92: goto tr26;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr90;
+	goto tr22;
+case 69:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 115: goto tr92;
+	}
+	goto tr22;
+case 70:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+		case 105: goto tr93;
+	}
+	goto tr22;
+case 71:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 58: goto tr94;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	goto tr22;
+case 72:
+	switch( (*p) ) {
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 92: goto tr26;
+	}
+	if ( 97 <= (*p) && (*p) <= 122 )
+		goto tr95;
+	goto tr22;
+case 73:
+	switch( (*p) ) {
+		case 32: goto tr96;
+		case 34: goto tr24;
+		case 60: goto tr25;
+		case 62: goto tr97;
+		case 92: goto tr26;
+	}
+	if ( (*p) > 13 ) {
+		if ( 97 <= (*p) && (*p) <= 122 )
+			goto tr95;
+	} else if ( (*p) >= 9 )
+		goto tr96;
+	goto tr22;
+case 74:
+	switch( (*p) ) {
+		case 60: goto tr1;
+		case 62: goto tr98;
+	}
+	goto tr0;
+case 79:
+	if ( (*p) == 60 )
+		goto tr112;
+	goto tr111;
+	}
+
+	tr0: cs = 0; goto f0;
+	tr9: cs = 0; goto f2;
+	tr111: cs = 0; goto f10;
+	tr1: cs = 1; goto f1;
+	tr112: cs = 1; goto f12;
+	tr2: cs = 2; goto f0;
+	tr4: cs = 3; goto f0;
+	tr5: cs = 4; goto f0;
+	tr6: cs = 5; goto f0;
+	tr7: cs = 6; goto f0;
+	tr8: cs = 7; goto f0;
+	tr3: cs = 8; goto f0;
+	tr10: cs = 9; goto f0;
+	tr11: cs = 10; goto f0;
+	tr12: cs = 11; goto f0;
+	tr13: cs = 12; goto f0;
+	tr14: cs = 13; goto f3;
+	tr24: cs = 13; goto f7;
+	tr100: cs = 13; goto f11;
+	tr16: cs = 14; goto f0;
+	tr17: cs = 15; goto f0;
+	tr21: cs = 16; goto f0;
+	tr20: cs = 16; goto f6;
+	tr22: cs = 17; goto f0;
+	tr91: cs = 17; goto f2;
+	tr108: cs = 17; goto f10;
+	tr25: cs = 18; goto f1;
+	tr109: cs = 18; goto f12;
+	tr27: cs = 19; goto f0;
+	tr26: cs = 20; goto f0;
+	tr110: cs = 20; goto f10;
+	tr96: cs = 21; goto f3;
+	tr30: cs = 21; goto f7;
+	tr105: cs = 21; goto f11;
+	tr31: cs = 22; goto f0;
+	tr32: cs = 23; goto f0;
+	tr36: cs = 24; goto f0;
+	tr35: cs = 24; goto f6;
+	tr37: cs = 25; goto f0;
+	tr79: cs = 25; goto f2;
+	tr103: cs = 25; goto f10;
+	tr59: cs = 26; goto f3;
+	tr38: cs = 26; goto f7;
+	tr104: cs = 26; goto f11;
+	tr23: cs = 27; goto f0;
+	tr54: cs = 27; goto f2;
+	tr99: cs = 27; goto f10;
+	tr44: cs = 28; goto f1;
+	tr101: cs = 28; goto f12;
+	tr47: cs = 29; goto f0;
+	tr46: cs = 30; goto f0;
+	tr102: cs = 30; goto f10;
+	tr49: cs = 31; goto f0;
+	tr50: cs = 32; goto f0;
+	tr51: cs = 33; goto f0;
+	tr52: cs = 34; goto f0;
+	tr53: cs = 35; goto f0;
+	tr48: cs = 36; goto f0;
+	tr55: cs = 37; goto f0;
+	tr56: cs = 38; goto f0;
+	tr57: cs = 39; goto f0;
+	tr58: cs = 40; goto f0;
+	tr41: cs = 41; goto f0;
+	tr42: cs = 42; goto f0;
+	tr62: cs = 43; goto f0;
+	tr61: cs = 43; goto f6;
+	tr43: cs = 44; goto f0;
+	tr39: cs = 45; goto f1;
+	tr106: cs = 45; goto f12;
+	tr64: cs = 46; goto f0;
+	tr40: cs = 47; goto f0;
+	tr107: cs = 47; goto f10;
+	tr84: cs = 48; goto f3;
+	tr67: cs = 48; goto f7;
+	tr68: cs = 49; goto f0;
+	tr69: cs = 50; goto f0;
+	tr73: cs = 51; goto f0;
+	tr72: cs = 51; goto f6;
+	tr70: cs = 52; goto f0;
+	tr66: cs = 53; goto f0;
+	tr75: cs = 54; goto f0;
+	tr76: cs = 55; goto f0;
+	tr77: cs = 56; goto f0;
+	tr78: cs = 57; goto f0;
+	tr65: cs = 58; goto f0;
+	tr80: cs = 59; goto f0;
+	tr81: cs = 60; goto f0;
+	tr82: cs = 61; goto f0;
+	tr83: cs = 62; goto f0;
+	tr33: cs = 63; goto f0;
+	tr29: cs = 64; goto f0;
+	tr87: cs = 65; goto f0;
+	tr88: cs = 66; goto f0;
+	tr89: cs = 67; goto f0;
+	tr90: cs = 68; goto f0;
+	tr28: cs = 69; goto f0;
+	tr92: cs = 70; goto f0;
+	tr93: cs = 71; goto f0;
+	tr94: cs = 72; goto f0;
+	tr95: cs = 73; goto f0;
+	tr18: cs = 74; goto f0;
+	tr60: cs = 76; goto f4;
+	tr45: cs = 76; goto f5;
+	tr63: cs = 76; goto f8;
+	tr85: cs = 77; goto f4;
+	tr71: cs = 77; goto f5;
+	tr74: cs = 77; goto f8;
+	tr97: cs = 78; goto f4;
+	tr34: cs = 78; goto f5;
+	tr86: cs = 78; goto f8;
+	tr15: cs = 79; goto f4;
+	tr19: cs = 79; goto f5;
+	tr98: cs = 79; goto f8;
+
+f0:
+#line 280 "parser.rl"
 	{
-		switch ( *_acts++ )
-		{
-	case 0:
-#line 71 "parser.rl"
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+	goto _again;
+f1:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 144 "parser.rl"
 	{
     parser->mark = p;
-//    printf( "begin\n" );
+    //debug_string( "begin", p, 1 );
   }
-	break;
-	case 1:
-#line 75 "parser.rl"
+	goto _again;
+f10:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 148 "parser.rl"
 	{
 //    printf( "finish\n" );
   }
-	break;
-	case 2:
-#line 80 "parser.rl"
+	goto _again;
+f3:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 153 "parser.rl"
 	{
     parser->tag_text = parser->mark+1;
     parser->tag_text_length = p - (parser->mark+1);
-//    debug_string( "have esi start", parser->tag_text, parser->tag_text_length );
     parser->mark = p;
   }
-	break;
-	case 3:
-#line 87 "parser.rl"
+	goto _again;
+f8:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 160 "parser.rl"
 	{
-//    debug_string( "parsed esi tag", parser->tag_text, parser->tag_text_length );
+    /* trim the tag text */
+    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+
+    /* send the start tag and end tag message */
+    esi_parser_flush_output( parser );
     parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
+    esi_parser_flush_output( parser );
     parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
+    esi_parser_flush_output( parser );
+
+    /* mark the position */
     parser->tag_text = NULL;
     parser->tag_text_length = 0;
+    parser->mark = p;
+
+    /* clear out the echo buffer */
+    esi_parser_echobuffer_clear( parser );
   }
-	break;
-	case 4:
-#line 95 "parser.rl"
+	goto _again;
+f5:
+#line 280 "parser.rl"
 	{
-//    debug_string( "parsed esi tag", parser->tag_text, parser->tag_text_length );
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 182 "parser.rl"
+	{
+    /* trim tag text */
+    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+    
+    /* send the start and end tag message */
+    esi_parser_flush_output( parser );
     parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->attributes, parser->user_data );
+    esi_parser_flush_output( parser );
+
     parser->tag_text = NULL;
     parser->tag_text_length = 0;
+    parser->mark = p;
+    
+    /* clear out the echo buffer */
+    esi_parser_echobuffer_clear( parser );
   }
-	break;
-	case 5:
-#line 102 "parser.rl"
+	goto _again;
+f6:
+#line 280 "parser.rl"
 	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 201 "parser.rl"
+	{
+    /* save the attribute  key start */
     parser->attr_key = parser->mark;
+    /* compute the length of the key */
     parser->attr_key_length = p - parser->mark;
+    /* save the position following the key */
     parser->mark = p;
-//    debug_string( "\tattribute key", parser->attr_key, parser->attr_key_length );
+
+    /* trim the attribute key */
+    ltrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
+    rtrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
   }
-	break;
-	case 6:
-#line 109 "parser.rl"
+	goto _again;
+f7:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 215 "parser.rl"
 	{
     ESIAttribute *attr;
+
+    /* save the attribute value start */
     parser->attr_value = parser->mark;
+    /* compute the length of the value */
     parser->attr_value_length = p - parser->mark;
+    /* svae the position following the value */
     parser->mark = p;
-    // allocate a new attribute
+    
+    /* trim the attribute value */
+    ltrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
+    rtrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
+
+    /* using the attr_key and attr_value, allocate a new attribute object */
     attr = esi_attribute_new( parser->attr_key, parser->attr_key_length, 
                               parser->attr_value, parser->attr_value_length );
-    if( parser->attributes ){
+
+    /* add the new attribute to the list of attributes */
+    if( parser->attributes ) {
       parser->last->next = attr;
       parser->last = attr;
     }
-    else{
+    else {
       parser->last = parser->attributes = attr;
     }
-//    debug_string( "\tattribute value", parser->attr_value, parser->attr_value_length );
   }
-	break;
-	case 7:
-#line 127 "parser.rl"
+	goto _again;
+f4:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 244 "parser.rl"
 	{
+
     parser->tag_text = parser->mark;
     parser->tag_text_length = p - parser->mark;
+
     parser->mark = p;
+
+    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+
+    esi_parser_flush_output( parser );
     parser->start_tag_handler( data, parser->tag_text, parser->tag_text_length, NULL, parser->user_data );
+    esi_parser_flush_output( parser );
+
+    esi_parser_echobuffer_clear( parser );
   }
-	break;
-	case 8:
-#line 134 "parser.rl"
+	goto _again;
+f2:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 262 "parser.rl"
 	{
+    /* offset by 2 to account for the </ characters */
     parser->tag_text = parser->mark+2;
     parser->tag_text_length = p - (parser->mark+2);
+
     parser->mark = p;
+    
+    ltrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+    rtrim_pointer( &(parser->tag_text), p, &(parser->tag_text_length) );
+    
+    esi_parser_flush_output( parser );
     parser->end_tag_handler( data, parser->tag_text, parser->tag_text_length, parser->user_data );
+    esi_parser_flush_output( parser );
+
+    esi_parser_echobuffer_clear( parser );
   }
-	break;
-	case 9:
-#line 141 "parser.rl"
+	goto _again;
+f12:
+#line 280 "parser.rl"
 	{
-    switch( cs ){
-    case 0:
-      if( parser->prev_state != 12 && parser->prev_state != 7 ){
-        if( parser->echobuffer && (parser->prev_state != (esi_en_main +1)) && parser->prev_state != 60 ){
-          // stream echobuffer
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
           esi_parser_echo_buffer( parser );
         }
-//    printf( "[%d: %c]", cs, *p );
-        // stream the current character
+        /* send the current character */
         esi_parser_echo_char( parser, *p );
       }
-      // clear the echobuffer
+      /* clear the echo buffer */
       esi_parser_echobuffer_clear( parser );
       break;
     default:
-      // append characters to echobuffer
+      /* append to the echo buffer */
       esi_parser_concat_to_echobuffer( parser, *p );
     }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
     parser->prev_state = cs;
   }
-	break;
-#line 599 "parser.c"
-		}
-	}
+#line 144 "parser.rl"
+	{
+    parser->mark = p;
+    //debug_string( "begin", p, 1 );
+  }
+#line 148 "parser.rl"
+	{
+//    printf( "finish\n" );
+  }
+	goto _again;
+f11:
+#line 280 "parser.rl"
+	{
+    //printf( "[%c:%d],", *p, cs );
+    switch( cs ) {
+    case 0: /* non matching state */
+      if( parser->prev_state != 12 && parser->prev_state != 7 ){ /* states following a possible end state for a tag */
+        if( parser->echobuffer && parser->echobuffer_index != -1 ){
+          /* send the echo buffer */
+          esi_parser_echo_buffer( parser );
+        }
+        /* send the current character */
+        esi_parser_echo_char( parser, *p );
+      }
+      /* clear the echo buffer */
+      esi_parser_echobuffer_clear( parser );
+      break;
+    default:
+      /* append to the echo buffer */
+      esi_parser_concat_to_echobuffer( parser, *p );
+    }
+    /* save the previous state, necessary for end case detection such as />  and </esi:try>  the trailing > character
+      is state 12 and 7
+    */
+    parser->prev_state = cs;
+  }
+#line 215 "parser.rl"
+	{
+    ESIAttribute *attr;
+
+    /* save the attribute value start */
+    parser->attr_value = parser->mark;
+    /* compute the length of the value */
+    parser->attr_value_length = p - parser->mark;
+    /* svae the position following the value */
+    parser->mark = p;
+    
+    /* trim the attribute value */
+    ltrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
+    rtrim_pointer( &(parser->attr_value), p, &(parser->attr_value_length) );
+
+    /* using the attr_key and attr_value, allocate a new attribute object */
+    attr = esi_attribute_new( parser->attr_key, parser->attr_key_length, 
+                              parser->attr_value, parser->attr_value_length );
+
+    /* add the new attribute to the list of attributes */
+    if( parser->attributes ) {
+      parser->last->next = attr;
+      parser->last = attr;
+    }
+    else {
+      parser->last = parser->attributes = attr;
+    }
+  }
+#line 148 "parser.rl"
+	{
+//    printf( "finish\n" );
+  }
+	goto _again;
 
 _again:
 	if ( ++p != pe )
 		goto _resume;
-	_out: {}
+	_test_eof: {}
+	if ( p == eof )
+	{
+	switch ( _esi_eof_actions[cs] ) {
+	case 10:
+#line 148 "parser.rl"
+	{
+//    printf( "finish\n" );
+  }
+	break;
+#line 1814 "parser.c"
+	}
 	}
-#line 294 "parser.rl"
+
+	}
+#line 529 "parser.rl"
 
   parser->cs = cs;
 
-  if( cs != esi_start && cs != 0 ){
+  if( cs != esi_start && cs != 0 ) {
 
+    /* reached the end and we're not at a termination point save the buffer as overflow */
     if( !parser->overflow_data ){
       // recompute mark, tag_text, attr_key, and attr_value since they all exist within overflow_data
       int mark_offset = compute_offset( parser->mark, data );
       int tag_text_offset = compute_offset( parser->tag_text, data );
       int attr_key_offset = compute_offset( parser->attr_key, data );
       int attr_value_offset = compute_offset( parser->attr_value, data );
+      //debug_string( "mark before move", parser->mark, 1 );
 
-      parser->overflow_data = (char*)malloc( sizeof( char ) * length );
+      if( ESI_OUTPUT_BUFFER_SIZE > length ) {
+        parser->echobuffer_allocated = ESI_OUTPUT_BUFFER_SIZE;
+      }
+      else {
+        parser->echobuffer_allocated = length;
+      }
+      parser->overflow_data = (char*)malloc( sizeof( char ) * parser->echobuffer_allocated );
       memcpy( parser->overflow_data, data, length );
       parser->overflow_data_size = length;
+      //printf( "allocate overflow data: %ld\n", parser->echobuffer_allocated );
 
       // in our new memory space mark will now be
-      parser->mark = ( mark_offset > 0 ) ? parser->overflow_data + mark_offset : NULL;
-      parser->tag_text = ( tag_text_offset > 0 ) ? parser->overflow_data + tag_text_offset : NULL;
-      parser->attr_key = ( attr_key_offset > 0 ) ? parser->overflow_data + attr_key_offset : NULL;
-      parser->attr_value = ( attr_value_offset > 0 ) ? parser->overflow_data + attr_value_offset : NULL;
+      parser->mark = ( mark_offset >= 0 ) ? parser->overflow_data + mark_offset : NULL;
+      parser->tag_text = ( tag_text_offset >= 0 ) ? parser->overflow_data + tag_text_offset : NULL;
+      parser->attr_key = ( attr_key_offset >= 0 ) ? parser->overflow_data + attr_key_offset : NULL;
+      parser->attr_value = ( attr_value_offset >= 0 ) ? parser->overflow_data + attr_value_offset : NULL;
+      //if( parser->mark ){ debug_string( "mark after  move", parser->mark, 1 ); } else { printf( "mark is now empty\n" ); }
     }
 
-  }else if( parser->overflow_data ){
+  }else if( parser->overflow_data ) {
+    /* dump the overflow buffer execution ended at a final state */
     free( parser->overflow_data );
     parser->overflow_data = NULL;
     parser->overflow_data_size = 0;
@@ -638,9 +1860,7 @@ _again:
 }
 int esi_parser_finish( ESIParser *parser )
 {
-  
-#line 643 "parser.c"
-#line 328 "parser.rl"
+  esi_parser_flush_output( parser );
   return 0;
 }