コード例 #1
0
ファイル: e-canvas-utils.c プロジェクト: Distrotech/evolution
static void
e_canvas_show_area (GnomeCanvas *canvas,
                    gdouble x1,
                    gdouble y1,
                    gdouble x2,
                    gdouble y2)
{
	GtkAdjustment *h, *v;
	gint dx = 0, dy = 0;
	gdouble page_size;
	gdouble lower;
	gdouble upper;
	gdouble value;

	g_return_if_fail (canvas != NULL);
	g_return_if_fail (GNOME_IS_CANVAS (canvas));

	h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
	page_size = gtk_adjustment_get_page_size (h);
	lower = gtk_adjustment_get_lower (h);
	upper = gtk_adjustment_get_upper (h);
	value = gtk_adjustment_get_value (h);
	dx = compute_offset (x1, x2, value, value + page_size);
	if (dx)
		gtk_adjustment_set_value (h, CLAMP (value + dx, lower, upper - page_size));

	v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
	page_size = gtk_adjustment_get_page_size (v);
	lower = gtk_adjustment_get_lower (v);
	upper = gtk_adjustment_get_upper (v);
	value = gtk_adjustment_get_value (v);
	dy = compute_offset (y1, y2, value, value + page_size);
	if (dy)
		gtk_adjustment_set_value (v, CLAMP (value + dy, lower, upper - page_size));
}
コード例 #2
0
bool Flasher_::flash(const uint8_t *address, const uint8_t *bufp,
                     size_t buflen) {

  if (buflen == 0) return true;

  Data partial R2P_FLASH_ALIGNED;

  // Write the unaligned buffer beginning
  size_t offset = compute_offset(address, WORD_ALIGNMENT);
  address -= offset;
  partial = *reinterpret_cast<const Data *>(address);
  if (offset + buflen <= WORD_ALIGNMENT) {
    // A single word to write
    memcpy(reinterpret_cast<uint8_t *>(&partial) + offset, bufp, buflen);
    return flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                         WORD_ALIGNMENT);
  } else {
    memcpy(reinterpret_cast<uint8_t *>(&partial) + offset, bufp,
           WORD_ALIGNMENT - offset);
    if (!flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                       WORD_ALIGNMENT)) {
      return false;
    }
  }
  address += WORD_ALIGNMENT;
  bufp += WORD_ALIGNMENT - offset;
  buflen -= WORD_ALIGNMENT - offset;

  // Write the aligned buffer middle
  offset = compute_offset(address + buflen, WORD_ALIGNMENT);
  while (buflen > offset) {
    partial = *reinterpret_cast<const Data *>(bufp);
    if (!flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                       WORD_ALIGNMENT)) {
      return false;
    }
    address += WORD_ALIGNMENT;
    bufp += WORD_ALIGNMENT;
    buflen -= WORD_ALIGNMENT;
  }

  // Write the unaligned buffer end
  if (offset > 0) {
    partial = *reinterpret_cast<const Data *>(address);
    memcpy(&partial, bufp, offset);
    if (!flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                       WORD_ALIGNMENT)) {
      return false;
    }
  }
  return  true;
}
コード例 #3
0
bool Flasher_::erase(const uint8_t *address, size_t length) {

  if (length == 0) return true;

  Data partial R2P_FLASH_ALIGNED;

  // Erase the unaligned buffer beginning
  size_t offset = compute_offset(address, WORD_ALIGNMENT);
  address -= offset;
  partial = *reinterpret_cast<const Data *>(address);
  if (offset + length <= WORD_ALIGNMENT) {
    // A single word to write
    memcpy(reinterpret_cast<uint8_t *>(&partial) + offset,
           reinterpret_cast<const uint8_t *>(&erased_word) + offset, length);
    return flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                         WORD_ALIGNMENT);
  } else {
    memcpy(reinterpret_cast<uint8_t *>(&partial) + offset,
           reinterpret_cast<const uint8_t *>(&erased_word) + offset,
           WORD_ALIGNMENT - offset);
    if (!flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                       WORD_ALIGNMENT)) {
      return false;
    }
  }
  address += WORD_ALIGNMENT;
  length -= WORD_ALIGNMENT - offset;

  // Erase the aligned buffer middle
  offset = compute_offset(address + length, WORD_ALIGNMENT);
  while (length > offset) {
    if (!flash_aligned(reinterpret_cast<const Data *>(address), &erased_word,
                       WORD_ALIGNMENT)) {
      return false;
    }
    address += WORD_ALIGNMENT;
    length -= WORD_ALIGNMENT;
  }

  // Erase the unaligned buffer end
  if (offset > 0) {
    partial = *reinterpret_cast<const Data *>(address);
    memcpy(&partial, &erased_word, offset);
    if (!flash_aligned(reinterpret_cast<const Data *>(address), &partial,
                       WORD_ALIGNMENT)) {
      return false;
    }
  }
  return  true;
}
コード例 #4
0
ファイル: breakpoint.c プロジェクト: naurril/sbcl
void handle_breakpoint(os_context_t *context)
{
    lispobj code;
    DX_ALLOC_SAP(context_sap, context);

    fake_foreign_function_call(context);

#ifndef LISP_FEATURE_SB_SAFEPOINT
    unblock_gc_signals(0, 0);
#endif
    code = find_code(context);

#ifndef LISP_FEATURE_WIN32
    /* Don't disallow recursive breakpoint traps. Otherwise, we can't
     * use debugger breakpoints anywhere in here. */
    thread_sigmask(SIG_SETMASK, os_context_sigmask_addr(context), 0);
#endif

    funcall3(StaticSymbolFunction(HANDLE_BREAKPOINT),
             compute_offset(context, code),
             code,
             context_sap);

    undo_fake_foreign_function_call(context);
}
コード例 #5
0
void brw_emit_unfilled_clip( struct brw_clip_compile *c )
{
   struct brw_compile *p = &c->func;

   c->need_direction = ((c->key.offset_ccw || c->key.offset_cw) ||
			(c->key.fill_ccw != c->key.fill_cw) ||
			c->key.fill_ccw == CLIP_CULL ||
			c->key.fill_cw == CLIP_CULL ||
			c->key.copy_bfc_cw ||
			c->key.copy_bfc_ccw);

   brw_clip_tri_alloc_regs(c, 3 + c->key.nr_userclip + 6);
   brw_clip_tri_init_vertices(c);
   brw_clip_init_ff_sync(c);

   assert(brw_clip_have_varying(c, VARYING_SLOT_EDGE));

   if (c->key.fill_ccw == CLIP_CULL &&
       c->key.fill_cw == CLIP_CULL) {
      brw_clip_kill_thread(c);
      return;
   }

   merge_edgeflags(c);

   /* Need to use the inlist indirection here:
    */
   if (c->need_direction)
      compute_tri_direction(c);

   if (c->key.fill_ccw == CLIP_CULL ||
       c->key.fill_cw == CLIP_CULL)
      cull_direction(c);

   if (c->key.offset_ccw ||
       c->key.offset_cw)
      compute_offset(c);

   if (c->key.copy_bfc_ccw ||
       c->key.copy_bfc_cw)
      copy_bfc(c);

   /* Need to do this whether we clip or not:
    */
   if (c->has_flat_shading)
      brw_clip_tri_flat_shade(c);

   brw_clip_init_clipmask(c);
   brw_CMP(p, vec1(brw_null_reg()), BRW_CONDITIONAL_NZ, c->reg.planemask, brw_imm_ud(0));
   brw_IF(p, BRW_EXECUTE_1);
   {
      brw_clip_init_planes(c);
      brw_clip_tri(c);
      check_nr_verts(c);
   }
   brw_ENDIF(p);

   emit_unfilled_primitives(c);
   brw_clip_kill_thread(c);
}
コード例 #6
0
/*
 * this function computes the position of the alignment point
 * for each object in the list, and attaches it to the
 * object as object data.
 */
static void
compute_offsets (GList             *list,
                 GimpAlignmentType  alignment)
{
  GList *l;

  for (l = list; l; l = g_list_next (l))
    compute_offset (G_OBJECT (l->data), alignment);
}
コード例 #7
0
ファイル: init.c プロジェクト: cshintov/Learning-C
/* returns op_args or targets depending on the opcodes */
int get_op_arg(unsigned* pycbuf, int cur)
{
    int l = pycbuf[cur+1];
    int m = pycbuf[cur+2];
    int oparg = l | m << 8; 
    int opcode = pycbuf[cur];
    if (opcode >= JUMP_FORWARD && opcode <= POP_JUMP_IF_TRUE)
        oparg = compute_offset(pycbuf, cur, oparg);
    return oparg;
}
コード例 #8
0
ファイル: e-canvas-utils.c プロジェクト: Distrotech/evolution
static gboolean
e_canvas_area_shown (GnomeCanvas *canvas,
                     gdouble x1,
                     gdouble y1,
                     gdouble x2,
                     gdouble y2)
{
	GtkAdjustment *h, *v;
	gint dx = 0, dy = 0;
	gdouble page_size;
	gdouble lower;
	gdouble upper;
	gdouble value;

	g_return_val_if_fail (canvas != NULL, FALSE);
	g_return_val_if_fail (GNOME_IS_CANVAS (canvas), FALSE);

	h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
	page_size = gtk_adjustment_get_page_size (h);
	lower = gtk_adjustment_get_lower (h);
	upper = gtk_adjustment_get_upper (h);
	value = gtk_adjustment_get_value (h);
	dx = compute_offset (x1, x2, value, value + page_size);
	if (CLAMP (value + dx, lower, upper - page_size) - value != 0)
		return FALSE;

	v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
	page_size = gtk_adjustment_get_page_size (v);
	lower = gtk_adjustment_get_lower (v);
	upper = gtk_adjustment_get_upper (v);
	value = gtk_adjustment_get_value (v);
	dy = compute_offset (y1, y2, value, value + page_size);
	if (CLAMP (value + dy, lower, upper - page_size) - value != 0)
		return FALSE;
	return TRUE;
}
コード例 #9
0
ファイル: breakpoint.c プロジェクト: naurril/sbcl
void *handle_fun_end_breakpoint(os_context_t *context)
{
    lispobj code, lra;
    struct code *codeptr;
    DX_ALLOC_SAP(context_sap, context);

    fake_foreign_function_call(context);

#ifndef LISP_FEATURE_SB_SAFEPOINT
    unblock_gc_signals(0, 0);
#endif

    code = find_code(context);
    codeptr = (struct code *)native_pointer(code);

#ifndef LISP_FEATURE_WIN32
    /* Don't disallow recursive breakpoint traps. Otherwise, we can't
     * use debugger breakpoints anywhere in here. */
    thread_sigmask(SIG_SETMASK, os_context_sigmask_addr(context), 0);
#endif

    funcall3(StaticSymbolFunction(HANDLE_BREAKPOINT),
             compute_offset(context, code),
             code,
             context_sap);

    lra = codeptr->constants[REAL_LRA_SLOT];

#ifdef LISP_FEATURE_PPC
    /* PPC now passes LRA objects in reg_LRA during return.  Other
     * platforms should as well, but haven't been fixed yet. */
    *os_context_register_addr(context, reg_LRA) = lra;
#else
#ifdef reg_CODE
    *os_context_register_addr(context, reg_CODE) = lra;
#endif
#endif

    undo_fake_foreign_function_call(context);

#ifdef reg_LRA
    return (void *)(lra-OTHER_POINTER_LOWTAG+sizeof(lispobj));
#else
    return compute_pc(lra, fixnum_value(codeptr->constants[REAL_LRA_SLOT+1]));
#endif
}
コード例 #10
0
Mesh marching_cubes(Grid& grid, double isovalue, SurfaceType surface_type)
{
    Mesh mesh;
    int offset[8];
    Vertex* vertices[12];
    unordered_set<Vertex*, vertex_hash, vertex_equals> vertex_set;
    
    compute_offset(grid, offset);

    for(int z = 0; z < grid.get_axis(2)-1; z++) {
        for(int y = 0; y < grid.get_axis(1)-1; y++) {
            for(int x = 0; x < grid.get_axis(0)-1; x++) {
                int ic = grid.index(x,y,z); 
                int table_index = get_index(grid, ic, offset, isovalue);

                for(int i = 0; i < 12; i++) {
                    if(edge_table[table_index] & (1 << i)) {
                        int v[3], u[3];
                        get_grid_edge(x, y, z, i, v, u);
                        double sv = grid[grid.index(v[0],v[1],v[2])];
                        double su = grid[grid.index(u[0],u[1],u[2])];
                        double vc[3] = {(v[0]-grid.get_axis(0)/2.0)*grid.get_spacing(0), 
                                        (v[1]-grid.get_axis(1)/2.0)*grid.get_spacing(1), 
                                        (v[2]-grid.get_axis(2)/2.0)*grid.get_spacing(2)};
                        double uc[3] = {(u[0]-grid.get_axis(0)/2.0)*grid.get_spacing(0),
                                        (u[1]-grid.get_axis(1)/2.0)*grid.get_spacing(1), 
                                        (u[2]-grid.get_axis(2)/2.0)*grid.get_spacing(2)};
                        if(surface_type == NO_SURFACE) {
                            vertices[i] = lerp(vc, sv, uc, su, isovalue);
                        } else {
                            vertices[i] = find_cut_point(vc, sv, uc, su, isovalue, surface_type);
                        }
                        vertices[i] = merge_vertex(vertices[i], vertex_set, mesh);
                    }
                }

                for(int i = 0; triangle_table[table_index][i] != -1; i += 3) {
                    Vertex *v0, *v1, *v2;

                    v0 = vertices[triangle_table[table_index][i]];
                    v1 = vertices[triangle_table[table_index][i+1]];
                    v2 = vertices[triangle_table[table_index][i+2]];

                    if(!is_degenerate(v0, v1, v2)) {
                        Face* f = new Face;
                        
                        f->v.push_back(v0);
                        f->v.push_back(v1);
                        f->v.push_back(v2);
                        v0->f.push_back(f);
                        v1->f.push_back(f);
                        v2->f.push_back(f);

                        Edge* e0 = create_edge(v0, v1, f, mesh);
                        Edge* e1 = create_edge(v1, v2, f, mesh);
                        Edge* e2 = create_edge(v2, v0, f, mesh);
                    
                        f->e.push_back(e0);
                        f->e.push_back(e1);
                        f->e.push_back(e2);
                        mesh.add(f);
                    }
                }
            }
        }
    }
    compute_normals(mesh);
    return mesh;
}
コード例 #11
0
/**
 * gimp_image_arrange_objects:
 * @image:                The #GimpImage to which the objects belong.
 * @list:                 A #GList of objects to be aligned.
 * @alignment:            The point on each target object to bring into alignment.
 * @reference:            The #GObject to align the targets with, or #NULL.
 * @reference_alignment:  The point on the reference object to align the target item with..
 * @offset:               How much to shift the target from perfect alignment..
 *
 * This function shifts the positions of a set of target objects, which can be
 * "items" or guides, to bring them into a specified type of alignment with a
 * reference object, which can be an item, guide, or image.  If the requested
 * alignment does not make sense (i.e., trying to align a vertical guide vertically),
 * nothing happens and no error message is generated.
 *
 * The objects in the list are sorted into increasing order before
 * being arranged, where the order is defined by the type of alignment
 * being requested.  If the @reference argument is #NULL, then the first
 * object in the sorted list is used as reference.
 *
 * When there are multiple target objects, they are arranged so that the spacing
 * between consecutive ones is given by the argument @offset.
 */
void
gimp_image_arrange_objects (GimpImage         *image,
                            GList             *list,
                            GimpAlignmentType  alignment,
                            GObject           *reference,
                            GimpAlignmentType  reference_alignment,
                            gint               offset)
{
  gboolean do_x               = FALSE;
  gboolean do_y               = FALSE;
  gint     z0                 = 0;
  GList   *object_list;

  g_return_if_fail (GIMP_IS_IMAGE (image));
  g_return_if_fail (G_IS_OBJECT (reference) || reference == NULL);

  /* get offsets used for sorting */
  switch (alignment)
    {
      /* order vertically for horizontal alignment */
    case GIMP_ALIGN_LEFT:
    case GIMP_ALIGN_HCENTER:
    case GIMP_ALIGN_RIGHT:
      do_x = TRUE;
      compute_offsets (list, GIMP_ALIGN_TOP);
      break;
      /* order horizontally for horizontal arrangement */
    case GIMP_ARRANGE_LEFT:
    case GIMP_ARRANGE_HCENTER:
    case GIMP_ARRANGE_RIGHT:
      do_x = TRUE;
      compute_offsets (list, alignment);
      break;
      /* order horizontally for vertical alignment */
    case GIMP_ALIGN_TOP:
    case GIMP_ALIGN_VCENTER:
    case GIMP_ALIGN_BOTTOM:
      do_y = TRUE;
      compute_offsets (list, GIMP_ALIGN_LEFT);
      break;
      /* order vertically for vertical arrangement */
    case GIMP_ARRANGE_TOP:
    case GIMP_ARRANGE_VCENTER:
    case GIMP_ARRANGE_BOTTOM:
      do_y = TRUE;
      compute_offsets (list, alignment);
      break;
    }

  object_list = sort_by_offset (list);

  /* now get offsets used for aligning */
  compute_offsets (list, alignment);

  if (reference == NULL)
    {
      reference = G_OBJECT (object_list->data);
      object_list = g_list_next (object_list);
    }
  else
    compute_offset (reference, reference_alignment);

  z0 = GPOINTER_TO_INT (g_object_get_data (reference, "align-offset"));

  if (object_list)
    {
      GList *l;
      gint   n;

      /* FIXME: undo group type is wrong */
      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_DISPLACE,
                                   C_("undo-type", "Arrange Objects"));

      for (l = object_list, n = 1; l; l = g_list_next (l), n++)
        {
          GObject *target          = G_OBJECT (l->data);
          gint     xtranslate      = 0;
          gint     ytranslate      = 0;
          gint     z1;

          z1 = GPOINTER_TO_INT (g_object_get_data (target,
                                                    "align-offset"));

          if (do_x)
            xtranslate = z0 - z1 + n * offset;

          if (do_y)
            ytranslate = z0 - z1 + n * offset;

          /* now actually align the target object */
          if (GIMP_IS_ITEM (target))
            {
              gimp_item_translate (GIMP_ITEM (target),
                                   xtranslate, ytranslate, TRUE);
            }
          else if (GIMP_IS_GUIDE (target))
            {
              GimpGuide *guide = GIMP_GUIDE (target);

              switch (gimp_guide_get_orientation (guide))
                {
                case GIMP_ORIENTATION_VERTICAL:
                  gimp_image_move_guide (image, guide, z1 + xtranslate, TRUE);
                  break;

                case GIMP_ORIENTATION_HORIZONTAL:
                  gimp_image_move_guide (image, guide, z1 + ytranslate, TRUE);
                  break;

                default:
                  break;
                }
            }
        }

      gimp_image_undo_group_end (image);
    }

  g_list_free (object_list);
}
コード例 #12
0
ファイル: ngx_esi_parser.c プロジェクト: Safe3/nginx-esi
/* 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 || data == 0 ){ return cs; }

  /* scan data for any '<esi:' start sequences, /<$/, /<e$/, /<es$/, /<esi$/, /<esi:$/ */
  if( cs == 0 ) { 
    pindex = esi_parser_scan_for_start( parser, data, length );
    if( pindex == -1 ) {
      for( pindex = 0; pindex < (int)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 );
    int tag_text_offset = compute_offset( parser->tag_text, parser->overflow_data );
    int attr_key_offset = compute_offset( parser->attr_key, parser->overflow_data );
    int attr_value_offset = compute_offset( parser->attr_value, parser->overflow_data );

    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;
 
    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;

  }

  if( !parser->mark ) {
    parser->mark = p;
  }

//  printf( "cs: %d, ", cs );

  
#line 393 "ngx_esi_parser.c"
	{
	if ( p == pe )
		goto _test_eof;
_resume:
	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 296 "ngx_esi_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 != (size_t)-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 296 "ngx_esi_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 != (size_t)-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 "ngx_esi_parser.rl"
	{
    parser->mark = p;
    //debug_string( "begin", p, 1 );
  }
	goto _again;
f10:
#line 296 "ngx_esi_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 != (size_t)-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 "ngx_esi_parser.rl"
	{
//    printf( "finish\n" );
  }
	goto _again;
f3:
#line 296 "ngx_esi_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 != (size_t)-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 "ngx_esi_parser.rl"
	{
    parser->tag_text = parser->mark+1;
    parser->tag_text_length = p - (parser->mark+1);
    parser->mark = p;
  }
	goto _again;
f8:
#line 296 "ngx_esi_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 != (size_t)-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 "ngx_esi_parser.rl"
	{
    /* 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 );

    if( parser->attributes ) {
      esi_attribute_free( parser->attributes );
      parser->attributes = NULL;
    }

    /* 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 );
  }
	goto _again;
f5:
#line 296 "ngx_esi_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 != (size_t)-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 187 "ngx_esi_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 );
    
    if( parser->attributes ) {
      esi_attribute_free( parser->attributes );
      parser->attributes = NULL;
    }

    /* 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 );
  }
	goto _again;
f6:
#line 296 "ngx_esi_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 != (size_t)-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 212 "ngx_esi_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;

    /* trim the attribute key */
    ltrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
    rtrim_pointer( &(parser->attr_key), p, &(parser->attr_key_length) );
  }
	goto _again;
f7:
#line 296 "ngx_esi_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 != (size_t)-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 226 "ngx_esi_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;
    }
  }
	goto _again;
f4:
#line 296 "ngx_esi_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 != (size_t)-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 255 "ngx_esi_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 );
    
    if( parser->attributes ) {
      esi_attribute_free( parser->attributes );
      parser->attributes = NULL;
    }

    esi_parser_echobuffer_clear( parser );
  }
	goto _again;
f2:
#line 296 "ngx_esi_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 != (size_t)-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 278 "ngx_esi_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 );
  }
	goto _again;
f12:
#line 296 "ngx_esi_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 != (size_t)-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 "ngx_esi_parser.rl"
	{
    parser->mark = p;
    //debug_string( "begin", p, 1 );
  }
#line 148 "ngx_esi_parser.rl"
	{
//    printf( "finish\n" );
  }
	goto _again;
f11:
#line 296 "ngx_esi_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 != (size_t)-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 226 "ngx_esi_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 "ngx_esi_parser.rl"
	{
//    printf( "finish\n" );
  }
	goto _again;

_again:
	if ( ++p != pe )
		goto _resume;
	_test_eof: {}
	if ( p == eof )
	{
	switch ( _esi_eof_actions[cs] ) {
	case 10:
#line 148 "ngx_esi_parser.rl"
	{
//    printf( "finish\n" );
  }
	break;
#line 1830 "ngx_esi_parser.c"
	}
	}

	}
#line 545 "ngx_esi_parser.rl"

  parser->cs = cs;

  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 );

      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;
      //if( parser->mark ){ debug_string( "mark after  move", parser->mark, 1 ); } else { printf( "mark is now empty\n" ); }
    }

  }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;
  }

  return cs;
}