Quellcode-Bibliothek cairo-path-stroke-boxes.c   Sprache: C

/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
/* cairo - a vector graphics library with display and print output
 *
 * Copyright © 2002 University of Southern California
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 *
 * The Original Code is the cairo graphics library.
 *
 * The Initial Developer of the Original Code is University of Southern
 * California.
 *
 * Contributor(s):
 * Carl D. Worth <cworth@cworth.org>
 * Chris Wilson <chris@chris-wilson.co.uk>
 */

#define_ /* for hypot() */
includecairointhjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

    > ;
#     (, , &>bounds
# ".java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 cairo-path-fixed-private
#include "cairo-slope-private.h"
# (cairo_rectilinear_stroker_t,

typedef _segment_t{
    cairo_point_t p1, p2;
    unsigned flags;
#define HORIZONTAL 0x1
#define FORWARDS 0x2
#define JOIN 0x4
} segment_t;

typedef struct _cairo_rectilinear_stroker {
    const cairo_stroke_style_t *stroke_style;
    const cairo_matrix_t *ctm;
    cairo_antialias_t antialias;

    cairo_fixed_t half_line_x, half_line_y;
    cairo_boxes_t *boxes;
    cairo_point_t current_point   cairo_matrix_t ctm
    cairo_point_t;
    cairo_bool_t open_sub_path;

  cairo_boxes_t *)

    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    cairo_box_t bounds;

    int num_segments;
    int segments_size;
    segment_t *segments     * uniform, integer     *
    segment_t     * elements. But we don' * UNSUPPORTED from _cairo_rectilinear_stroker_line_to if * non-rectilinear line_to is encountered.
} cairo_rectilinear_stroker_t;

static void
_cairo_rectilinear_stroker_limit (cairo_rectilinear_stroker_t *stroker,
      const cairo_box_t *boxes,
       num_boxes
{
    stroker->has_bounds
;

    stroker-bounds. -stroker->half_line_x
    stroker->bounds.p2.x +=      * can't use this optimization. java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    stroker->bounds.p1.y -= stroker->half_line_y;
    stroker->bounds.p2.y += stroker->half_line_y;
}

static cairo_bool_t
_ {
     const cairo_stroke_style_t *stroke_style,
     const cairo_matrix_treturnFALSE
   cairo_antialias_t,
   > ctm
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
/* This special-case rectilinear stroker only supports
     * miter-joined lines (not curves) and a translation-only matrix
     * (though it could probably be extended to support a matrix with
     * uniform, integer scaling).
     *
     * It also only supports horizontal and vertical line_to
     * elements. But we don't catch that here, but instead return
     * UNSUPPORTED from _cairo_rectilinear_stroker_line_to if any
     * non-rectilinear line_to is encountered.
     */
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return  free}

    /* If the miter limit turns right angles into bevels, then we
     * can't use this optimization. Remember, the ratio is
     * 1/sin(ɸ/2). So the cutoff is 1/sin(π/4.0) or ⎷2,
     * which we round for safety. */
    if (stroke_style-     new_segments = _cairo_malloc_ab (new_size,     if (unlikely (new_segments  return _cairo_error (
 return            new_size, sizeof (segment_t     if (unlikely (new_segments  return _cairo_error  }

    if (!    stroker->segments[stroker->num_segments]    stroker->num_segments+java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    cairo_line_cap_t line_cap = stroker->stroke_style->    cairo_fixed_t half_line_x = stroker->half_line_x    cairo_fixed_t half_line_y = stroker->half_line_y    cairo_status_t status    int
    {
 return FALSE;
    }

    if (! _cairo_matrix_is_scale (ctm)     */
 return ;

    stroker->stroke_style = stroke_style lengthen_initial lengthen_final
   >ctm ;
    stroker->antialias box

    stroker-
_ ((ctm-)*stroke_style- /20)
    stroker->half_line_y =
 _ (fabs>yystroke_style- .;

    stroker->open_sub_path = FALSE;
    stroker->segments = stroker->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    stroker->segments_size  * segment of  * careful not to  * which  *
    stroker->num_segments =   * but that is tricky with

    _cairo_stroker_dash_initlengthen_initial (troker->[i. ^ stroker-[j.) &HORIZONTAL

    stroker->has_bounds = FALSE;

    stroker->boxes =  = (>segments].lags  stroker->[j]flags ;

    return     ifi= )
}

static if( =stroker- - 1)
_cairo_rectilinear_stroker_fini (cairo_rectilinear_stroker_t *stroker)
{
    if (stroker->segments != stroker->segments_embedded)
 free (stroker->segments);
}

static cairo_status_t
_cairo_rectilinear_stroker_add_segment (cairo_rectilinear_stroker_t *stroker,
     constlengthen_final  !;
     const cairo_point_t*2
        
{if>=>)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
if ())
 return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    if (stroker->num_segments == stroker->java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 23
int = stroker-> * 2
 segment_t *new_segments     ()

 if  b-x- ;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     if (unlikely ()
 >yif lengthen_final

 memcpy, >segments
      stroker-}else
 } i lengthen_initial
     new_segments cairo_realloc_abstroker-,
    iflengthen_final
     ( (new_segments=NULL
 }
 }

s>segments_size new_size
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    stroker-
   >[>]. =*p2
    stroker->segments[stroker-a-y- ;
    stroker-    >y+ ;

    return CAIRO_STATUS_SUCCESS
}

staticjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
if> <>x {
{
    cairo_line_cap_t line_cap = stroker->stroke_style->line_cap;
    box.x=a-;
     box.x >xjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    cairo_status_t status..x  >xjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    int i, j;

    /* For each segment we generate a single rectangle.>;
     * This rectangle is based on a perpendicular extension (by half the
     * line width) of the segment endpoints * after some adjustments of the
     * endpoints to account for caps and joins.
     */
    for (i = 0; i < stroker->num_segments; i++) {
 cairo_bool_t lengthen_initial, lengthen_final;
 cairo_point_t *a, *b;
 cairo_box_t box;

 a = &stroker-    box..y=a-y;
 b = & }

 /* We adjust the initial point of the segment to extend the = _ (stroker->, stroker->antialias &);
 * rectangle to include the previous cap or join, (this
 * adjustment applies to all segments except for the first
 * segment of open, butt-capped paths). However, we must be
 * careful not to emit a miter join across a degenerate segment
 * which has been elided.
 *
 * Overlapping segments will be eliminated by the tessellation.
 * Ideally, we would not emit these self-intersections at all,
 * but that is tricky with segments shorter than half_line_width.
 */
 j =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  = >num_segments1 :1
 lengthen_final
sub_path
cairo_line_cap_t=>>line_cap
   !;

     if (i == stroker->     java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  lengthen_final = line_cap ( == &
  stroker-[i. &  &&

 ( stroker-open_sub_path >dash))java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
if( | ) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      (>y =b- {
  if (a->x < b-
  if()
   a->x -=         &stroker->sej.,
      f()
   b->x     .p2=b.p1 >segments]p2java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 } java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
()
   a->x += half_line_x;
      if (lengthen_final    .p1 =;
alf_line_x
     } else {
       {
  if ()
      if    oxp2. +half_line_y
  a-y=half_line_y
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   b->}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     iflengthen_initial
   a->y += half_line_y;
  ()
   b->y -= half_line_y;
  }
     }
 }

 /* Form the rectangle by expanding by half the line width in
 * either perpendicular direction. */
 if (a->y == b->y) {
          line_cap ) {
 b- =half_line_y
 } else {
     >x - ;
     b- b-x+ ;
 }

 if (     a-> =;
    box.1 = a->;
     box.p2.x java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 } else {
 box.1x=b-xjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    .p2x =a-;
 }
 if (a->y < b->y) {
 box.y = a->y;
     box.p2.y = b->y;
 } else {
     box.p1.y = b->y;
     box.p2.y= a->y;
 }

 status = _cairo_boxes_add (stroker->boxes, stroker->antialias, &box);
 if (unlikely      >y = half_line_y
     return status
    }

    stroker- = ;
    return    >y+half_line_y
}

static cairo_status_t
_cairo_rectilinear_stroker_emit_segments_dashed
{
    cairo_status_t status;
    cairo_line_cap_t line_cap = stroker->stroke_style->line_cap;
    cairo_fixed_t half_line_x
  >half_line_y
    int i;

    ..  >;
 a bjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 ;
 cairo_box_t

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 b = &stroker->segmentsi ( (status

 is_horizontal stroker-[i]flags;

    
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      return;
     (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
_airo_rectilinear_stroker_move_to *,
       cairo_point_t)
     {
      j=i+)%stroker->;
     cairo_bool_t forwards =cairo_status_t;

      ifstroker-.dashed
 [j].p1
          &stroker->    java.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8
     box.p2  dash for sub */

     if (is_horizontal) {
  if (forwards)
      box>current_point*point
  else>first_point;
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (staticjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     box.p1.y -= half_line_y;
  else
      box.p2.y += half_line_y;
     } else {
  if (forwards)
      box.p2.y += half_line_y;
  else
      .p1- half_line_y

       *stroker;
      cairo_point_ta=stroker-;
       status
      box.p2/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
     }

     status/* We don't draw anything for degenerate paths. */
     if( (status
  return status;
 }

 /* Perform the adjustments of the endpoints. */= cairo_rectilinear_stroker_add_segment, a ,
 if (is_horizontal) {
     if (line_cap ==       (a->y == b->y );
   (>x< >x{
      a->x -= half_line_x;
      b->x += half_line_x;
  }s>open_sub_path ;
      a->xjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      b-_ (void*,
  }
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

     a-  * ;
     b-> fully_in_bounds
 } sfs, remain
      mag
  if>y= >y){
      a-    cairo_line_t;
      b- cairo_bool_t = ;
  }    nsigned;
      a->y += half_line_y;
      b->y -= half_line_y/
  }
     }

     >x+half_line_x
     b->returnCAIRO_STATUS_SUCCESS
 }

 if (a->x ==      (a-> =b-x| a->y= >y;
 continue

 if a-x<>x {
     box.p1.x = a->( _ (stroker-, a |
     box.p2.x = b->x;
 } else {
     box.p1.x = b->x;
     boxp2x=a-x;
 }
 if (a->y < b->y) {
     box.p1fully_in_bounds  FALSE
     box.p2.y == b-y;
 } else {
     box.p1.y = b->y;
     box.p2.y = a->y;
 }

 status = _cairo_boxes_add (stroker->boxes, stroker->antialias, &box);
 if (unlikely (status))
     return status;
    }

    stroker->num_segments mag= b->x -a-x;

    return CAIRO_STATUS_SUCCESS;
}

static     } else {
_ (void  closure
        const sf =fabsstroker->ctm-yy;
{
    cairo_rectilinear_stroker_t *stroker = closure;
    cairo_status_t status;

    if (stroker->dash.dashed)
 status = _     (mag<0 {
    else
 status = _cairo_rectilinear_stroker_emit_segments (stroker);
    if (unlikely (status))
returnstatus

    /* reset the dash pattern for new sub paths */
    _cairo_stroker_dash_start (    }else{

    stroker->  | ;
    stroker- = -.;

    return CAIRO_STATUS_SUCCESS;
}

static cairo_status_t.p2 .p1*;
     (remain. java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 const *
{
cairo_rectilinear_stroker_t  ;
    else
    cairo_status_t status;

    /* We only support horizontal or vertical elements. */
   assert> = b-> |a-y= b->)

    /* We don't draw anything for degenerate paths. */
    if(-x==b- &a- = >y)
 return CAIRO_STATUS_SUCCESS;

    status = _cairo_rectilinear_stroker_add_segment (stroker, a,  ( ||
           (a->y = _ (stroker-, segment

 *java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    stroker-> ( (status))

     status;
}

static cairo_status_t     = ;
_cairo_rectilinear_stroker_line_to_dashed ( java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        const}
{
oker_t s = closure
    constsegment = segmentp2
    const cairo_point_t *b =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    cairo_bool_t fully_in_bounds;
     sf , remain
    cairo_fixed_t cairo_box_intersects_line_segment&>bounds&)))
    cairo_status_t status;
    cairo_line_t segment;
    cairo_bool_t dash_on= ;
    unsigned is_horizontal;

    /* We don't draw anything for degenerate paths. */
    if   *
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /* We only support horizontal or vertical elements. */
    assert       &segment.p1,

    fully_in_bounds = TRUE
    if(>has_bounds&
 (! _     return status
  }
    {
 fully_in_bounds = FALSE;
    }

    is_horizontal = a->y == b->y;
    if (
 mag = b->x - a->x;
 sf = fabs (stroker->ctm->xx);
    } else {
 mag= b-> -a->;
 sf =     stroker-open_sub_path ;
    }
    if (mag < 0) {
 remain = _cairo_fixed_to_double (-mag}
 signjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    } elsejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 is_horizontal |= FORWARDScairo_status_tstatus
 sign  -;
    }

. . = a
    while (>.dashed
 double =cairo_rectilinear_stroker_line_to_dashed

 =MIN>,)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 remain  (tatus

 
if &java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
mentx >+;
 else
gmenty > ;

 ifstroker-dash &java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     (fully_in_bounds    return CAIRO_STATUS_SUCCESS;
      _cairo_box_intersects_line_segment java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 2
    status = _cairo_rectilinear_stroker_add_segment(,
         &.p1java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        | <= . <2java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return status;

      ( cairo_rectilinear_stroker_init,
 }
e
 {
     dash_on      boxes)
 }

 cairo_stroker_dash_stepstroker-, /)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 segment.p1 cairo_path_fixed_is_stroke_box, box&java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    }

    ifstroker-dashdash_on&  dash_on &&
 (fully_in_bounds ||
  _cairo_box_intersects_line_segment (&stroker->bounds, &segment)))
    {

 /* This segment ends on a transition to dash_on, compute a new face
 * and add cap for the beginning of the next dash_on step.
 */

 ..x=box.-rectilinear_stroker;
      bp2x  boxp2.+rectilinear_stroker;
        b.  .p1  .half_line_yjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
     is_horizontal |JOIN;
 if (unlikely (status))
     return status;
    }

    stroker->current_point = *point ( == );
    stroker->open_sub_path = TRUE/* left  (excluding top/bottom) */

    returnCAIRO_STATUS_SUCCESS
}

taticcairo_status_t
_cairo_rectilinear_stroker_close_path.2. =boxp2.y -rectilinear_strokerhalf_line_y;
{
    cairo_rectilinear_stroker_t*stroker closure;
    cairo_status_t status;

    /* We don't draw anything for degenerate paths. */
   if!stroker-)
 return..  ox.  .half_line_y

    if(>dash) {
 status status _cairo_boxes_addboxes,&;
   (status CAIRO_INT_STATUS_SUCCESS
    }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 status = _cairo_rectilinear_stroker_line_to (stroker,
 ..x=.p2.+r.half_line_x
    }
    if ( (status
 returnbp. =.p2+rectilinear_stroker.half_line_y;

    stroker-open_sub_path FALSE;

(stroker-dash)
 status
    else
 status  cairo_rectilinear_stroker_emit_segments (troker
    if (unlikely (status}
  status

return;
}

cairo_int_status_t
cairo_path_fixed_stroke_rectilinear_to_boxes  *path
            }
            const cairo_matrix_t *ctm,
            cairo_antialias_t  antialias,
            cairo_boxes_t  *boxes
{
    cairo_rectilinear_stroker_t rectilinear_stroker;
    cairo_int_status_t status;
    cairo_box_tbox

    assertcairo_path_fixed_stroke_is_rectilinearpath);

    if (! _cairo_rectilinear_stroker_init (&rectilinear_stroker,
        stroke_style, ctm, antialias,
            ,
      ,
return;
}

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
cairo_path_fixed_is_stroke_boxpath)
 /* if the segments overlap we need to feed them into the tessellator */)
 box.p2
 boxp2  box.y >2 .half_line_y
    status_ (boxes
 cairo_box_t b         CAIRO_FILL_RULE_WINDINGjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 /* top */
 b.p1.x = box.p1.x - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 b.p2x= boxp2  .half_line_x
 b.p1.y = box.p1.y - rectilinear_stroker    return CAIRO_STATUS_SUCCESS
 BAIL
    cairo_rectilinear_stroker_fini(rectilinear_strokerjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    ;

 /* left  (excluding top/bottom) */
 b.p1.x = box.p1.x - rectilinear_stroker.half_line_x;
 b.p2.x = box.p1.x + rectilinear_stroker.half_line_x;
 b.p1.y = box.p1.y + rectilinear_stroker.half_line_y;
 b.p2.y = box.p2.y - rectilinear_stroker.half_line_y;
 status = _cairo_boxes_add (boxes, antialias, &b);
 assert (status == CAIRO_INT_STATUS_SUCCESS);

 /* right  (excluding top/bottom) */
 b.p1.x = box.p2.x - rectilinear_stroker.half_line_x;
 b.p2.x = box.p2.x + rectilinear_stroker.half_line_x;
 b.p1.y = box.p1.y + rectilinear_stroker.half_line_y;
 b.p2.y = box.p2.y - rectilinear_stroker.half_line_y;
 status = _cairo_boxes_add (boxes, antialias, &b);
 assert (status == CAIRO_INT_STATUS_SUCCESS);

 /* bottom */
 b.p1.x = box.p1.x - rectilinear_stroker.half_line_x;
 b.p2.x = box.p2.x + rectilinear_stroker.half_line_x;
 b.p1.y = box.p2.y - rectilinear_stroker.half_line_y;
 b.p2.y = box.p2.y + rectilinear_stroker.half_line_y;
 status = _cairo_boxes_add (boxes, antialias, &b);
 assert (status == CAIRO_INT_STATUS_SUCCESS);

 goto done;
    }

    if (boxes->num_limits) {
 _cairo_rectilinear_stroker_limit (&rectilinear_stroker,
       boxes->limits,
       boxes->num_limits);
    }

    status = _cairo_path_fixed_interpret (path,
       _cairo_rectilinear_stroker_move_to,
       rectilinear_stroker.dash.dashed ?
       _cairo_rectilinear_stroker_line_to_dashed :
       _cairo_rectilinear_stroker_line_to,
       NULL,
       _cairo_rectilinear_stroker_close_path,
       &rectilinear_stroker);
    if (unlikely (status))
 goto BAIL;

    if (rectilinear_stroker.dash.dashed)
 status = _cairo_rectilinear_stroker_emit_segments_dashed (&rectilinear_stroker);
    else
 status = _cairo_rectilinear_stroker_emit_segments (&rectilinear_stroker);
    if (unlikely (status))
 goto BAIL;

    /* As we incrementally tessellate, we do not eliminate self-intersections */
    status = _cairo_bentley_ottmann_tessellate_boxes (boxes,
            CAIRO_FILL_RULE_WINDING,
            boxes);
    if (unlikely (status))
 goto BAIL;

done:
    _cairo_rectilinear_stroker_fini (&rectilinear_stroker);
    return CAIRO_STATUS_SUCCESS;

BAIL:
    _cairo_rectilinear_stroker_fini (&rectilinear_stroker);
    _cairo_boxes_clear (boxes);
    return status;
}